If you want to do object-oriented programming you definitely should have a look at SIMULA. SIMULA is the first and still the most advanced object-oriented programming language available on a wide variety of machines *including* the Atari ST.
SIMULA has been in general use for twenty years and the soundness of its philosophical foundation has been thoroughly established.

SIMULA in a Nutshell

Conventional general-purpose algorithmic capability in the style of ALGOL 60.

Object-oriented programming (classes) encompassing encapsulation, inheritance, information hiding, autonomous activity and strong typing, supporting the concepts of modularisation, generalisation, specialisation, abstraction, polymorphism and pseudo-parallelism.

Basic features for manipulating text strings.

File concept supporting sequential and direct access methods for byte- and record-structured files.

Large repertoire of utility functions.

Features supporting 2-way linked lists. More complicated list structures such as trees and lattices are easily constructed from the basic class facilities.

Features supporting discrete event simulation in various styles including the object-oriented process view.

It should be emphasised that although in many quarters SIMULA is best known for its simulation features, it is a truly general- purpose language in the widest sense and was the inspiration for almost all developments in the field of object-oriented programming. For a growing number of users the name is becoming an acronym for SIMple Universal LAnguage.

What you get with each SIMULA system

Object oriented programming. A typical SIMULA program execution consists of a set of interacting processes or *objects*. Objects are incarnations of some prototype or *class*, generated during the execution of the program. Programs written in SIMULA in the object-oriented style preserve more accurately the identities and relationships of the functional entities occurring naturally in the computation.

Strong typing, checked mostly at compile time, ensuring that objects are manipulated in a manner consistent with their specification.

Objects may act independently of each other in "quasi- parallel". This enables the class objects to act as coroutines, so that the autonomous activity of any object may be temporarily suspended, later to be resumed at the exact point of suspension. Coroutines facilitate a faithful representation of systems composed of not only passive objects but also active ones in which distinct bursts of activity are tightly coupled in the notion of a coherent process. This feature is an extra dimension to those commonly associated with object-oriented languages and is only recently beginning to appear in some of the newer ones.

List processing. The standard class "Simset" may be invoked to add list processing capabilities to the basic language features. The programmer will then have tools for the efficient manipulation of common aggregate information structures, including queues, dequeues, stacks and cyclic buffers. The facilities of Simset can be further refined for more specialised purposes.

Simulation. Application of the standard class "Simulation" converts SIMULA into a powerful tool for discrete event simulation in a style which preserves in the model the inherent structure of the system under study. Object-oriented programming originated in process-oriented simulation and simulation in SIMULA is the epitome of the object-oriented paradigm.

Powerful text handling, dynamic arrays, flexible file handling, etc.

Modularisation. Separate compilation of classes and procedures is an integral part of the language. The strong typing extends to separately compiled modules allowing the construction of large SIMULA systems to be partitioned into subtasks, which may be assigned to different work groups without fear of undetected incompatibilities.

Garbage collection. Languages without automatic object storage administration cause their practitioners enormous problems in determining the life span of objects. This leads either to the premature demise of useful objects or to the silting up of memory resulting in unwanted and sometimes irreproducible situations which defy diagnosis. SIMULA has automatic garbage collection, eliminating intractable problems of this nature.

Portability. SIMULA has a rigid standard definition and programs are highly portable between different computer systems (source code compatibility).

Contact for SIMULA in Germany:

          SIMULA Project
          c/o University Dortmund / IRB
          P.O.B. 50 05 00
          D - W4600 Dortmund 50
          F.R. Germany

The most recent version is stored on the Simula database on Bitnet and Internet. On Bitnet get a copy by sending GET SIMULA INFO as first line of your email to Listserv@dearn.

On Internet use Gopher or ftp to and look in the pub/simula directory.
Send additions and corrections to Jan Scheutjens

If you have some comments,or suggestions please mail to :