Last updated
Simula - logo.svg
Paradigms Multi-paradigm: procedural, imperative, structured, object-oriented
Family ALGOL
Designed by Ole-Johan Dahl
Developer Kristen Nygaard
First appeared1962;59 years ago (1962)
Stable release
Simula 67, Simula I
Typing discipline Static, nominative
Scope Lexical
Implementation language ALGOL 60 (primarily; some components Simscript)
OS Unix-like, Windows, z/OS, TOPS-10, MVS
Influenced by
ALGOL 60, Simscript
Object-oriented programming languages

Simula is the name of two simulation programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. Syntactically, it is a fairly faithful superset of ALGOL 60, [1] :1.3.1 also influenced by the design of Simscript. [2]


Simula 67 introduced objects, [1] :2, 5.3 classes, [1] :1.3.3, 2 inheritance and subclasses, [1] :2.2.1 virtual procedures, [1] :2.2.3 coroutines, [1] :9.2 and discrete event simulation, [1] :14.2 and features garbage collection. [1] :9.1 Also other forms of subtyping (besides inheriting subclasses) were introduced in Simula derivatives.[ citation needed ]

Simula is considered the first object-oriented programming language. As its name suggests, the first Simula version by 1962 was designed for doing simulations; Simula 67 though was designed to be a general-purpose programming language [3] and provided the framework for many of the features of object-oriented languages today.

Simula has been used in a wide range of applications such as simulating very-large-scale integration (VLSI) designs, process modeling, communication protocols, algorithms, and other applications such as typesetting, computer graphics, and education. The influence of Simula is often understated, and Simula-type objects are reimplemented in C++, Object Pascal, Java, C#, and many other languages. Computer scientists such as Bjarne Stroustrup, creator of C++, and James Gosling, creator of Java, have acknowledged Simula as a major influence. [4]


The following account is based on Jan Rune Holmevik's historical essay. [5] [6]

Kristen Nygaard started writing computer simulation programs in 1957. Nygaard saw a need for a better way to describe the heterogeneity and the operation of a system. To go further with his ideas on a formal computer language for describing a system, Nygaard realized that he needed someone with more computer programming skills than he had. Ole-Johan Dahl joined him on his work January 1962. The decision of linking the language up to ALGOL 60 was made shortly after. By May 1962, the main concepts for a simulation language were set. SIMULA I was born, a special purpose programming language for simulating discrete event systems.

Kristen Nygaard was invited to visit the Eckert–Mauchly Computer Corporation late May 1962 in connection with the marketing of their new UNIVAC 1107 computer. At that visit, Nygaard presented the ideas of Simula to Robert Bemer, the director of systems programming at Univac. Bemer was a great ALGOL fan and found the Simula project compelling. Bemer was also chairperson of a session at the second international conference on information processing hosted by International Federation for Information Processing (IFIP). He invited Nygaard, who presented the paper "SIMULA – An Extension of ALGOL to the Description of Discrete-Event Networks".

The Norwegian Computing Center got a UNIVAC 1107 in August 1963 at a considerable discount, on which Dahl implemented the SIMULA I under contract with UNIVAC. The implementation was based on the UNIVAC ALGOL 60 compiler. SIMULA I was fully operational on the UNIVAC 1107 by January 1965. In the following few years, Dahl and Nygaard spent a lot of time teaching Simula. Simula spread to several countries around the world and SIMULA I was later implemented on other computers including the Burroughs B5500 and the Russian Ural-16.

In 1966 C. A. R. Hoare introduced the concept of record class construct, which Dahl and Nygaard extended with the concept of prefixing and other features to meet their requirements for a generalized process concept. Dahl and Nygaard presented their paper on Class and Subclass declarations at the IFIP Working Conference on simulation languages in Oslo, May 1967. This paper became the first formal definition of Simula 67. In June 1967, a conference was held to standardize the language and initiate a number of implementations. Dahl proposed to unify the type and the class concept. This led to serious discussions, and the proposal was rejected by the board. Simula 67 was formally standardized on the first meeting of the Simula Standards Group (SSG) in February 1968.

Simula was influential in the development of Smalltalk and later object-oriented programming languages. It also helped inspire the actor model of concurrent computation although Simula only supports coroutines and not true concurrency. [7]

In the late sixties and the early seventies, there were four main implementations of Simula:

These implementations were ported to a wide range of platforms. The TOPS-10 implemented the concept of public, protected, and private member variables and procedures, that later was integrated into Simula 87. Simula 87 is the latest standard and is ported to a wide range of platforms. There are mainly four implementations:

