INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS EN SIMULA

© 1997 J. Sklenar (jaroslav.sklenar@um.edu.mt)

Este documento se basa en un seminario de tecnología de la información titulado "30 años de Programación Orientada a Objetos (OOP)" celebrado en la Universidad de Malta el 5/12/1997. El primer Lenguaje Orientado a Objetos (OOL) Simula 67 fue introducido oficialmente por Ole Johan Dahl y Kristen Nygaard en la Conferencia de Trabajo TC 2 de la IFIP sobre Lenguajes de Simulación en Lysebu, cerca de Oslo, en mayo de 1967. Treinta años representan una generación humana y varias generaciones de computadoras. A pesar de estar en uso durante tanto tiempo, todo el trabajo de programación moderna realizado hoy se basa en los principios de la POO introducidos por primera vez en la definición de Simula. Y lo que es más importante, Simula contiene facilidades que hasta ahora no se han utilizado completamente y ni siquiera comprendido, no solo por el público general de programación, sino también por personas de la comunidad de POO. El propósito de la charla fue hacer una breve introducción de las características principales de Simula, principalmente aquellas que no están presentes en otros lenguajes orientados a objetos. Lo mismo es el propósito de este documento.

Para aquellos interesados en profundizar aún más en este tema y necesiten ayuda con sus ensayos sobre la historia y el impacto de la Programación Orientada a Objetos, pueden considerar servicios que ofrezcan "write my essay". Estos servicios pueden proporcionar asistencia personalizada para escribir ensayos que aborden aspectos específicos de la POO, sus fundamentos y su evolución a lo largo de los años, asegurando una comprensión más profunda y detallada del tema.

Notas:

1. En el texto siguiente, el término "objeto" significa una instancia de clase (nota que los "objetos" de Object Pascal y algunos otros OOL son, de hecho, clases).
2. Puede descargar todos los programas (simprogs.zip) dados en este documento y algunos más. También hay una unidad Turbo Pascal SIMSET.PAS muy similar a Simset de Simula. Úsela si desea trabajar con estructuras de datos con un número variable de elementos. Descomprima el archivo zip en algún directorio, donde encontrará una lista de programas junto con una breve descripción en el archivo Readme.
3. Si eres nuevo en la simulación, considera navegar por la página de Simulación que explica las ideas básicas de la simulación por computadora.

---------------------------------------------------------------------------------------------

‍

CONTENIDO:

1. SIMULA: HECHOS BÁSICOS
2. HISTORIA DE SIMULA I
3. HISTORIA DE SIMULA 67
4. TIPOS DE DATOS EN SIMULA
5. SENTENCIAS EN SIMULA
6. PROCEDIMIENTOS EN SIMULA
7. CLASES EN SIMULA
8. PAQUETES EN SIMULA = CLASES ANIDADAS
9. PAQUETES ESTÁNDAR EN SIMULA
10. SISTEMAS CUASIPARALELOS EN SIMULA
11. SIMULACIÓN = EL MUNDO DE LOS PROCESOS PARALELOS
12. CLASES ANIDADAS EN SIMULA
13. SIMULACIÓN ANIDADA EN SIMULA
14. ¿QUÉ ESTÁ MAL CON SIMULA?
15. REFERENCIAS

SIMULA - DATOS BÁSICOS

Simula I = Lenguaje de simulación discreta orientado a procesos basado en Algol 60. (1964 - 1965) Lenguaje de simulación. (Simple universal language.)

Simula 67 = Lenguaje general orientado a objetos con clases de sistema que admiten listas enlazadas (la clase de sistema Simset) y simulación discreta orientada a procesos (la clase de sistema Simulation). (1967 - 1971) Lenguaje universal simple.

Simula = Simula 67 (El número ya no se utiliza, porque Simula I no se ha utilizado durante mucho tiempo).

Figura 1: Partes principales y líneas de interfaz en el entorno de Simula.

HISTORIA DE SIMULA I

