On the Possibility of Complexity Trauma
I'm curious about some experiences I've had in the course of my work as a software developer. My curiosity comes from a place of profound ignorance, based on subjective observations of my own mental and emotional state.
This is not a well researched or thoroughly studied position, nor is it:
- An assertion of fact
- A veiled shot at an employer or project from my past
- An excuse for toxic or unprofessional behaviour
- A manifesto
- A cry for help
- A call to arms
It's to do with a particular kind of anxiety. There are lots and lots of ways that work can make a person anxious, so I want to be clear: I'm asking about a particular, fairly narrow, set of circumstances.
With all that in mind, here's what I'm curious about: sometimes, when I'm working on a software project, I become anxious and overwhelmed by the task I'm presented with. This can happen even on projects that aren't very complex, that I've successfully worked on before, where I'm confident are within my abilities, and in teams that are capable and supportive. Sometimes the anxiety halts my progress completely. Other times, it drives me to anticipate needs that will almost certainly not come up, or add checks and verifications to my code far in excess of what's helpful or necessary.
In my (entirely anecdotal) experience, this out-of-place anxiety feels like times when:
- I was working with code that was hard to understand, such as code with sophisticated class hierarchies, clever metaprogramming or DSLs, elegant and succinct type systems, or highly separated and abstracted components
- I was working in a domain (e.g. finance, genomics) that involved specific technical knowledge that I didn't have time to acquire for myself, so I had to rely on others to resolve ambiguities
- I was working on a system where history, circumstance, and mismanagement had run their course so far that the procedures for developing and operating it were impenetrably opaque
This anxiety isn't a debilitating problem, but it's one I've reckoned with and learned to work around.
The question I'd like to ask is this: how plausible is it that, while I was working on complex systems that I had no way to understand, I experienced a very mild form of psychological trauma which can be triggered (in the technical sense) later, even by much milder challenges?
How plausible is it that experiencing overwhelming complexity can have lasting negative effects on a developer, even when the other aspects of the work are supportive, rewarding, and safe?
Responses to fear
Whether or not this idea of "complexity trauma" has legs, I think its hypothetical implications are worth considering.
For example, reflecting on the ways that my programming preferences have changed in the past few years, there are some themes that could be understood as a response to complexity trauma:
I'm more tolerant of verbose code if it's easier to understand. (e.g. function calls are preferable to a DSL; duplicated, straightforward classes are preferable to a complex inheritance tree)
I'm less tolerant of very general abstractions (e.g. matrix operations, category theory)
I adopt stricter code formatting and linting tools, and gravitate towards programming languages with features like type checking
I sometimes struggle to not code defensively, even in contexts where it's not valuable (e.g. adding tests and error handling to scripts that will be run once and then discarded)
I prefer to use familiar/generic tools, even if they're subpar or not the best fit (e.g. Emacs and RipGrep instead of full IDEs with refactoring tools)
More generally, I think this kind of feeling can make one want to embark on a big-bang refactor or re-write. I've learned to suppress these impulses, but I think this might be a helpful way to understand them.
What to do if this is true
If you feel like you might be permanently affected by the overwhelming complexities of past projects, what can you do with that feeling?
The obvious thing to do would be to reduce the complexity of the projects you're working on; seas of ink and terabytes of text have been dedicated to this topic, so I won't dwell on it overlong. However, sometimes (for whatever professional or personal reason) one can't avoid working on a complex and ambiguous system. All of the good coding practices in all of the books and blogs won't keep you from having to work on difficult code. In those cases, what should one do?
I think it's valuable just to know that this emotional response is coming. It can't be prevented, but perhaps it can be prepared for. Whether it's keeping a work journal, having rituals to help ground you, finding ways to compartmentalize, collaborating with supportive co-workers, or something completely different, a strategy devised while you're feeling sharp and collected will probably work better than trying to figure it out when you're overwhelmed. Being ready for these feelings and choosing to accept them as part of the work might ward off their worst effects.
Other than this, I don't have any particularly good or novel advice beyond "adopt good programming practices", "work with supporting colleagues", and "scope your projects appropriately", but that's good advice whether or not complexity trauma is a thing.