Every company is a tech company these days. From software startups to hedge funds to
pharmaceutical giants to big media, they’re all increasingly in the business of software. Quality code has become
not only a necessity, but a competitive differentiator.
And as companies compete around software, the people who can make it happen – software engineers – are becoming increasingly important. But how do you spot the ‘cream of the crop’ programmers? In this post we outline the top ten traits of a rockstar developer.
We’ve written here before about the future of software development, in which a few smart developers can leverage libraries
and web services to build large-scale systems of unprecedented complexity. It only takes a couple of smart engineers to create quality software of immense value, and below is a list of the top ten qualities you should look for when hiring a developer:
- Loves To Code
- Gets Things Done
- Continuously Refactors Code
- Uses Design Patterns
- Writes Tests
- Leverages Existing Code
- Focuses on Usability
- Writes Maintainable Code
- Can Code in Any Language
- Knows Basic Computer Science
1. Loves To Code
Programming is a labor of love. Like any occupation, truly great things are achieved only with passion.
It is a common misconception that writing code is mechanical and purely scientific. In truth, the best software
engineers are craftsman, bringing energy, ingenuity, and creativity to every line of code.
Great engineers know when a small piece of code is shaping up perfectly and when the pieces of a large system
start to fit together like a puzzle. Engineers who love to code derive pleasure from building software in much the same way a composer
might feel ecstatic about finishing a symphony. It is that feeling of excitement and accomplishment that makes rockstar engineers love to code.
2. Gets Things Done
There are plenty of technical people out there who talk about software instead writing it.
One of the most important traits of a great software engineer is that they actually code. They actually get things done. Smart people know
that the best way to solve problems is go straight at them. Instead of spending weeks designing complex,
unnecessary infrastructure and libraries, a good engineer should ask: What is the simplest path to solving the problem at hand?
The recent methodologies for building software, called Agile practices, focus on just that.
The idea is to break complex projects into short iterations, each of which focuses on a small set of incremental features.
Because each iteration takes just a few weeks to code, the features are manageable and simple. Teams that follow agile practices never
create infrastructure for its own sake, instead they are focused on addressing a simple set of requirements. The secret is that
when this approach is applied iteratively, a rich, complex piece of software arises naturally.
3. Continuously Refactors Code
Coding is very much like sculpting. Just like an artist is constantly perfecting his masterpiece, an engineer continuously
reshapes his code to meet requirements in the best possible way. The discipline of reshaping code
is known as refactoring and was formally described by Martin Fowler
in his seminal book. The original idea behind refactoring was to improve code without changing what it does, moving pieces of the software around
to ensure that the system is free of rot and also does what it is supposed to do based on current requirements.
Continuous refactoring allows developers to solve another well-known problem – black box legacy code that no one wants to touch.
For decades engineering culture dictated that you should not change the things that work. The issue, though, is that over time you become
a slave to the old code, which grows unstable and incompatible. Refactoring changes that, because instead of the code owning you, you
own the code. Refactoring establishes ongoing dialogue between the engineer and the code and leads to ownership, certainty,
confidence, and stability in the system.
4. Uses Design Patterns
Ever since the so called Gang of Four published their famous Design Patterns book, world-class engineers
have been talking about patterns. Patterns are ubiquitous in our world – both in nature and all human endeavors; software engineering
is no exception. Patterns are recurrent scenarios and mechanisms that live across languages and systems.
A good engineer always recognizes and leverages patterns, but is not driven by them. Instead of trying to fit the system into a set of patterns, the engineer recognizes opportunities in which to apply patterns.
Applying a pattern ensures correctness since it leverages existing know-how: a method for solving a particular
engineering problem that has worked before.
5. Writes Tests
Long gone are the days when engineers thought of testing as beneath them. After all, how
can you be certain that your code is actually working if you never test it? An agile practice called Unit Testing
has recently gained popularity because it focuses on writing tests to mirror the code. As the system grows, the body
of tests grows with it, providing proof that the code actually works. Experienced engineers know and understand the value of tests, because their goal is to create a working system.
Good engineers will always write a test once a bug has been exposed to make sure it does not come back again. But a good engineer also knows
not to waste time writing trivial or redundant tests, instead focusing on testing the essential parts of each component.
6. Leverages Existing Code
Reinventing the wheel has always been one of the biggest problems in the software industry.
From inventing new languages to rewriting libraries, the strange drive to ignore and redo what is already there and already works has
been the cause of a lot of software failures. A rockstar engineer will focus on three essential kinds of reuse. First of all,
the reuse of internal infrastructure, the code that he and his peers have written. Secondly, the use of third party libraries,
for example, in Java, the libraries that are part of JDK or popular libraries provided by the Apache Foundation. And finally, a good engineer would look to leverage web-scale web service, like the ones offered by Amazon. Correct leveraging of existing
infrastructure allows rockstar engineers to focus on what is most essential – the application itself.
7. Focuses on Usability
Good engineers always focus on the users. Whether the user is a business or an individual, whether
the engineer works for a consumer software company or an investment bank, the focus is on working, usable software.
How will users interact with the system? Does it provide a simple, intuitive, and smooth experience? The notion that
because a software engineer is a techie, he or she thus can not relate to how other people interact with the system is deeply flawed.
Good engineers work hard to make the system simple and usable. They think about customers all the time and do not
try to invent convoluted stuff that can only be understood and appreciated by geeks.
8. Writes Maintainable Code
The other secret of good engineers is that it takes the same amount of time to write good code as it does to write bad code.
A disciplined engineer thinks about the maintainability and evolution of the code from its first line. There is never any reason to write ugly code, a method that spawns multiple pages, or code with cryptic variable names. Rockstars write code
which follows naming conventions, code which is compact, simple and not overly clever. Each line of code serves
its purpose and resides in the right place. The bits that are difficult to understand are commented, but otherwise
naming conventions are clear. Expressive names for methods and variables can make the code self-explanatory.
9. Can Code in Any Language
A good engineer might have a favorite programming language but is never religious about it.
There are many great programming languages these days and to say that you only can code in one of them
is to demonstrate a lack of versatility. In Java, C#, or C++ you can write any modern software. You can code the back end of
any web site in PHP, in Perl, or in Ruby. At the end of the day, the language does not matter as much as the libraries
that come with it. A good engineer knows that and is willing and able to learn new languages, new libraries and
new ways of building systems.
10. Knows Basic Computer Science
The last, but certainly not the least trait of a great engineer is a solid foundation.
A good engineer might not have a degree in computer science but must know the basics –
data structures and algorithms. How can you build large scale software without knowing what a hashtable is?
Or the difference between a linked list and an array? These are the basics that everyone should know.
And the algorithms are just as important – from binary search to different sorts to graph traversals,
a rockstar engineer must know and internalize the basics. These foundations are necessary to make the
right design decisions when building any modern piece of software.
There are many traits that distinguish great software engineers. Among the ones we discussed, passion
is certainly very important. Knowing the basics like code reuse, design patterns, fundamental data structures,
and algorithms is necessary, while agile practices of refactoring and unit testing help engineers iteratively evolve
complex software. Most importantly, rockstar engineers believe in simplicity and common sense. It is these
beliefs that help them succeed in building the seemingly impossible, complex software systems that are necessary in today’s world.
Let us know what other traits you think a rockstar software engineer should have, in the comments below.