What distinguishes great software engineers?
Published: 2020-12-18 09:52:45

---
title: What distinguishes great software engineers?
published: true
date: 2020-12-18 00:00:00 UTC
tags: 
canonical_url: https://hugomartins.io/essays/2020/12/what-distinguishes-great-software-engineers/
---

Great software engineers are difficult to characterize. All of us want to - most likely - be one, few of us get to a stage where our peers recognize us as such. In order to be able to _be_ a great software engineer, we need to understand _what is_ a great software engineer. In order to understand what great software engineers are, we need to understand what characterizes them. That’s precisely what Li et al. explore in _“What Distinguishes Great Software Engineers?”_.

This paper explores the characteristics that define great software engineers. To explore such subjective, unclear concepts, Li et al. have conducted a quantitative study with software engineers (“developers” in the paper’s study nomenclature) alongside a qualitative study to clarify and interpret results and explore ambiguous, or contradictory information. In total, this survey reached 1926 engineers, as part of the quantitative study, and conducted 77 email interviews, as part of the qualitative study. Both studies were conducted with “expert engineers”, stratified into “experienced engineers” and “very experienced engineers”. (Li et al 2020:335)

There are clear limitations on this study, in particular because the entire study was conducted at Microsoft, with only Microsoft engineers. Nonetheless, it provides solid insights, forming a solid base of study for future research.

## Most Relevant Attributes

> ”(…), attributes associated with decision-making were rated the highest (median ranking of 17 and 33.3% in the bottom half), followed closely by attributes of the software product (median ranking of 17.5 and 33.3% in the bottom half).”

Through the survey and the follow up email interviews, Li et al. found that, at least in the particular context of Microsoft, 5 attributes are essential to becoming a great software engineers:

- _“Pays attention to coding details, such as error handling, memory, performance, style”_;
- _“Mentally capable of handling complexity; can comprehend multiple interacting software components”_;
- _“Continuously improving: improves themselves, their product, or their surroundings”_;
- _“Honest: provide credible information and feedback that others can act on”_;
- _“Open-minded: lets new information change their thinking”_.

## Least Relevant Attributes

> “Overall, attributes associated with interacting with teammates were rated the lowest (high agreement on low importance), with a median ranking of 40 (lowest among the 4 groups) and 77.8% of attributes in the bottom half of rankings; they are followed by personality attributes (median ranking of 24 and 44.4% in the bottom half).” (Li et al 2020:335)

Microsoft engineers have signaled that the least relevant attributes seem to be:

- _“Knowledgeable about people and the organization: aware of others’ responsibilities and knowledge”_;
- _“Challenges others to improve: encourages expanding capabilities and goals”_;
- _“Personable: establishes trusting, positive social relationships”_;
- _“Hardworking: is willing to work more than 8 hour days to deliver”_;
- _“Trades favors: builds personal equity with others allowing them to call upon others later”_.

## What Makes an Engineer a Great Engineer?

> “Our results suggest that, at least at Microsoft, the most important aspect of being a great engineer is being a competent coder.” (Li et al 2020:341)

First and foremost, being a competent coder seems to be the most relevant high-level characteristic of a great software engineer. Mastery of code, given that code is the ultimate artifact shipped as a product, is ultimately the most important predictor of being a great software engineer. It is by no means the _only_ important characteristic, but it is _clearly_ important. These findings align with findings from previous studies, as Li et al suggest in the paper.

> “Great engineers distinguish themselves from others by considering the context of their software product, maximizing the value of their current actions, adjusted for probable future value and costs.” (Li et al 2020:342)

Following being a competent coder, it seems to be a necessity being able to achieve an equilibrium between crafting great code _now_ and crafting great code that is future-proof. This topic isn’t consensual, with some subjects considering that _antecipation_ and _long-term thinking_ are more important than _“now”_. For the most part, though, subjects believe that “predicting the future was futile”, with those attributes being almost detrimental. Essentially, this is interpreted as: writing code that saves on future repair and maintenance costs is important _but_ being able to weight savings against “possible forfeiting of revenue due to inaction” is even better. A great engineer is able to balance the delicate equilibrium between writing the best possible code, with existing deadlines and constraints.

> “Great engineers differentiated themselves from others by going through the right processes for making informed decisions.” (Li et al 2020:343)

As expected, being a great software engineer also depends on being great at making decisions. As a software engineers, we make decisions on a daily basis and all decisions need to be informed. Knowing how to make the most appropriate decisions, with the information available, becomes a key characteristic of a great software engineer. Furthermore, modern organizations leveraging DevOps practices tend to rely on individual contributions, judgment and decision-making to remove bureaucracy, improve flow and encourage innovation on blame-free cultures, exacerbating the need for great engineers that use the appropriate processes for making informed decisions.

> “Great engineers distinguished themselves by making others’ jobs easier, helping them to make their decisions more efficiently (or, at minimum, they did not make them worse).” (Li et al 2020:344)

Great engineers are enablers of others, in their respective teams as well as inside their organizations as a whole.

> “Our findings suggest that because the field of software engineering is changing constantly, those who do not grow and evolve risk becoming obsolete (see Section 4.1.3). Consequently, we believe it is not a specific set of knowledge but rather the desire, ability, and capacity to learn that distinguishes great engineers.” (Li et al 2020:345)

Being a continuous learner, with a high-degree of curiosity and ability to learn is also a key attribute of great software engineers. Technology evolves at a fast pace and it takes commitment, discipline and knowing how to learn, in order to be able to continuously learn.

## Conclusions

Studies such as these have implications for researchers, software engineers, technological leaders and educators. Knowing what distinguishes great software engineers doesn’t necessarily generate a great software engineer but it is a great step towards understanding how we can evolve, transform and grow as software engineers. It also allows us to understand how we can help fellow software engineers grow and become greater themselves.

Finally, the last sentence of this paper, which I found immensely inspiring:

> “After all, great software cannot exist without great software engineers — a butt in a seat somewhere — to type “Commit.”” (Li et al 2020:349)

Li, Paul Luo, Amy J. Ko, and Andrew Begel. “What Distinguishes Great Software Engineers?” _Empirical Software Engineering_ 25, no. 1 (January 2020): 322–52. [https://doi.org/10.1007/s10664-019-09773-y](https://doi.org/10.1007/s10664-019-09773-y).

## Further Reading

M. P. Robillard, W. Coelho, and G. C. Murphy, “How effective developers investigate source code: an exploratory study,” _IIEEE Trans. Software Eng._, vol. 30, no. 12, pp. 889–903, Dec. 2004, doi: 10.1109/TSE.2004.101.

S. Baltes and S. Diehl, “Towards a theory of software development expertise,” in _Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering - ESEC/FSE 2018_, Lake Buena Vista, FL, USA, 2018, pp. 187–200, doi: 10.<sup>1145</sup>⁄<sub>3236024</sub>.3236061.