Just a quick introduction note: this is only one way to think about becoming a better programmer. It’s almost certainly not the only way to think about it and I give you some perspective so that you may find your own way. This is a list of what I believe are 15 common characteristics that all good programmers share and are signals that you`ll be a great addition to any programming team.
1) Knowing one programming language like a boss
Programming languages are just tools for telling computers what to do. It is better to have a strong command of one than a weak command of a bunch. Good programmers have at least one language that they know inside and out and can reach for to easily solve whatever problem is at hand.
2) Attention to detail
In programming, the details matter. Computers are incredibly stupid (more on this in a minute). You can’t be vague; you can’t describe your program 3/4 of the way and then say “Ya know what I mean?” and have the compiler figure out the rest. If the language says you have to declare variables before using them, you have to. If the language says you have to use parentheses here and square brackets there, you have to.
3) Ability to abstract, think on several levels
This is probably the most important skill in programming. One of the most powerful techniques for managing the complexity of a software system (or any complex system) is to compartmentalize it into little „black box“ processes which perform useful tasks but which hide some details so you don’t have to think about them all the time. Compartmentalization, or abstraction, is a vital skill in programming, or in managing any complex system. We can only keep a small number of things in our head at one time. A large program might have 100,000 or 1,000,000 or 10,000,000 lines of code. If it were necessary to understand all of the lines together and at once to understand the program, the program would be impossible to write or understand. Only if it is possible to think about small pieces in isolation will it ever be possible to work with a large program.
4) Epic memory
There are a lot of things to remember while programming: the syntax of the language, the set of prewritten functions that are available for you to call and what parameters they take, what variables and functions you’ve defined in your program and how you’re using them, techniques you’ve used or seen in the past which you can apply to new problems, bugs you’ve had in the past which you can either try to avoid or at least recognize by their symptoms. The more of these details you can keep in your head at one time (as opposed to looking them up all the time), the more successful you’ll be at programming.
5) Being a systematic debugger
Being a systematic debugger means that you have a good mental model of your code and that when you run into a bug—that is, when your program doesn’t work as expected—you generate hypotheses about what’s wrong, instead of blindly changing things until your program works.
6) Having a good mental model of your programming environment
Most programs interact with the outside world, so having an understanding of your environment is important. This includes the I/O and concurrency primitives that your language provides, the way your language finds, loads, compiles, and runs code, the way that your program gets information from the outside world (e.g., environmental variables and command line arguments), and the way your OS handles file access, device access, search paths, etc.
7) Having a good mental model of the hardware you use
Knowing how your hardware works makes it easier to write efficient programs. Even if you are writing programs in a higher level language, understanding things like the call stack, the MMU, the cost of context switching, the memory hierarchy, and the characteristics of the network you are connected to will inform your programming decisions.
8) Being comfortable with algorithmic thinking
A lot of people confuse algorithmic thinking with knowing a bunch of particular algorithms like quicksort or binary search. An algorithm is a set of steps describing a calculation. Much of programming is simply describing algorithms to a computer. Being comfortable with algorithmic thinking means having good intuition for how to store and manipulate your data, being able to think both iteratively and recursively, and being able to reason about the performance characteristics of the code you write.
9) Being comfortable with mathematical thinking
Programming is not as math-heavy as many non-programmers think, but as you start tackling tougher problems, you’ll find that being comfortable with math comes in handy. Many interesting areas of programming like computer graphics, signal processing, and cryptography require a deep understanding of math. Even just measuring the performance of your code can require some statistical thinking.
10) Being able to write a program from scratch
It is hard to imagine a good programmer who cannot write a program from scratch.
11) Being able to work on a small piece of a large program
Most of the time you’re not writing a program from scratch. Instead, you’re working with other programmers on a large project.
12) Knowing how to structure your code
Well-structured code allows you to easily navigate up and down through layers of abstraction. In a well-structured program, you can ignore implementation details when they don’t matter and modify the implementation without having to make changes in all the places where the code is used.
13) Having a large code radius
Your code radius is the size of the largest program you’re comfortable writing from scratch. Increasing your code radius takes practice. The structural tools that work well for a 500 line program are not necessarily the same as the ones that work for a 5,000 line program or a 50,000 line program.
14) Being a type master
Often it’s faster to try out a few different solutions and decide which is the most elegant than to figure out the correct one just by thinking about it. If you find “quickly” to be too subjective, consider the inverse: It’s hard to imagine a good programmer who is slow.
15) Being productive with your tools
Good programmers use their tools effectively. This doesn’t mean you have to use all the tools available in order to be a good programmer—not everyone likes IDEs and plenty of good programmers prefer printf to a debugger—just that good programmers are productive with the tools they choose to use.
Of course there’s some overlap between the ones that are listed. However, these are the qualities I deliberately work to build over the years and consider