The three key virtues of a programmer are laziness, impatience, and hubris. These may sound like vices rather than virtues, akin to sloth, wrath, and pride. Would those pillars of Catholic virtue -- diligence, patience, and humility -- not be better choices? Such is the apparent perversity of the person who loves programming in the eyes of the common folk, however, that notions of virtue and vice are turned on their collective head.
Larry Wall is at least one of the originators of the idea that laziness, impatience, and hubris are the chief virtues of a programmer. In the "bible" of Perl programmers, Programming Perl (also known as the "Camel book"), these virtues are described thusly:
Laziness - The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write labor-saving programs that other people will find useful, and document what you wrote so you don't have to answer so many questions about it. Hence, the first great virtue of a programmer. Also hence, this book. See also impatience and hubris.
Impatience - The anger you feel when the computer is being lazy. This makes you write programs that don't just react to your needs, but actually anticipate them. Or at least pretend to. Hence, the second great virtue of a programmer. See also laziness and hubris.
Hubris - Excessive pride, the sort of thing Zeus zaps you for. Also the quality that makes you write (and maintain) programs that other people won't want to say bad things about. Hence, the third great virtue of a programmer. See also laziness and impatience.
Some time later, Larry Wall described his motivation for creating the Perl programming language in an interview with Marjorie Richardson, casting it in terms of these three virtues:
I could have solved my problem with awk and shell eventually, but I possess a fortuitous surplus of the three chief virtues of a programmer: Laziness, Impatience and Hubris. I was too lazy to do it in awk because it would have been hard to get awk to jump through the hoops I was wanting it to jump through. I was too impatient to wait for awk to finish because it was so slow. And finally, I had the hubris to think I could do better.
Software advocates like Eric Raymond and entrepreneurial programmer luminaries like Paul Graham assign the label "hacker" to the most creative and talented of computer programmers. It is this category of programmer that is most easily defined by laziness, impatience, and hubris, as the terms are described by Larry Wall and Programming Perl co-authors Randal L. Schwartz and Tom Christiansen. This conception of the motivations of software development stands in contrast to the typical motivations of what some call "daycoders": people who write code purely for the paycheck, who are not interested in improving the state of the art of computer software or the challenge of creation per se, but simply do so toward some other, fully pragmatic end, without any personal concern for the process itself.
A tale of three virtues affected me recently. Over the years, dealing with content management systems designed primarily for Weblog use, I have quickly become dissatisfied with many common characteristics of this category of software application. They tend to:
. . . be big, bloated, featuritis-afflicted, spaghetti-coded monstrosities that have essentially zero relationship to the concept of elegant design.
. . . break things during upgrades.
. . . be difficult to configure to meet my needs.
. . . load slowly.
. . . impose unnecessarily large resource demands on the Web server, such as the typical requirement for dozens of database hits for every page load in WordPress.
. . . behave as though they know what the user wants better than the user knows, thus making it difficult to do what I actually want to do.
. . . be highly prone to security vulnerabilities.
. . . be written in PHP, with is really a miserable language, or rely on frameworks that are largely unnecessary for my simple CMS needs.
I have become increasingly impatient with all these shortcomings of the common CMS over time. Despite diligently searching for options that would satisfy my needs, and being willing to bend on some of those points of dissatisfaction with common CMSes suitable for Weblog use if it would mean solving the problem of other, more annoying points of dissatisfaction, I never actually found anything to suit my preferences.
This made impatience the first of the three virtues of a programmer to influence me with regard to CMSes.
My hubris led me to consider the possibility of writing my own CMS. I gradually came to the conclusion that, if I want something done right in terms of developing a decent CMS for a Weblog, I would have to do it myself -- where "right" means "right for me". Given a little time and effort, I decided that I should be able to do so without too much trouble. All it would take was a little diligence.
This made hubris the second of the three virtues of a programmer to influence mee with regard to CMSes.
Did you notice the use of the term "diligence" above? My laziness served at first as a discouragement from writing my own CMS. That is, in fact, a good thing most of the time -- because when something else is serving your needs enough that your laziness does not overcome it, there is always the possibility that you should not bother putting in the effort. In this case, however, it was misapplied laziness. If ever there was a piece of software I should have written but did not do so, it was a CMS that satisfied my relatively simple needs much better than garbage heaps like WordPress.
For several years, I avoided writing my own CMS, out of laziness. Ultimately, only laziness itself would prove a powerful enough motivator to overcome that laziness. Fight fire with fire, as the saying goes.
I believe it was 27 September 2010 that I started formatting some IRC logs for display on the Web. I was hacking away at the logs in Vim, using its powerful editing capabilities to ease the process of eliminating extraneous text and adding markup, when I decided that I was doing far too much work. At least part of this should be handled automatically, especially given the way the BlueCloth library (a Markdown implementation) for the Ruby language mostly Does The Right Thing when handed plain text of the sort found in IRC logs (with minor edits like adding double-spacing).
In less than twenty minutes -- most of which time was spent deciding what I wanted to do and how I wanted to do it -- I wrote a relatively simple script that:
. . . works by way of eruby.
. . . a page formatted for the Web, using CSS for easily adjusted presentation.
. . . produces a menu of available logs by scanning for files whose names fit a particular pattern.
. . . generates pages with well-formatted content from those files, using Markdown syntax.
. . . does not have any of the common shortcomings of CMSes I described above.
When I was done, I suddenly realized I had created the basis for that CMS I had been putting off for so many years. My laziness-fueled procrastination was finally over come, not by willpower or determination, but by greater laziness.
I came up with the term "lump" by running a simple script that randomly selects words from a computer's spelling dictionary. The first two words it selected were "interinsurer" and "juniorship", but I decided neither of them was really appropriate. Lump, then, became the name of my incredibly simple content management system.
Perhaps the first two letters stand for Lightweight and Unpretentious; thanks, n8, for making that observation. Maybe someday I will come up with a complete backronym for LUMP. Lightweight Unpretentious Murphy Protection -- because if it's simple enough, not much can go wrong -- might work; thanks for the suggestion, Sterling. In the meantime, though, I am satisfied with the name Lump.