Mastering Programming - The Three Essential Virtues for Programmers

Written on 05 January 2024 by Ryan Souza -- Also published on:

Summary: Discover how the unusual virtues - Laziness, Impatience and Arrogance - can be the key to excellence in programming. This article explores how these characteristics, far from being flaws, are fundamental to innovation, efficiency and confidence in software development

Three programmers representing the three virtues, laziness, impatience and arrogance.


Are You a Good Programmer?

Do you consider yourself a great programmer? In the universe of programming, self-assessment is a common and often intricate task. When faced with lines of code, complex algorithms, and development challenges, it’s natural to ask ourselves: “Am I on the right track? Am I a good programmer?” These doubts, however, are inherent to all who seek excellence in this area.

To answer these questions and delve deeper into the definition of a successful programmer, we’ll explore the three virtues of a programmer. These virtues, identified by Larry Wall, the creator of the Perl programming language, are not just abstract qualities but practical principles that can lead to significant improvements in our work. In this article, we will discuss each of them and how they combine to create a more efficient and effective programmer.

1. Laziness

lazy programmer

Larry Wall describes laziness as:

“The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write programs that save work for others and document what you wrote so you don’t have to answer so many questions.”

This virtue encourages us to seek efficient and reusable solutions. Laziness is not about avoiding work, but about maximizing productivity by creating tools that automate tasks and improving documentation to facilitate the use and maintenance of software.

For example, a developer who writes a script to automate the deployment of software updates. Instead of manually performing the same steps repeatedly, the script runs the entire process automatically, saving valuable time. This approach not only reduces the workload but also minimizes the margin of error, ensuring greater consistency and reliability in work.

2. Impatience

impatient programmer

Wall describes impatience as:

“The anger you feel when the computer is being slow. It makes you write programs that not only react to your needs but anticipate them.”

Impatience drives us to develop faster and more efficient solutions. It is linked to dissatisfaction with slowness and inefficiency, leading to the optimization of algorithms and the search for quicker responses. This virtue complements laziness, aiming for efficiency not only in automation but also in execution time.

For example, a programmer may develop an automated testing system that not only runs tests more quickly and efficiently but also identifies and focuses on critical areas of the software. Instead of manually testing every aspect after each change, the system performs targeted tests, significantly reducing waiting time and increasing productivity. This reflects the constructive impatience of a developer who wants immediate and accurate results, without compromising quality.

3. Arrogance

arrogant programmer

Wall defines arrogance as:

“The quality that makes you write (and maintain) programs that others won’t want to talk badly about.”

Arrogance, far from being a negative trait, reflects confidence in the quality of one’s own work. It’s the drive to create elegant and effective solutions that withstand scrutiny and earn admiration. This virtue is a sign of maturity and experience, encouraging the continuous pursuit of improvements and innovations in code.

This virtue is intrinsically linked to experience. Over time, we develop “constructive arrogance,” a deep confidence in the value of our work. This is not about a sense of superiority, but rather a recognition of the quality of what we produce, translating into a kind of positive pride in our work. It’s that feeling of satisfaction when you look at a code you wrote and think: “This turned out really good.”

For example, when you face complicated code and manage to simplify it, that is arrogance in the best sense. You recognize the effectiveness of your work and feel justified self-confidence in your abilities.

This feeling even starts with the first steps, like writing your first “Hello World”. It may seem simple, but it’s yours and represents a promising beginning. Even though it’s a small step, you feel great, you feel like the best programmer in the world. You feel arrogant. And that’s good.


Exploring the three virtues of a programmer, we realize that they are more than abstract qualities. They are practical principles for continuous improvement. An exemplary programmer is one who combines laziness (to automate), impatience (to optimize), and arrogance (to perfect), facing challenges with skill and confidence.

A good personal definition of mine is:

“A good programmer is naturally lazy, always looking for ways to automate the repetitive; instinctively impatient, speeding up and improving codes quickly; and sufficiently arrogant to believe that they can always make the code better.”

An important thing to highlight is that these virtues are all developed over time and with experience, you don’t need to worry that you’re not a good programmer for not fitting all of them, that’s normal. The important thing is that you are always seeking to improve and refine, and over time you will develop these virtues and become a better programmer, at least in Larry Wall’s view ;).

I hope you enjoyed the article and that it made you reflect at least a little. If you have any questions or suggestions, leave a comment below or contact me through LinkedIn or the contact tab on my site.

Back to top ⬆️

Found any error? feel free to open a pull request on the fonte deste post no Github.