(Fuente: Jan Rune Holmevik: Compilando Simula - ver REFERENCIAS)

1952: Kristen Nygaard comienza a trabajar en Investigación Operativa, incluyendo la redacción de modelos de simulación. Problema: cómo conceptualizar el mundo real de manera compleja. Desde el principio, Simula tenía la intención de ser tanto una descripción del sistema como un lenguaje de programación.

1960: Algol 60 con su verdadera estructura de mecanismo de bloques recursivos basada en el principio de la pila. Se introdujeron todas las estructuras de control importantes. Simula estaba destinado a ser un paquete con un preprocesador para Algol 60.

1962: Ole-Johan Dahl y Kristen Nygaard se encuentran en el Centro de Computación Noruego (NCC) en Oslo. La primera propuesta formal de lenguaje se presentó en el Congreso Mundial IFIP 62 en Múnich.

1962: Proyecto Simula respaldado por UNIVAC, que resultó en la instalación de UNIVAC 1107 en el NCC en 1963.

1963: Conflicto entre el estricto mecanismo de pila Algol y las sofisticadas instalaciones de simulación de Simula orientadas más al principio de la cola. Se abandonó la idea del preprocesador, y Simula sería un lenguaje independiente basado en Algol.

1963: Ole-Johan Dahl trabaja en un nuevo esquema de asignación de almacenamiento basado en una lista bidimensional de áreas libres.

1964: La idea original de clientes pasivos moviéndose a través de una red de componentes activos (enfoque de actividad) se convirtió en un factor limitante. La idea opuesta es posible: clientes activos moviéndose a través de una red pasiva. Esto resultó en un concepto general unificador:

Sistema = conjunto de procesos cuasiparalelos que interactúan.

1964: Primer prototipo del compilador de Simula funcionando en el UNIVAC 1107 del NCC en diciembre, el manual de Simula I apareció en mayo de 1965. Durante el primer año, Simula se aplicó a una amplia variedad de problemas de Investigación Operativa.

HISTORIA DE SIMULA 67

(Fuente: Jan Rune Holmevik: Compilando Simula - ver REFERENCIAS)

1965-66: Simula I se utiliza en Suecia, Alemania, Estados Unidos (Burroughs B5500), la Unión Soviética (URAL 16) y otros países. Esfuerzo por introducir y enseñar el lenguaje.

1965: El concepto de clase de registro de Tony Hoare se presenta en el boletín Algol. Después de un examen cuidadoso, Nygaard y Dahl aceptan las ideas, pero aún falta un tipo de concepto generalizado.

1966: Introducción de la idea de prefijación. Los procesos (más tarde objetos) se componen de dos capas: capa de prefijo, capa principal. Idea de subclases. Nygaard y Dahl comienzan a trabajar en un nuevo lenguaje de alto nivel general.

1967 (mayo): Simula 67 se introduce oficialmente por Dahl y Nygaard en la Conferencia de Trabajo TC 2 de la IFIP sobre Lenguajes de Simulación en Lysebu, cerca de Oslo.

1967 (junio): Definición del estándar Simula 67 llamado Common Base Standard.

1968: Primera reunión del Grupo de Estándares de Simula (SSG). Después de aceptar el manejo de cadenas y la E/S realizado por Bjorn Myhrhaug, Simula queda formalmente congelado.

1973: Se funda la Asociación de Usuarios de Simula (ASU). Simula se utiliza en más de 250 sitios ese año.

Implementaciones:

1969 CDC 3300, 3600 (Noruega - Universidad de Oslo, NDRE)

1971 UNIVAC 1100 (NCC)

1972 IBM 360/370 (NCC)

1972 CII 10070, IRIS 80 (Francia)

1973/74 CDC 6000 (Francia, Países Bajos), CDC Cyber 70 (NDRE)

1975 DEC 10 (Suecia) etc.

Revistas:

Actas de las conferencias anuales de la ASU (primera en 1973 en Oslo)

