Simula: The Language That Invented Objects Before Anyone Called Them That

Zusammenfassung

In 1967, two Norwegian computer scientists published a programming language specification that contained nearly every idea that would later define object-oriented programming: classes, objects, inheritance, polymorphism via virtual procedures, and garbage collection. Their language — Simula 67 — was designed to simulate physical systems, not to found a paradigm. They did not call their approach “object-oriented”; that term was coined by Alan Kay, who had read their papers and was inspired to build Smalltalk. Virtually every major programming language in use today — Java, C++, Python, Ruby, C#, Swift — descends intellectually from Simula 67. Its inventors died six weeks apart in 2002, the year after they received the ACM Turing Award.

The Problem: Simulating Ships and Reactors

Kristen Nygaard was a mathematician at the Norwegian Computing Centre (NCC) in Oslo who, by the early 1960s, had become interested in using computers to simulate complex real-world systems: shipping logistics, nuclear reactor behavior, factory production flows. The simulations he needed were systems of interacting entities — ships moving through fjords, workers handling tasks on assembly lines, particles interacting in a reactor — each entity with its own state and behavior, each interacting with others according to defined rules.

The programming languages available in 1962 — primarily FORTRAN and early COBOL — were designed for numerical computation and data processing, not for modeling interacting autonomous entities. Nygaard had a specific vision: he wanted a language in which you could describe a class of objects (ships, workers, particles) by specifying their properties and their behaviors, and then instantiate multiple individual objects of that class and let them interact.

He needed someone who could provide the mathematical and implementation machinery to make this happen. He found Ole-Johan Dahl, a computer scientist at NCC who had expertise in the programming language ALGOL 60 and in the formal specification of computational systems.

Nygaard described himself, in retrospect, as the requirements engineer — he knew what the language needed to do. Dahl was the implementer — he designed how to make it work. Their collaboration began in 1962 and lasted until both their deaths in 2002.

ALGOL 60 and the Foundation

Simula began as an extension of ALGOL 60 — the Algorithmic Language 1960, widely considered the most elegant programming language of its era. ALGOL introduced block structure, lexical scoping, recursive procedures, and pass-by-value vs. pass-by-name parameter passing. Many of these concepts, uncommon in 1960, are now standard in virtually every programming language.

Nygaard and Dahl’s first version, Simula I (1962–1965), added to ALGOL 60 the concept of a “process” — a program component that represented an autonomous entity capable of holding state and performing actions over time. Multiple processes could be active simultaneously, interleaving their execution. This was designed directly for discrete-event simulation: each “event” (a ship arriving, a task completing) was handled by a process that advanced through a sequence of activities.

Simula I was a working system and a genuine innovation, but it was ad hoc: the simulation-specific features were not abstractions that generalized beyond simulation contexts. Dahl recognized this and proposed a more fundamental redesign.

Simula 67: The Seminal Specification

Simula 67, published in 1967 in a paper by Ole-Johan Dahl and Kristen Nygaard, introduced the concepts that would define object-oriented programming:

Classes and Objects. A class is a template that specifies: (1) the data items (later called “attributes” or “instance variables” or “fields”) that each instance will hold, and (2) the procedures (later called “methods”) that can operate on those data items. An object is an individual instance of a class — created at runtime, allocated its own copy of the class’s data, able to invoke the class’s procedures in the context of its own data.

The real-world mapping was explicit: a class named “Ship” described the properties and behaviors common to all ships; a specific ship object represented one particular vessel with its own tonnage, position, and cargo.

Inheritance. A class can be declared as a subclass of another class, inheriting all of its data and procedures and extending or overriding them. A “ContainerShip” subclass could inherit everything from “Ship” and add the specific properties and behaviors unique to container vessels. This created a natural hierarchy: particular kinds of things are kinds of more general things, and code written for the general kind works automatically for all specific kinds.

Virtual Procedures. A procedure could be declared “virtual” in a class, meaning that subclasses could replace it with their own implementation. When an object’s procedure was called, the runtime would automatically invoke the version defined in the object’s actual class — even if the calling code knew only the superclass type. This is the mechanism now called polymorphism: a container ship and a tanker, both treated as ships, would respond differently to the same procedure call, according to their own nature.

Garbage Collection. Dahl implemented automatic memory management: when an object was no longer reachable from any reference, the system would automatically reclaim its memory. This eliminated a class of programming errors (memory leaks, dangling pointers) at the cost of some runtime overhead. Garbage collection was controversial in 1967 — it seemed expensive on the limited hardware of the time — and its adoption varied considerably in subsequent languages.

Coroutines. Simula 67 supported coroutines — procedures that could suspend their execution and resume from the suspension point — enabling the cooperative multitasking central to simulation. This was a deeper kind of control flow than the subroutine calls of ALGOL.

Simula 67 vs. Later OOP Languages

Simula 67 contained every major concept of object-oriented programming as it is practiced today. Java (1995), C++ (1983), Python (1991), and most other OOP languages add syntactic conveniences, different memory management strategies, or language-specific features, but the conceptual vocabulary — classes, objects, inheritance, polymorphism — traces directly to Simula 67. The main thing Simula 67 lacked, relative to modern languages, was information hiding: its class attributes were not private by default. Encapsulation (preventing external code from directly accessing an object’s internal data) was a design choice left to the programmer rather than enforced by the language.

