Logic is not a life jacket

Confessions of a software developer. Predictably, nothing scandalous.

I’ve been working in tech for more than a decade now; I also have been coding from more than half my life, starting when I was 15 years old, when my brain was soft and supple and I decided to use all that powerful neuroplasticity to learn PHP and write a chat-based RPG.

While I have admittedly met and even worked with some well-adjusted human beings in this industry, I also couldn’t help but notice that a lot of developers tend to be pretty weird.

Why is that, you might ask? Is it the pretty big overlap in the Venn diagram of neurodivergence and people that are living their best lives tapping arcane symbols on a (mechanical, obviously) keyboard in a windowless room?

I’m just kidding, tech offices are usually pretty cool, and generally do have windows.

I believe that developers have some of the most interesting, vibrant, brilliant minds. A dev with a hobby is often world class at it, if only there were world championships of overengineering a smart-home setup to the point of driving any other person mildly insane.
When we get that intense obsession for something, we go deep, we go often, and then usually forget about it when our attention laser switches to something else. Basically, picture the Eye of Sauron, but instead of hobbits with an ancient and powerful ring, we seek the arcane knowledge containing all of the nuances of mating rituals of bonobos on Wikipedia.

On the flip side, many developers are often painfully underequipped to deal with the intrinsic complexity of being a human (or maybe this is just a projection, and the “many developers” are just, well… me).
Don’t get me wrong, we can be efficiency machines who live and get paid to solve problems, so we tend to be very effective at the procedural aspects of life. You’ll see a lot of the markers of traditional success, financial wealth, a plethora of hobbies, good education, sometimes even great physical health (tho I can’t say it’s usually a priority for the deskbound, slowly turning-into-a-shrimp developer population, but I could write an entire other essay about this).

Coding is by definition trying to reverse entropy, making sense of an abstract specification and neatly organise reality so that it bends to your will. The machine listens to your incantations and, if they’re good enough, clear enough, logical enough, does what you want it to do, always, deterministically, in a consistent and repeatable manner.

Of course, sometimes things don’t go as planned. Enter bugs. Bugs are like cockroaches (in the sense that we are often innately repulsed by them, want to squish them, and that they will probably survive past the extinction of the entire human race), they’re an imperfection, a flaw, there just to be fixed.
These issues might appear due to unforeseen conditions, interference of different systems, or, god forbid, because of your own faulty commands. This can send the message that improving them will fix everything; that life gets better when you think more clearly, more logically, more consequentially.

When you code, you take a problem and you surgically decompose it into sections that can be reasoned about, dissected, understood, and then, a bit like a god, you tell the universe which rules to apply to make the problem go away.

Every day developers live in a cycle of:

1. Coffee.

2. Articulate intent in the most logical way possible. If there’s any uncertainty, clarify it, and then be even more precise. Add fine-grained rules to capture the fact that there was uncertainty, but now there isn’t.

3. See if it works, test it, play with it, try to break it. If there’s any problem, go back to step 2 (or 1, if you really want to get it done).

   1. Happy path: Problem solved, nice! Enjoy the dopamine hit. Go check whether the new mechanical keyboard has been shipped already.

   2. Unhappy path: Problem still not solved; it’s the end of the day. This is a personal tragedy. Try not to think about it. While having a shower or sleeping, the solution comes in a flash of inspiration. Go back to step 2 in the middle of the night because it is now an obsession and it needs to be resolved.

4. Repeat

Unsurprisingly, this loop has consequences:

• We can figure out the most efficient way to fill tax forms in a language we don’t even speak in twenty minutes flat, no big deal. We're solution machines. Give us chaos and we will make an orderly box wrapped up in a neat bow.

• Our code breaks all day every day until it doesn't. We get "NOPE! Here's what might've gone wrong" in menacing red letters, over and over. Failure doesn't get more explicit (and more helpful) than that. This cultivates something precious: a genuine trial-and-error approach to life, an experimental mindset that becomes second nature.

• We often subconsciously build a hierarchy: logic > almost anything else, definitely emotions or feelings. Machines do not give a fuck if we’re hungry or sad or if we’re questioning our existence, so we can’t let those pesky things get in the way. Box them up, block, delete and move on.
  We live in our own head; the more we do it, the more we tend to earn, the more we get reinforced. The statistics say that software developers have among the highest suicide rates of any white-collar profession ¹ — and as much as this is a phenomenon far bigger than what I can address here, I do often wonder how much this has to do with it.

• We internalise that certainty is always reachable, given the right words, the right set of rules, better thinking, logical assumptions. That errors are just transient problems we can get rid of, patch, fix, hide, neutralise. That we can terraform reality with the sheer power of our minds.

  That subtle, subconscious desire that everything will be fine if, else. That, in the end, you can control the outcome.

  Eventually the code will compile, the tests will pass, your partner will ask you to marry them, or your mother will finally see you as a whole human being. Success! Green checkmark, onto the next problem to solve.