Boletín informativo de la ASU

TIPOS DE DATOS EN SIMULA

Simula contiene todas las instalaciones comunes de los lenguajes de tercera generación de alto nivel. Es por eso que los dos capítulos siguientes son resúmenes muy breves, siendo el texto la única excepción.

Tipos de Valor

• Integer (Entero)
• Short Integer (Entero Corto)
• Real (Real)
• Long Real (Real Largo)
• Boolean (Booleano)
• Character (Carácter)

Tipos de Referencia

• Referencia a Objeto Declaración: Ref( Identificador de Objeto) (None es el valor trivial)
• Texto Constantes: "A", "Simula", Notext

Conceptualmente, el Texto es una instancia de clase que tiene sus atributos y métodos.

Métodos:

• Boolean Procedure Constant; (Verdadero si es constante)
• Text Procedure Main; (Cadena principal - el texto es una parte de Principal)
• Integer Procedure Start; (Posición de inicio en Principal)
• Integer Procedure Length; (Número de caracteres)
• Integer Procedure Pos; (Posición actual)
• Procedure SetPos(i); Integer i; (Cambiar posición)
• Boolean Procedure More; (Verdadero si Pos <= Longitud)
• Character Procedure GetChar; (Carácter desde Pos)
• Procedure PutChar(c); Character c; (Almacenar carácter en Pos)
• Text Procedure Sub(i, n); Integer i,n; (Subcadena en i de longitud n)
• Text Procedure Strip; (Elimina los espacios a la derecha)

Métodos de Desedición:

• Integer Procedure GetInt; (Lee un entero)
• Long Real Procedure GetReal; (Lee un real)
• Integer Procedure GetFrac; (Como ObtenerEntero, ignora espacios)

Métodos de Edición:

• Procedure PutInt(i); Integer i; (Escribe el valor entero)
• Procedure PutFix(i, n); Integer i,n; (Escribe el valor decimal)
• Procedure PutReal(r, n); Long Real r; Integer n; (Escribe en formato científico)
• Procedure PutFrac(i, n); Integer i,n; (Grupos de 3, espacios)

Generación de Texto:

• Text Procedure Blanks(n); Integer n; (Devuelve n espacios)
• Text Procedure Copy(T); Text T; (Devuelve una copia de T)

Arreglos

Ejemplos de arreglos declarados en bloques (n, m, a, b son variables globales):

• Integer Array MyList (1:100)
• Array Matrix (1:n, 1:m); (El tipo implícito es real)
• Character Array Buffer (1: Si a>b entonces a else b)

SENTENCIAS EN SIMULA

Sentencias simples

Asignación :=    Ejemplos:  X := If a>b Then a Else b ;  X:=Y:=0;  ( ** disponible )

Asignación de Referencia :- Ejemplos: Queue :- New Head;   T :- Blanks(80);

Procedimiento

Go to   Goto

Sentencias estructuradas

Begin ... End;

If ... Then ... ; If ... Then ... Else ... ;

Switch  Ejemplo:

Switch Target := L1, L2, L3, ... ; 

Goto Target( Index_expression );

  L1: ... 

  L2: ...

While ... do ... ;

For (muy general) Ejemplo:

Begin

   Integer i;

   For i:= 1, 13, 20 step 10 until 40, 70, i+1 while i lt 76,

       100 step 50 until 250, 1000, 1500 do  OutInt(i,5);

End;

Salida: 1 13 20 30 40 70 71 72 73 74 75 100 150 200 250 1000 1500

PROCEDIMIENTOS EN SIMULA

Modos de Paso de Parámetros:

Figura 2: Modos de paso de parámetros aplicados a un parámetro de texto.

‍

Procedimientos

Ejemplo de procedimiento con dos parámetros de entrada y uno de salida: (Muestra un texto con sangría a la derecha)

