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:

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:

This anxiety isn't a debilitating problem, but it's one I've reckoned with and learned to work around.

The question

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:

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.