In November 2001, Dahl and Nygaard were awarded the IEEE John von Neumann Medal by the Institute of Electrical and Electronics Engineers "For the introduction of the concepts underlying object-oriented programming through the design and implementation of SIMULA 67". In April 2002, they received the 2001 A. M. Turing Award by the Association for Computing Machinery (ACM), with the citation: "For ideas fundamental to the emergence of object oriented programming, through their design of the programming languages Simula I and Simula 67." Unfortunately neither Dahl nor Nygaard could make it to the ACM Turing Award Lecture, [10] scheduled to be delivered at the November 2002 OOPSLA conference in Seattle, as they died in June and August of that year, respectively. [11]

Simula Research Laboratory is a research institute named after the Simula language, and Nygaard held a part-time position there from the opening in 2001. The new Computer Science building at the University of Oslo is named Ole Johan Dahl's House, in Dahl's honour, and the main auditorium is named Simula.

Sample code

Minimal program

The empty computer file is the minimal program in Simula, measured by the size of the source code. It consists of one thing only; a dummy statement.

However, the minimal program is more conveniently represented as an empty block:


It begins executing and immediately terminates. The language lacks any return value from the program.

Classic Hello world

An example of a Hello world program in Simula:

BeginOutText ("Hello, World!");    Outimage; End;

Simula is case-insensitive.

Classes, subclasses and virtual procedures

A more realistic example with use of classes, [1] :1.3.3, 2 subclasses [1] :2.2.1 and virtual procedures: [1] :2.2.3

BeginClass Glyph;       Virtual: Procedure print IsProcedure print;;    BeginEnd;        Glyph Class Char (c);       Character c;    BeginProcedure print;         OutChar(c);    End;        Glyph Class Line (elements);       Ref (Glyph) Array elements;    BeginProcedure print;       BeginInteger i;          For i:= 1 Step 1 Until UpperBound (elements, 1) Do             elements (i).print;          OutImage;       End;    End;        Ref (Glyph) rg;    Ref (Glyph) Array rgs (1 : 4);        ! Main program;    rgs (1):- New Char ('A');    rgs (2):- New Char ('b');    rgs (3):- New Char ('b');    rgs (4):- New Char ('a');    rg:- New Line (rgs);    rg.print; End;

The above example has one super class (Glyph) with two subclasses (Char and Line). There is one virtual procedure with two implementations. The execution starts by executing the main program. Simula lacks the concept of abstract classes, since classes with pure virtual procedures can be instantiated. This means that in the above example, all classes can be instantiated. Calling a pure virtual procedure will however produce a run-time error.

Call by name

Simula supports call by name [1] :8.2.3 so the Jensen's Device can easily be implemented. However, the default transmission mode for simple parameter is call by value, contrary to ALGOL which used call by name. The source code for the Jensen's Device must therefore specify call by name for the parameters when compiled by a Simula compiler.

Another much simpler example is the summation function which can be implemented as follows:

RealProcedure Sigma (k, m, n, u);    Name k, u;    Integer k, m, n; Real u; BeginReal s;    k:= m;    While k <= n DoBegin s:= s + u; k:= k + 1; End;    Sigma:= s; End;

The above code uses call by name for the controlling variable (k) and the expression (u). This allows the controlling variable to be used in the expression.

Note that the Simula standard allows for certain restrictions on the controlling variable in a for loop. The above code therefore uses a while loop for maximum portability.

The following:

can then be implemented as follows:

Z:= Sigma (i, 1, 100, 1 / (i + a) ** 2);


Simula includes a simulation [1] :14.2 package for doing discrete event simulations. This simulation package is based on Simula's object-oriented features and its coroutine [1] :9.2 concept.

Sam, Sally, and Andy are shopping for clothes. They must share one fitting room. Each one of them is browsing the store for about 12 minutes and then uses the fitting room exclusively for about three minutes, each following a normal distribution. A simulation of their fitting room experience is as follows:

