H ? « »

Language peer sets for SIMULA 67:
Norway
Norway/1967
Designed 1967
1960s languages
Third generation
High Cold War
Genus Process interaction
Specialised Languages
Process interaction
Discrete
Simulating
Process interaction/1967
Discrete/1967
Simulating/1967
Process interaction/Norway
Discrete/Norway
Simulating/Norway
Specialised Languages
Specialised Languages/1967
Specialised Languages/no

SIMULA 67(ID:301/sim053)

Object-oriented simulation language 

alternate simple view
Country: Norway
Designed 1967
Published: 1967
Genus: Process interaction
Sammet category: Specialised Languages


for SImple Universal LAnguage

Generla purpose language derived from Algol and Simula 1, with influences from SIMSCRIPT

Introduced important OOP concepts like classes and objects, inheritance, and dynamic binding.  The language was defined in 1967 in the "SIMULA Common Base Language". The language definition has been maintained by the SIMULA Standards Group (SSG), and the latest definition is found in the "SIMULA Standard", adopted by the SSG in 1986.

The "object-orientation" involved in SIMULA 67 pertains to the "object-system" with comprised the system which the simulation stood for, and was an extension to the (then current) notion of "problem-oriented" languages as opposed to "machine-oriented" languages.

Simula 67 works as a general-purpose language because it models all programming problems as simulations - it is modelling real-world systems every time it runs. Thus it is properly an "object-system"-oriented language, which is a move away from the ideal of an abstract algorithm being the dominating force in program design. The notion of an "object" as an entity per-se does not arrive until the biological metaphor involved in the creation of SmallTalk.



People:
Structures:
Related languages
Simscript N SIMULA 67   Incorporated some features of
SIMULA SIMULA 67   Evolution of
SIMULA 67 2.PAK   Based on
SIMULA 67 ABEL   Evolution of
SIMULA 67 Astral   Extension of
SIMULA 67 BETA   Evolution of
SIMULA 67 C with Classes   Influence
SIMULA 67 DELTA   Evolution of
SIMULA 67 DEMOS   Extension of
SIMULA 67 DISCO   Based on
SIMULA 67 FLEX   Subset
SIMULA 67 Framework Simula   Evolution of
SIMULA 67 GPSSS   Augmentation of
SIMULA 67 HEOPS   Incorporated features of
SIMULA 67 LOGLAN   Evolution of
SIMULA 67 MODEL   Incorporated some features of
SIMULA 67 Newton   Incorporated some features of
SIMULA 67 POOMAS   Subset

