One of the most common questions about software development is how to become more productive as a programmer. It is well known that there is a big difference in productivity between mediocre programmers and great programmers, although this is still a little understood phenomenon. For example, there has been anecdotal evidence that the amount of work a great programmer can produce in a week cannot be matched by a mediocre one even in a year’s worth of effort.

So, what is the source of the difference? In general, it includes everything from intellectual capacity to focus, but there is usually a small number of common elements that can be observed in the work of every good developer. It is helpful to try to incorporate such elements to our normal workflow as much as possible. Here I talk about three practices that I have commonly observed on highly skilled developers.

Doing the right thing first

A great foundation for creating correct software involves the avoidance of cargo-cult: that is, the practice of doing things just because they seem to work on the surface. Smart people don’t do something because somebody else told them to do, or because it seems to work most of the time.
Excellent programmers go the extra mile to understand how something works.

This practice can be generalized to any aspect of life, but it is absolutely essential in software development. For example, the cause for most software bugs usually lies hidden in something that was not well understood by the programmer when the code was initially written.

People who don’t look for the root causes of what they are doing are prone to development that uses cookie-cut strategies, including the following: using copy-and-paste from online forums as their primary way of solving problems; incorporating code generation tools that create templates that seem correct, without understanding why and how they work; using libraries and frameworks that are unnecessary just because they are employed by existing code.

The best way to avoid this issue is to make sure you understand what you are doing at every step of software creation. Given the complexity of today’s architecture it is true that complete knowledge is very hard or maybe impossible to achieve. However, good programmers strive to learn at least the essential facts about everything they are doing.

Being proactive in improving the system organization

Another issue that is very important is the way your organize software. Great professionals take care not only of how the current work is performed, but also how past work is organized. They continuously look for methods that can improve the existing code base in a way that will make future decisions easier to make.

There are several approaches that one can take in this direction. One is to use refactoring tools, which are quickly becoming so common on most IDEs. Modern refactoring tools can help turn spaghetti code into reasonably readable code with little work. And using automated testing tools can make the whole process even simpler.

Another suggestion is to allocate time to fix small issues, including things like formatting, proper commenting, and related problems. Although such small things don’t seem to be a high priority issue, they have the potential to turn a code base into a unmanageable mess if left without proper attention. Good programmers know that this kind of effort can reap dividends almost immediately, due to the improved maintainability of the resulting code.

Development Speed

Another overlooked factor in programmer productivity is speed. Usually people equate quick effort with solutions that were not well designed. While it takes time to do the right thing, it is also important to proceed at full speed when a good solution has been decided upon.

There are several factors that affect programming speed. Most of them have to do with badly managed programming environments. For example, some projects require approval even for small changes in a code base. This kind of bureaucracy can yield bad results for the general quality of a software project.

Another issue that may impair development speed is the use of wrong or outdated tools. For example, there is no excuse for failing to use a modern source control application. We currently have so many high quality options such as subversion, git, and mercurial, and they are all free. A good developer should be able to just pick the best tools available and use them as needed.

To progress quickly it is also essential to have fast feedback. This is usually achieved by the use of testing tools, such as unit testing frameworks and libraries. These days, there are unit testing frameworks for every major programming language, so improving in this aspect should be a matter of simply designing tests, and applying them in a way that exercises the functionality you’re implementing or modifying.

Conclusion

Great developers are hard to find, but everyone can learn important lessons from their practices. I have observed throughout my career that good developers are extremely concerned with doing things for the right reasons, by understanding as much as they can about the problem and the language of implementation. They are also very proactive about organizing the system for optimum work performance. Finally, they are able to produce high quality work in a speedy manner, and they use whatever tools are necessary to achieve such results.

Image credit: commons.wikimedia.org

Similar Posts:

• Day 18: Development Speed is Important
• Why great programmers don’t make as much money as soccer stars?
• How to measure productivity for developers?
• Day 29: Fix the Cause, Not the Symptom
• Day 17: Write Clean Code