esc
Anthology / Yagnipedia / Hate

Hate

The only emotion that requires a committed relationship
Phenomenon · First observed The first time a developer used a tool long enough to understand it · Severity: Critical

Hate, in the context of software engineering, is a strong and persistent emotional response directed at a technology, framework, language, or configuration format with which the practitioner has extensive personal experience. It is frequently mistaken for a rational evaluation. It is not. It is a relationship.

The defining characteristic of technical hate — the property that separates it from mere dislike, annoyance, or the blank stare of someone who has never heard of the technology in question — is that hate requires intimacy. Nobody hates a programming language they have never used. You cannot hate Haskell from a distance. You can fear it, you can be confused by it, you can make jokes about monads at parties where nobody laughs. But to truly hate Haskell, you must have written Haskell. You must have understood Haskell. You must have, at some point, seen the elegance of Haskell, felt the brief intoxicating clarity of a type system that catches errors at compile time — and then spent four hours trying to parse a CSV file.

Hate is not the opposite of love. Hate is love’s forwarding address.

“Nobody hates a thing they haven’t cared about. Hate is just love that has read the documentation.”
— The Caffeinated Squirrel, at 3:14 AM, uninstalling a framework it had mass-evangelised six days earlier

The Intimacy Requirement

The most important property of technical hate is its prerequisite: proximity.

Consider YAML. Nobody who has glanced at a YAML file in passing hates YAML. It looks clean. It looks readable. It looks, to the uninitiated eye, like the kind of format that was designed by someone who cared about human beings. The hatred of YAML begins approximately forty-five minutes into your first attempt to debug a deployment failure caused by an indentation error on line 847 of a file that looked correct in every editor you own. The hatred deepens when you learn that YAML interprets the string no as a boolean. The hatred achieves its final form when a production outage is traced to a country code — NO, for Norway — being silently converted to false.

You cannot arrive at this hatred without having used YAML. You cannot arrive at this hatred without having trusted YAML. The hatred is not about the indentation. The hatred is about the betrayal.

The same principle applies universally:

“I don’t hate anything. Hate implies a preference, and preferences imply attachment, and attachment implies you have something to lose. I use whatever solves the problem.”
— The Lizard

The Lizard’s complete absence of technical hatred is, by scholarly consensus, its most unsettling characteristic.

The Context Theorem

Technical hate is almost never about the technology. It is about the context in which the technology was used.

This is the theorem that most practitioners refuse to accept, because accepting it would require them to admit that their hatred of PHP is not a rational assessment of PHP’s type system but a compressed emotional memory of the job where they maintained a PHP codebase written by someone who had learned PHP from a YouTube video in 2007, while sitting in an open-plan office next to a man who ate tuna sandwiches at his desk and called every meeting “a quick sync.”

The technology is the scapegoat. The context is the crime.

Consider the developer who hates Spring Boot. If you ask them why, they will talk about dependency injection, auto-configuration, annotations that summon behaviour from the void. These are legitimate criticisms. But if you keep asking — if you peel back the layers of technical reasoning like an onion that is also crying — you will eventually reach the core: a two-year period at a company where the architecture was Spring Boot, the management was dysfunctional, the deploys were manual, and the developer spent every Friday afternoon fixing bugs that were created every Monday morning by a team that did not write tests.

The developer does not hate Spring Boot. The developer hates 2019.

But “I hate 2019” is not a sentence that gets engagement on social media, and “I hate Spring Boot” is. So the context is compressed into the technology, and the technology carries the weight of the memory, and the developer will spend the rest of their career avoiding Spring Boot the way a person who was bitten by a dog avoids dogs — not because all dogs bite, but because this one did, and the teeth were real.

riclib has been observed performing this context compression with notable efficiency. Technologies he has hated include, at various points, every technology he has ever used professionally. The hatred is temporary. The technology changes. The pattern does not. Asked about this, he noted that “the common factor in all my tech hatreds is me,” which is either profound self-awareness or the kind of thing people say when they’ve been in therapy long enough.

The Uncanny Valley of Almost-Right

The things developers hate most are not the things that are entirely wrong. Entirely wrong technologies are easy to dismiss. Nobody has strong feelings about a language that doesn’t compile. You shrug. You move on. You forget it existed.

The things developers hate most are the things that are almost right.

This is the Uncanny Valley of technology adoption. The language that is ninety percent of what you want and ten percent of what makes you want to throw your laptop into the sea. The framework that solves nine of your ten problems and makes the tenth problem worse. The configuration format that is readable, logical, well-designed, and interprets Norway as a boolean value.