Simulation BeginClass FittingRoom; BeginRef (Head) door;       Boolean inUse;       Procedure request; BeginIf inUse ThenBegin              Wait (door);              door.First.Out;          End;          inUse:= True;       End;       Procedure leave; Begin          inUse:= False;          Activate door.First;       End;       door:- New Head;    End;        Procedure report (message); Text message; Begin       OutFix (Time, 2, 0); OutText (": " & message); OutImage;    End;        Process Class Person (pname); Text pname; BeginWhileTrueDoBegin          Hold (Normal (12, 4, u));          report  (pname & " is requesting the fitting room");          fittingroom1.request;          report (pname & " has entered the fitting room");          Hold (Normal (3, 1, u));          fittingroom1.leave;          report (pname & " has left the fitting room");       End;    End;        Integer u;    Ref (FittingRoom) fittingRoom1;        fittingRoom1:- New FittingRoom;    ActivateNew Person ("Sam");    ActivateNew Person ("Sally");    ActivateNew Person ("Andy");    Hold (100); End;

The main block is prefixed with Simulation for enabling simulation. The simulation package can be used on any block and simulations can even be nested when simulating someone doing simulations.

The fitting room object uses a queue (door) for getting access to the fitting room. When someone requests the fitting room and it's in use they must wait in this queue (Wait (door)). When someone leaves the fitting room the first one (if any) is released from the queue (Activate door.first) and accordingly removed from the door queue (door.First.Out).

Person is a subclass of Process and its activity is described using hold (time for browsing the store and time spent in the fitting room) and calls procedures in the fitting room object for requesting and leaving the fitting room.

The main program creates all the objects and activates all the person objects to put them into the event queue. The main program holds for 100 minutes of simulated time before the program terminates.

See also


  1. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 Dahl, Ole-Johan; Myhrhaug, Bjørn; Nygaard, Kristen (1970). Common Base Language (PDF) (Report). Norwegian Computing Center. Archived from the original on 2013-12-25. Retrieved 17 November 2020.CS1 maint: unfit URL (link)
  2. Nygaard, Kristen (1978). "The Development of the Simula Languages" (PDF). The development of .. SIMULA I and SIMULA 67... were influenced by the design of SIMSCRIPT ...
  3. Kristen Nygaard and Ole-Johan Dahl. 1978. The development of the SIMULA languages. History of programming languages. Association for Computing Machinery, New York, NY, USA, 439–480. DOI:
  4. Wong, William. "Before C, What Did You Use?". Electronic Design. Retrieved 22 May 2017.
  5. Holmevik, Jan Rune (1994). "Compiling Simula: A historical study of technological genesis" (PDF). IEEE Annals of the History of Computing. 16 (4): 25–37. doi:10.1109/85.329756. S2CID   18148999 . Retrieved 12 May 2010.
  6. Holmevik, Jan Rune. "Compiling Simula". Oslo, Norway: Institute for Studies in Research and Higher Education. Archived from the original on 20 April 2009. Retrieved 19 April 2017.
  7. Lehrmann Madsen, Ole (2014). "Building Safe Concurrency Abstractions". In Agha, Gul; Igarashi, Atsushi; Kobayashi, Naoki; Masuhara, Hidehiko; Matsuoka, Satoshi; Shibayama, Etsuya; Taura, Kenjiro (eds.). Concurrent Objects and Beyond. Lecture Notes in Computer Science. 8665. Berlin: Springer. p. 68. doi:10.1007/978-3-662-44471-9. ISBN   978-3-662-44471-9. S2CID   1000741.
  8. "GNU Cim".
  9. "Portable Simula Revisited". GitHub. Retrieved 17 June 2019.
  10. "ACM Turing Award Lectures". Retrieved 14 January 2012.
  11. "ACM Ole-Johan Dahl and Kristen Nygaard - Obituary". Archived from the original on 19 July 2011. Retrieved 14 January 2012.


Further reading

Related Research Articles

ALGOL Family of programming languages

ALGOL is a family of imperative computer programming languages originally developed in 1958. ALGOL heavily influenced many other languages and was the standard method for algorithm description used by the Association for Computing Machinery (ACM) in textbooks and academic sources for more than thirty years.

Pascal (programming language) Programming language

Pascal is an imperative and procedural programming language, designed by Niklaus Wirth as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honour of the French mathematician, philosopher and physicist Blaise Pascal.

A computer simulation language is used to describe the operation of a simulation on a computer. There are two major types of simulation: continuous and discrete event though more modern languages can handle more complex combinations. Most languages also have a graphical interface and at least a simple statistic gathering capability for the analysis of the results. An important part of discrete-event languages is the ability to generate pseudo-random numbers and variants from different probability distributions.

Norwegian Computing Center

