Alan Perlis

Alan Perlis (1922–1990) was the first recipient of the Turing Award, awarded in 1966 for his influence on advanced programming techniques and the construction of compiler-builders. He was not a theorist who happened to build systems, nor a systems engineer who happened to think theoretically. He was a synthesizer: someone who moved between the formal and the practical with the ease of someone who did not recognize the boundary between them. His epigrams — collected in the ACM's Epigrams in Programming — are not witty asides but compressed arguments about the nature of computation, the limits of formalism, and the human dimensions of programming.

Perlis's career traced the emergence of computer science from electrical engineering. He studied at Carnegie Tech (now Carnegie Mellon), served in the Army Air Forces during World War II, and returned to build one of the first programming courses in the United States. His early work on the IT compiler and the ALGOL programming language established him as a central figure in the shift from machine-specific coding to machine-independent algorithmic expression. The ALGOL project was not merely a language design exercise; it was an attempt to create a lingua franca for communicating algorithms across the fragmented landscape of early computing hardware.

Epigrams as Systems Thinking

Perlis's epigrams are the most accessible entry point into his thought, and they are more systematic than they appear. Consider a selection:

"One man's constant is another man's variable." This is not a joke about preferences; it is a claim about the relativity of abstraction. What is fixed in one system is parametric in another, and the choice of what to fix is a design decision that shapes the entire architecture. The epigram anticipates the systems-theoretic insight that boundaries are not discovered but drawn.

"A language that doesn't affect the way you think about programming is not worth knowing." This is a stronger claim than it seems. Perlis is not saying that languages are tools; he is saying that languages are cognitive technologies. A programming language is not a notation for expressing what you already think; it is a system for thinking what you could not think without it. This is the Sapir-Whorf hypothesis applied to computation, and it grounds the later development of domain-specific languages, type theory, and functional programming.

"It is easier to write an incorrect program than understand a correct one." This is an observation about complexity and comprehension that predates the modern software crisis by decades. Perlis recognized that the difficulty of software engineering is not the difficulty of writing code but the difficulty of reading it — of reconstructing the intent and the reasoning that produced it. The epigram is a justification for the entire field of software engineering, from structured programming to formal verification to literate programming.

"Every program is a part of some other program and rarely fits." This is the most systems-oriented of the epigrams. Perlis is stating that software is not a collection of independent artifacts but an ecology of interacting components, each of which is constrained by the context in which it operates. The "fit" problem is the integration problem: the reason that software reuse is harder than it should be, that libraries have version conflicts, and that systems fail at their interfaces. The epigram is a diagnosis of why software engineering is hard, and it has not been refuted by fifty years of subsequent practice.

The Compiler as a System

Perlis's most influential technical work was on the Gargoyle compiler and the compiler-compiler approach to language implementation. The idea was not to write a compiler for each language but to write a system that could generate compilers from language specifications. This was the ancestor of modern parser generators, attribute grammar systems, and domain-specific language frameworks. The compiler was not a program but a metaprogram: a system that produced systems.

The compiler-compiler approach embodies a systems-theoretic principle that Perlis never named but consistently practiced: the level of abstraction should match the level of generality. If you are building one compiler, you write one compiler. If you are building many compilers, you write a compiler generator. The investment in the meta-level pays off only when the number of instances is large enough, and the decision of when to abstract is itself a systems design choice. Perlis's intuition for this choice — his sense of when to generalize and when to specialize — was one of his defining strengths.

Perlis and the Education of Programmers

Perlis was a committed educator who believed that programming should be taught early and taught as a mode of thought, not as a vocational skill. He chaired the ACM curriculum committee that produced the influential Curriculum 68 report, which defined computer science as an academic discipline distinct from electrical engineering and mathematics. The report's argument — that computer science is the study of algorithms, data structures, and the machines that execute them — is now so obvious that it is hard to remember it was ever controversial. Perlis made it obvious.

His teaching philosophy was not about transmitting facts but about cultivating the capacity for abstraction. He believed that a programmer who could not think in multiple languages, at multiple levels of abstraction, and with multiple models of computation was not a programmer but a technician. The systems thinker, in Perlis's view, was someone who could move between the machine level and the mathematical level without losing coherence — who could see the register allocation problem and the type-theoretic problem as two aspects of the same question.

Alan Perlis was the first person to receive the Turing Award, but he was also the first person to deserve it — not because he invented a particular algorithm or built a particular system, but because he invented the conceptual space in which algorithms and systems could be discussed as a unified discipline. He did not solve problems; he showed us what problems were worth solving.