ronynn's blog

The Doomsday Programmer

March 12, 2025

2026 update: My opinions have some changes, additions and clarifications:-

1. You might be reliant on programming languages mostly commonly found pre-installed in consumer computers, which as of present will likely be the browser, then python2, ruby if you find a mac. And if you are proficient, use powershell, bash, perl as they will also be present depending on the computer.
2. You should probably not be using a system levels programming language anyway in a doomsday scenario, if you leave memory leaks among other bugs you can end up damaging the hardware in some cases.
3. If you have the luxury to store software and can run it on the computers available, rely on those that don’t completely rely on online package managers, and are easy enough for you that you can build most things from scratch using the stdlib (python3, bun, odin compiler). I for example am keeping termux apk on my phones, and copy of some js files from cdn for local projects: petite-vue, chart.js (I imagine I might need charts for anything I might build and they should look good from the beginning).
4. Debugging without gdb is a nice to have skill but you should ideally learn to debug all available tools properly.
5. Maybe keep a local llm model if your device can run it, and if you do have your programming language of choice installed, then for the most part you are done. The journey of learning the basics can still happen but you don’t have to lose sleep over it.

Programming is a craft that can create wonders, machines, games, art, but too many of us have gotten lazy. We’ve fallen into the trap of relying on crutches, libraries, frameworks, fancy editors that promise to make our lives easier but end up weighing us down. Enter doomsday programming: the antidote to our crutch addiction. I’m here to make the case for stripping things down to the bare essentials and embracing the doomsday way.

So why go full minimalist? Picture this: the apocalypse hits. The internet’s gone, computers are toast, and your precious software is kaput(corrupted). How would you fare as a programmer? If you’ve been leaning on crutches all along, you’d be up a creek without a paddle. You would not know how to run code without installing dependencies, or how to debug code without using tools. But if you’ve been honing your doomsday skills, you’d be ready to roll. You’d know how to write code from scratch, run it with minimal resources, and debug it using nothing but your wits. It’s survival of the fittest, programmer edition.

The beauty of doomsday programming lies in its simplicity and self-reliance. By ditching the crutches, you sidestep all the headaches that come with modern programming. No more bugs from dodgy dependencies, no more bloat from unnecessary features, no more reliance on external services or proprietary libraries. Your code becomes leaner and more resilient. It’s code that you own, control, and can trust to work anywhere, anytime.

But let’s not kid ourselves; embracing the doomsday mindset ain’t easy. There’s a siren song to using those shiny libraries, frameworks, and editors that promise to do all the heavy lifting for us. And let’s not forget the naysayers who’ll scoff at our back-to-basics approach. But here’s the kicker: the struggle is worth it. Because when you eschew the crutches, you learn more, you grow more, and you achieve more. It’s a journey of self-discovery and mastery (just like learning vim).

Imagine you’re knee-deep in a Node.js project, tasked with parsing some JSON data. The air is thick with the scent of dependencies:axios, moment, fs-extra?each one adding its own layer of complexity to your codebase. But as you weave these dependencies into your project, you can’t help but feel a nagging sense of unease. And sure enough, when the network connection drops or a dependency decides to throw a tantrum, your once-smooth project grinds to a halt. It’s like trying to juggle flaming torches in a hurricane: wet, also far from optimized.

Now, let’s switch gears to Nim. Here, parsing JSON is a different story altogether. In Nim’s minimalist world, there’s no need for a laundry list of dependencies. Nope, parsing JSON is as simple as breathing, thanks to Nim’s sleek and efficient standard library. So, while your Node.js counterparts are drowning in a sea of require statements (ideally import statements, also none of this applies if using bun instead of nodejs but it doesn’t run on all devices though), you’re sailing smoothly, unencumbered by the weight of unnecessary baggage.

Here’s a taste of what Nim code might look like for parsing JSON:

import json

# Define your JSON string
let jsonString = """
{
  "name": "John Doe",
  "age": 30,
  "city": "New York"
}
"""

# Parse the JSON string into a Nim data structure
let jsonData = parseJson(jsonString)

# Access individual fields
echo "Name:", jsonData["name"]
echo "Age:", jsonData["age"]
echo "City:", jsonData["city"]

Clean, concise, and devoid of excess. That’s the Nim way. So, the next time you find yourself drowning in dependencies, remember: simplicity isn’t just a virtue but duty too.

May your code be clean, your logic sound, and your resolve unshakeable.

Doomsday programming isn’t just a philosophy; it’s a way of life. It’s about embracing simplicity, honing our skills, and striving for excellence in everything we do. It is an ideology that advocates for using no crutches and only the essentials to make your work. Doomsday programming prepares you for the worst-case scenario, makes your work more robust, and independent. Doomsday programming is a defence of simplicity, a celebration of skill in pursuit of excellence (this line reminds me of the constitution and the Will Smith movie).

The article may have been insistent, but there’s a kernel of truth in the doomsday programming ideology. While it’s not a call to abandon all modern conveniences, it is a reminder of the serious benefits that come from embracing simplicity and self-reliance in programming. Going forward, I expect just as much from other programming environments too.

This post isn’t a promotional piece for Nim. Rather, it’s a reflection on the troubles I’ve faced due to dependency hell countless times, specially older React projects simply not building. Reading posts like these, and reflecting on the virtues of simplicity and skill, has a calming effect. It reaffirms the importance of mastering the basics, being prepared for the worst, and finding a certain peace in knowing my code is clean, my logic is sound, and my resolve is unshakeable.

Doomsday programming shouldn’t just be a philosophy on coding setup but a way of life. It’s about embracing simplicity, honing our skills to strive for excellence in everything we do.