Begin

   Procedure RightText(T, N, FitsIn); Text T; Integer N;

            Name FitsIn; Boolean FitsIn;

   Begin

   Integer I;

   FitsIn := N >= T.Length;  

      For i:=1 step 1 until N-T.Length do OutText(" ");

   OutText(T)

   End of RightText; 

   RightText("Short", 30); OutImage;

   RightText("And the long one", 30);

End of Program;

Salida:

                      Short

           And the long one

Funciones = Procedimientos de Tipo

Ejemplo de función entera con dos parámetros de entrada: (Calcula el máximo común divisor)

Begin

 Integer Procedure GCD(M, N); Integer M, N;

  Begin

  While M<>N do

     If M<N then N := N - M else M := M - N;

  GCD := M

  End of GCD; 

  Integer A, B;

  OutText("Enter an integer number: "); OutImage; A := InInt;

  OutText("Enter an integer number: "); OutImage; B := InInt;

  OutText("Greatest Common Divisor of your numbers is ");

  OutInt(GCD(A,B), 4); OutImage;

End of Program;

Nota: Una función puede ser llamada como si fuera un procedimiento sin tipo.

CLASES EN SIMULA

Figura 3: Las clases en Simula están compuestas por cuatro partes.

Declaración:

Class Rectangle (Width, Height); Real Width, Height;                           ! Class with two parameters;Begin    Real Area, Perimeter;  ! Attributes;    Procedure Update;   ! Methods (Can be Virtual);    Begin      Area := Width * Height;      Perimeter := 2*(Width + Height)    End of Update;    Boolean Procedure IsSquare;      IsSquare := Width=Height;     Update;             ! Life of rectangle started at creation;    OutText("Rectangle created: "); OutFix(Width,2,6);    OutFix(Height,2,6); OutImageEnd of Rectangle;Generación de Objetos:Ref(Rectangle) R; (Variable de referencia de clase)...R :- New Rectangle(50, 40); Actividades involucradas en esta generación de objetos:      Memory allocation, reference stored to R.      Copying values to parameters (value passing only).      Starting the object's body (life rules).Declaración de Subclases:Rectangle Class LocRectangle (X, Y); Integer X, Y;Begin                                     ! More parameters;   Boolean Tall;                         ! More attributes;   Procedure Move (Dx, Dy); Integer Dx, Dy;  ! More methods;   Begin      X := X + Dx; Y := Y + Dy   End of Move;                                             ! Additional life rules;   Tall := Height > Width;   OutText("Located at: "); OutFix(X,2,6); OutFix(Y,2,6); OutImageEnd of LocRectangle;

Object Generation:

Ref(Rectangle) R; (Variables de referencia de clase)
Ref(LocRectangle) LR;

...

R :- New Rectangle(50, 40);
LR :- New LocRectangle(20, 30, 100, 200); (Ten en cuenta que también se proporcionan parámetros para la clase principal.)

Actividades involucradas en la generación de objetos anterior:

   Memory allocation, reference stored to LR.

   Copying values to all parameters (parent class first).

   Starting the body of the parent class, then the subclass.

Esto se puede generalizar a una secuencia de prefijos de cualquier longitud:

Class A; Begin ... LifeA End;
A Class B; Begin ... LifeB End;
B Class C; Begin ... LifeC End;
Ref(C) X;

...

X :- New C;

Si no se cambia por Inner (ver el siguiente párrafo), la secuencia de actividades involucradas en la generación de objetos anterior es:

  LifeA LifeB LifeC 

Rompiendo las reglas de vida con la declaración Inner:

Ejemplos de declaraciones:

Class A; Begin LifeA1 Inner; LifeA2 End;
A Class B; Begin LifeB1 Inner; LifeB2 End;
B Class C; Begin LifeC1 Inner; LifeC2 End;
Ref(C) X;

X :- New C;

La secuencia de actividades involucradas en la generación de objetos anterior es:

  LifeA1 LifeB1 LifeC1 (Inner en la vida de C ignorado) LifeC2 LifeB2 LifeA2

