Some casual surfing led me to this article from a couple of years ago, titled "How to recognize a good programmer". It was a nice read, but as many in the comments pointed out, the criteria the author set forth most likely describe himself and are not really useful as rules-of-thumb on how to recognize a good programmer.
It got me thinking though, on what are the attributes I consider useful in fellow programmers. So what makes a good programmer?
An analytical thinker
Programmers need to be problem solvers. The process of programming requires that we systematically break complicated problems down, plan and implement solutions and find / eliminate small inconsistencies in code (bugs).
Analytical thinking also manifests in the ability to follow complicated logic through disparate code segments and understand it. It allows us to grasp abstract concepts such as Object Oriented methodology and design patterns and implement it in practice.
Has his priorities straight
If I would ask you to rate the following according to priority, how would you order them?
- LOC (lines-of-code) count
Take a moment to think about that, and then consider:
- If you picked LOC count first, you failed big time in my book. In fact, LOC optimization can often go directly against the other metrics (such as maintainability). A lower LOC count should never be a goal, only a result of careful application of well factored architecture.
- If you picked performance first, you are probably the guy who keeps writing articles about how you should use a while loop instead of a for loop since it came out a few milliseconds faster in your benchmarks. You might be inflicted with a case of premature optimization.
We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil.
Performance should only be good enough to satisfy the requirements of the application. Aside from caveats to well-known pitfalls (such as executing queries in each iteration of a long loop), performance optimizations should be deferred to the very last and even then should be used appropriately (profile ... profile ... profile ... optimize).
The only exception to this is if you are primarily developing performance dependent applications (such as low-level system drivers).
- Security is on somewhat of a middle ground. Depending on the application and distribution model it can be completely useless or mission critical. It's mostly somewhere in between, and thus can't be ranked as number one.
- Maintainability is definitely one of the most important attributes of a software application. High maintainability allows you to improve other attributes (such as performance), when it is needed.
Maintainability is the single most important factor for keeping productivity up and costs down. For a long time I strongly believed this to be the most important attribute of software design.
- The most important attribute is usability. In the end, the worth of your application is only as much value as it delivers to the end-user.
We should always remember - software is not written to serve its developers or the systems they run on. They are written to solve problems. If those problems are not solved, then the project is a failure.
I wrote usability here as a more general term than just UI/UX effectiveness. Even a command line application or a background service has its usability factor in the sense of how well it answers a specific need.
Gets things done
In principle, it’s simple. You’re looking for people who are
1. Smart, and
2. Get things done.
Quite possibly the single most important trait in a developer. You can excel at all the previous attributes and still be a mediocre programmer if you just can't get things done. One average but productive developer could easily replace several highly talented but slowly moving developers, depending on his responsibilities.
At the end of the day you definitely want more highly-productive developers than those who are high on theory but not actual work.
Does more than "just enough"
Getting things done is important. Getting things done "the right way" is even more important.
Constantly paying off your technical debt is crucial - if you keep accruing debt by "hacking" quick fixes that work now but are not maintainable, you only create the appearance of progress. In reality, the cost of getting rid of a large technical debt could become prohibitive before you know it.
Taking the time to constantly refactor code into a more maintainable state is the best way to prevent the spiral into project oblivion.
A person could be a very capable programmer on technical ability alone, however if he does not own up to his mistakes and does not respect deadlines he could become a liability very quickly.
Responsibility also means to know where to let go of your ego for the good of the project. We developer often high large egos as we consider ourselves experts on many things. Putting the project first is a sign of a good developer.
Good human relations
Another all-around useful trait, this one applies to programmers as well. There is some stereotype that programmers are reclusive, unsociable creatures - programmers are still people ;).
In order to be a part of a team or handle clients, a programmer must have above basic social skills. Rudeness, arrogance, short-temper - do not have a place in a professional work environment. All it takes is one bad apple to ruin the mood for everybody.
That's about it
If you answer to all of the above, you are probably a pretty good programmer (and you are welcome to apply with us :)).
If you read the article I mentioned at the beginning, you might notice I didn't mention passion or technological diversity as qualifying traits. Simply put, I don't think they're very relevant to the quality of a programmer.
Passion is nice to have, however I've known many very professional and high-quality developers who were just content to go about their work professionally from 9 to 5 and then go home and have a meaningful and fulfilling family life. A programmer can definitely completely professional without being passionate about programming.
Technological diversity is another nice to have but not a prerequisite - as long as you are in command of the technologies you work with, a lack of diversity shouldn't affect you too much. Decision makers need to be well aware of all the options before starting a project, however nowadays the choice of technology simply is not that important.
You can achieve good results regardless of the programming language and database engine among other consideration. The biggest consideration should be the type of skills available to your personnel.
I hope to see more suggestions and thoughts in the comments on what you think make a good programmer.
To know when the next article is published, please subscribe to new articles using your Email below or follow me on Twitter.