Price sticky
image result for error handling

How to implement complete error handling without obscuring code logic


Implementing error handling without obscuring code logic


Developers write a program to solve some problems. Each problem has its input set and the standard output set. But what about those inputs that do not have an output? How will your software react to such a situation?

No code is perfect. Writing bug-free is not only a myth but also a bad practice to follow. If your code looks to have no errors, it’s evident you’ve missed it. Every code has errors and vulnerabilities or may have had one. But it becomes your responsibility to make your software such that it can handle when such problems arise. This ability and area are known as error handling.

Error handling is when your software is capable of countering or confiscating errors that may have been brought on by a programmer’s mistake or a genuine problem. Error handling is fundamental and also a topic full of complexity. Errors usually happen while programming, and developers forget to expect the unexpected while writing. If someone had thought of that earlier, then the code would be clean and well to go, at least for some time. What if the error is not a programming mistake but a case that is rare to happen but can happen sometimes? We need to create a difference in such cases to know more about it.

Error Handling v/s Exception Handling

Error is something that is a programming fault, and when it occurs, there is nothing other than stepping into it, changing and fixing that fault. But in the meantime, your software must be configured so that it can handle this error without creating any other fatal errors. Error handling is easier in small software, but in large-scale software, it is sometimes a waste of time. This is the point when error handling gets converted into exception handling.

Exception handling is a form of error handling, just with the difference that your code does not jump to an error state when any issue arises. Rather it reads the issue as an exception state and returns back a predefined output. Consider an example: A software asks you to upload a file but fails to open it and throws a FileNotFoundException at your code. Now either your software can break down as the process has reached the shore of the sea, or you can anticipate this issue beforehand and build a bridge.

A bridge can be something that skips this step and jump to the conclusion if it is a soft real-time process. Or can give back a notification to retry again or later if it’s a hard real-time process. Building this exception handling case is important because it’s hard to know when or how an exception can arise. But having exception and error handling techniques in your code is highly important.

What are your tricks for error handling without complicating your code?

We’ve established that our code must be able to recover itself if any issues arise, and let’s now see how one can do this without increasing complications.

  • If you can sense an error in your code but solving this will either make your code complex or will increase technical debt, it’s better to create it into an exception.
  • If you can sense what type of exceptions may arise, create a small separate code to rebound from this state.
  • Be specific about all different exceptions. Depending on your program, these exceptions may hamper your data if not written well.
  • Try using statements that can make error handling for you. For example, JavaScript has an error-handling statement try..catch..finally. You can use the try block to write and execute your program. If no issues arise, it’ll pass without any errors. But if any error arises, a catch block is where you can deal with it without shutting down the system. If you have a response to such errors or final responses to the user, the final block will take them to that irrespective of any error caught or not. Remember final block always executes but is an optional block to write.
  • If possible, create your error hierarchy. Many languages have a variety of exceptions and error handling classes. But to get readability and uniformity with your code, it’s best to create your own.
  • Resist your urge to handle all exceptions. We don’t wish your program to fail but doing everything at once will cost you time and also compromise your code’s manageability. An exception can be handled at any point in time in the call stack.

Wanted to keep your code error-free? Signup today and start analyzing your code for Free!


Sounds difficult? It is if you are still working with traditional and manual ways. Using CodeGrip, an automated tool for code quality, you can easily implement error handling.CodeGrip reads your code and analyzes it line by line, finding out errors. It points to the error location in your code so that you can correct it using error handling. It makes sure you don’t miss any error.

Liked what you read? Subscribe and get fresh updates.


    P.S. Don’t forget to share this post.

    Post a Comment