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?
* Security
* Maintainability
* Usability
* Performance
* LOC (lines-of-code) count
Take a moment to think about that, and then consider:
1. 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.
2. 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.
Donald Knuth
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).
3. 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.
4. 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.
However ...
5. 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.
Responsible
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.
http://www.techfounder.net/2009/07/22/what-makes-a-good-programmer/
.
