Three virtues of a great programmer
thethreevirtues.com
thethreevirtues.com
Perl was a gazillion times more powerful than Bourne and C-shell (including all the Unix shell tools like `awk`), much more rapid than working in C, incredibly terse (perhaps too much so), and also portable (to all the oddball systems you might have).
And the purposes to which Perl was put were often to automate things you'd been doing manually, or that you couldn't do without Perl.
You'd be quietly doing big things with Perl. And there were sayings about how you'd automated your job, and presumably spent your time writing more Perl scripts and reading Usenet. And the occasional joke of replacing someone else with a one-line Perl script.
Also, note that not only was this before the dotcom boom (when programmers suddenly were no longer nerds but getting rich and fashionable), but also-- a lot of the programmers using Perl professionally weren't even professional programmers, but actually sysadmins or random university researchers, who happened to have the power of Perl. The majority of professional programmers on Unix actually didn't know Perl.
So, Perl people speaking of Perl people in terms of vices could be seen as a self-deprecating, joking spin conscious of the unusual power that they wielded.
Visual Basic as a tool for building Windows programs with GUIs was pretty hard to beat though.
Maybe there are tools that churn out fully-polished react just as easily nowadays, but I wrote a janky little data visualization app in 2 hours at my internship and they ended up using it for almost 15 years.
As a result, every command line bit of glue code I've written for the last decade or so has been in python. At a certain point, it does start to get unwieldy and you can indeed write some awful code in it, but then again, I've seen some pretty awful bash scripts too.
My favorite trick is the fact that you can tell python to
Then you write it again in a better language...
Python isn't appreciably faster than something like Typescript to someone with actual experience making programs professionally.
Ruby has the syntactic power to write stuff very succintly, lot of good apis (and some crappy too), had since its inception a good repl which perl always ignored..
There was a time, just before the rails boom, when ruby had a lot of traction in admins and that-era-devops circles
It's for non-programmers.
I used to like Perl, but I found it hard work at times not to create something that, without ample commenting which arguably removes a lot of the benefit of terseness, even I wouldn't understand without some thought when looking at it a few months down the line.
Perl was (is? - I assume it is still used a fair bit) often referred to as a write-only programming language for this reason.
Not ad-hominem but where were you 95-2006 because Gawk, Sed and Burne shell were the answer to read only perl scripts. That is one of the reasons Perl is basically no longer used: it was used without discipline.
There was actually a progressive mode amongst those systems programmers I knew who knew what they were doing at the time.
* bash + sed for the easy stuff * bash + gawk or just gawk for the ETL stuff * TCL for systems glue + swig * C when you are bespoke or need performance
Perl was great in theory but I cringed every time I saw a script.
At the same time, it is rare for me to see a Bourne/Bash script without obvious serious defects in it.
(Many people don't understand the shell script textual substitution evaluation model at all. And even those people who do, the model gets very hard to reason about as soon as you try to do some data value handling that's absolutely trivial in most high-level languages.)
When I first encountered them as a hobbyist, they were surprising, as perhaps intended, due to the framing of classic vices as virtues. On some reflection though, it made sense, and shaped my understanding of programming as somehow _inherently different_ than other types of creation.
When I got started with a professional career, they functioned to soften the edge of anxiety. It meant that the community of programmers who came before me - which presumably included Larry Wall - would understand that these patterns in coder behavior were ultimately beneficial and that I would maybe fit in with a corporate programming environment. (Now I know that this isn’t always true; sometimes coworkers, both programmers and non-programmers, don’t always realize these unintuitive points, and in some special cases, those programmer instincts aren’t actually valuable.)
At some point, I disagreed with the framing. As others have pointed out, the patterns can be reframed as classic or functional virtues such as curiosity. Then I backpedaled and realized that the framing is important because these are unintuitive patterns and it makes us re-think habitual incentives that reward, e.g., work that is more productive but not more effective.
How did it hit me now? I realize that it’s also related to power dynamics. Programmers are assets to their employers but they’re also potential disrupters. The traditional “virtuous” framing of potentially-less-effective behavior, like patience, is related to the organizing and taming of a workforce.
It’s also related to the types of problems we encounter. When we work with computers, Larry’s list does usually lead to more effective outcomes. But when working with other humans, who have their own agency and idiosyncrasies, the traditional virtues are better-adapted behavior. This is also more true for the complex technical systems we deal with nowadays. So, as our careers transition from programming to system engineering and/or management, the traditional virtues become more relevant.
Anyhow, this is an evergreen and thought-provoking nugget of wisdom. Thanks to Larry Wall and those who have preserved it.
* Flexibility: being able to wriggle out of tight spots and escape when irate users seem to have you cornered
* Ingenuity: realizing that you can use syslog to send messages to your friend on another system
* Patience: remaining capable of waiting until the final sendmail bug is fixed
* Persistence: the compulsion to try just-one-more-thing to fix a problem before going home
* Adherence to Routine: insisting on real milk and sugar-in-the-raw in your coffee (which is Kona or nothing)
* Attention to Detail: noticing that the clock on one of your systems is using Aleutian time, and changing all the others to match
* Laziness: writing a 250-line Perl script to avoid typing 15 characters
I took the last one to heart and have admired those who could utilize the first one, because I never could.
But Curiosity is orthogonal and important. The best programmers I know were always curious: Why was it built that way? Why does it give that output? Why did she say that? Curiosity is the beginning of knowledge. If you're not curious, you will miss out on a lot of opportunities for learning and improvement.
Curious people are curious about others too, not just systems.
It’s related to caring. You have to care to be curious and we could use more people taking care in their lives.
Maybe Snooping? Nosiness? Meddling?
Im going with: Making perfect the enemy of the good.
It's the utter subjectiveness of "best practices" that aren't tied to actual issues of performance, security, or flexibility, or worse - blowing one or more of these attributes of good code way out of proportion to the actual importance of the code.
And "readability"? Don't get me started ... there's hardly a linter rule that I haven't seen turned into a caricature of what it was intended to do.
What devs do is part art and part science, and there's hardly consensus on which part is which.
You can understand why I, personally, would think this is a virtue.
(To be clear: I mean this as a good thing. Audacity… seems pretty important, and very nice to have, at the right times and places)
I completely agree with your take though. There is so much "distraction" in what are best practices, readability, etc.. It's all so subjective. Best practice for what? Readability for who?
I feel like software engineering : engineering :: psychiatry : medicine.
https://youtu.be/CmIGPGPdxTI?si=vOxiooCemwR7CygI
I found it incredibly interesting.
Having pride means that I want to write code that others view as good code and won't look at in the future as a mad hatter's ramblings.
The Three Virtues of a Great Programmer - https://news.ycombinator.com/item?id=32487944 - Aug 2022 (2 comments)
Larry Wall's Three Great Virtues of a Programmer - https://news.ycombinator.com/item?id=24107571 - Aug 2020 (1 comment)
Develop the three great virtues of a programmer: laziness, impatience, and hubris - https://news.ycombinator.com/item?id=11516215 - April 2016 (72 comments)
The Three Virtues of a GREAT Programmer - https://news.ycombinator.com/item?id=10942079 - Jan 2016 (4 comments)
The Three Great Virtues of a Programmer: Laziness, Impatience, and Hubris - https://news.ycombinator.com/item?id=9788088 - June 2015 (67 comments)
Pride often leads to unintentional blindness and irrational defensiveness. Humility is where the fun is.
I'd add a conditional lesser virtue when working on certain codebases that should have been accounted for when making perl6: Fear.
Maybe it's not so much laziness, but more so a hatred of tedium.
You will never get it "right" the first time as much as you can avoid doing it "very wrong".
The key is to have enough experience and taste to appropriately break down problems into pieces that encapsulate the volatility of the various domains.
Then you can refactor easier which should be the real goal.
Prune and tend to the garden.
Some people see effective people making 'bad' decisions and miss the bit where there were eight bad ways to accomplish something and they rejected 6 as being more work overall. Then they take their misreading of the situation as justification for YOLOing decisions to avoid analysis paralysis.
YAGNI.
Hesitation to avoid unnecessary work, sure. But not to anticipate future requirements.
The number of times I've had to fight a fancy design that left expansion points / abstractions for future features that were never needed (or not in the form the designers expected) enormously outnumber the times any such thing was useful.
Just make the code do its current job in the simplest way possible. That's the easiest design to expand later.
Is a reason like, "being built like shit by the cheapest contractors that won the bid" ever a good reason?
My work is huge on what I call, "fire, forget, then rewrite." Basically, we have tons of legacy apps that have lifespans of like 10 - 20 years, many of which never receive a single update. So, they eventually get old and unsupported enough that it's honestly just easier/quicker to rewrite them.
And in case you were wondering, yes, I work in Gov..
The first time I ever saw him speak was the 1997 first annual O'Reilly Perl conference. I remember thinking, "This guy is a jerk" while also thinking "I love this guy"
I often give a similar list as a glib answer in interviews when asked "what are your greatest strengths?"
Mine are usually: I'm stupid (not smart enough to overcomplicate), lazy (prefer turning MVP in on time rather than adding too many bells and whistles), and forgetful (document everything because I won't remember what I was doing the next day).
Working too hard means you're liable to disappear for 6+months, no sane employer should want that!
But there were others as well. Burnout is complicated.
I will say tho, it gave me persistent back problems and RSI for two years :). But that again is not just “working hard”. It was bad posture, lack of stretching, breaks and exercise, I think.
Edit: Perhaps it’s the nature of the work or working hard unhealthily (physical and mental?) or the person’s characteristics.
Because this is that.
(I've worked (and interviewed) as a programmer at VC backed startups and FAANG in SF and NYC over the past 12 years)
"Besides a mathematical inclination, an exceptionally good mastery of one's native tongue is the most vital asset of a competent programmer."
This means being able to write down a description of a problem or a solution in a clear and concise way. This is the test I would use if I hired people (not only programmers). At my job I have noticed that quite a few people cannot write proper sentences or are way too verbose in their writing.
Does that imply that one cannot be a competent programmer if working on an environment where the spoken tongue is not their native one?
https://www.cs.virginia.edu/~evans/cs655/readings/ewd498.htm...
So I've always substituted arrogance for hubris: the belief that you better understand, and can better address, the requirements than any off-the-shelf library/program/ecosystem.
But you don't get big changes or ambitious intellectual growth without spotting that - if you did choose to break those sorts of rules - you could build something really new and exciting.
Anyhow that's how I've always taken the "hubris" part - knowing when there's an opportunity to achieve something in a way that someone will tell you is too risky.
I've always taken this sort of advice, such as "never reinvent the wheel" to mean "inventing the wheel is time consuming so give yourself an advantage by using already existing wheels", which really has nothing to do with hubris.
I never took it as "Don't bother trying to reinvent the wheel because you aren't capable of it"
If you want to build a car however, focus on building the car and not creating a new kind of wheel.
Look at the Apollo moon rovers, for instance: they couldn't use off-the-shelf wheels for those.
There's only one person I ever met who thought manual memory management was a good idea, and their code was terrible in lots of other ways besides that, so I can't say I've ever thought about that particular example.
But after a decade or so of "don't roll your own crypro", I've also heard that if you specifically want to get into cryptography, the only way to do it is to research existing crypro libraries and work your way upwards, starting from "can I find bugs someone else already found, without reading the full details of their report?" and eventually rolling your own.
[0] That said, I'd now also add that libraries serve as Schelling points to make it easier to find jobs and to find workers.
He could have just used the word "pride" (which is far broader and has positive meanings too) instead. In some ways "ambition" might be a better fit.
In the context of "code that is going to be reviewed" maybe even "vanity" might have been closer to what he was getting at? (did you even RUN this?) Except us old neck beards obviously don't care about how WE look ;)} - just how our code reads.
I think "take pride in your work" would have substituted well; but given the options, maybe hubris was fine - he explains what he means in a couple of sentences.
Using a word and then redefining it seems very humpty dumpty "a word means what I want it to mean"
Part of the impact of jokes of this form is that you are supposed to be able to sort of reason your way there without explanation. But while laziness and impatience rely on the common usage of the terms, hubris is off in left field, and not even in a way that's commonly understood amongst software developers. Hubris is not "pride, but more so", it is specifically "unjustified pride". A lot of people first encounter the word "hubris" in high school literature/English class, talking about the common tropes of ancient Greek tragedies, where it is necessarily unjustified pride. I guess there's a way to understand "hubris" as "excessive (abrasively so) justified pride", but that seems vanishingly rare. I'd argue that that distinction makes "hubris" here misleading. When I (and, I expect, most people who learned the word in high school), read that a good programmer should have hubris, I understand that to mean a good programmer should be confidently wrong.
Serving static blog content should be trivial if your code isn't absolute lunacy.
I think Larry Wall gives us some great insights wrapped in great humour.
The virtue of not thinking you're building something great when you're building something awful
The really great coders I've worked with live and breathe the work, and come 5pm on a weekday they just continue on coding only this time for fun at home themselves.