Notas:

1. La ausencia de Inner es lo mismo que Inner justo antes del fin de la clase.
2. Mayormente, se permite un Inner en el cuerpo de la clase.

Bloques de prefijación:

Supongamos un programa con la siguiente estructura:

Begin

   Class A(P); Integer P;

   Begin  LifeA1  Inner;  LifeA2  End;

   Part1

   A(3) Begin

  Block body

   End;

   Part2

End;

Actividades involucradas en la ejecución del bloque prefijado anterior:

    - Crear una instancia de clase de A.

    - Copiar valores a su(s) parámetro(s).

    - Iniciar el cuerpo de la clase, que incluye la ejecución del código del bloque.

Entonces, en el programa anterior, la secuencia de operaciones es la siguiente:

Part1   LifeA1   Block body   LifeA2   Part2

El bloque prefijado es conceptualmente una instancia de clase sin nombre que tiene:

•    parámetros de la clase de prefijo
•    más atributos (atributos de la clase + variables locales del bloque)
•    más métodos (métodos de la clase + procedimientos locales del bloque)
•    reglas de vida más complejas (cuerpo de la clase + cuerpo del bloque).

Notas:

• El mecanismo de prefijación de bloques no es muy útil en el caso de clases simples. El posible uso es la importación de declaraciones de clases (parámetros, atributos y métodos) en el bloque. Se supone que se utiliza principalmente con las clases principales (consulte el siguiente capítulo), que representan módulos creados por principios de OOP. Prefijar un bloque con una clase principal (como por ejemplo Simulation) puede importar entornos de programación completos o lenguajes específicos basados en Simula.
• En los programas de Simula, no hay desasignación explícita de memoria porque el Recolector de Basura recupera automáticamente la memoria ocupada por instancias de clase no referenciadas.

Navigation in the prefix sequence

El siguiente texto se basa en estas declaraciones:

Class A; Begin Ref(A) Link; Procedure Show; ... End;
A Class B; Begin Procedure Show; ... End;
B Class C; Begin Procedure Show; ... End;

Ref(A) XA, First, Current; Ref(B) XB; Ref(C) XC;

1. Calificación mediante la declaración Inspect

a) Simple

Inspect XA do Show; básicamente hace lo mismo queXA.Show;

La diferencia es que con Inspect, si XA = None, la declaración después de do se ignora. Si XA = None, XA.Show resulta en un error en tiempo de ejecución.

b) Probando None mediante la cláusula Otherwise

Inspect XA do Begin
  Show; ...
End
Otherwise Begin
  OutText("Sorry, XA not created"); OutImage
End;

c) Probando el tipo mediante la cláusula When

Mostrando una lista enlazada compuesta por varios elementos de tipos A, B y C, cuyo puntero principal está en First:

Current :- First;

While Current ne None do begin

  Inspect Current

When A do Show ! Show of A;

When B do Show ! Show of B;

When C do Show ! Show of C;

Otherwise OutText("Not a (sub)class of A");

  OutImage;

  Current :- Current.Link

End While;

2. Calificación instantánea mediante la cláusula Qua

Supongamos estas declaraciones basadas en las declaraciones anteriores:XA :- New B;  XB :- New B;XA.Show;     ! Show of A;XA Qua B.Show;  ! Show of B - it is possible to go down;XB Qua A.Show;  ! Show of A - it is possible to go up;XA :- New A;XA Qua B.Show;  ! This is illegal - attributes of B do not exist;

Nota: Propiedades normales de una variable de referencia calificada como B declarada como Ref(B) XB:

• No puede referenciar objetos de la clase A.
• Puede referenciar objetos de la clase B, lo que permite acceder a los atributos de B y a aquellos de A que no han sido redeclarados en B.
• Puede referenciar objetos de la clase C, pero solo se pueden acceder a los atributos de B y no a los atributos de A que no han sido redeclarados.

