Simulation Readings Series SIMULA’s Place in Simulation History

Citation: McHaney, Roger, Simulation Readings Series: SIMULA’s Place in Simulation History, Kansas State University, Manhattan, KansasSIMULA (SIMulation LAnguage) is a computer programming language that was conceptualized, designed, and created at the Norwegian Computing Centre in Oslo by Ole-Johan Dahl and Kristen Nygaard. Originally, SIMULA was intended to facilitate development of models for complex real world systems. It contained elements of both a standardized system description and a programming language. With system concepts based on Nygaard's experience working with operations research projects in the early 1950's, SIMULA was implemented as a discrete event computer simulation language. Initial constructs were influenced by symbolic notation used in the 1950's to construct flow diagrams representing system operation and rules governing system behaviors [1]. Early foundations for SIMULA first appeared in 1961. By this time, Nygaard had developed a fragmentary set of ideas that relied on Monte Carlo techniques to represent random variation in the occurrence of delays experienced by customers passing through a network of processes. These processes consisted of a queue portion and a service portion. The service portions were constructed with a series of statements governing the action of passive entities or customers that used these stations. Customers were created at a given station and after completing service, would be transferred to the queue of another station. After obtaining and completing service there, the process would be repeated. These transfers would continue until the customer had traversed the network and left the system. The timing and sequence of these stations would determine the number of customers that could be served over a period of time [2]. Although Nygaard had experience with computers, he did not have sufficient knowledge to develop his own programming language. He recruited software expert Ole-Johan Dahl to help him move SIMULA from theory to implementation. In the spring of 1962 Nygaard and Dahl released the first formal proposal for SIMULA. They decided that the best way to make it a real programming language was to link it to an existing, strong language. ALGOL 60, a popular programming language in Europe at the time was selected and SIMULA was developed as an extension, which allowed discrete event simulation construction. Later, SIMULA was expanded and re-implemented as a full-scale general purpose programming language. Although SIMULA has never achieved wide usage, the concepts developed within the language have been highly influential on modern computer programming. SIMULA has been credited with introducing objectoriented programming concepts like classes, objects, inheritance, and dynamic binding [3]. SIMULA's primary use is to develop computer models of systems such as ticket counters, production lines, manufacturing systems, and concurrent processing of computer programs. Today a wide variety of discrete event computer simulation software packages, such as GPSS/H, SIMAN, and ProModel, are used to create similar applications [4–8]. For further reading on simulation in general see Robinson [9–11]

A survey of electric and hybrid vehicle simulation programs

Results of a survey conducted within the United States to determine the extent of development and capabilities of automotive performance simulation programs suitable for electric and hybrid vehicle studies are summarized. Altogether, 111 programs were identified as being in a usable state. The complexity of the existing programs spans a range from a page of simple desktop calculator instructions to 300,000 lines of a high-level programming language. The capability to simulate electric vehicles was most common, heat-engines second, and hybrid vehicles least common. Batch-operated programs are slightly more common than interactive ones, and one-third can be operated in either mode. The most commonly used language was FORTRAN, the language typically used by engineers. The higher-level simulation languages (e.g. SIMSCRIPT, GPSS, SIMULA) used by "model builders" were conspicuously lacking

Performance analysis of local area networks

A simulation of the TCP/IP protocol running on a CSMA/CD data link layer was described. The simulation was implemented using the simula language, and object oriented discrete event language. It allows the user to set the number of stations at run time, as well as some station parameters. Those parameters are the interrupt time and the dma transfer rate for each station. In addition, the user may configure the network at run time with stations of differing characteristics. Two types are available, and the parameters of both types are read from input files at run time. The parameters include the dma transfer rate, interrupt time, data rate, average message size, maximum frame size and the average interarrival time of messages per station. The information collected for the network is the throughput and the mean delay per packet. For each station, the number of messages attempted as well as the number of messages successfully transmitted is collected in addition to the throughput and mean packet delay per station

Object Inheritance Without Classes

Which comes first: the object or the class? Language designers enjoy the conceptual simplicity of object-based languages (such as Emerald or Self) while many programmers prefer the pragmatic utility of classical inheritance (as in Simula and Java). Programmers in object-based languages have a tendency to build libraries to support traditional inheritance, and language implementations are often contorted to the same end. In this paper, we revisit the relationship between classes and objects. We model various kinds of inheritance in the context of an object-oriented language whose objects are not defined by classes, and explain why class inheritance and initialisation cannot be easily modelled purely by delegation

Parallel compilation: A design and its application to SIMULA 67

A design is presented for a parallel compilation facility for the SIMULA 67 programming language. The proposed facility allows top-down, bottom-up, or parallel development and integration of program modules. An evaluation of the proposal and a discussion of its applicability to other languages are then given

Entwurf und Implementierung von CSSA - Beschreibung der Sprache, des Compilers und des Mehrrechnersimulationssystems : Teil E II: Programmdokumentation Teil II

CSSA (Computing System for Societies of Agents) is an interactive programming language for asynchronous multiprocessor systems. Computations are done by concurrently working sequential modules, called agents which implement objects of data and control abstractions. Communication is done by passing messages to acquainted agents. The receiving agent creates an instance of an operation capability referred to in the message. Since agents can be created during the computation and acquaintances can be transmitted in messages the heterarchical agent-net may dynamically change. The language described in volume B of the CSSA-documentation has been successfully implemented for a multiprocessor simulation system running on a general purpose computer. This system allows the execution of CSSA-applications on a wide range of simulated multicomputer configurations. The use of the system is described in volume C. This volume contains the documentation of the different system-components including program sceletons and complete source-listings. Portability problems are discussed in the description of the program development system which is realized in the Siemens BS2000 command language. The reader is expected to have a certain knowledge of this language. Compiler and runtime system are written in SIMULA using to a large degree the more sophisticated language concepts of SIMULA, such as CLASS SIMULATION, hierarchical class definitions, virtual attributes of classes and prefix blocks. Therefore extensive knowledge of the SIMULA language is necessary for reading this volume

Block oriented simulation of combined systems

summary:A programming system BOSCOS is described, which permits the computer to transform descriptions of combined systems into corresponding simulation programmes. The combined systems are composed of continuous blocks and discrete processes. The blocks behave according to ordinary differential equations or assignment statements, or represent networks composed of such blocks; the structure of the networks can vary in time. Interactions between blocks and processes are possible. The system has been implemented as a knowledge base (a class of formal definitions) in a object oriented programming language SIMULA

Component-based simulation for a reconfiguration study of transitic systems

This paper is organized as follows. Part A presents the context of reconfiguring transitic systems and the main idea in implementing the decision step. It comprises sections 1 to 3. Section 3 presents an example that illustrates the concepts presented in the next sections. Parts B and C express the models and principles used to simulate transitic systems, the result of which will be helpful for choosing the new configuration. Part B focuses mainly on models. It comprises sections 4 to 6. Part C focuses mainly on simulation principles. It comprises sections 7 to 10

An object-oriented approach to application generation

The TUBA system consists of a set of integrated tools for the generation of business-oriented applications. Tools and applications have a modular structure, represented by class objects. The article describes the architecture of the environments for file processing, screen handling and report writing