Murder your Darlings — Emotional Attachment to Programming Languages

Kevin Hoffman
4 min readJan 11, 2018

As a writer of fiction as well as tech books, I’m familiar with the phrase “murder your darlings” and its ilk. The intent of this advice, as best I can tell, is to remind writers that emotional attachment to their characters can influence their judgment and their writing will suffer for it.

Despite many modern-day claims to the origin of this phrase, “murder your darlings” is actually a piece of writing advice from Sir Arthur Quiller-Couch’s 1914 essay On Style and it is still meaningful today. I will get back to this phrase in a moment.

I firmly believe that in order for developers to be truly effective, they must be passionate. We need to love what we do and how we do it. Sure, every day there are annoying aspects of our job, but that makes our passion even more necessary. This passion keeps us grinding past the excruciatingly boring and frustrating parts of our day.

This passion — the internal fire that thrives on learning and discovery and the creation of new and amazing things — is responsible for great open source works like Kubernetes, Docker, Cloud Foundry, the ever-growing collection of hosted Cloud Native Computing Foundation projects, and countless other projects of which we as a development community should be exceedingly proud.

While many view our profession as a cold, calculating, dispassionate one, this couldn’t be further from the truth. As we learn, our mind imprints sensory and emotional memories along with that knowledge. We don’t absorb empty facts in a vacuum. We remember how we felt when we first learned about the Quantum Transactional Interpretation, we remember the smell of the first giant library we entered.

Whenever a conversation leans toward the C programming language, my mind conjures the image of my grandfather. I can smell the rich wood in his office, the cracked leather of his chair. I can see the worn green calendar corners affixed to the top of his desk. I remember the sheer awe that I felt when I loaded the floppy for the Borland C compiler into his AT&T computer. While today I may not use raw C for much other than IoT work, I will always have fond memories and a very strong bond with the C language.

I have a similar feeling of joy when I think of Pascal. I remember the first online game I ever wrote, Corporate Wars, a game designed to run on 2400 baud dial-up Bulletin Board Systems (BBS) where users engaged in 16-colored ASCII text espionage against each other online.

Fast-forward (quite) a few years to when I learned Go. I remember the day I first experienced it with vivid clarity. I remember the fun and camaraderie of being in a small, windowless, dank closet with some of the funniest, smartest people I know, hacking on things with a language I’d never seen before in order to create functionality to meet an absurd deadline. I will never forget that day, and I still feel some of that lighthearted joy every time I sit down to write code in Go.

Rust made me feel that explorer’s high that I felt when I first encountered C. I felt like a spelunker, digging deep into a cavern filled with hidden treasures. Except that mine was booby trapped and guarded by a vicious, borrow-checking compiler.

Elixir fills me with a zen-like calm that I experience with no other language. It’s not the “high” of using Go, or the rolled-up sleeve knee-deep in the muck feeling of Rust. Instead, it’s a strange feeling of being “at peace”.

All of this is finally leading somewhere, possibly even to a point. Early in my career, I engaged in language zealotry. I was a language bigot. I truly and honestly believed that there was one language in which to write all software, and that I was objectively correct in my choice. This is a toxic mentality and I am glad that I ditched this philosophy many, many years ago.

It is also toxic to refuse to acknowledge that developers form emotional bonds with languages. Our experiences learning, using, and growing with a particular programming language form an emotional imprint that we can’t ignore. Trying to do so invalidates us and our experiences. There are countless articles on team communications and functioning dynamics that tell you to stop caring about your programming languages. This is supposed to be the software development equivalent of murder your darlings.

This is utter and complete horse shit. You cannot and should never stop caring about the languages you know. They are as much a part of you as the memories you accumulated around that language.

Rather, we should acknowledge and embrace the fact that we love (and even hate) some languages. We should respect the fact that others have their own (potentially vastly different) emotional bonds. These feelings make us who we are. However, through acknowledgement of our emotional attachment to languages we can make objective decisions about which language is the best for a particular problem given budget, availability of people, company history, deadlines, requirements, etc.

I love Go, but I don’t claim that it is the single universal best language. I love Elixir, and yet I don’t claim the same of it. I actively loathe Java, despite having spent many years building production applications in it of which I am very proud. I also don’t insult Java developers for loving something I don’t, because doing so would dishonor my own emotional memories and experiences.

Telling people to stop being passionate about their programming languages suppresses their passion for the job; for the art and discovery and awe of software development. We simply cannot put out that fire. With self-awareness and free and trusted team communication, we can be passionate, love what we love, and still get the job done.



Kevin Hoffman

In relentless pursuit of elegant simplicity. Tinkerer, writer of tech, fantasy, and sci-fi. Converting napkin drawings into code for @CapitalOne