Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
If we refer to exceptions as bugs, why not just call it a bug in the first place instead of an exception?
If in the code it's called exception and as soon as it occurs it's called a bug. Then why not call it a bug in the first place?
Thank you for any answer or comment.
Well, it's pretty simple: not all exceptions are bugs (and similarly, not all bugs manifest themselves as exceptions).
As example of an exception that's not a bug, if you're reading a file from a USB drive and someone yanks the drive out of the socket. That's going to raise an exception (in most languages that support exceptions, that is). But it's not a bug in the code.
Conversely, a bug might manifest itself as a calculation error or something. You still get an answer, it's just not the right one.
Having said that, an exception that makes its way all the way to the top of the stack likely is a bug. In my USB example above, you should be able to catch that exception and present a nice error to the user saying "We couldn't read from the file because it's no longer connected." or something. If you just present them with an IOException and some funky error code, then that's a bug. But the exception itself is not.
Plain and simple, an exception is not (always) a bug!
An exception is thrown (or should be) when something exceptional happens. If there is a problem with my hard drive and a file cannot be written, that is not a bug. That is a failure of the hardware.
A bug is generally a result of bad programming. If an application does something that is not expected as a result of a programming error, that is a bug.
They are not the same thing.
A bug is unintended behavior of a piece of software: the software doesn't do what it is supposed to do. Bugs can live at all levels of software development, ranging from plain old typos through logical errors up to inadequate functional specs.
An exception, by contrast, can refer to either an unusual condition of a program, deviating from normal operation, or, more specifically, to the language construct used to signal and handle such conditions.
The fact that an exception occurs can be a sign of a bug, but often it isn't. For example, an application that is supposed to download a document from a URL and process it locally might throw an exception when the remote server is down: the application is deviating from normal operation (it cannot download and process the document), but if it handles the exception properly and recovers, then there is no bug.
Conversely, the presence of a bug doesn't necessarily manifest itself as an exception. An application might silently discard data you enter instead of storing it in its database; no exception gets thrown, but it is still a bug.
Exceptions and bugs are not at all related. Sure, sometimes you throw an exception and it means a bug. But sometimes it just means an exceptional, unusual circumstance, which is not necessarily a bug in the program at all. Especially in an exception-happy language like Java, where every standard operation and it's dog throws about five different exceptions- for example, opening file failed, reading file failed, etc.
Exceptions are not always bug related. Think of it as something that could go wrong with what you are doing.
An example that comes to mind is InetAddress.getByName() which is used to resolve a domain name. If something happens and an UnknownHostException is thrown its not really a code issue.
A software bug is the common term used to describe an error, flaw, mistake, failure, or fault in a computer program or system that produces an incorrect or unexpected result, or causes it to behave in unintended ways. Might even be a spelling mistake on a label.
Exceptions are different to bugs. Each kind of exception (access violation, stack overflow, and so on) can be raised to a debugger as either a "first chance" or "second chance" exception. First chance exceptions are, by definition, non-fatal unless they are not handled properly with an error handler, at which point they are raised again as a second chance exception (which only a debugger can handle).
If no debugger handles a second chance exception, the application is shut down.
You might legitimately raise an exception yourself, you would hopefully never introduce a bug on purpose.
All exceptions are not bugs. It can be a topic of debate that all bugs are exceptions or not.
We can say exceptions are the events that are not part of the normal or expected flow of application. These events can be independent of how the code is written where as a bug is essentially result of bad code(like wrong calculation).
Here is an example of how not handling an exception can be a bug.
Let us suppose there is a program that writes some data to an external storage device. While writing the external storage device was unplugged, crashed or may be destroyed(for what ever reason). Now this is an exceptional case, now regardless the programming language supports exceptional handling or not if the program crashes or misbehaves due to this event, it is a bug.(The end user may have not idea what happended. It is also very unpleasent). But if program aborts the process gracefully, notify the user(in other words handle the exeption) this is clearly not a bug.
The try catch machanism programing languages provide is essentially a tool to ease our way out to handle unexpected events.
Synopsis: Exceptions are evidence of bad outcomes, bugs are (some of the) causes of bad outcomes. The problem (to be solved) isn't the exception, the problem is what caused the exception.
Resoning: A bug is a defect in the design or implementation of a product (not limited to software). For example, not using a properly rated relay (time/sensitivity/reliability/capacity) either due to incorrect specs or simple build error. An exception is a real world / run time deviation from predicted (dare I say 'expected'?) behavior, e.g., the loss of control of a vehicle while driving.
Clearly, a bug can cause an exception as the example in 1) could lead to the example in 2). But not all exceptions would be caused by bugs, e.g., loss of control of a vehicle because the operator had a stroke.
Since this question has been re-opened for a bounty, let me mention my CUJ article from 2003 entitled "An Exception or a Bug?", which seems to address exactly the OP's question.
Basically, the article defines the terms "bug" and "exception" (giving examples), and proposes strategies for dealing with each.
The article proposes not to "handle" bugs but instead flag them with assertions. In contrast, true exceptions require handling through code (possibly throwing/catching exceptions).
The main point is that bugs require the exact opposite strategy than exceptions.
The aforementioned article is available now from Dr.Dobb's at: http://www.drdobbs.com/an-exception-or-a-bug/184401686
