“If debugging is the process of removing software bugs, then programming must be the process of putting them in.”
The Story
In 1968, Edsger W. Dijkstra wrote a letter to the editor of Communications of the ACM. Its original title was "A Case Against the GO TO Statement." The editor, Niklaus Wirth, published it under a more provocative headline: "Go To Statement Considered Harmful." That title — and the argument beneath it — restructured how an entire field thinks about writing code.
The argument was precise. Dijkstra observed that when programs use unrestricted GOTO statements, the correspondence between the program's static text and its dynamic execution becomes hopelessly tangled. You can no longer look at a line of code and reason about the state of the program when that line executes, because control could have arrived from anywhere. The program's text tells you what operations exist; it tells you nothing about the order in which they happen. The result is spaghetti — code that can only be understood by tracing every possible execution path, which in any non-trivial program is effectively impossible.
Structured programming — using only sequence, selection (if/else), and iteration (loops) — restores that correspondence. The static structure of the code mirrors its dynamic behavior. You can reason locally. You can verify correctness by examining pieces. You can build large systems from small, comprehensible components.
This was not a popular position in 1968. GOTO was everywhere. Assembly programmers saw structured programming as an unnecessary constraint. The debate raged for a decade. Dijkstra won — not because he shouted loudest, but because he was right, and the evidence accumulated with every software project that tried to maintain unstructured code at scale.
But "Go To Considered Harmful" was a single letter in a career of extraordinary depth. Dijkstra's contributions span the foundations of computer science:
Dijkstra's algorithm (1956) solves the shortest-path problem in weighted graphs. Every GPS navigation system, every network routing protocol, every pathfinding system in every video game uses either Dijkstra's algorithm or a descendant of it. He developed it in twenty minutes, without pencil and paper, while sitting at a cafe in Amsterdam. He was twenty-six.
Semaphores (1965) provided the first clean mechanism for coordinating concurrent processes. Before semaphores, concurrent programming was ad hoc — programmers used busy-waiting, hardware locks, or custom signaling schemes that were impossible to reason about formally. Dijkstra's semaphore abstraction — a counter with atomic wait and signal operations — gave the field a tool that was simple enough to analyze mathematically and powerful enough to solve real synchronization problems. Every mutex, every condition variable, every concurrent data structure in modern operating systems descends from this concept.
The THE multiprogramming system (1968) was one of the first operating systems designed with formal layering — each layer providing services to the layer above and using only services from the layer below. This wasn't just good engineering practice. It was a demonstration that complex systems could be built from verifiable components, each layer proven correct independently. The layered architecture pattern that dominates modern systems design — the OSI model, the TCP/IP stack, microservice layers — traces its intellectual lineage here.
And then there were the EWD manuscripts. Over forty years, Dijkstra wrote 1,318 handwritten documents — technical notes, proofs, arguments, meditations on the craft of programming — numbered sequentially (EWD 0 through EWD 1318). He wrote them by hand, photocopied them, and mailed them to a distribution list of colleagues. They were the original technical blog, decades before the web existed. They covered algorithms, verification, education, language design, the philosophy of mathematics, and the ethics of the profession. They remain some of the clearest technical writing ever produced.
Dijkstra received the Turing Award in 1972 — among the youngest recipients at the time — "for fundamental contributions to programming as a high, intellectual challenge." He continued working until shortly before his death in 2002, at the University of Texas at Austin.
Why They're in the Hall
Dijkstra is a Pioneer and Voice whose influence permeates TechnicalDepth so thoroughly that it's difficult to point at any single exhibit and say "this is the Dijkstra exhibit." He's the substrate. His ideas are the intellectual foundation that the entire complexity domain rests on.
The "Go To Considered Harmful" letter is literally the origin point for the GOTO spaghetti anti-pattern documented on the Foundation floor. When TechnicalDepth exhibits show tangled control flow, unmaintainable state machines, or code where the only way to understand behavior is to trace execution line by line — they're showing the exact pathology Dijkstra diagnosed in 1968. Structured programming isn't just a historical artifact. It's the first and most fundamental defense against complexity, and every modern language enforces it as a default.
His work on semaphores and concurrent programming underlies every exhibit dealing with race conditions, deadlocks, and shared-state bugs. The dining philosophers problem — Dijkstra's formulation — remains the standard teaching example for concurrency hazards sixty years after he proposed it.
But Dijkstra's deepest contribution to TechnicalDepth's mission is philosophical. He believed — and argued repeatedly, with the precision and stubbornness of a mathematician — that programming is a discipline of thought, not a craft of typing. That the purpose of formal methods is not to prove programs correct after the fact, but to construct programs that are correct by design. That simplicity is not a starting point to be abandoned when things get complex, but a goal to be maintained especially when things get complex.
"Simplicity is a great virtue," he wrote in EWD 896, "but it requires hard work to achieve it and education to appreciate it. And to make matters worse: complexity sells better."
That sentence could be TechnicalDepth's epigraph.
His other famous observation — "Computer Science is no more about computers than astronomy is about telescopes" — captures something essential about what TechnicalDepth is trying to do. The exhibits aren't about specific languages or frameworks. They're about patterns of thought. Dijkstra understood this before almost anyone else: the computer is incidental. The thinking is the thing.