Every software engineer or developer might have asked this question to themselves or to their colleagues at some point. How to make myself better as an engineer or developer? If you haven’t, you should.

The answers would differ from person to person. Some might even go very specific. But there are somethings that so many agree upon which could be applied by pretty much every one in the industry.

The ability to consider many different scenarios is a must have trait for any good engineer. This applies both to the internal and external events that can occur as well as the logic in the program. Asking the following questions might help us discover what types of events the software needs to handle.

• What if this queue becomes full?
• What if other server restarts while this server is restarting?
• What if there is no response to this request?

Also, the following questions might help us find the different paths in the logic.

• What if none of these arguments are true?
• What happens if the argument is null? Etc.

Software is primarily about solving problems. So, before we start writing code, we need to be clear on how to solve the problem. The ability to break down a problem into smaller chunks is a formidable weapon in any engineer’s arsenal. But it doesn’t stop there. We should be able to model the problem in such a way that the resulting program is easy to reason about, easy to implement and test.

Properly naming classes, methods, functions and variables goes a long way. When done well, the software becomes self-documenting. That is, the function of the code is quite clear just from reading the source code. Self-documenting codes naturally leads to smaller methods, rather than a few large ones, simply because we get more places to put meaningful names.

Naming things is not easy as it sounds. It needs to be clear in our mind what each name represents. Sometimes that might change during the development process. That is why renaming is just as important as naming.

Managing complexity is undoubtedly one of the biggest challenges in software development. Consistency is key here. It reduces some of the complexity by allowing us to see patterns and infer how things are named, used and handled. We do not require to use much brain power to remember exceptions and random variations, with consistency. Consistency applies to variable names and grouping, method naming, the division into modules, directory structure, documentation, the GUI, logging, error-handling etc. For instance, if some variables are related and appear together, try to use them in the same order. This will make it easier to see if any goes missing or if they have been mixed up. There is a high chance for inconsistencies while modifying a software. Good engineers always ensure that even the small parts are right and the consistency is kept while modification.

We are constantly learning as a software engineer. We have to understand what a feature is supposed to do before adding it. It goes without saying prior to that we must understand what the existing code does. It will make the addition of the new feature that much simpler. We also have to learn about the surrounding systems in order to interface with them appropriately. Obviously, the ability to learn fast will make us more effective, but not necessarily always.

If we have these skills, we can learn new languages and tools much quicker and create exceptional software.

Disclaimer : The views and opinions expressed in the article belong solely to the author, and not necessarily to the author's employer, organisation, committee or other group or individual.