Simula 67 and the Invention of Classes and Objects
Ole-Johan Dahl and Kristen Nygaard transformed simulation-language design into a new programming model built around classes, objects, inheritance and processes, creating the conceptual foundation of object-oriented programming.
Simula began as a language for describing systems that evolve over time
Kristen Nygaard and Ole-Johan Dahl began the Simula project at the Norwegian Computing Center in the early 1960s. The Computer History Museum records the first written reference to Simula in January 1962 and describes the project as an object-oriented language created for simulation.[2]
Simulation was a demanding programming domain because a model may contain many entities that behave independently but interact through a shared environment. Customers, machines, queues, ships or communication nodes each have state and behavior that change over simulated time.
The design problem was representation, not only arithmetic
Traditional numerical code could represent a system through arrays and procedures, but Nygaard wanted the program structure itself to resemble the structure of the system being modeled. That pressure led toward objects.
The first Simula extended ALGOL for discrete-event simulation
The Computer History Museum’s 1965 timeline describes Simula as based largely on ALGOL 60 and notes that it grouped data and instructions into entities representing parts of a simulated system.[1] ALGOL gave Dahl and Nygaard block structure, procedures and lexical organization; Simula added facilities for processes that could suspend and resume as simulated events occurred.
The first language was specialized around simulation, but the designers soon realized that its representation mechanisms could be generalized beyond simulation.
A process joined data with a continuing activity
A simulated entity needed both stored attributes and behavior that unfolded over time. This combination encouraged the designers to treat an entity as more than a record passed among unrelated procedures.
Simula 67 generalized the class concept
By the time of Simula 67, classes had become a general programming abstraction. A class could describe data fields and procedures together, and program execution could create multiple object instances from that description. The later Simula Research Laboratory history identifies Dahl and Nygaard’s work as the origin of object-oriented programming.[3]
Objects changed the programmer’s unit of decomposition. Instead of organizing all operations by procedure or all data by global structure, related state and behavior could be encapsulated inside instances corresponding to conceptual entities.
Classes supported specialization through prefixing
Simula allowed one class to extend another through a mechanism historically described as prefixing and later understood as inheritance. A specialized class could reuse and refine a more general abstraction.
The design introduced ideas later recognized as object orientation
A historical review of object-oriented programming describes Simula as the foundational work from which later object-oriented languages developed and emphasizes the importance of its classes, objects and inheritance mechanisms.[4]
Terms and implementation details changed later, especially through Smalltalk and C++, but Simula established the deep idea that a program can be organized as interacting objects whose internal state and operations belong together.
Object orientation was discovered through modeling
The designers did not begin with a manifesto about a future programming paradigm. They arrived at classes and objects because simulations were easier to express when program structure mirrored the conceptual structure of the modeled world.
Coroutines and processes gave Simula an unusually rich execution model
Simula’s process facilities allowed simulated activities to pause and resume, which required runtime support beyond a simple procedure call stack. This influenced later thinking about coroutines, cooperative processes and event-based programming.
These execution concepts reinforced the object model because a simulated object could have both persistent state and a continuing activity. The result was a language where abstractions represented not only data but ongoing behavior.
The language influenced both Smalltalk and C++
Simula’s influence became especially visible through people who encountered it directly. Alan Kay has described Simula as an important influence on Smalltalk, while Bjarne Stroustrup later drew explicitly on Simula’s class model when creating C++.
Simula Research Laboratory’s historical account notes that object orientation spread internationally through these later languages even when Simula itself remained comparatively specialized.[3]
Dahl and Nygaard were later recognized for more than one language feature
The Simula Research Laboratory’s 2001 annual report notes that Dahl and Nygaard received the 2001 ACM A.M. Turing Award and the 2002 IEEE John von Neumann Medal for their development of Simula and object orientation.[5]
The recognition reflects that their contribution was not simply one syntax construct. They changed the conceptual model available to programmers for organizing complex software.
Why Simula 67 belongs in the core history of programming languages
Simula 67 transformed a simulation problem into a general language architecture. Classes described reusable kinds of entities, objects represented instances, inheritance expressed specialization, and process mechanisms supported entities with continuing behavior.[1][4]
Nearly every later object-oriented language altered Simula’s details, but the conceptual lineage is direct enough that classes and objects remain one of the clearest examples of a domain-specific programming idea becoming a general-purpose software paradigm.
Simulation also gave object orientation a powerful explanatory metaphor. A program could be understood as a population of entities with identities, local state and behavior rather than as one global store transformed by unrelated procedures. That metaphor made object-oriented design attractive well beyond simulation, especially for graphical interfaces and large application frameworks.
The later success of object orientation should not be projected backward as inevitable. Simula’s classes emerged from concrete simulation needs, and only later did the wider field recognize that the abstraction could organize many kinds of software.
Simula’s influence also depended on a subtle shift in what counted as a reusable abstraction. A procedure packages an operation; a class packages a model of a kind of thing, including both the information it carries and the operations associated with it. That distinction became especially powerful as software systems grew larger and programmers needed to preserve conceptual boundaries across many modules. Later object-oriented languages changed access-control rules, method dispatch, interfaces and memory management, but they kept returning to the same basic promise: software can be organized around enduring entities whose behavior travels with their state. Simula therefore matters not only because it introduced vocabulary later called object-oriented. It demonstrated that a language’s abstraction mechanisms can mirror the categories that programmers use to understand a problem domain, turning modeling decisions into executable program structure.
Works Cited
- 01
- 02Computer History Museum — January 5, 1962: First Written Reference to Simula computerhistory.org
- 03
- 04
- 05Simula Research Laboratory — Annual Report 2001 web-backend.simula.no
CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.
Submit a research lead