Develop and debug like the pros
By Aaron Emmert
The goal of any well-designed software is to enhance the user’s experience by fixing a previous struggle. Automating day-to-day tasks and supporting others provides convenience, but at the same time, when the system doesn’t work how it should, it gets really frustrating.
A software traffic jam that stops all productivity makes users question the system’s reliability and reduces their trust in it. Not to mention the consequences if the bug isn’t handled well, either from slow diagnosis or apathetic tech support.
I have a few tips, ranging from general design to debugging, that can either prevent traffic jams from happening or at least reduce the user’s impact with fast solutions when they do happen.
Keep data and business logic separate
When code is broken up and properly organized by purpose, it makes the code more intuitive and readable as well as helps the developer narrow down the cause of defects. Essentially, making a virtual assembly line where each step within an automated process is completed perfectly and reliably every time. But if there was a defect, you can trace it to the step responsible.
For example, if you find yourself writing the same code in multiple places, you can put it in one method (step) and call it when needed. Within Appian, a low-code business process automation software, you can see the list of dependents of any object and where that object is used.
Additionally, each step is standardized so it can be used in different scenarios; like a perfect lego block. That way, multiple assembly lines can re-use the same step instead of needing to create a custom version every time.
Don’t assume anything
Using our assembly line example, each step within a process answers the following questions: What exactly are you receiving, what exactly are you doing, and what exactly is the end result? In other words, methods (steps) define the list of criteria, the code that’s implemented, and the expected result. Any uncertainty can lead to defects when there’s a step you think functions one way, that actually functions differently.
While it may sound obvious, you can’t fix an issue if you don’t know exactly what the code is doing. Making assumptions speeds up your decision making but it can also backfire by misleading you, which leads me to our final point.
Work through the debugging confusion
When I was in school, there were times when no matter how something was explained to me, I still couldn’t understand. It just didn’t click. At times like these, my professor would talk about the fundamentals, or try a different approach to help me understand. Which is exactly what we should do with our code.
Try starting from scratch or break up the steps even more to make them more intuitive. In other words, rewrite the code so it is not as complex. Sometimes redesigning the process will indirectly fix your current issue, but as the saying goes, it might create others as well.
It’s important to focus on the longevity of a software system as a whole because the cost of maintaining the system is usually more than the cost to initially build it. Although developers can implement complex algorithms or create functionality in fewer lines of codes, having simple and intuitive code will make the software much easier to maintain. This low-code development style is one of the benefits of using Appian, where it emphasizes fast development and defect resolution.
About the author
As an Appian developer, Aaron strives to meet and exceed the expectations of our clients. He grew up in Superior, Wisconsin, where he’s a fan of the Packers, dairy products, and cider. His hobbies include walking the dog, exercising, reading and playing video games. Read more of Aaron’s blogs here.