<-- home

You Are The Problem

Virtually every company seems to have a minority group with an unrealistic (almost sexual) desire to use “New Thing” (NT). NT is usually popular in stack overflow surveys and frequent Hacker News posts titled “Our journey to NT” or “N reasons we chose NT” or “NT Reach Around.” They rarely have any substance. Understandable because neither does porn and yet it produces similar unrealistic desires. The regurgitated anecdotes are rarely (read never) reason enough in themselves to make an argument for NT let alone argument enough to needlessly migrate everything you have. Normally they’re just empty bullet points followed by an easy decision to go with the choice you’ve been trained to want. C to C++. Java to C#. 8 years ago they wanted Node.js. 5 years ago they wanted to write Go. Now it’s Rust. Then it was closure. And on and on back to Unix time zero.

  • NT is faster
  • NT just works
  • NT has a good experience
  • NT is less lines of code
  • NT scales better
  • NT is easier to maintain
  • NT has better runtime
  • NT is simpler
  • NT manages dependencies better

Hardly any of this is even verifiable, let alone thought provoking. They’re just things to say like “not my president.” They have no tangible meaning. They make a superficial argument for NT that was similarly made for OT a few years ago. Whatever you think has changed in 5 years hasn’t. It’s the same problem solved with a slightly different way. There is no panacea language and there is a virtually 100% chance that whatever you’re doing will work with OT with half the effort you put into air humping NT. And in 5 years you’re going to hate it anyway because familiarity breeds contempt. You say OT is slow. Maybe but not slow enough to matter. OT is slow like a string is long. Inherently it has no slowness and depends entirely on what you compare it to. And besides, the chances that your HTTP requests need 20ms from the runtime are zero. As much as you might want to hate SQL Server, .NET, and Windows these things sufficiently power one of the most popular websites in our field (a website that has uptime and response time metrics likely better than anything you’ve ever written).

The problem is rarely (read never) the language or runtime. The problem is you. If you rewrite software then you are the problem. The sooner you recognize this the sooner you can start solving hard problems and stop compulsively rewriting CRUD handlers in NT after NT after NT after Kubernetes, Apache Mesos, Go, Rust, Node, Python, Ruby, Scala, Java, ChatGPT, … None of this matters anywhere near as much as you think it does and none of it is the problem. The people are the problem. The organizational tolerance for wet dream inducing greener grass is the problem. The insatiable yearning to do NT so that you can blame OT, the legacy system, monoliths, the people before you. Anything to take the focus off of the fact that you should optimize OT. The uncanny need to strangler fig everything you either didn’t make or made poorly. The reason it’s slow or shitty or hard to maintain is that you spend more time reading fruitless articles on Hacker News than learning your craft. And even if you didn’t have a word in the creation of “legacy system” or OT you passively agree to the perpetual persistence of OT’s problems. Even if you didn’t write it, every day that it persists is your fault. Not “the business” or “those fuckheads who wrote it.” You.

OT can do the job if you chose to acknowledge that it’s not the language or tooling. It’s you. The existence of a snipe can be proven with a single instance of a snipe. Somewhere there exists a running instances of the thing you neglect outperforming everything you’ve ever written. If OT was the problem OT wouldn’t work and yet Wikipedia runs on PHP. Arguably the most important website on the internet runs on fucking PHP. Not just runs, but consistently works and has desirable response times and uptime. You do not need Rust or Go. The language is not going to generate good code because you can’t write good code or you would have already done so. Your argument to abandon PHP for Go because Go is better is flattened by the fact that you’ll never be as good as Wikipedia. And even though you want to feign superiority and call Wikipedia just a blog site to undermine it’s complexity in an attempt to undermine the evidence – you’re wrong. If that’s mentally where you are then you are a burden to your company and your team and this industry.

NT is Tomorrows OT