I have just recently realised that the “running down the flowchart” algorithm I have in my head whenever I need to take a decision, for example:

This flowchart might or might not be fictional.

is actually a form of over-thinking called catastrophising. Who knew, right!?

I was just preparing for all of the possible scenarios, in case the Zombie Apocalypse finally happens and I am ready to pivot into a self-sustaining homestead at the drop of a hat.
The irony is that the flowchart works, in a way, as it does actually prevent some of the problems. And part of me still believes that this is how it should be. Most other humans are just terribly inefficient.
But where do we draw the line between being prepared and being neurotic? Between effectively solving potential problems and fictional ones? Between existing in the imagination of the future and the reality of today?
That line — between certainty and uncertainty — is often where we try to control the uncontrollable.

Sitting with uncertainty, while it is a universally difficult experience (otherwise we wouldn’t have meditation practices, most religions, hard drugs, iPhones, and Burning Man), I’d argue it is the final boss of a software developer.
A lot of us would rather spend eternity in Dante's eighth circle, submerged in boiling pitch and prodded back under by demons every time we surface, than sit for one afternoon in uncertainty.

When things are uncertain, when we don’t know all the parameters, or even worse, the parameters can change, we can’t come up with our magic words to solve anything. We can’t neatly break the problem down and divide-and-conquer it.

To add insult to injury, the pattern matching superpower is also great until it’s not. It helps in quickly figuring things out, but it also sometimes creates the belief that we know how things should work. Past performance must lead to future performance.

We often try to resolve this tension by throwing more knowledge at it, which sometimes works, sometimes doesn’t, but the pernicious thing is the set of fundamental beliefs underlying:

With enough time/knowledge/thinking/attempts/logic

• all things are fundamentally fixable.

• a deterministic mental model of reality can be created.

• it is possible to know and predict the future.

• it is possible to know and predict other people.

all of which are just orbiting around the kernel of:

With enough time/knowledge/thinking/attempts/logic we won’t ever have to feel bad.

A lot of the skills this wonky profession helps develop are extremely useful when it is a choice to employ them, not the default; when we’re intentional and aware of their limitations, of when they fail us and backfire, making life actually harder.

From being the architects of reality, even if just a digital slice of it, we might have to face that not everything can be fixed, changed, or removed.

From being the ones who make things happen, we might have to face that sometimes there’s nothing we can do.

From imposing our will, we might have to face that a certain level of powerlessness and surrender is at the core of this silly human life.

---

When I was much younger I truly, truly, truly, couldn’t understand the actions of my first boyfriend when we broke up (“but this does not make any sense! It’s just illogical” I can still hear myself say. I’d love to go back and give myself a ‘Good Will Hunting’-style hug, and just say that it’s ok, that sometimes I won’t know why people act in a certain way, and might never. And even worse, people can just change their minds without any reason).

Suffice to say: I’m thick in the middle of my own journey. It took me the passing of my dad and the dissolution of a couple of important relationships for me to really stop striving for the illusion of control.

It’s a long way to go, and it occasionally sucks, but I’m happy I’m on this journey.

Side effects may include: I sometimes cry when I listen to certain songs, I’m far less inclined to see things in black and white, which pisses me off to no end, because it was so much more efficient (you, you are great, I’m with you; you, you are pretty shite, get out).
I am starting to appreciate the beauty and the terror of life in all its imperfections, and accept that sometimes I might want to do things even if they don’t make any sense and they don’t neatly follow a 5-step plan. And that’s ok.
I am also learning — and even tolerating, sometimes — that people are amazing and fickle and can do things just because. And I can’t reliably pattern-match it, nor predict it with a neat algorithm, nor always protect myself from the consequences of said actions.
That some bugs will never be patched, some might not even be bugs in the first place, and that no amount of pristine logic will remove all the uncertainty.
That I don’t need to have all the information to make the next step, and the next.
That, in the end, the resilience of my system is something that software can’t easily replicate: it’s self-healing, self-adapting, with built-in redundancy. And I’m learning to trust that it can fail gracefully.

And, as much as I will always try to read more, lift more, learn more, feel more, sometimes A⇒B and B⇒C, but A ⇏ C and there’s nothing I can (or should) do about it.

---

Anyway. These observations are all mine, so they might be and probably are quite wrong. Most of this is fully anecdotal. I haven’t run an actual study (but I’d love to in the future. Data! Numbers! Statistics! Gimme, gimme).

TLDR: A developer rationalises her feelings on an essay about how developers tend to rationalise their feelings instead of just feeling them. I’ll give myself a “at least you tried!” medal and see myself out.

1. Wong et al. 2023. Mental Wellbeing at Work: Perspectives of Software Engineers. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems (CHI '23), April 23–28, 2023, Hamburg, Germany. ACM, New York, NY, USA 15 Pages. https://doi.org/10.1145/3544548.3581528