Ole-Johan Dahl and Kristen Nygaard: The Inventors of Object-Oriented Programming

Zusammenfassung

In a computing research center in Oslo in the early 1960s, two Norwegian scientists solved a problem that was strangling the development of complex software: how to structure a program that models a world made of interacting, independent entities. Their answer was the class and the object — bundling data with the procedures that operate on it, allowing programs to mirror the structure of the systems they described. Simula 67, the language Ole-Johan Dahl and Kristen Nygaard published in 1967, introduced inheritance, virtual procedures, and garbage collection; it became the direct ancestor of every object-oriented language that followed. They received the Turing Award in 2001. Both were dead by the end of 2002.

Two Men, One Problem

Kristen Nygaard was not a mathematician or a computer scientist by training; he was an operations researcher. Born in Oslo in 1926, he had spent the 1950s working at the Norwegian Defence Research Establishment (NDRE), where his job was to model complex systems — logistics networks, military operations, industrial processes — to help planners understand how they behaved. Operations research was a young field that had grown out of World War II, and its central tool was the model: a formal representation of a system that could be manipulated mathematically to explore its behavior.

By the late 1950s, Nygaard had moved to the Norwegian Computing Centre (NCC) in Oslo, where he was attempting to build computer simulations of complex systems. The problem he kept encountering was not mathematical but structural. The systems he wanted to simulate — ship traffic in Oslo harbor, industrial processes, military operations — were made up of many independent entities (ships, machines, soldiers) that each had their own properties and behaviors and interacted with each other according to complex rules. Writing programs to simulate these systems in the programming languages available — FORTRAN, COBOL, early ALGOL — produced code of nightmarish complexity. The state of every entity had to be tracked in separate arrays; the procedures that described each entity’s behavior were scattered through the code; any change to one part of the system required tracing through every place it affected everything else.

Ole-Johan Dahl was Nygaard’s opposite in temperament: precise, mathematical, theoretical. Born in 1931, he had trained in mathematics and numerical analysis, and by the time he encountered Nygaard at the NCC in the early 1960s, he had the formal tools to take Nygaard’s intuition about program structure and turn it into working software. Nygaard knew what the problem was and what the solution should feel like; Dahl knew how to implement it.

Their collaboration began around 1961. Nygaard had the problem and the domain knowledge; Dahl had the programming skills and the mathematical framework. The combination — unusual in the history of programming language design, which tends to produce individual creators — proved generative in a way that neither could have achieved alone.

Simula I: Classes Are Born

Their first language, Simula I, grew out of concepts they fixed in 1962; its compiler was running on the NCC’s UNIVAC 1107 by December 1964 and the language was operational in early 1965. It was built on top of ALGOL 60, the block-structured language that was then the most advanced programming language available. Simula I extended ALGOL with two key concepts.

The first was the class: a template that defined a type of object in the simulation — a ship, a machine, a customer — by combining data (the ship’s position, speed, cargo) with the procedures that operated on that data (move, turn, load, unload). Each entity in the simulation was an instance of a class: it had its own copies of the data fields, and it responded to procedure calls according to the class definition. For the first time, a programmer could write a Ship class, create fifty Ship instances, and have each one independently maintain its own state.

The second was the coroutine: a way of interleaving the execution of multiple independent processes, allowing a simulation to advance one ship’s behavior, then another’s, then a third’s, without losing track of where each one was. Coroutines would not become mainstream for another fifty years — the async/await patterns of modern Python and JavaScript are their direct descendants — but in 1962 they were essential for simulation programming.

Simula I was used at the NCC for real projects. Norwegian industrial and shipping companies used it to simulate their operations — test how changes in scheduling would affect throughput, model the behavior of systems too complex to analyze analytically. It was not a research toy; it was production software solving real problems for real clients.

Simula 67: The Complete Vision

The version that changed programming history was Simula 67, published in 1967 after five years of refinement. Simula 67 introduced features that went well beyond simulation into a general theory of program structure.

Class inheritance — the ability to define a new class as an extension of an existing one, inheriting its data and procedures and adding new ones — appeared for the first time as a systematic language feature. A FreighterShip could be defined as a subclass of Ship, inheriting the Ship’s position, speed, and movement procedures while adding cargo capacity and loading procedures. This meant that code could be organized hierarchically: general behavior in parent classes, specific behavior in children. Changes to the general behavior propagated automatically to all subclasses.

Virtual procedures enabled polymorphism: a procedure defined in a parent class could be overridden in subclasses, so that calling the same procedure on different objects would produce different behavior depending on the actual type of the object. You could write a loop that called draw() on every object in a graphics scene without knowing whether each object was a rectangle, a circle, or a line — each would draw itself correctly.

Garbage collection — automatic management of memory, freeing programmers from the need to manually track and release allocated memory — appeared in Simula 67 as a first-class language feature. This was not the first garbage collector (LISP had one since 1960), but its appearance in a general-purpose systems language was remarkable for 1967 and would not become mainstream until Java popularized it in 1995.

Together, these features constituted the core of what would later be called object-oriented programming: encapsulation, inheritance, polymorphism, and automatic memory management. Dahl and Nygaard had not used the term “object-oriented” — that phrase was coined by Alan Kay — but they had invented the practice.