Estas propiedades normales pueden superarse mediante Inspect o Qua. Ten en cuenta que, según la tercera regla, el mecanismo normal de enlace tardío (como en Object Pascal, por ejemplo) no funciona automáticamente en Simula. La solución a este problema es Inspect con cláusulas When, como se muestra en el ejemplo anterior. La aproximación de Simula quizás sea menos amigable para el usuario, pero es más general y el programador tiene todo bajo control.

3. Referenciándose a sí mismo mediante This

El siguiente código es un método de A que agrega el objeto a la lista First:Procedure Add_to_List(First); Name First; Ref(A) First;BeginLink :- First; First :- This AEnd;

4. Probando la Calificación mediante Is e In

Los siguientes segmentos de código autoexplicativos, basados en las declaraciones Ref(B) XB y Ref(A) XA, muestran el uso de los operadores muy amigables Is e In. Ten en cuenta que, por ejemplo, Object Pascal no tiene un equivalente de In. La única solución a este problema en Object Pascal es la implementación de métodos que devuelvan la identificación de los ancestros.

If XB is B then

  OutText("XB is B")

Else

  OutText("XB is either subclass of B or None");

If XA in B then

  OutText("XA is either B or its subclass")

Else

  OutText("XA is either A or None");

5. Protección de atributos

Los atributos Hidden solo pueden ser utilizados en el cuerpo de la clase donde se declaran.Los atributos Protected solo pueden ser utilizados en los cuerpos de la clase donde se declaran y en todas las subclases.

PAQUETES EN SIMULA = CLASES ANIDADAS

Figura 4: Las clases en Simula se pueden anidar a cualquier profundidad.

Las clases que contienen declaraciones de clases locales se llaman clases principales. El siguiente código de ejemplo define una clase principal llamada Geometry.

! The program defines the main class "Geometry". ;

! It represents a theory with terms "point, rectangle, circle, and line".;

Class Geometry;

Begin

  Class Point(X,Y); Real X,Y;

  Begin

Procedure Print; Begin  ...  End;

Procedure Shift(Dx, Dy); Real Dx, Dy; Begin  ...  End;

Print;              ! Life of point;

  End of Point;

 Class Rectangle(RecName, Width, Height);

    Text RecName; Real Width, Height;

  Begin

Real Area, Perimeter;

Procedure Update; Begin  ...  End;

Procedure Show; Begin  ...  End;

Update; Show;       ! Life of rectangle;

  End of Rectangle; 

  Class Circle(Radius, Center); Real Radius; Ref(Point) Center;

  Begin

Procedure Shift(Dx, Dy); Real Dx, Dy; Begin  ...  End;

OutText("Circle created at "); ! Life of circle;

Center.Print;

  End of Circle; 

  Class Line(M,N); Ref(Point) M,N; ! Line defined by two points;

  Begin

Real Slope;

Slope :=  ...  ;   ! Life of line;

  End of Line; 

  !Variables declared in geometry: ;

  Ref(Point) Origin, A, B;

  Ref(Line) X,Y;

 !Life of geometry: ;

Origin :- New Point(0,0); ! Creating the origin;  

‍A :- New Point(1,0);

B :- New Point(0,1);  

X :- New Line(Origin,

A); ! Creating the axes;  

Y :- New Line(Origin, B);  

OutText("*** Geometry initialized ***"); OutImage;

End of Geometry;

El siguiente programa utiliza la clase principal Geometry. Observa cómo las clases declaradas en Geometry se utilizan para declarar subclases especializadas para el problema que se está resolviendo. Más tarde, es posible declarar y utilizar variables de referencia calificadas en clases tanto importadas como declaradas localmente. Esta es la idea fundamental de los paquetes basados en Simula o los lenguajes definidos por el usuario (¿cuál es la diferencia?).

External Class Geometry;

Geometry Begin  ! Subclasses declared in the prefixed block: ;  

Point Class Color_Point(C); Character C; Begin  ...  End;  

Rectangle Class Square; Begin  ...  End;  

