Last night I saw Central Square Theater’s production of Breaking the Code, and I’m still thinking about it. The play follows Alan Turing’s life, from breaking Enigma to his prosecution for homosexuality. It’s easy to treat Turing as a historical figure we honor with statues and currency, but watching his story unfold on stage hit differently. This was a guy who basically invented computer science while the field didn’t even have a name yet, and we destroyed him for it.
What struck me most wasn’t the tragedy, though that’s certainly there. It was how relevant his approach to problem-solving feels today. Turing didn’t just crack codes. He thought about computation itself as an abstract system, separate from any physical implementation. The Turing machine exists in pure theory, but it gave us the vocabulary to reason about what computers can and cannot do.
The Architecture of Abstraction
When I’m designing systems today, I’m constantly working with layers of abstraction. We build APIs that hide implementation details. We create interfaces that let us swap out components without rewriting everything downstream. This isn’t just good practice, it’s the only way to manage complexity at scale.
Turing understood this before we had programming languages, before we had transistors, before we had anything resembling modern computing infrastructure. His work on computability gave us a framework for thinking about problems independent of the machines that solve them. That’s the kind of architecture thinking that matters.
The irony is that while Turing was building these elegant abstractions, the British government treated him as a security risk and eventually a criminal. They couldn’t see past the surface to recognize what they had. We do the same thing in tech all the time. We fixate on the implementation, the language choice, the framework, and miss the underlying design that actually matters.
What Breaking Enigma Teaches Us About System Design
The Enigma machine was considered unbreakable because of its complexity. Multiple rotors, plugboard settings, daily key changes. The mathematical combinations were astronomical. But Turing didn’t try to brute force it. He looked for patterns, for structural weaknesses in how humans used the system.
This is where the Bombe came in. Not a computer in the modern sense, but a mechanical system designed to exploit specific properties of Enigma’s design. Turing identified that German operators would never encode a letter as itself, a constraint that seemed like good security but actually created exploitable patterns. He found the invariants in the system and built a machine to leverage them.
I think about this when I’m debugging production issues or optimizing performance. The naive approach is to throw more resources at the problem or try every possible solution. The Turing approach is to understand the system’s constraints deeply enough that you can see what’s actually possible. Find the invariants. Exploit the structure.
Modern artificial intelligence research owes everything to this kind of thinking. Neural networks are just functions, but the architecture of how we compose them determines what they can learn. Transformers work because someone understood the structural properties of attention mechanisms. It’s abstraction and invariants all the way down.
The Human Cost of Our Systems
Here’s what the play doesn’t let you forget: Turing saved countless lives by shortening the war, then the same government that relied on his genius chemically castrated him. He died at 41, likely by suicide. We built statues later, but that doesn’t fix anything.
When we talk about system architecture, we usually mean technical systems. But the social and legal systems matter just as much, especially when they intersect with technology. Turing’s prosecution wasn’t a bug in an otherwise functional society. It was the system working exactly as designed, just with values we now recognize as monstrous.
I see echoes of this in how we build technology today. We design surveillance systems without thinking about who gets surveilled. We optimize for engagement without considering what that does to human psychology. We build AI systems that encode existing biases and call it progress. The architecture of our social systems shapes what our technical systems become.
The play ends ambiguously, which feels right. Turing’s legacy is complicated. He gave us the theoretical foundation for everything we do in computing, but we failed him completely as a society. Maybe that tension is the point. The systems we build, technical and social, reflect our values whether we intend them to or not.
Watching Breaking the Code in a theater full of people, many probably working in tech, I wondered how many of us think about the ethical architecture of what we’re building with the same rigor we apply to our technical designs.