Skip to main content

I’ve been thinking about what separates the great programmers from the simply good programmers. Here are a few thoughts. If you have some additional thoughts, please login and comment on this post,

1. It’s not about the coding stage.

Sure, the great programmers are also great coders. But it’s more than that. I think the great programmers are also great engineers. An engineer knows his tools. An engineer knows how to break down a complex problem into pieces that he can solve, and then knows how to reassemble the pieces to make up a whole. An engineer knows the problem domain intimately. In the context of programming, this means that you understand the problem you are trying to solve; you understand how it fits in to the larger framework; and you understand the limitations of the technology.

2. It is about the coding stage.

Reading great code is like reading a well-written novel. The story just flows off the page. The data structures are exactly what is needed to solve the problem. The code is broken up into procedures whose function is clear from their name, use, and code. The names are descriptive. The code is consistently indented. Comments are strategically placed, helpful, serious, and not redundant with the executable code. Comments don’t question the behavior of the nearby code (if you are ever tempted to do this, stop and take the time to figure out what is going on instead!) Code is never needlessly duplicated; any given action is implemented only once. Functions perform a task without gratuitous side effects. Thought has been given to obvious future enhancements, and reasonable provision has been made to anticipate them in the current design.

3. They are fearless.

A programmer who won’t work on a piece of code because he thinks it is too complicated or too fragile is probably right. But they are not referring to the code. They are referring to their own abilities! The great programmers, when confronted with a mess, know when and how to build a case to management that it is time to re-implement the gnarly code in question. The worst programmers simply dive in and make the mess worse.

4. The great programmers are always thinking about performance.

They know that if they pick the right data structure for the task at hand, they have already avoided most performance problems. But they don’t make any assumptions about performance. When they get their code debugged, they take the time to run stress tests and shake it out at max throttle. They understand that getting code to work at 1 TPS is not the same as getting it to work at 1000 TPS. They also understand that getting it to work for 15 minutes is not the same as getting it to work for days and weeks on end.

5. The great programmers don’t guess.

When they get to something they need to know, and don’t know, they figure out how to acquire the necessary knowledge, without guessing, and without wasting a lot of time.

I hope you find this list intriguing, and also helpful.

© 2024 Stratus Technologies.