Top 10 Traits of a Rockstar Software Engineer
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.
Conclusion
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.
Comments
Subscribe to comments for this post OR Subscribe to comments for all ReadWriteWeb posts
I think this is a good list that can apply (with a little adaptation) to any profession.
Excellent observation, but what about frameworks? Presumably a rock star developer would probably build his own MVC framework that adoring fans would contribute to and help develop.
If everyone's a tech company it follows Adam's Law (like Moore's Law but wholly fabricated) that everyone needs Rockstar Engineers and therefore everyone needs to find Rockstar Engineers, which is where the Jerry Maguire's (complete with cute kid and doey eyed love interest) come in, placing the greatest talent in the greatest organisations and start-ups.
Great, you made me a Rockstar Software Engineer.
Cool! The Ten Commandments of a Software Engineer
Great content...!
I suggest abaut that before, now you have excellent observation, and i aggree with you...
With number 10 I think you also need to make mention of things like networks, protocols, state/session servers, and technology in general. More often than not an excellent developer can hold a conversation with the infrastructure guys about servers and switches, while conversing with the designers about UI and usability, all while helping propel the agile framework envisioned by management to new levels of effeciency.
To me, a good developer is a jack of all trades, AND master of their own.
I've posted a few thoughts on my web site, as there are a few things I'd want to add/change. I considered it more as a task of hiring to help me decide what I might change.
http://www.wiredprairie.us/blog/index.php/archives/80
This article list important traits to be A software developer, but I believe that we should add "good communication skills" to the list.
I beheld some developers with great experience and expertise. However, due to lack of communication skills, their ideas are not recognized and not given important tasks. Anyway, software industry needs team work, communication is basics of team!
Damn. 8 out of 10. Is that a B-?
I echo the sentiment about communication skills and would suggest, simply, "writing" as a key element on the list. If the list were only about making a rock star Software Engineer and not about hiring good rock star Software Engineers for your company, I'd say it's out of scope.
If the intended audience for this is non-developers looking to identify Rockstar engineers, I think you have to be careful about how you present "Gets Things Done". In practice, your #2 and #8 are often in opposition.
Solid list, I would add, "takes pride in his/her work".
Great article to sell books! Very good!
Its a good list but I would remove design patterns from it.
There is one thing, they need to be good at programming. A bad programmer might refactor their code a million times but a good coder might not need to refactor.
I have worked with plenty of coders who would be rockstars by your list but simply are not because they didn't have number 1.
Passion for coding is what makes me code, I am like a mad inventor but its programs and web apps I create :P
If you just read that and at the end you said "Wow, RWW just did an article on me", then I want to talk with you.
This article was wonderful! Also Alex, Thank you for saying "Ruby" and not "Rails"... that makes you awesome. ;)
I think the sad truth is that most jobs dont allow you to be a Rock Star programmer or develop into being a rock star programmer
Most programming jobs might pay well, but are spent doing maintenance or patching of code bases that have been worked on by multiple programmers of varying ability.
This was called "Patching the Turd" at one of my old jobs.
The code quickly becomes a patch work of convoluted logic and the desire for elegance gives way to the time constraints of life. Apathy sets in and a downward spiral of attitude ensues.
The real question is, how to turn that around. If I find myself in one of these "patching the turd" jobs, can I make the job evolve beyond this. This could be a lot of work given personal and team inertia, but i have faith that its possible. Ahh to dream.
-
Hey Alex,
Given that AdaptiveBlue's been hiring, I'm sure this stuff's been on your mind. You should include a tinyurl to this article with your hiring tweets ;-).
I'd add "creativity" to this list, but I think it's partially implied by your references to usability and refactoring. I think the most brilliant coders are those that come up with elegant and simple to complex problems - that's definitely worth calling out explicitly as a trait of a great coder, no? When someone can find a 10 line solution to a problem that most coders would solve in 50 lines...that's great code.
Great article.
This list of traits hardly makes for a 'rock star' engineer. This list is simply a manager's wet dream of an obedient drone. Rock star engineers, like real rock stars, could give a sh*t about the rules, and about such high minded self styled fashions on programming.
Sorry to tell you but rock star engineers have these attributes:
1) Love to program.
2) Are naturals and can't even imagine why somebody would write a book called "Software Maintenance" or "Usability". Anybody reading such a book probably has no business programming in the first place.
3) Creative. They have ideas on everything, and they expect anybody with an idea to prove it. Afterall this is engineering, not fashion design.
4) Willing to debate. Willing to respect ideas over people. Willing to disect an architecture and rip it apart if it sucks, and expects such to not be taken personally.
Sorry to tell you, you're list has nothing to do with being a rock star engineer -- it only says what you need to do to kiss some manager's ass.
Am I the only one who thinks the phrase "rockstar engineer" in this context is an oxymoron? Engineering is in principle directly opposed to the entire "rockstar" mentality.
And there are issues with that list even leaving aside the underlying oxymoron. I can understand the urge to avoid paralysis by analysis, for example, but saying that a good engineer will just run straight at a problem without working out a design is simply saying that you don't understand what an engineer actually is or does.
Also, you're missing the number one thing that defines a good engineer - he or she writes documentation. Lots of it. If you have a good engineer doing something, you know that if they get hit by a bus on the way into work tomorrow morning, then their colleagues will be able to see what they were doing, where they were going with it, and can step right in and take up where they left off. Forget this "loves to code" malarky, every teenager who ever took a CS course loved to code; the problem is that teaching them not to code is how you make decent engineers.
Engineers. We may not be sexy rockstar gods amongst men, but we are the ones you want writing the software that controls your oncology radiation treatment machines or your ABS brake systems or your banking software.
Code a backend in Perl PHP or anything? Yea right, get good at programming in one of the languages is enough of an undertaking let alone trying to learn how to code in 3 or 4 languages like a true code ninja.
For me, I don't think it is really about popular techniques or technologies -- those always change with time -- instead the desirable qualities would have to be:
a) Loves to 'build' things.
b) Loves to communicate their ideas.
c) Likes to analyze and understand everything.
d) Works independently (but not necessarily by themselves).
e) Wants to do it right (but can be flexible).
f) Thinks abstractly.
g) Needs to finish what they started.
Paul.
http://theprogrammersparadox.blogspot.com
You know, if you modify these traits, they're really traints of successful people in general.
They focus on productivity and keep tinkering till they get things right.
Raza Imam
http://SoftwareSweatshop.com
A good list with a bad title. Rockstars? We don't need no stinkin' Rockstars! @Francis Tarwater explains why:
"[Rockstars] Are naturals and can't even imagine why somebody would write a book called "Software Maintenance" or "Usability". Anybody reading such a book probably has no business programming in the first place."
I had the unfortunate experience of working with an ego-driven 'Rockstar' programmer. He was a tool, plain and simple. Yeah, he could write good code but his real expertise was being a full-time a**hole. He left (thankfully) after just one year with us. In my opinion, our team's overall code productivity improved AFTER he left.
Greg
A lot of these are things that make software valuables cool or desirable to *other software developers* but not necessarily to businesses (or software development organizations).
Being able to code in any language is a big one -- I'd rather hire someone who has a lot of depth in one or two languages than a jack-of-all-trades who can go on at length about how the project should really be redone in Lisp.
Hello,
I agree with 9 of these 10. I think _knowing_ design patterns is important (for communication with other engineers) but using them is not very important and sometimes can be harmful. The Singleton pattern has done more harm than good: "Finally, I have a way to use global variables in an object oriented language!" When you interview an engineer and they tell you they know the Singleton pattern, make sure you ask them the negatives of using it.
You might want to add a point #11: They stay current (eg: they read blogs, etc.)
I know a couple of programmers who have these qualities but cant get along with people. Are impatient, intolerant, arrogant and dont know how to compromise.
It doesnt matter if you know every design pattern in the book, a code ninja in 5 languages and can code like the wind, if you are a jerk with bad people skills, you are worthless.
If you cant be depended upon by your employer or your teammates, you are just dead weight.
You left that one off the list
@Jo: I would agree. I think these are some great points that can be adequately applied to nearly any profession. I'm glad it ended on a note about "passion" as it can really drive much of the list.
Good post.
Excellent. Deep observation put in right words. Also all the characteristics are supported with relevant literature. Fantastic research. Being a "long time" software engineer, I have been thinking and practicing most of these attributes. But you have put it so nicely and have definitely added new characteristics like Focuses on Usability and Leverages Existing Code. In today's Web 2.0 world of distributed computing consisting of decoupled services frontended with thin but rich interface components, definitely these traits of usability and re-use ability are great. Also I would add two properties -
knows the accessibility and
practices & preaches security.
Thanks,
How can anyone have all of these qualities while working for a startup???
As a rockstar (I prefer "Pirate", actually) techie it's interesting to read this. As a blogger, I'm a bit jaded with these endless top ten lists ...
Reminds me a little of this: http://eurojism.com/2008/top-ten-how-to-write-a-top-ten-lists-list/
A decent list, but I'd add a couple.
First, as Mark Dennehy pointed out, documentation is a key. Maybe that's implied by 'maintainable code,' but in my experience, many 'rockstars' are more interested in moving on to the next piece of coding rather than making sure that what they've just produced is well documented.
More serious is the lack of attention to security (as pointed out by Phoenix2Life). That brilliant, usable, but unsecure application the rockstar produced is a million times worse than a less elegant, but secure, application.
Failure to code for security, even in low risk applications, could expose a company to big losses, plus lots of negative PR. We should never forget that most developers of malware would score a perfect 10 on this list: they love coding, excel in each of the areas, and truly are programming superstars. It's just that they're motivated by malice and/or profit.
Someone who is not writing secure code needs to get a grade of zero, even if they are aces at the other areas.
I have to vehemently disagree on the "program in any language." Any programmer can switch to the language du jour, but if you are going to use the rockstar analogy, I don't think I've ever seen The Rolling Stones switching to bluegrass, or Bruce Springsteen giving techno a whirl. You can't write amazing code if you are constantly hopping from one language to the next, because you never truly master anything.
No where did you mention secure coding techniques in this list. With all the problems the software industry is having in our times, I believe secure software coding is of prominent importance to be a "rockstar Software Engineer"
i think author is a business man who is in day dreaming.
there is no ROCKSTAR programmer.
great article man...keep it up...1 of best article i ever read in web abt Sw Egr
Francis Tarwater: #2 is an utterly absurd comment.
Other attributes of Rockstar Programmers:
11. Will refuse to go into a sinkhole. You want *what* coded in PHP? You can't pay me enough to do that.
12. Knows how to handle a project where iterations can't be small enough to fit Agile Methods.
13. Recognizes every one of those books as kiddie stuff, the stuff you pick up, digest, and move on from
Some points are just naive -
1. Focuses on usability - "They think about customers all the time and do not try to invent convoluted stuff that can only be understood and appreciated by geeks."
Yeah right. Linux, Emacs, Python, PHP, are very easily accessible to "customers". Truth is geeks create stuff for geeks all the time.
2. Can program in any language - "At the end of the day, the language does not matter as much as the libraries that come with it."
Says who? Think about it this way - why would Sun bother with Java? Why did C++ come up after C? Why do people bother with Perl/Python/PHP/Erlang/Ruby and the whole lot? I'd expect a rock star programmer to be intimate with the limits of the tool he uses.
If this list is ordered in decreasing priority, then number 5 should be number 1.
You assume that a "rockstar" is using OOP, but it might not be the case.