Personal

One of the most important traits of a good software developer, in my opinion, is consistency. Consistency is needed in so many different aspects of a daily programmers life, and yet it can be easily forgotten when hard times come.

Consistent learning

This one is, I’d say, the most obvious. If you want to get on top, and stay there, you have to consistently invest your time and energy to learn new things. Be it new technologies, new concepts or a new version of a language in which you consider yourself as an expert, you have to constantly devote some time and energy to be able to grasp it. Constant and consistent wish for learning new things is something that puts you on a good path of becoming a better software engineer.

Consistent performance

Whatever you do, you should be consistent. Unless, of course, you slack and under perform. To explain, we all have our good days and bad days, but you should try to do your best, even on a bad day. Being a consistent performer makes you reliable, and, I believe, most teams would rather have a reliable team player with average software engineering skills than a brilliant one from whom you never know what will come out as a product of the day. When you perform consistently, no matter what level, it makes it easier for others to plan with you, because they know what they can expect.

Consistent behavior

This is one aspect that can be easily forgotten. We, as software engineers, are often regarded as introvert geeks who the most prefer to be left alone and talk to a computer. However, that is so far away from the truth. In 21st century it is very difficult for a single person to create something, without much interaction with others, so we should all try to be as good as possible colleagues one to another. You should try to make yourself a valuable member of every team, and you will become so not only with your technical skills, but also with predictable behavior and solid soft skills. Consistent behavior will make it easy to other people to know what they can expect from you, how will you behave in most situations, and that will help them avoid one thing that most people don’t like – uncertainty. When you consistently behave nicely to other people, provide constructive solutions and help others be better, you are becoming a valuable team member and most people will want to work with you.

Source code

This one is as much a team effort as a personal one. I highly value code which is consistently written. I think that consistency makes it much easier to read it. When the same patterns are applied in each and every class/file, you don’t have to spend much time thinking about the representation of authors idea. Consistency is the reason why we have the code style guides, so that we don’t have to spend energy trying to figure out some common things. When the source code is consistent, it is easy to read and update it, or to say it differently, communicate with it.

You can find style guides for the language of your choosing, freely available on the Internet, so I won’t go into details explaining it. However, there are some things that are usually not explained by these documents, and can improve the consistency and readability of your code.

Methods alignment

One might argue that it’s really not important how methods within a class are aligned, because all modern IDEs can take you directly to a method. Still, I think that it makes the class much easier to read, for all those whom might be interested in doing it, if you align methods consistently throughout your project. So, if in one class you put your private methods below methods that use them, and static methods below them, for example, then use the same way to organize methods everywhere, and don’t put in another class private methods on the top, since you will break the consistency.

Class naming

You should name your classes consistently, in a way that if you name a class of specific usage as *Helper, don’t name the other one, in the same project, with the similar usage *Util, or vice versa. The consistency in naming will help a reader figure out what the class does without the need to open it, if he is not actually interested in looking into the implementation.

Arguments

This is one more thing that can mess up the readability of a class. If you consistently put arguments of the same type or usage at the same place in the method header, it will make it easier for a reader to memorize the code. It will help him avoid spending energy figuring out what argument is for what, especially if you don’t enforce the type safety and pass the arguments of type String, or similar, to your methods.

I think these small examples should be enough to show what I mean by having software that is written consistently. Code that is consistent, looks nice and is easier to read than inconsistently organized code. From my own experience, such source code is much easier to maintain, upgrade or refactor. When someone needs to make a change to it, it will not give them a headache of only trying to figure out what is happening where.

To reflect on applying consistency on a personal level – just as the source code, it will help you become a better developer and coworker, and your consistency will help your coworkers communicate with you. It will make you a reliable team member, from whom people know what to expect in which situation, and a more pleasant person to work with.

Please feel free to share your thoughts in comments on consistency, in every aspect of developers life. Also, if you disagree with anything I wrote, I’d be happy to hear your arguments.