The almost-right technology is more infuriating than the entirely-wrong technology because the almost-right technology shows you what could have been. It is a glimpse of the better world, with a catch. And the catch is always in the part you need most.

“I LOVED that framework. I loved it for six glorious weeks. Then I tried to do the one thing it couldn’t do, and it was the one thing I needed, and now I hate it with the intensity of a thousand suns, each of which is also on fire, which I realise suns already are, which is how angry I am — I can’t even construct a metaphor properly.”
— The Caffeinated Squirrel, submitting a GitHub issue titled “Feature Request” that read, in its entirety, “why”

This is why the most heated flame wars in software are not between entirely different paradigms — nobody argues between assembly language and Python, because they are not in competition — but between technologies that occupy the same niche. React vs. Vue. Vim vs. Emacs. Tabs vs. spaces. These are wars between near-identical siblings, each of whom is convinced the other is the evil twin. The hatred is proportional to the similarity.

The Squirrel Cycle

The Caffeinated Squirrel provides the most thoroughly documented case study of technical hate in the known literature, primarily because the Squirrel’s emotional relationship with technology follows a predictable and well-characterised cycle:

  1. Discovery (Monday): The Squirrel encounters a new framework. The Squirrel reads the landing page. The landing page has a dark theme and a code example that fits in four lines. The Squirrel is in love.

  2. Evangelism (Tuesday–Wednesday): The Squirrel rewrites a side project in the new framework. The Squirrel posts about the new framework. The Squirrel suggests the new framework for the team’s production system. The Squirrel uses the phrase “game-changer” without irony.

  3. Friction (Thursday): The Squirrel encounters a limitation. The limitation is not severe. The Squirrel files a GitHub issue. The Squirrel’s tone is still constructive.

  4. Betrayal (Friday): The Squirrel encounters a second limitation. This limitation is in the area the Squirrel cares about most. The Squirrel realises that the framework’s design philosophy is fundamentally incompatible with the Squirrel’s needs. The Squirrel does not blame its own needs. The Squirrel blames the framework.

  5. Hate (the following Monday): The Squirrel hates the framework with a purity and intensity that would be admirable if it were directed at something that deserved it. The Squirrel writes a blog post titled “Why I Left [Framework].” The blog post is 4,000 words. The Squirrel used the framework for six days.

  6. Discovery (the following Tuesday): The Squirrel encounters a new framework.

The cycle has a period of approximately one week. The Squirrel has completed this cycle with React, Vue, Svelte, Solid, Qwik, Astro, and three frameworks that no longer exist, partly because the Squirrel’s blog post about leaving them was the most traffic their documentation site ever received.

The Lizard Exception

The Lizard does not hate any technology. This is not because The Lizard has not used enough technologies to form opinions — The Lizard has used more technologies than most developers have heard of, including several that predate the concept of a “developer.” It is because The Lizard does not form emotional attachments to tools.

The Lizard uses a tool. The tool works, or it does not. If it works, The Lizard continues using it. If it does not, The Lizard uses a different tool. There is no betrayal, because there was no trust. There is no heartbreak, because there was no love. The Lizard’s relationship with technology is purely transactional, and transactions do not generate hate.

This is, by all accounts, deeply suspicious.

“Something is wrong with anyone who has never hated a technology. It means either they have never used one long enough to be disappointed, or they are incapable of disappointment. I don’t know which is worse.”
— riclib, after The Lizard expressed no opinion about YAML

The scholarly community remains divided on whether The Lizard’s absence of hate represents enlightenment or pathology. The Lizard has not weighed in on the debate, because weighing in would require having an opinion, and having an opinion is the first step toward having a hatred, and The Lizard does not take first steps toward places it does not intend to go.

The Hate Graph

If you plot a developer’s hatreds on a timeline and overlay it with their employment history, a pattern emerges that is obvious in retrospect and invisible in the moment:

Every technology hatred corresponds to a job.

The developer hates PHP because of the agency job. The developer hates Java because of the enterprise job. The developer hates Ruby because of the startup job. The developer hates whatever they used at the job they hated, and they love whatever they used at the job they loved, and the technologies themselves are bystanders — innocent variables in an equation that is actually about commute times, management quality, and whether the office had natural light.

This means that a developer’s list of hated technologies is, read correctly, an autobiography. It is a compressed history of everywhere they have worked, everyone they have worked with, and every 2 AM production incident that taught them something they did not want to learn.

The technologies are the chapters. The hatred is the narrative. And the narrative is always, always, always about the context.

Measured Characteristics

See Also

See Also