Alan Kay’s Debt

Alan Kay, who later designed Smalltalk and coined the term “object-oriented programming,” encountered Simula 67 while a graduate student at the University of Utah in the late 1960s. He later described reading the Simula 67 papers as one of the most significant intellectual experiences of his life: “I realized that the object was a more fundamental entity than the class.” Kay extended Simula’s ideas in radical directions — in Smalltalk, everything was an object, and computation proceeded entirely through message passing — but he consistently credited Dahl and Nygaard as the origin point. Stroustrup’s C++ is an even more direct lineage: he studied Simula 67 at Cambridge, and C++ is essentially “C with Simula’s classes,” the name he originally gave the language.

The Diffusion Problem: Why They Were Forgotten

Dahl and Nygaard’s achievement was enormous, and for roughly two decades it was almost invisible outside Scandinavia. The reasons illuminate how ideas spread — or fail to spread — in computing history.

Simula 67 was a Scandinavian language from a small research center, published without the institutional backing of Bell Labs, MIT, or a major university press. Its primary documentation was technical reports from the NCC, not papers in major journals. The language ran on specific hardware (primarily Univac and Burroughs mainframes) and required a runtime library that was difficult to port. American computing, which was the center of the field, paid little attention to European research unless it arrived with substantial institutional sponsorship.

The researchers who did encounter Simula 67 were disproportionately influential: Alan Kay read it and built Smalltalk. Bjarne Stroustrup read it and built C++. But these transmissions happened through individuals, not through any systematic recognition of Dahl and Nygaard’s priority. When object-oriented programming became commercially important — when C++ and Objective-C arrived in the mid-1980s, when Java democratized OOP in 1995 — the intellectual history was often elided. Textbooks described classes and inheritance as if they had no specific inventors.

For the full history of how Simula’s ideas propagated through the OOP lineage, see The OOP Revolution, Alan Kay and Smalltalk, and Bjarne Stroustrup and C++.

Nygaard’s Political Life

One of the unusual features of Kristen Nygaard’s biography is that his contributions to computing history exist alongside a parallel career in left-wing Norwegian politics. In the 1970s, he became a leading figure in the Norwegian trade union movement’s engagement with technology, arguing that workers needed to understand and have input into the computer systems being introduced in their workplaces. This was not merely rhetorical; Nygaard helped develop the Iron and Metal Workers’ Agreement with the Norwegian Iron and Metalworkers’ Union — a legal framework requiring unions to be consulted before computer systems were introduced that would change working conditions.

This work, sometimes called participatory design or Scandinavian design methods, influenced a generation of human-computer interaction researchers and established principles of worker involvement in technology implementation that remain influential in European labor law and software development methodology.

Nygaard was also a founding member and technology policy advisor to the Norwegian Socialist Party (Sosialistisk Venstreparti), which was formed in 1975. He saw computing and political economy as deeply connected: who controlled data systems controlled power, and the design of software was not value-neutral but embedded in structures of authority and access. This perspective was unusual among programming language designers, most of whom preferred to think of their work as purely technical.

The Turing Award and the Final Year

The ACM Turing Award for 2001 went to Ole-Johan Dahl and Kristen Nygaard, cited for “ideas fundamental to the emergence of object-oriented programming, through their design of the programming languages Simula I and Simula 67.” The award was thirty-four years after Simula 67 — a delay that reflected how long it had taken the field to trace the intellectual lineage of OOP back to its Norwegian origin.

Both men received the award in good health. Both died in 2002.

Ole-Johan Dahl died on June 29, 2002, from lung cancer, at the age of seventy.

Kristen Nygaard died on August 10, 2002, from a stroke, at the age of seventy-five.

They died forty-two days apart, the same year their field finally gave them the recognition they had been waiting for. The coincidence was noted throughout the computing world; it had the quality of a story too symmetrical to be true, but it was true.

The Legacy in Every Line of Code

The OOP paradigm that Dahl and Nygaard originated became, through C++, Java, Python, Ruby, Swift, Kotlin, and dozens of other languages, the dominant way of organizing software. By the early 2000s, most software written commercially was object-oriented; the class hierarchy, the method call, the interface — these were the basic vocabulary of programming for hundreds of millions of people who had never heard of Simula.

The specific features of Simula 67 — classes, inheritance, virtual procedures, garbage collection — appear in essentially every object-oriented language written since. Some (Python, Ruby, Smalltalk-inspired languages) extended the model; some (C++) added it to existing paradigms; some (Java) democratized it for mass adoption. None of them escaped the shape Dahl and Nygaard gave to the idea in Oslo, in a research center that was solving shipping simulations, in a decade when the concept of “software engineering” did not yet exist.

The Simulation Insight

Dahl and Nygaard’s insight was fundamentally about modeling: programs are more maintainable when their structure mirrors the structure of the domain they describe. A program that simulates ships should contain objects that behave like ships, not arrays of coordinates and lookup tables. This correspondence between program structure and world structure — which seems obvious in retrospect — was not obvious in 1962, and articulating it changed programming.