Nevertheless, since you’re in heat it won’t go unnoticed so you manage to convince “the business” to let you rewrite your exercise in futility with NT. You’ll write OT in your flavor of NT – shitty. You write Go like Ruby because you expect Go to do things better than Ruby. You know Ruby idioms so you write Go like Ruby because “Go is rad and faster than Ruby.” So as long as you write the same solution in Go everything is better! In other words, what you believe is that “if this was written in Go it would be faster, better, easier” because you ignore the obvious: No matter how many benchmarks you make Ruby is not the problem. What you should have said is “If this was written better it would be better.” Don’t write it better in Go. Write it better in Ruby and stop spending your salary on rewriting your JSON HTTP handlers in NT every time things get difficult or boring or you get aroused by the cleavage of the new programming language.

Neglect is the most frequent cause of bad software.

Don’t trade the devil you barely know for the devil you just met. “Vanilla Rust is faster than Django”, but it also lacks a lot of what Django has out of the box. Most of which you absolutely do not need…until you do. You fail to understand that as bad as your Django is it solved problems you didn’t even know existed. Poorly perhaps, but a problem solved poorly for you is an unknown unknown you will never understand. Removing the crutches of Django in exchange for vanilla Rust will force you to learn, but at what cost and what’s stopping you from improving Django/Python other than sheer laziness and stupidity? What if instead you optimized OT? What if OT has a p95 of 300ms not because “Python is slow” but because you subconsciously allow Python to be slow? You can drastically reduce your cyclomatic complexity by understanding more about OT, your business requirements, and your shitty code.

The problem is compulsive obsession and willful ignorance. If you learn how to make Python run at 20ms p95 you lose your chance to write OMGLang or whatever script kiddies want on Stack Overflow surveys this year. You miss out on a useless exercise of converting who-gives-a-shit-lang to omg-it-has-a-vim-plugin-lang. I hate to spoil this for you new generations but NT is not new. It has crusty underwear underneath the fluffy anthropomorphic animal mascots and marketing landing pages. Every NT will be tomorrows OT and if you think otherwise you’re either blindly zealous or too inexperienced to be making decisions or both.

Instead you want to chase the wind called Rust today or Go in 2017 or Node in 2012. In 5 years everyone will want to know how to move from Rust to New-Thing-2027 just like with Go to Rust and Node to Go ad nauseam/infinitum. You will have discovered that Rust didn’t fix your problems only moved them to your blindspot in exchange for new problems you haven’t even uncovered yet because you’ve yet to even see that language naked. Rust doesn’t fix Go. Go doesn’t fix Node.js. Node.js doesn’t fix Java. New toothpaste doesn’t fix your bad gum hygiene. They don’t fix your problems because you don’t fully understand your problems until NT makes them up for you. It’s called marketing and it’s not surprising that the most successfully marketed generations continue to fall for the same old psychological propaganda traps.

Edit: No doubt a large chunk of readers will argue that they have unique circumstances that require NT. I hear you. Just know that everyone else says the same thing. “No but we really do. We are unique.” I know. So is everyone else. Start from the top and read again.

Edit: if you think I’m biased for or against any language or tech stack then you need to reevaluate your thinking skills. The tech is not good or bad. It just is. And you can choose to learn how to deal with it or not. You can have preferences. My preferences are for the things I know the most because I’m familiar with the limitations and caveats and I have learned how to optimize for them. If my company disagrees then it is my job to become as familiar with the tech stack they do use. Instead, I have to constantly deal with the religious crusades of every developer in heat for NT.

Edit: if you are searching for company success stories of NT to prove me wrong go ahead. Company X succeeds migrating to NT because they wanted to migrate to NT. They would have had similar success had they put half the effort into OT. Like with politics, google told you what you wanted to hear. Company X migrated to Rust from PHP and saw a, b, c improvements. The obvious (and therefore incorrect) fact is that NT was the solution. The solution was energy and focus. Put that into OT and maybe one day you’ll be as good as Wikipedia or Stack Exchange.