! Variables declared in the prefixed block: ;  

Ref(Color_Point) A1;  Ref(Point) C, D;

Ref(Circle) K;

  Ref(Line) E, F;

  Ref(Rectangle) R1;

  Ref(Square) S1; 

! Block body: ;

  C :- New Point(5,6);

  D :- New Point(20,30);

  A1 :- New Color_Point(3, 4, 'G');

  K :- New Circle(10, C);

E :- New Line(C, D);  

F :- X;  K.Shift (1,1);  

R1 :- New Rectangle("Rec_R1", 5, 4);  

S1 :- New Square("Square_S1", 4, 6);

S1.Show;

End of prefixed block;

PAQUETES ESTÁNDAR DE SIMULA

Entorno - las instalaciones del sistema

Atributos disponibles para:

Constantes ambientales (MaxInt, MaxReal, ...)

Métodos disponibles para:

• Operaciones aritméticas básicas (Mod, Abs, ...)
• Manipulación básica de texto y caracteres (Copy, Blanks, UpCase, ...)
• Funciones matemáticas (Sin, Exp, ...)
• Funciones extremas (Max, Min)
• Números aleatorios (Draw, Uniform, Normal, Histo, ...)
• Información del compilador (SourceLine, SIMULAId)
• Otros (Error, Límite superior/inferior de matrices, Fecha, Hora, ...)

BasicIO - el mundo exterior

Todas las operaciones de entrada y salida están representadas por métodos de objetos de archivo. Un ancestro común llamado File - consulta la Figura 5 - implementa instalaciones comunes a todos los archivos. Sus subclases son ByteFile e ImageFile (archivo de texto, "imagen" es su búfer de texto). Ambos se especializan aún más según el método de acceso (entrada, salida, acceso directo). OutFile tiene un descendiente adicional llamado PrintFile que implementa salida de texto orientada a página. Ten en cuenta que Simula no tiene archivos tipados, compuestos, por ejemplo, de registros. Este tipo de archivos se pueden implementar mediante archivos de bytes. La Figura 5 contiene algunos métodos más importantes con nombres autoexplicativos.

Figura 5: Jerarquía de clases de archivos en Simula.

Marco del programa

Todas las instalaciones del sistema en Simula se implementan conceptualmente como clases con ciertos atributos, métodos y clases locales. Los programas de usuario se escriben como si estuvieran insertados en el siguiente marco. Ten en cuenta que las reglas de vida de la clase BasicIO crean y abren los archivos del sistema antes de comenzar el código del usuario. Después de su terminación, los archivos del sistema se cierran. El código del usuario se inserta en una declaración doble de Inspect. Esto significa que los métodos de los archivos del sistema (como, por ejemplo, GetInt, OutImage, etc.) no necesitan ir precedidos por el nombre del archivo.

Begin

  Class Environment; ...

  Environment Class BasicIO ... ;

  Begin

Ref(InFile) SysIn; Ref(OutFile) SysOut; ...

Class Simset ... ;

Simset Class Simulation ... ;

Procedure Terminate_Program;

Begin ... ; GoTo STOP End;

  ...

SysIn :- New InFile ( ... );

SysOut :- New PrintFile ( ... );

SysIn.Open ( ... );

SysOut.Open ( ... );

Inner;             ! This starts the user program;

   STOP: SysIn.Close ( ... );

SysOut.Close ( ... )

  End BasicIO;

BasicIO Begin

Inspect SysIn do

   Inspect SysOut do

Begin            ! User program starts by this begin;

    User statements

   End;             ! Last line of user program;

End;

End;

Simset - el mundo de las listas enlazadas

La clase del sistema Simset implementa listas enlazadas circulares bidireccionales con el elemento principal involucrado en el enlace, que originalmente se llamaban "conjuntos", consulta la Figura 6.

Figura 6: Listas enlazadas de Simula implementadas en la clase del sistema Simset.

Read the second part of the article here.