When I first founded Devskiller seven years ago, my team’s goal was to help companies find great developers. Since then, I had the opportunity to work with Fortune 500 companies, as well as smaller ones globally. I spoke to technical people like CTOs, IT managers, team leaders, team members, and HR representatives. All these people were responsible for finding and hiring top tech talent. They were all facing a universal problem: how to hire great programmers. They were also chasing after the same developer strengths.
It all starts with identifying a good developer when you see one. This brings us to the critical question: What are the key developer strengths? There has been much discussion on the subject. I recommend you to read this Quora thread. It’s packed full of insights from some serious industry masterminds.
Based on our own experience, hundreds of talks and tens of pivots along our way, we should chip into the discussion. We’ve come up with a list of key developer strengths.
Software Developer Strengths And Weaknesses
Developer strength #1: Curiosity
“Curiosity is, in great and generous minds, the first passion and the last”, said Samuel Johnson. That is also true for programmers (and their great and generous minds). Let’s look for a more contemporary reference which develops Johnson’s point of view. Dan Pupius says that “curiosity is important throughout the life of an engineer”. It pushes you to learn new languages, experiment, and look for new solutions. That’s exactly what you want in an engineer. It also drives you to investigate the architectural choices of others, as well as question assumptions. Pupius claims that a lot of qualities usually associated with great engineering “stem from a rich sense of curiosity”.
John Allspaw, Chief Technology Officer at Etsy makes a good point in his post “On being a senior engineer”. He says that top-notch developers are inquisitive. They tend to ask themselves and their peers questions while they work.
- “What could I be missing?”
- “How will this not work?”
- “Will you please shoot as many holes as possible into my thinking on this?”
- “Even if it’s technically sound, is it understandable enough for the rest of the organization to operate, troubleshoot, and extend it?”
I couldn’t agree more. At first glance, it may seem that these questions are asked by a serial pessimist. That’s not actually the case. They are asked by an inquisitive individual with a passion to write elegant and self-consistent systems. Don’t mistake thoroughness for a “we’re all doomed” attitude.
Source: Campaign Brief
Developer strength #2: Technical skills
Rahul Varshneya says that “fine art and programming are similar in that great technical skills don’t make for a great artist or programmer”. Greatness doesn’t come from technical skills alone. However, you can’t expect exceptional results from people who don’t have the right skills for the job. You should think of skills as one of the elements of the puzzle which doesn’t do much in isolation. It can do wonders when accompanied by other developer strengths, though. Luckily, the presence of key developer strengths is super easy to verify with coding tests.
Remember that knowledge of technical minutia is important. But.. If you come across a promising candidate who exhibits all the developer strengths but is still learning, consider hiring them for a junior position. You’ll be surprised how far they can go.
Speed & productivity
A Sackman, Erikson, and Grant study discovered a 10-fold difference in productivity between programmers. The research is not without flaws, though. It doesn’t “control for differences in individual capabilities”. It also combines results from users working in low-level and high-level programming languages.
Image source: Construx.com
Steve McConnell argues that research available on the subject on the subject is not free from limitations. It’s not conclusive but is definitely suggestive. And that’s exactly how you should look at it.
Salaries don’t often reflect this order-of-magnitude differences between developers. Is there a way to measure developer productivity and should you even attempt to do that?
Sadly, measuring developer productivity has eluded us so far. We know that lines of code (SLOC, or Source Lines of Code) are not a measure which is synonymous to the value of the developer. As a matter of fact, less is more in the world of code (as long as it’s self-consistent and fully functional). According to Phil Haack, providing concise, maintainable, and understandable code is superior to punching volumes of code fast. Why? Think about what happens when you want to add new features or updates. It usually takes hours to decipher brittle code and patch it up. This typically comes with a steep price tag, too. Let me put it this way: what you save on a fast but uncareful developer, you end up spending on the QA team.
If you’re interested in productivity in IT, read “The myth of Developer Productivity” by Dustin Barnes.
Paul Haack says that best developers know when to code and when not to. He argues that reinventing the wheel puts unnecessary strain on the project. Instead, use existing libraries to save time. Sounds logical, doesn’t it? Doing everything from scratch is still one of the biggest time thieves, though.
Awareness also manifests itself through the risk tolerance threshold. This is crucial because often you need to refactor live systems. That’s where things can go wrong. Being able to realistically assess the risk without the ego getting in the way is definitely one of the key developer strengths.
Developer strength #3: Intuition
As Varshneya argues, while some devs struggle to come up with a solution, it comes naturally to others. It’s “as if an epiphany hits them at the moment they sit to create programs or solve a problem.”
Great software developers understand algorithms and architectures intuitively. This ability allows them to learn quickly, which brings us to the next quality.
Developer strength #4: Love of learning
According to John Krystynak, “genuine commitment to continuous learning” is one of the key developer strengths. “You have to love the fundamental practice of going from not knowing to knowing, every single day” otherwise you won’t be good at it.
This holds especially true in the world of IT. While it’s useful to have your way of doing things, it’s essential you venture out of what you know. Find faster ways of getting things done. One of the ways to do that is by noticing patterns and drawing conclusions.
There are a great many ways to develop when you’re a developer (pun intended).
- Attending industry events, such as conferences and hackathons. Thomas So of AppLovin calls them job readiness training.
- Finding a mentor.
- Working on a side project.
- Asking for peer feedback.
Developer strength #5: Adaptability
The IT world is changing rapidly and as a developer, you need to stay adaptable. It’s a safe bet to hire people who are always on the lookout for new tools and ways of doing things. They often follow industry news and simply care about the craft.
The more you know, also outside of your preferred technology, the more of an asset you are to both your team and the entire organization. As Marius Mazilu claims, “diversity of technology has become so widespread that being a specialist in one particular technology is not necessarily a guaranteed success track.” Mazilu believes being more versatile is critical. That’s because mature technologies are more stable and cannot keep up. This means your skill set becomes outdated fast. On the other hand, novel frameworks typically require a massive time investment because they are unstable. As he argues, “you may be shocked to discover one day that they do not love you back”.
Mazilu has 7 simple rules you should follow to keep up with the technology.
- Trust gut feeling.
- Always go back to the basics.
- Watch out for the silver bullets. These include well-marketed technologies which are widely used because despite not fitting the project.
- Learn to debug.
- Learn to script.
- Don’t get obsessed with what your code looks like.
- Go with the crowd.
Developer strength #6: A positive attitude
A positive attitude is one of the key qualities of a great software developer. Programmers solve problems day in and day out, but that doesn’t mean they should dwell on them. A “getting sh*t done” attitude is much needed, partially because tasks and tickets tend to pile up. It’s important to decide when it’s time to push a good enough solution out the door and move on to the next thing on the list. The caveat here would be to not flood your developers with more tasks than they can handle and keep things realistic.
Damien Filiatrault puts “positive attitude” on the top of his list of essential qualities possessed by good developers. He says you can test the waters and ask a few seemingly simple “small talk” type questions to see if the responses focus on the positives or negatives. These questions include:
- “Do you consider yourself lucky? (cocky or humble).
- How was your commute to the interview? (complainer or no worries)”.
Developer strength #7: Embracing mentorship
John Krystynak says that “great programmers don’t become great in isolation.“ I salute him for saying that. One of the reasons why the mentorship model works so well in IT is because some developers learn most efficiently by apprenticeship. It simply takes less time to figure things out if you can watch a more seasoned colleague at work. Another reason why top techies advocate mentorship is because it requires you to expose both your strengths and weaknesses. This teaches you volumes about keeping your ego in check.
One of the best things you can do as an employer to foster that kind of attitude in your organization is to pair seasoned programmers with freshmen. You might think that this will most likely put a strain on the mentor who is already most likely beyond busy. Bear in mind that both the mentee and the mentor learn from that arrangement. If you can’t explain something to your mentee, it means you don’t really understand it well enough. Or can’t communicate it well enough. This means there are learning opportunities for both parties in this relationship.
Developer strength #8: Communication skills
Damien Filiatrault states that “good communication skills directly correlate with good development skills.” Here’s why.
- You need to know what questions to ask when you don’t understand or need to double-check.
- It’s possible to figure things out based on communication with colleagues. That means you don’t need to rely on written specifications.
- Concepts are understood and communicated quickly in a team of successful developers.
- Great programmers can communicate cogently with both technical and non-technical staff.
Developer strengths: conclusion
It’s becoming more difficult to find excellent programmers. The tech industry is going through a talent scarcity situation. This means we need more developers that we can possibly find, and companies are going out of their ways to attract top tech talent.
Identifying developers strengths crucial to growing your business is a must. Be quick though! When you come across a promising candidate, act fast. In the scarcity situation, recruiters fight over the same candidates.
What are the key developer strengths? Looking forward to hearing your thoughts!
Editor’s note: This post was originally published in April 2017 and has been updated for accuracy and comprehensiveness.