Simula 67 — Classes and Inheritance Enter a Programming Language

In May 1967, at Lysebu outside Oslo, IFIP TC2 held a working conference on simulation programming languages. Ole-Johan Dahl chaired it. The paper he and Kristen Nygaard submitted was titled "Class and subclass declarations".

Most of the concepts in most of today's programming languages can be traced from that room.

Prehistory: It Came Out of Simulation

The starting point was not language design. It was queues.

Kristen Nygaard had worked on Monte Carlo simulations at the Norwegian Defence Research Establishment before moving in 1960 to the Norwegian Computing Center (Norsk Regnesentral). What he wanted was a notation in which complex dynamic systems could be described at a far higher level than the practice of the time allowed. In a letter of January 1962 he reported that his ideas for describing queueing systems were now reasonably clear — and that he was meeting an expert programmer about implementation the next day. The programmer was Dahl.

In August 1962 the two presented the idea at the IFIP World Congress in Munich. At that stage — the version usually called Simula 0 — a system consisted of a fixed number of "stations", each with a queue of "customers", and the plan was to implement it as a preprocessor to an ALGOL compiler. It was never implemented.

What stopped them was ALGOL's last-in-first-out discipline. If procedure calls must live and die on a stack, objects with independent lifetimes cannot be expressed. So they went into the compiler and replaced stack allocation with a heap and automatic reclamation of memory. Given that freedom, they saw the language could be generalised: the active stations and passive customers collapsed into a single concept, the process.

Simula I — processes declared with the keyword activity — had a settled definition by March 1964, and the implementation, produced by reworking the UNIVAC 1107's ALGOL compiler, was finished in January 1965. Dahl led it, with Bjørn Myhrhaug and Sigurd Kubosch. By then the language had dynamic object creation, a reference-counting garbage collector, coroutine-like quasi-parallel execution, and access to an object's variables and procedures from outside. What it did not have was subclasses. Pointers were untyped, and getting at a process's interior required an ungainly inspect ... when construction to determine the actual type first.

The Breakthrough of Late 1966

Using Simula I on real problems showed it was good for more than simulation, and from January 1965 the two began generalising it into a general-purpose language.

The spark was a paper on record handling by C.A.R. Hoare in Algol Bulletin 21 (November 1965). Hoare proposed describing records by record classes, with record subclasses as extensions, and typing pointer variables by class so that a pointer could refer only to records of that class or its subclasses — type safety without an unacceptable loss of flexibility.

But Hoare's scheme required a class and all its subclasses to be written inside one closed syntactic unit, and that did not fit the other things Dahl and Nygaard wanted. The deadlock broke late in 1966, when they saw that a subclass could be declared independently of where its superclass was declared. The syntax made the superclass a prefix: C class D(...); begin ... end. This is why Simula literature says "prefix class" where later languages say superclass or base class.

The consequence is the one that mattered. General-purpose classes could be written separately, put in public libraries in source or compiled form, and subclassed later by different users for their own purposes. It was also what made it possible to reimplement all of Simula I's simulation machinery as a package written in Simula 67. For attribute access they took the dot notation now universal, rather than Hoare's attribute(pointer).

Virtual Procedures Arrived After the Deadline

The paper went in during March 1967, just in time. The design of virtual procedures was settled after that.

The problem was specific. Classes, like procedures, could take formal parameters, but for technical reasons procedures were not allowed as class parameters — even though it was obviously useful to have "the same statements" behave slightly differently in different objects. After considerable argument they arrived at the mechanism: declare a procedure in class C as virtual, and a subclass D may redefine it, with the redefinition taking effect in D's objects even when the call sits in C's own code. The same call site activates different versions of the procedure. The proposal reached the Lysebu conference just in time and was folded into the final version of the paper.

What modern languages call virtual methods and dynamic dispatch is the product of those few weeks.

Freezing It, and Shipping It

In May 1967 a contract was signed with Control Data for implementations: KCIN for the CDC 3600, the University of Oslo for the CDC 3300, and Control Data itself in Paris for the CDC 6000 series. In June the "Simula 67 Common Base Conference" met at the NCC and set up the Simula Standardization Group. At that meeting Dahl and Nygaard proposed named inline objects — using classes as types in ordinary variable declarations — and the implementers voted it down, presumably because the job was already large enough.

The language was formally frozen by the Simula 67 Common Base Language report, accepted by the Standards Group on 10 February 1968 and published as NCC Publication S-2 that May. The title page of its revised edition (S-22, October 1970) records that SIMULA is a trademark of the Norwegian Computing Center and that the document is under NCC copyright — a marked contrast with BASIC, given away in the same decade.

The Control Data compilers were finished during spring 1969. The NCC then completed implementations for the UNIVAC 1100 series (March 1971) and for the IBM System/360 and 370 (May 1972).

The Missing Term, and Two Descendants

It is worth recording what Simula 67 did not have. Multiple inheritance is absent. So is the phrase "object-oriented programming", which Alan Kay began using at Xerox PARC years later and which was never Dahl and Nygaard's term. "The first object-oriented language" is therefore a claim to handle carefully; the wording the IEEE Milestone citation settles on is that the language introduced all the elements now considered essential to an object-oriented language — encapsulation, inheritance, late binding, and dynamic object creation.

Two lines of descent run out of it. One goes through Alan Kay, who took up Simula's ideas at PARC in the 1970s and produced Smalltalk. The other goes through C++: Bjarne Stroustrup opens his HOPL-II history by stating that "C++ was designed to provide Simula's facilities for program organization together with C's efficiency and flexibility for systems programming." He had written the simulator for his Cambridge doctoral work in Simula, and describes being struck by how directly the class concept let him map the concepts of his application onto the constructs of the language.

Dahl and Nygaard shared the 2001 ACM A.M. Turing Award and the 2002 IEEE John von Neumann Medal. On 27 September 2017 an IEEE Milestone plaque, "Object-Oriented Programming, 1961-1967", was dedicated at the University of Oslo.

One last thing, about how the two of them worked. In their own HOPL paper they noted that in some research teams a new idea is treated with loving care and admiring exclamations — and that this was not the case in the Simula development, where an announced new idea would prompt the other one to brighten up and "do his best to kill it off". Nothing survived into the language without a long argument first.