References:
  • Dahl, O.-J. (1968) Dahl, O.-J. "Discrete event simulation languages" (notes from NATO school lectures) pp 349-394
          in Genuys, F. (1968) Genuys, F. ed.: Programming Languages. Academic Press, London, 1968
  • Dahl, O.-J. and Nygaard, K. (1968) Dahl, O.-J. and Nygaard, K. "Class and subclass declarations"
          in Buxton, J. (1968) Buxton, J. ed.: Simulation Programming Languages. Proceedings from the IFIP Working Conference in Oslo, May 1967, North Holland, 1968.
  • Dahl, O.J., Myhrhaug, B., Nygaard, K., SIMULA 67 - (1968) Dahl, O.J., Myhrhaug, B., Nygaard, K., SIMULA 67 - Common Base Language. Norwegian Computing Center Forskningveien 1B, Oslo 3, Norway (May 1968).
          in Buxton, J. (1968) Buxton, J. ed.: Simulation Programming Languages. Proceedings from the IFIP Working Conference in Oslo, May 1967, North Holland, 1968.
  • Dahl, Ole-Johan; Myhrhaug, Bjørn; Nygaard, Kristen (1968) Dahl, Ole-Johan; Myhrhaug, Bjørn; Nygaard, Kristen "Some features of the SIMULA 67 language" Abstract
          in [Proceedings] (1968) Proceedings of the second conference on Applications of simulations, 1968, New York, New York, United States
  • Ichbiah, Jean D. (1971) Ichbiah, Jean D. "Extensibility in Simula 67" pp84-86 Abstract
          in [ISEL 1971] (1971) [ACM] SIGPLAN Notices 6(12) December 1971 Proceedings of the international symposium on Extensible languages Grenoble, France 1971
  • Vaucher, Jean G. (1971) Vaucher, Jean G. "Simulation data structures using SIMULA 67" pp255-260 Abstract
          in [Proceedings] (1971) The 5th Winter Simulation Conference 8-10 December 1971 Waldorf-Astoria Hotel, New York, NY
  • Kay, I. M. (1972) Kay, I. M. "Digital Discrete Simulation Languages. Discussion and Inventory" Extract: Simula and Simula 67
          in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
  • Birtwistle, G. M. (1973) Birtwistle, G. M. "Simula - Its Features and Prospects" in "High Level Programming Languages - The Way Ahead" (National Computing Centre, 1973)
          in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
  • Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Ny (1973) Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Nygaard, K. "Simula begin", Studentlitteratur, Lund, Sweden, 1973.
          in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
  • Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Ny (1973) Birtwistle, G. M.; Dahl, O-J.; Myhrhaug, B. and Nygaard, K. "Simula begin", Studentlitteratur, Lund, Sweden, 1973.
          in Kay Ira M. (1972) Kay Ira M. and John McLeod,(Eds.), Progress in Simulation. New York: Gordon and Breach 1972
  • Ichbiah and Morse (1973) Ichbiah, J.D., Morse, S.P., "General concepts of the Simula 67 Programming Language"
          in Halpern, Mark I and Shaw Christopher J (eds) (1973) Halpern, Mark I and Shaw Christopher J (eds) "Annual Review in Automatic Programming" (7) 1973 Pergamon Press, Oxford
  • Sammet, Jean E. (1973) Sammet, Jean E. "Roster of Programming Languages for 1973" p147
          in (1974) ACM Computing Reviews 15(04) April 1974
  • Palme, Jacob (1976) Palme, Jacob "Experience from the Standardization of the SIMULA Programming Language" pp405-409
          in (1976) Software — Practice and Experience 6(03) July-September 1976
  • (1976) The Higher Order Language Working Group (HOLWG) Working Paper on 23 exisitng programming languages
          in (1976) Software — Practice and Experience 6(03) July-September 1976
  • Wichmann, B. A. (1976) Wichmann, B. A. "Ackermann's function: a study in the efficiency of calling procedures" BIT 16 (1976), pp103-110 Abstract Extract: Introduction Extract: Ackermann's function Extract: Acknowledgements Extract: Results of tests (altered to include authors where known) Extract: Program listing Extract: Properties of the algorithm Extract: Notes on the results and Factors influencing the execution speed Extract: Conclusion
          in (1976) Software — Practice and Experience 6(03) July-September 1976
  • Foster, J. (1977) Foster, J. M. and Foster, P. D. Abstract data and functors pp161-167
          in [Proceedings] (1977) Proceedings of the Strathclyde ALGOL 68 conference Glasgow, Scotland 1977
  • Sammet, Jean E (1978) Sammet, Jean E "Roster of programming languages for 1976-77" pp56-85
          in [SIGPLAN] (1978) SIGPLAN Notices 13(11) Nov 1978
  • Eklundh, Berth (1979) Eklundh, Berth "SIMULA-a way of thinking" Abstract
          in [Proceedings] (1979) The 11th Winter Simulation Conference 3-5 December 1979 Holiday Inn Embarcadero, San Diego, CA
  • Atkins, S. M. (1980) Atkins, S. M. "A comparison of SIMULA and GPSS for simulating sparse traffic" Simulation 34, 3 (March 1980), 93- 100.
          in [Proceedings] (1979) The 11th Winter Simulation Conference 3-5 December 1979 Holiday Inn Embarcadero, San Diego, CA
  • Palme, Jacob (1981) Palme, Jacob "Uses of the SIMULA Process Concept" Foersvarets Forskningsanstalt, Stockholm (Sweden). Feb 81, FOA-C-10172-M6
          in [Proceedings] (1979) The 11th Winter Simulation Conference 3-5 December 1979 Holiday Inn Embarcadero, San Diego, CA
  • Steensgaard-Madsen, J. (1981) Steensgaard-Madsen, J. " Statement-Oriented Approach to Data Abstraction" pp1-10 Extract: Introduction
          in (1981) TOPLAS 3(1) January 1981
  • Kreutzer, W. (1982) Kreutzer, W. review of Palme 1982 in ACM Computing Reviews August 1982 Abstract
          in (1981) TOPLAS 3(1) January 1981
  • Papazoglou, M P.; Georgiadis, P I.; Maritsas, D G (1984) Papazoglou, M P.; Georgiadis, P I.; Maritsas, D G. "An outline of the programming language SIMULA" pp107 - 131
          in (1984) Computer Languages 9(2)
  • (1987) "Data Processing Programming Languages SIMULA", Swedish Standard SS 63 61 14 (1987), ISBN 91-7162-234-9, available through ANSI.
          in (1984) Computer Languages 9(2)
  • (1987) "Et portabelt Simula-system bygget paa C." Hovedoppgave til cand.scient-graden av Sverre Johansen. Institutt for informatikk, Universitetet i Oslo, Mai 1987.
          in (1984) Computer Languages 9(2)
  • (1987) "Object-Oriented Programming with SIMULA", Bjorn Kirkerud, A-W 1989. Abstract
          in (1984) Computer Languages 9(2)
  • (1989) "Viderefoering og testing av et portabelt Simula-system." Hovedoppgave til cand.scient.-graden av Terje Mjoes. Institutt for informatikk, Universitetet i Oslo, April 1989.
          in (1984) Computer Languages 9(2)
  • J. R. Holmevik, (1994) J. R. Holmevik, "Compiling SIMULA: a historical study of technological genesis" pp25-37
          in [AHC] (1994) Annals of the History of Computing 16(1) Spring 1994
  • George Gray (2002) George Gray "UNIVAC and ALGOL" Unisys History Newsletter 6(2) June 2002 Extract: Information Online copy at UNISIS History
          in [AHC] (1994) Annals of the History of Computing 16(1) Spring 1994
    Resources
    • Simula to C translator
    •  EBNF - Syntax of SIMULA 67


        1 <program> :: {<block prefix>}<block> | {<block prefix>}<compound statement>
        2  <block prefix> ::= <class identifier>{(<actual paremeter list>)}
        3   <block> ::= <block head>;<compound tail>
        4    <block head> ::= <block head>;<declaration> | BEGIN <declaration>

        5 <declaration> ::= <type declaration> | <array declaration> | <switch declaration> | <procedure declaration> | <class declaration> | <external declaration>
        6  <type declaration> ::= <type><identifier list>
        7   <type> ::= BOOLEAN | CHARACTER | INTEGER | REAL | REF(<class declaration>) | TEXT
        8   <identifier list> ::= {<identifier list>,}<identifier>
        9  <array declaration> ::= {<type>} ARRAY <array list>
       10   <array list> ::={<array list>,} <array segment>
       11    <array segment> ::= <identifier list>[<bound pair list>]
       12     <bound pair list> ::= {<bound pair list>,}<arithmetic expression>:<arithmetic expression>
       13  <switch declaration> ::= SWITCH <switch identifier> := <switch list>
       14   <switch identifier> ::= <identifier>
       15   <switch list> ::= {<switch list>,}<designational expression>
       16  <procedure declaration> ::= {<type>} PROCEDURE <procedure heading>;<proceduere body>
       17   <procedure heading> ::= <procedure identifier>{<formal parameter part>;{<mode part>;}<specification part>}
       18    <formal parameter part> ::= (<identifier list>)
       19    <mode part> ::= {<value part>;}<name part> | {<name part>;}<value part>
       20     <value part> ::= VALUE <identifier list>
       21     <name part> ::= NAME <identifier list>
       22    <specification part> ::= {<specification part>;}<specifier><identifier list>
       23     <specifier> ::= {<type>} ARRAY | LABEL | {<virtual part>;}<identifier list>
       24   <procedure body> ::= <statement>
       25  <class declaration> :: {<prefix>} CLASS <class heding>;{<virtual part>;}<class body>
       26   <prefix> ::= <class identifier>
       27   <class heading> ::= <class identifier>{<formal paremeter part>;{<value part>;}<specification part>}
       28    <class identifier> ::= <identifier>
       29   <virtual part> ::= VIRTUAL: <virtual specification part>
       30    <virtual specification part> ::= {<virtual specification part>;}<virtual specifier><identifier list>
       31     <virtual specifier> ::= LABEL | {<type>} PROCEDURE | SWITCH
       32   <class body> ::= <split body> | <statement>
       33    <split body> :: <initial part> INNER; <compound tail>
       34     <initial part> ::= BEGIN | <block head>; | <initial part><statement>
       35  <external declaration> ::= EXTERNAL {<type>} PROCEDURE <external list> | EXTERNAL CLASS <external list>
       36   <external list> ::= {<external list>,}<external item>
       37    <external item> ::= <external identifier> | <identifier> = <external identifier>

       38 <compound statement> ::= BEGIN <compound tail>
       39  <compound tail> ::= END | <statement>;<compound tail>
       40   <statement> ::= <label list><statement> | <conditional statement> | <connection statement> | <repetition statement> | <unconditional statement>
       41    <label list> ::= {<label list>}<label>:
       42     <label> ::= <identifier>
       43    <conditional statement> ::= <if clause><connection statement> | <if clause><repetition statement> | <if clause><unconditional statement>{ELSE <statement>}
       44     <if clause> ::= IF <Boolean expression> THEN
       45    <connection statement> ::= INSPECT <object expression><connection part>{OTHERWISE <statement>}
       46     <connection part> ::= DO <statement> | <selective part>
       47      <selective part> ::= {<selective part>} WHEN <class identifier> DO <statement>
       48    <repetition statement> ::=<for statement> | <while statement>
       49     <for statement> ::= FOR <variable> :- <reference list> DO <statement> | FOR <variable> := <value list> DO <statement>
       50      <reference list> ::= {<reference list>,}<reference expression> {WHILE <Boolean expression>}
       51      <value list> ::= {<value list>,}<value list element>
       52       <value list element> ::= <value expression>{WHILE <Boolean expression>} | <arithmetic expression> STEP <arithmetic expression> UNTIL <arithmetic expression>
       53     <while statement> ::= WHILE <Boolean expression> DO <statement>
       54    <unconditional statement> ::= <basic statement> | {<block prefix>}<block> | {<block prefix>}<compound statement>
       55     <basic statement> ::= <activation statement> | <assignment statement> | <dummy statement> | <goto statement> | <object generator> | <procedure satement>
       56      <activation statement> ::=<activator><object expression>{<scheduling part>}
       57       <activator> ::= ACTIVATE | REACTIVATE
       58       <scheduling part> ::= AT <arithmetic expression>{PRIOR} | DELAY <arithmetic expression> {PRIOR} | BEFORE <object expression> | AFTER <object expression>
       59      <assignment statement> ::= <reference assignment> | <value assignment>
       60       <reference assignment> ::= <reference left part> :- <reference right part>
       61        <reference left part> ::= <variable> | <procedure identifiere>
       62        <reference right part> ::= <reference expression> | <reference assignment>
       63       <value assignment> ::= <value left part> := <value right part>
       64        <value left part> ::= <variable> | <procedure identifier> | <simple text expression>
       65        <value right part> ::= <value expression> | <value assignment>
       66      <dummy statement> ::= <empty>
       67      <goto statement> ::= GOTO <designational expression>
       68      <object generator> ::= NEW <class identifier> {(<actual parameter list>)}
       69      <procedure statement> ::= {<simple reference expression>,}<procedure identifier>{(<actual parameter list>)}
       70       <simple reference expression> ::= <simple object expression> | <simple text expression>
       71       <actual parameter list> ::= {<actual parameter list>,}<actual parameter>
       72        <actual parameter> ::= <expression> | <array identifier> | <procedure identifier> | <switch identifier>
       73         <array identifier> ::= {<simple object expression>.}<identifier>
       74         <procedure identifier> ::= {<simple reference expression>.}<identifier>

       75 <expression> ::= <designational expression> | <reference expression> | <value expression>
       76  <designational expression> ::= <simple designational expression> | <if clause> <simple designational expression> ELSE <designational expression>
       77   <simple designational expression> ::= (<designational expression>) | <labal> | <switch designator>
       78    <switch designator> ::= <switch identifier>[<arithmetic expression>]
       79  <reference expression> ::= <object expression> | <text expression>
       80   <object expression> ::= <simple object expression> | <if clause><simple object expression> ELSE <object expression>
       81    <simple object expression> ::= (<object expression>) | NONE | <function designator> | <local object> | <object generator> | <qualified object> | <variable>
       82     <fuction designator> ::= <procedure identifier> {(<actual parameter list>)}
       83     <local object> ::= THIS <class identifier>
       84     <qualified object> ::= <simple object expression> QUA <class identifier>
       85   <text expression> ::= <simple text expression> | <if clause><simple text expression> ELSE <text expression>
       86    <simple text expression> ::= (<text expression>) | NOTEXT | <function designator> | <variable>
       87   <value expression> ::= <arithmetic expression> | <Boolean expression> | <character expression> | <text value expression>
       88    <simple arithmetic expression> ::= <simple arithmetic expression> | <if clause><simple arithmetic expression> ELSE <arithmetic expression>
       89     <simple arithmetic expression> ::= {{<simple arithmetic expression>}<adding operator>}<arithmetic term>
       90      <adding operator> ::= + | -
       91      <arithmetic term> ::= {<arithmetic term><multiplying operator>}<arithmetic factor>
       92       <multiplying operator> ::= x | / | ÷
       93       <arithmetic factor> ::= {<arithmetic factor>^}<arithmetic primary>
       94        <arithmetic primary> ::= (<arithmetic expression>) | <function designator> | <unsigned number> | <variable>
       95         <unsigned number> ::= <decimal number> {<exponent part>} | <exponent part>
       96          <decimal number> ::= <unsigned integer>{<decimal fraction>} | <decimal fraction>
       97           <unsigned integer> ::= {<unsigned integer>}<digit>
       98           <decimal fraction> ::= .<unsigned integer>
       99          <exponent part> ::= \10{<adding operator>}<unsigned integer>
      100    <Boolean expression> ::= <simple Boolean> | <if clause><simple Boolean> ELSE <Boolean expression>
      101     <simple Boolean> ::= {<simple Boolean> \equ} <implication>
      102      <implication> ::= {<implication> \imp}<Boolean term>
      103       <Boolean term> ::= {<Boolean term> \or}<Boolean factor>
      104        <Boolean factor> ::= {<Boolean factor> \and}{\not}<Boolean primary>
      105         <Boolean primary> ::= (<Boolean expression>} | <logical value> | <function designator> | <relation> | <variable>
      106          <logical value> ::= TRUE | FALSE
      107          <relation> ::= <qualification relation> | <reference relation> | <value expression>
      108           <qualification relation> ::= <simple object expression><qualification tester><class identifier>
      109            <qualification tester> ::= IS | IN
      110           <reference releation> ::= <object reference relation> | <text reference relation>
      111            <object reference relation> ::= <simple object expression> <reference comparator><simple object expression>
      112             <reference comparator> ::= == | =/=
      113            <text reference relation> ::= <simple text expression><refernce comparator><simple text expression>
      114           <value relation> ::= <arithmetic relation> | <character relation> | <text value relation>
      115            <arithmetic relation> ::= <simple arithmetic expression><relational operator><simple arithmetic expression>
      116             <relational operator> ::= < | ¾ | = | „ | > | ‚
      117            <chracter relation> ::= <simple character expression><relational operator><simple character expression>
      118            <text value relation> ::= <simple text value><relational operator><simple text value>
      119    <character expression> ::= <simple character expression> | <if clause><simple character expression> ELSE <character expression>
      120     <simple character expression> ::= (<character expression> | <character constant> | <function designator> | <variable>
      121     <character constant> ::= ′<any basic symbol>′
      122   <text value expression> ::= <simple text value> | <if clause><simple text value> ′ELSE′ <text value expression>
      123    <simle text value> ::= <simple text expression> | <text constant>
      124     <text constant> ::= ′<any sequence of basic symbols>′

      125 <variable> ::= <simple object expression>.<variable> | <simple variable> | <subscripted variable>
      126  <simple variable> ::= <identifier>
      127   <identifier ::= {<identifier>}<letter> | <identifier><digit>
      128    <letter> ::= A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
      129    <digit> ::= 0|1|2|3|4|5|6|7|8|9|0
      130  <subscripted variable> ::= <array identifier>[<subscript list>]
      131   <subscript list> ::= {<subscript list>,}<arithmetic expression>

       


      # special signs:

      ÷    ... division - a line between two dots aligned verticaly  (92)
      ^    ... power - an up-arrow  (93)
      \10  ... power of ten - a lowered "10"  (99)
      \equ ... logical equation - three strokes aligned verticaly  (101)
      \imp ... logical implication - a "U" turned counter-clockwise  (102)
      \or  ... logical or - a sign like a "v"  (103)
      \and ... logical and - like a flipped "v"  (104)
      \not ... logical not "¬" - like a flipped and conter-clockwise turned "L" (104)

       

       

       

      ');">: Grammar
    • Ole-Johan and Kristen: some personal reminiscences
      "We oldies remember the good old days of the 1960's and 70's when hardly anyone gave a damn about objects. As a last aside, in 1960 I worked for one of the UK's grand old men of simulation, Tocher, for the summer. When I next saw him in 1974 I told him where I had been and he responded "Nygaard and Dahl. What's happened to them? They blazed onto the scene like comets in the early sixties, and then just vanished." Not quite, fortunately. I then tried to congratulate Tocher on using objects in the 1950's to structure his models (this he did calling them activity cycles. Tocher coded in octal not even assembler and resorted to an activity based simulation control structure). At this he blew his top and offendedly pronounced objects complete and utter rubbish."

    Search in: Google  Google scholar  World Cat  Yahoo  Overture  DBLP  Monash bib  NZ  IEEE  ACM portal  CiteSeer  CSB  ncstrl  jstor  Bookfinder