Alan Kay: “The Greatest Single Programming Language Ever Designed”

In 1966–1967, Alan Kay was a graduate student at the University of Utah’s computer science department, working under David Evans on graphics hardware. He encountered Simula’s concepts in papers and in conversations with colleagues who had worked with the language. He also read Ivan Sutherland’s Sketchpad thesis, which had implemented a prototype object system for computer graphics in 1963.

Kay later described the encounter with Simula 67 as a revelation: “I thought of objects being like biological cells and/or individual computers on a network, only able to communicate with messages.” His interpretation of Simula’s concepts went further than Nygaard and Dahl had intended: where they had built a simulation language that happened to use objects, Kay envisioned a language in which everything was an object, and computation was the exchange of messages between objects.

This vision led Kay to design Smalltalk at Xerox PARC beginning in 1971 — the language that, more than any other, spread object-oriented thinking as an explicit paradigm and coined the term “object-oriented programming.” In multiple interviews and papers, Kay credited Simula 67 as one of his two primary inspirations (the other being the FLEX machine and work on personal computing). He called Simula 67 “the greatest single programming language ever designed.”

Bjarne Stroustrup and C++

The path from Simula to mainstream software ran through a different figure. Bjarne Stroustrup was a Danish computer scientist who encountered Simula 67 as a student at Aarhus University and used it for his dissertation research on distributed systems at Cambridge University.

His experience with Simula was ambivalent: the object model was elegant and the simulation capabilities were exactly what his research required, but Simula was slow. The runtime overhead of its object system — garbage collection, dynamic dispatch — made it unsuitable for performance-critical software. Stroustrup began thinking about how to bring Simula’s object model into a language without sacrificing C’s performance characteristics.

In 1979, working at Bell Labs, Stroustrup began developing “C with Classes” — C with Simula-style classes added. The key design decision was to make the class system compatible with C’s manual memory management: objects were stack-allocated or heap-allocated and destroyed explicitly, trading the safety of garbage collection for the performance of explicit control. The language was renamed C++ and released publicly in 1983.

C++ spread rapidly through the systems programming community. By the early 1990s, it had become the dominant language for high-performance software development — operating systems, game engines, database engines, network infrastructure. Every C++ programmer was using concepts — classes, inheritance, virtual functions — that originated in Simula 67.

Stroustrup later wrote: “Simula had given me a way of thinking about problems that I still find essential: you model the system you’re trying to build as a set of interacting objects, each with their own state and behavior.”

The Inventors Who Missed Their Revolution

Nygaard and Dahl watched the object-oriented revolution unfold with mixed feelings. They had not designed a “paradigm” or a “philosophy” — they had designed a practical language for simulation. The conceptual apparatus they built, appropriated by Kay, Stroustrup, and dozens of others, became the dominant organizing principle of software engineering. They received acknowledgment from the research community but limited commercial recognition.

Kristen Nygaard pursued a political career alongside his technical work. He served as a technology advisor to Norway’s Socialist Left Party, was a central figure in Norwegian labor movement debates about computer technology and workers’ rights, and was involved in the development of Norwegian legislation on computer-based work systems. He argued throughout his career that computing professionals had social responsibilities — that the systems they built shaped working conditions and social power, and that workers had a right to participate in designing the systems they used.

In 2001, the ACM and IEEE awarded Nygaard and Dahl the ACM Turing Award — computing’s highest honor — for their invention of Simula 67 and “for fundamental concepts in software design.” The award described Simula as “the forerunner of all modern object-oriented programming languages.”

Ole-Johan Dahl died on June 29, 2002, at the age of 70, from a long illness.

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

Both died the same year they received the Turing Award. Neither had the chance to write the acceptance lecture that tradition entitled them to deliver.

The Object-Oriented World

The object-oriented paradigm that traces to Simula 67 now permeates software engineering so thoroughly that it is often invisible. Java, the language that dominated enterprise software development from the late 1990s through the 2010s, is object-oriented to its core — every program is a class. Python, now the most popular introductory programming language and a primary tool of data science and AI, treats everything as an object. Ruby, C#, Swift, Kotlin, Dart — the object-oriented model is the water programmers swim in.

The model is not without critics. The functional programming tradition argues that programs composed of pure functions — with no mutable state — are easier to reason about, test, and parallelize than object-oriented programs built around mutable object state. Languages like Haskell, Erlang, and (to varying degrees) Scala, Rust, and Kotlin have incorporated functional ideas as alternatives or complements to OOP. Some software engineers argue that object-oriented programming encouraged complexity and abstraction for their own sake — a disease called “overengineering” whose most extravagant symptoms appeared in large-scale Java enterprise development of the 2000s.

Nygaard and Dahl could not have anticipated these debates. They were trying to simulate ships. The concepts they developed to do so turned out to be the conceptual vocabulary that most programmers use to think about programs — a vocabulary so fundamental that, like all deep infrastructure, it is visible mainly when it fails.

For the visual programming systems that influenced Kay alongside Simula, see Ivan Sutherland and Sketchpad. For the programming language culture in which Simula’s ideas propagated, see The Algorithm as a Concept.