Simula: What Do you Know About It?

By: Ashwak Sarhan

It is said that if you want to do object-oriented programming, then having a look at SIMULA is a must. If you have not already got yourself familiar with it, here is a brief introduction, but first you may need to know a little about object oriented programming.

Object oriented programming uses two main parts to develop a program: data and operations on data. An object is a piece of code that can interact with other objects to solve a particular problem. Using objects makes it more appropriate to solve a problem in that you do not have to go with the sequence of coding steps like in procedural programming. What does all this have to do with SIMUAL? Well SIMULA was the first OOP language. In fact, SIMULA was the first to introduce objects, classes, sub-classes, methods, and garbage collection.

It was developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard, and has been used in a wide range of applications such as simulating VLSI designs, processes, protocols, algorithms, typesetting, computer graphics, and education. If you are an online student you may have used simulation test software to do an at-home test.

Although it was originally designed for discrete event simulation, it has been expanded to be used as a general purpose programming language. It is important to note that SIMULA is not merely a simulation language, as its name may suggest. Rather, it is a general purpose language with support for simulation. That means that using simulation is a plus.

Just like any other object oriented language, SIMULA uses the classic Hello World code to test its compiler. The UNIVAC Algol 60 was the first compiler on which the SIMULA functioned on January 1965. The couple of years that followed were busy time for Nygaard teaching the SIMULA, which quickly got a reputation as a simulation programming language.

Although SIMULA uses the call by value evaluation in which the argument expression is evaluated, and the resulting value is bound to the corresponding variable in the function (usually by capture-avoiding substitution or by copying the value into a new memory region), but it supports the call by name, in which the arguments to functions are not evaluated at all - rather, function arguments are substituted directly into the function body using capture-avoiding substitution.

For a little deeper look at SIMULA you may want to learn a little about its data types:
Value Types
Integer Short Integer
Real Long Real
Boolean Character
Reference Types
Object Reference Declaration: Ref( Object Identifier) (None is the trivial value)
Text Constants: "A", "Simula", Notext
Text is conceptually a class instance, that has its attributes and methods.
Boolean Procedure Constant; (True if constant)
Text Procedure Main; (Main string - the text is a part of Main)
Integer Procedure Start; (Starting position in Main)
Integer Procedure Length; (Number of characters)
Integer Procedure Pos; (Current position)
Procedure SetPos(i); Integer i; (Changing position)
Boolean Procedure More; (True if Pos <= Length)
Character Procedure GetChar; (Character from Pos)
Procedure PutChar(c); Character c; (Storing character to Pos)
Text Procedure Sub(i, n); Integer i,n; (Substring at i of length n)
Text Procedure Strip; (Removes right spaces)
De-editing Methods:
Integer Procedure GetInt; (Reads integer)
Long Real Procedure GetReal; (Reads real)
Integer Procedure GetFrac; (Like GetInt, ignores spaces)
Editing methods:
Procedure PutInt(i); Integer i; (Writes integer value)
Procedure PutFix(i, n); Integer i,n; (Writes decimal value)
Procedure PutReal(r, n); Long Real r; Integer n; (Writes in scientific format)
Procedure PutFrac(i, n); Integer i,n; (Groups of 3, spaces)
Text generation:
Text Procedure Blanks(n); Integer n; (Returns n blanks)
Text Procedure Copy(T); Text T; (Returns a copy of T)
A SIMULA program is made up of blocks, a sequence of instructions. Each block begins with the word begin, and ends with the word end. For your surprise, a file that contains only begin
is a complete program in SIMULA. This is known as an empty block. You may code the Hello World program as follows:
OutText ("Hello World!");
If you have everything installed and set up correctly, your output will be: Hello World! The code is made up of two major types of instruction: declarations and statements. You can always use comments in your SIMULA code. Comments in SIMULA however are used differently than other known programming languages. In some languages you use the (*) symbol to indicate a comment line; in some you use (). In SIMULA you use the keyword comment. For example, to comment your Hello World code you may insert the following line: comment My first SIMULA code.

SIMULA is not as commonly used as other ones such as C and C++, but it has its own power and uses. With some difference from other ones, it does have all the capabilities for a general purpose language.

How Object-Oriented Programming Started. (2007, May 23). Retrieved June 24, 2007, from
Object Oriented Programming. (1996, January 16). ). Retrieved June 24, 2007, from
Simula. (2007, May 23). In Wikipedia, The Free Encyclopedia. Retrieved June 24, 2007, from
What is a computer program? (2007, May 23. Retrieved June 24, 2007, from


» More on Programming