Norwegian Computing Center is a private, independent, non-profit research foundation founded in 1952. NR carries out contract research and development in the areas of computing and quantitative methods for a broad range of industrial, commercial and public service organisations in the national and international markets. NR's projects cover a large variety of applied and academic problems. NR has its offices near the university campus Blindern in Oslo, Norway, as part of what is known as Forskningsparken, Park of Research.

Ole-Johan Dahl

Ole-Johan Dahl was a Norwegian computer scientist. Dahl was a professor of computer science at the University of Oslo and is considered to be one of the fathers of Simula and object-oriented programming along with Kristen Nygaard.

Kristen Nygaard Computer scientist, mathematician

Kristen Nygaard was a Norwegian computer scientist, programming language pioneer, and politician. Internationally, Nygaard is acknowledged as the co-inventor of object-oriented programming and the programming language Simula with Ole-Johan Dahl in the 1960s. Nygaard and Dahl received the 2001 A. M. Turing Award for their contribution to computer science.

BETA is a pure object-oriented language originating within the "Scandinavian School" in object-orientation where the first object-oriented language Simula was developed. Among its notable features, it introduced nested classes, and unified classes with procedures into so called patterns.

In computer science, a smart pointer is an abstract data type that simulates a pointer while providing added features, such as automatic memory management or bounds checking. Such features are intended to reduce bugs caused by the misuse of pointers, while retaining efficiency. Smart pointers typically keep track of the memory they point to, and may also be used to manage other resources, such as network connections and file handles. Smart pointers were first popularized in the programming language C++ during the first half of the 1990s as rebuttal to criticisms of C++'s lack of automatic garbage collection.

ALGOL 60 is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them, representing a key advance in the rise of structured programming. ALGOL 60 was the first language implementing nested function definitions with lexical scope. It gave rise to many other programming languages, including CPL, Simula, BCPL, B, Pascal, and C. Practically every computer of the era had a systems programming language based on ALGOL 60 concepts.

The history of programming languages spans from documentation of early mechanical computers to modern tools for software development. Early programming languages were highly specialized, relying on mathematical notation and similarly obscure syntax. Throughout the 20th century, research in compiler theory led to the creation of high-level programming languages, which use a more accessible syntax to communicate instructions.

SIMSCRIPT is a free-form, English-like general-purpose simulation language conceived by Harry Markowitz and Bernard Hausner at the RAND Corporation in 1962. It was implemented as a Fortran preprocessor on the IBM 7090 and was designed for large discrete event simulations. It influenced Simula.

In computer programming, a nested function is a function which is defined within another function, the enclosing function. Due to simple recursive scope rules, a nested function is itself invisible outside of its immediately enclosing function, but can see (access) all local objects of its immediately enclosing function as well as of any function(s) which, in turn, encloses that function. The nesting is theoretically possible to unlimited depth, although only a few levels are normally used in practical programs.

Programming language theory Branch of computer science

Programming language theory (PLT) is a branch of computer science that deals with the design, implementation, analysis, characterization, and classification of formal languages known as programming languages and of their individual features. It falls within the discipline of computer science, both depending on and affecting mathematics, software engineering, linguistics and even cognitive science. It has become a well-recognized branch of computer science, and an active research area, with results published in numerous journals dedicated to PLT, as well as in general computer science and engineering publications.

Luca Cardelli

Luca Andrea Cardelli, Fellow of the Royal Society (FRS), is an Italian computer scientist who is a Research Professor at the University of Oxford in Oxford, UK. Cardelli is well known for his research in type theory and operational semantics. Among other contributions, in programming languages, he helped design the language Modula-3, implemented the first compiler for the (non-pure) functional language ML, defined the concept of typeful programming, and helped develop the experimental language Polyphonic C#.

History of Programming Languages (HOPL) is an infrequent ACM SIGPLAN conference. Past conferences were held in 1978, 1993, and 2007. The fourth conference was originally intended to take place in June 2020, but has been postponed.

ALGOL 68RS is the second ALGOL 68 compiler written by I. F. Currie and J. D. Morrison, at the Royal Signals and Radar Establishment (RSRE). Unlike the earlier ALGOL 68-R, it was designed to be portable, and implemented the language of the Revised Report.

Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code: data in the form of fields, and code, in the form of procedures.

Department of Informatics, University of Oslo

The Department of Informatics at the University of Oslo is the oldest and largest department for informatics in Norway. The department was in 2017 ranked number 1 in Norway, 3 in Europe, and 12 in the world in Computer Science and Engineering by Academic Ranking of World Universities.