ALGOL 68

ALGOL 68

Informe revisado sobre el lenguaje algorítmico – Algol 68 Editado por: A. van Wijngaarden et al, septiembre de 1973 [1]
Paradigmas	Multiparadigma : concurrente , imperativo
Familia	ALGOL
Diseñado por	A. van Wijngaarden , BJ Mailloux , JEL Peck y CHA Koster , et al.
Apareció por primera vez	Informe Final: 1968 ; hace 56 años r0 ( 1968 )
Versión estable	Algol 68/RR / Informe revisado: 1973 ; Hace 51 años r1 ( 1973 )
Disciplina de mecanografía	estático , fuerte , seguro , estructural
Alcance	Léxico
Implementaciones principales
ALGOL 68C , Algol 68 Genie (reciente), ALGOL 68-R , ALGOL 68RS , ALGOL 68S , FLACC , Алгол 68 Leningrado/Unidad de Leningrado, Odra ALGOL 68
Dialectos
ALGOL 68/FR (Informe final r0 )
Influenciado por
ALGOL 60 , ALGOL Y
Influenciado
C , [3] [5] C++ , [6] Bourne Shell , KornShell , Bash , Steelman , Ada , Python , [7] Seed7 , Mary , S3

ALGOL 68 (abreviatura de Lenguaje Algorítmico 1968 ) es un lenguaje de programación imperativo que fue concebido como sucesor del lenguaje de programación ALGOL 60 , diseñado con el objetivo de un alcance de aplicación mucho más amplio y una sintaxis y semántica definidas más rigurosamente.

La complejidad de la definición del lenguaje, que abarca varios cientos de páginas llenas de terminología no estándar, dificultó la implementación del compilador y se dijo que "no tenía implementaciones ni usuarios". Esto era sólo parcialmente cierto; ALGOL 68 encontró uso en varios nichos de mercado, especialmente en el Reino Unido , donde era popular en las máquinas de International Computers Limited (ICL), y en funciones de enseñanza. Fuera de estos campos, su uso fue relativamente limitado.

Sin embargo, las contribuciones de ALGOL 68 al campo de la informática han sido profundas, de amplio alcance y duraderas, aunque muchas de estas contribuciones solo se identificaron públicamente cuando reaparecieron en lenguajes de programación desarrollados posteriormente. Muchos lenguajes se desarrollaron específicamente como respuesta a la complejidad percibida del lenguaje, siendo el más notable Pascal , o fueron reimplementaciones para funciones específicas, como Ada .

Muchos lenguajes de la década de 1970 trazan su diseño específicamente a ALGOL 68, seleccionando algunas características y abandonando otras que se consideraban demasiado complejas o fuera del alcance de determinadas funciones. Entre ellos se encuentra el lenguaje C , que recibió la influencia directa de ALGOL 68, especialmente por su tipado fuerte y sus estructuras. La mayoría de los lenguajes modernos trazan al menos parte de su sintaxis a C o Pascal y, por lo tanto, directa o indirectamente a ALGOL 68.

Las características de ALGOL 68 incluyen sintaxis basada en expresiones, tipos y estructuras declarados por el usuario/uniones etiquetadas, un modelo de referencia de variables y parámetros de referencia, segmentación de cadenas, matrices y arreglos, y simultaneidad.

ALGOL 68 fue diseñado por el Grupo de Trabajo 2.1 sobre Cálculos y Lenguajes Algorítmicos de la Federación Internacional de Procesamiento de la Información (IFIP) . El 20 de diciembre de 1968, el lenguaje fue adoptado formalmente por el grupo y luego aprobado para su publicación por la Asamblea General de la IFIP.

ALGOL 68 se definió utilizando un formalismo , una gramática formal de dos niveles , inventada por Adriaan van Wijngaarden . Las gramáticas de Van Wijngaarden utilizan una gramática libre de contexto para generar un conjunto infinito de producciones que reconocerán un programa ALGOL 68 en particular; en particular, pueden expresar el tipo de requisitos que en muchos otros estándares técnicos de lenguajes de programación se etiquetan como semántica , y deben expresarse en prosa de lenguaje natural propensa a la ambigüedad, y luego implementarse en compiladores como código ad hoc adjunto al analizador de lenguaje formal.

Los principales objetivos y principios de diseño de ALGOL 68:

1. Completitud y claridad de la descripción ^[9]
2. Ortogonalidad del diseño ^[10]
3. Seguridad ^[11]
4. Eficiencia: ^[12]
   • Comprobación del modo estático
   • Análisis sintáctico independiente del modo
   • Compilación independiente
   • Optimización de bucles
   • Representaciones: en conjuntos de caracteres mínimos y más grandes

ALGOL 68 ha sido criticado, sobre todo por algunos miembros de su comité de diseño, como CAR Hoare y Edsger Dijkstra , por abandonar la simplicidad de ALGOL 60 , convertirse en un vehículo para ideas complejas o excesivamente generales y hacer poco para facilitar la tarea del escritor del compilador , en contraste con contemporáneos deliberadamente simples (y competidores) como C , S-algol y Pascal .

En 1970, ALGOL 68-R se convirtió en el primer compilador funcional para ALGOL 68.

En la revisión de 1973 se omitieron ciertas características, como los procedimientos , los gommas ^[13] y los límites formales . ^[14] Véase el lenguaje del informe no revisado.r0

Aunque las agencias de defensa europeas (en Gran Bretaña el Royal Signals and Radar Establishment (RSRE)) promovieron el uso de ALGOL 68 por sus esperadas ventajas en materia de seguridad, la parte estadounidense de la alianza OTAN decidió desarrollar un proyecto diferente, el lenguaje Ada , haciendo obligatorio su uso para los contratos de defensa estadounidenses.

ALGOL 68 también tuvo una influencia notable en la Unión Soviética , cuyos detalles se pueden encontrar en el artículo de Andrey Terekhov de 2014: "ALGOL 68 and Its Impact on the URSS and Russian Programming", ^[15] y "Алгол 68 и его влияние" . на программирование в СССР и России". ^[16]

Steve Bourne , que formaba parte del comité de revisión de ALGOL 68, llevó algunas de sus ideas a su shell Bourne (y, por tanto, a los shells Unix descendientes como Bash ) y a C (y, por tanto, a sus descendientes como C++ ).

La historia completa del proyecto se puede encontrar en A History of ALGOL 68 de CH Lindsey . ^{[17] [18]}

Para un tratamiento completo del lenguaje, consulte "Programming ALGOL 68 Made Easy" ^[19] del Dr. Sian Mountbatten, o "Learning ALGOL 68 Genie" ^[20] de Marcel van der Veer, que incluye el informe revisado.

ALGOL 68, como su nombre lo indica, es una continuación del lenguaje ALGOL que se formalizó por primera vez en 1960. Ese mismo año, la Federación Internacional para el Procesamiento de la Información (IFIP) formó y comenzó el Grupo de Trabajo sobre ALGOL, o WG2.1. Este grupo publicó una especificación ALGOL 60 actualizada en Roma en abril de 1962. En una reunión de seguimiento en marzo de 1964, se acordó que el grupo debería comenzar a trabajar en dos estándares de seguimiento, ALGOL X , que sería una redefinición del lenguaje con algunas adiciones, y un ALGOL Y , que tendría la capacidad de modificar sus propios programas al estilo del lenguaje LISP . ^[21]

La primera reunión del grupo ALGOL X se celebró en la Universidad de Princeton en mayo de 1965. Un informe de la reunión destacó dos temas con amplio apoyo: la introducción de la tipificación fuerte y el interés en los conceptos de Euler de "árboles" o "listas" para manejar colecciones. ^[22]

En la segunda reunión, celebrada en octubre en Francia, se presentaron tres propuestas formales: ALGOL W de Niklaus Wirth junto con comentarios sobre estructuras de registros de CAR (Tony) Hoare , un lenguaje similar de Gerhard Seegmüller y un artículo de Adriaan van Wijngaarden sobre "Diseño ortogonal y descripción de un lenguaje formal". Este último, escrito en una "gramática W" casi indescifrable, resultó ser un cambio decisivo en la evolución del lenguaje. La reunión finalizó con el acuerdo de que van Wijngaarden reescribiría la propuesta de Wirth/Hoare utilizando su gramática W. ^[22]

Esta tarea aparentemente sencilla resultó ser más difícil de lo esperado y la reunión de seguimiento tuvo que retrasarse seis meses. Cuando se reunió en abril de 1966 en Kootwijk , el borrador de van Wijngaarden permaneció incompleto y Wirth y Hoare presentaron una versión que utilizaba descripciones más tradicionales. En general, se acordó que su artículo era "el lenguaje correcto en el formalismo equivocado". ^[23] A medida que se exploraron estos enfoques, se hizo evidente que había una diferencia en la forma en que se describían los parámetros que tendría efectos en el mundo real y, aunque Wirth y Hoare protestaron porque las demoras adicionales podrían volverse interminables, el comité decidió esperar la versión de van Wijngaarden. Wirth implementó entonces su definición actual como ALGOL W. ^[24]

En la siguiente reunión en Varsovia en octubre de 1966, ^[25] hubo un informe inicial del Subcomité de E/S que se había reunido en el Laboratorio Nacional de Oak Ridge y la Universidad de Illinois pero que aún no había avanzado mucho. Se volvieron a explorar las dos propuestas de la reunión anterior y esta vez surgió un nuevo debate sobre el uso de punteros ; ALGOL W los usaba solo para hacer referencia a registros, mientras que la versión de van Wijngaarden podía apuntar a cualquier objeto. Para agregar confusión, John McCarthy presentó una nueva propuesta para la sobrecarga de operadores y la capacidad de encadenar construcciones y o , y Klaus Samelson quería permitir funciones anónimas . En la confusión resultante, hubo cierta discusión sobre abandonar todo el esfuerzo. ^[24] La confusión continuó durante lo que se suponía que sería la reunión de ALGOL Y en Zandvoort en mayo de 1967. ^[22]

Finalmente, en febrero de 1968 se publicó un borrador del informe, que fue recibido con «conmoción, horror y disconformidad», ^[22] debido principalmente a los cientos de páginas de gramática ilegible y terminología extraña. Charles H. Lindsey intentó averiguar qué «lenguaje se escondía en él», ^[26] un proceso que llevó seis semanas de trabajo. El documento resultante, «ALGOL 68 con menos lágrimas», ^[27] tuvo una amplia difusión. En una reunión más amplia sobre procesamiento de la información celebrada en Zúrich en mayo de 1968, los asistentes se quejaron de que se les estaba imponiendo el lenguaje y de que el IFIP era «el verdadero villano de esta situación irrazonable», ya que las reuniones eran en su mayoría a puerta cerrada y no había un mecanismo formal de retroalimentación. Wirth y Peter Naur renunciaron formalmente a sus puestos de autores en el WG2.1 en ese momento. ^[26]

La siguiente reunión del WG2.1 tuvo lugar en Tirrenia en junio de 1968. Se suponía que iba a discutir la publicación de compiladores y otros temas, pero en su lugar se derivó en una discusión sobre el lenguaje. van Wijngaarden respondió diciendo (o amenazando) que publicaría sólo una versión más del informe. En ese momento, Naur, Hoare y Wirth habían abandonado el proyecto y varios más amenazaban con hacerlo. ^[28] Siguieron varias reuniones más, North Berwick en agosto de 1968, Munich en diciembre, que produjeron la publicación del Informe oficial en enero de 1969, pero también dieron como resultado la redacción de un polémico Informe de Minoría. Finalmente, en Banff, Alberta , en septiembre de 1969, el proyecto se consideró en general completo y la discusión se centró principalmente en las erratas y una Introducción al Informe muy ampliada. ^[29]

El esfuerzo llevó cinco años, agotó a muchos de los grandes nombres de la informática y en varias ocasiones llegó a un punto muerto por cuestiones tanto de definición como del grupo en su conjunto. Hoare publicó una "Crítica de ALGOL 68" casi inmediatamente, ^[30] a la que se ha hecho referencia en muchas obras. Wirth continuó desarrollando el concepto de ALGOL W y lo publicó como Pascal en 1970.

La primera implementación del estándar, basada en el borrador del Informe de finales de 1968, fue introducida por el Royal Radar Establishment en el Reino Unido como ALGOL 68-R en julio de 1970. Sin embargo, se trataba de un subconjunto del lenguaje completo, y Barry Mailloux , el editor final del Informe, bromeó diciendo que "es una cuestión de moralidad. ¡Tenemos una Biblia y tú estás pecando!" ^[31] Sin embargo, esta versión se volvió muy popular en las máquinas ICL y se convirtió en un lenguaje ampliamente utilizado en la codificación militar, especialmente en el Reino Unido. ^[32]

Entre los cambios en 68-R estaba el requisito de que todas las variables se declararan antes de su primer uso. Esto tenía una ventaja significativa, ya que permitía que el compilador fuera de una sola pasada, ya que se reservaba espacio para las variables en el registro de activación antes de usarlo. Sin embargo, este cambio también tuvo el efecto secundario de exigir que los PROC se declararan dos veces, una como declaración de los tipos y otra como cuerpo del código. Otro cambio fue eliminar el modo VOID asumido , una expresión que no devuelve ningún valor (llamada declaración en otros lenguajes) y exigir que se agregue la palabra VOID donde se hubiera asumido. Además, 68-R eliminó los comandos de procesamiento paralelo explícito basados ​​en PAR . ^[31]

La primera implementación completa del lenguaje fue introducida en 1974 por CDC Netherlands para la serie de mainframes Control Data . Su uso fue limitado, principalmente en la enseñanza en Alemania y los Países Bajos. ^[32]

En 1976, la Universidad Carnegie Mellon introdujo una versión similar a 68-R, denominada 68S, que nuevamente era un compilador de una sola pasada basado en varias simplificaciones del original y destinado a usarse en máquinas más pequeñas como el DEC PDP-11 . También se usó principalmente con fines didácticos. ^[32]

No estuvo disponible una versión para mainframes de IBM hasta 1978, cuando la Universidad de Cambridge lanzó una . Estaba "casi terminada". Lindsey lanzó una versión para máquinas pequeñas, incluida la IBM PC, en 1984. ^[32]

Se conocen tres implementaciones de código abierto de Algol 68: ^[33]

• a68g , GPLv3 , escrito por Marcel van der Veer.
• algol68toc , un puerto de software de código abierto de ALGOL 68RS .
• Interfaz experimental de Algol68 para GCC , escrita por Jose E. Marchesi. ^[34]

• "Una breve historia de Algol 68"
• ALGOL 68 – ALGOL de tercera generación

• Marzo de 1968: Borrador de informe sobre el lenguaje algorítmico ALGOL 68 ^[42] – Editado por: Adriaan van Wijngaarden , Barry J. Mailloux , John Peck y Cornelis HA Koster .

"Van Wijngaarden caracterizó una vez a los cuatro autores, un tanto irónico, como: Koster: transputter, Peck: sintaxis, Mailloux: implementador, Van Wijngaarden: ideólogo del partido". – Koster.

• Octubre de 1968: Penúltimo borrador del informe sobre el lenguaje algorítmico ALGOL 68 — Capítulos 1-9 ^[43] Capítulos 10-12 ^[44] — Editado por: A. van Wijngaarden, BJ Mailloux, JEL Peck y CHA Koster.
• Diciembre de 1968: Informe sobre el lenguaje algorítmico ALGOL 68 - Separata de Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. ^[45] — Editado por: A. van Wijngaarden, BJ Mailloux, JEL Peck y CHA Koster.
• Marzo de 1970: Informe de la minoría, Boletín ALGOL AB31.1.1, firmado por Edsger Dijkstra , Fraser Duncan, Jan Garwick, Tony Hoare , Brian Randell , Gerhard Seegmüller, Wlad Turski y Mike Woodger .
• Septiembre de 1973: Informe revisado sobre el lenguaje algorítmico Algol 68 - Springer-Verlag 1976 ^[46] - Editado por: A. van Wijngaarden, B. Mailloux, J. Peck, K. Koster, Michel Sintzoff , Charles H. Lindsey , Lambert Meertens y Richard G. Fisker.
• Otros miembros del WG 2.1 activos en el diseño de ALGOL 68: ^[18] Friedrich L. Bauer • Hans Bekic • Gerhard Goos • Peter Zilahy Ingerman • Peter Landin • John McCarthy • Jack Merner • Peter Naur • Manfred Paul • Willem van der Poel • Doug Ross • Klaus Samelson • Niklaus Wirth • Nobuo Yoneda .

1968: El 20 de diciembre de 1968, el Grupo de Trabajo adoptó el "Informe Final" (MR 101), que luego fue aprobado por la Asamblea General del IFIP de la UNESCO para su publicación. Se realizaron traducciones de la norma al ruso , alemán , francés y búlgaro , y más tarde al japonés y al chino . ^[47] La ​​norma también se puso a disposición en Braille .

1984: El TC 97 consideró ALGOL 68 para su normalización como "Nuevo tema de trabajo" TC97/N1642 [2][3]. Alemania Occidental, Bélgica, Países Bajos, URSS y Checoslovaquia estaban dispuestos a participar en la preparación de la norma, pero la URSS y Checoslovaquia "no eran los miembros adecuados para los comités ISO adecuados"[4] y la normalización ISO de Algol 68 se estancó.[5]

1988: Posteriormente, ALGOL 68 se convirtió en uno de los estándares GOST en Rusia.

• GOST 27974-88 Lenguaje de programación ALGOL 68 — Язык программирования АЛГОЛ 68 ^[48]
• GOST 27975-88 Lenguaje de programación ALGOL 68 extendido — Язык программирования АЛГОЛ 68 расширенный ^[49]

El lenguaje estándar contiene alrededor de sesenta palabras reservadas, generalmente en negrita en la letra impresa, y algunas con equivalentes de "símbolo breve":

MODO , OP , PRIO , PROC , FLEX , MONTÓN , LOC , LARGO , REF , CORTO , BITS , BOOL , BYTES , CHAR , COMPL , INT , REAL , SEMA , CADENA , VACÍO , CANAL , ARCHIVO , FORMATO , ESTRUCTURA , UNIÓN , EN "@", O r0 , ES ":=:", NO  ES NO ES r0 ":/=:" ":≠:", DE "→" r0 , VERDADERO , FALSO , VACÍO , NULO "○", SALTAR "~", CO "¢", COMENTARIO "¢", PR , PRAGMAT , CASO ~ EN ~ OUSE ~ EN ~ SALIDA ~ ESAC "(~ | ~ |: ~ | ~ | ~)", PARA ~ DESDE ~ HASTA ~ POR ~ MIENTRAS ~ HACER ~ OD , SI ~ ENTONCES ~ ELIF ~ ENTONCES ~ SINO ~ FI "( ~ | ~ |: ~ | ~ | ~ )", PAR  COMIENZO ~ FIN "( ~ )", IR A , GOTO , SALIR "□" r0 .

La construcción básica del lenguaje es la unidad . Una unidad puede ser una fórmula , una cláusula adjunta , un texto rutinario o una de varias construcciones técnicamente necesarias (asignación, salto, omisión, nihil). El término técnico cláusula adjunta unifica algunas de las construcciones inherentemente entre corchetes conocidas como bloque , declaración do , declaración switch en otros lenguajes contemporáneos. Cuando se utilizan palabras clave, generalmente se utiliza la secuencia de caracteres invertida de la palabra clave introductoria para terminar el encierro, por ejemplo ( IF ~ THEN ~ ELSE ~ FI , CASE ~ IN ~ OUT ~ ESAC , FOR ~ WHILE ~ DO ~ OD ). Esta sintaxis de Comando Protegido fue reutilizada por Stephen Bourne en el shell Bourne común de Unix . Una expresión también puede producir un valor múltiple , que se construye a partir de otros valores mediante una cláusula colateral . Esta construcción simplemente se parece al paquete de parámetros de una llamada a procedimiento.

Los tipos de datos básicos (llamados modes en la jerga de Algol 68) son real, int, compl( número complejo ), bool, chary bits. bytesPor ejemplo:

INT n = 2; CO n se fija como una constante de 2. CO INT m := 3; CO m es una variable local recién creada cuyo valor se establece inicialmente en 3. CO CO Es la abreviatura de ref  int m = loc  int  := 3; CO REAL avogadro = 6.0221415⏨23; CO Número de Avogadro CO long long real long long pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510; COMPL raíz cuadrada de menos uno = 0 ⊥ 1;

Sin embargo, la declaración REAL x;es simplemente una sintaxis simplificada para . Es decir, es realmente el identificador constante para una referencia a una variable REAL local recién generada .REF REAL x = LOC REAL;x

Además, en lugar de definir tanto floaty double, como inty longy short, etc., ALGOL 68 proporciona modificadores , de modo que el común actual doublese escribiría como LONG REAL o LONG LONG REAL en su lugar, por ejemplo. Las constantes de preludio max real y min long intse proporcionan para adaptar los programas a diferentes implementaciones.

Todas las variables deben declararse, pero la declaración no tiene por qué preceder al primer uso.

declarante primitivo: INT , REAL , COMPL , COMPLEX ^G , BOOL , CHAR , CADENA , BITS , BYTES , FORMATO , ARCHIVO , TUBERÍA ^G , CANAL , SEMA

• BITS – un "vector empaquetado" de BOOL .
• BYTES – un "vector empaquetado" de CHAR .
• STRING – una matriz FLEXIBLE de CHAR .
• SEMA – un foro SEMA que puede inicializarse con el NIVEL DE OPERADOR .

Se pueden crear tipos complejos a partir de otros más simples utilizando varios constructores de tipos:

• Modo REF : una referencia a un valor de tipo modo , similar a & en C/C++ y REF en Pascal
• STRUCT : se utiliza para construir estructuras, como STRUCT en C/C++ y RECORD en Pascal
• UNION – se utiliza para crear uniones, como en C/C++ y Pascal
• PROC : se utiliza para especificar procedimientos, como funciones en C/C++ y procedimientos/funciones en Pascal

Para ver algunos ejemplos, consulte Comparación de ALGOL 68 y C++ .

Otros símbolos de declaración incluyen: FLEX , HEAP , LOC , REF , LONG , SHORT , EVENT ^S

• FLEX : declara que la matriz es flexible, es decir, que puede crecer en longitud según demanda.
• HEAP – asigna una parte variable del espacio libre del montón global.
• LOC – asigna a una variable algo de espacio libre en la pila local.
• LONG – declara que un INT , REAL o COMPL tenga un tamaño mayor a LONG .
• SHORT – declara que un INT , REAL o COMPL tenga un tamaño mayor a SHORT .

Se puede declarar un nombre para un modo (tipo) utilizando una declaración MODE , que es similar a TYPEDEF en C/C++ y TYPE en Pascal:

 INT máx=99; MODO nuevo modo = [0:9][0:máx] ESTRUCTURA ( LARGO  REAL a, b, c, CORTO  INT i, j, k, REF  REAL r );

Esto es similar al siguiente código C:

 const int max = 99 ; typedef struct { double a , b , c ; short i , j , k ; float * r ; } nuevo modo [ 9 + 1 ][ max + 1 ];                 

En ALGOL 68, solo aparece la indicación de modo NEWMODE a la izquierda del símbolo igual y, lo más notable, la construcción se realiza y se puede leer de izquierda a derecha sin tener en cuenta las prioridades. Además, el límite inferior de las matrices de Algol 68 es uno de manera predeterminada, pero puede ser cualquier número entero desde - max int hasta max int .

Las declaraciones de modo permiten que los tipos sean recursivos : definidos directa o indirectamente en términos de sí mismos. Esto está sujeto a algunas restricciones; por ejemplo, estas declaraciones son ilegales:

 MODO  A = REF  A  MODO  A = STRUCT ( A a, B b) MODO  A = PROC ( A a) A

Si bien estos son válidos:

 MODO  A = ESTRUCTURA ( REF  A a, B b) MODO  A = PROC ( REF  A a) REF  A

Las coerciones producen un coaccionado a partir de un coaccionado según tres criterios: el modo a priori del coaccionado antes de la aplicación de cualquier coerción, el modo a posteriori del coaccionado requerido después de esas coerciones y la posición sintáctica o "tipo" del coaccionado. Las coerciones pueden ser en cascada.

Las seis coerciones posibles se denominan desprocedimiento , desreferenciación , unión , ensanchamiento , remado y anulación . Cada coerción, excepto la unión , prescribe un efecto dinámico correspondiente sobre los valores asociados. Por lo tanto, muchas acciones primitivas pueden programarse implícitamente mediante coerciones.

Fortaleza del contexto – coerciones permitidas:

• suave – desprocedimiento
• Débil – desreferenciación o desprocedimiento, dando lugar a un nombre
• manso – desreferenciar o desproceder
• firme – manso, seguido de unificador
• Fuerte – firme, seguido de ensanchamiento, remo o vaciado

ALGOL 68 tiene una jerarquía de contextos que determinan el tipo de coerciones disponibles en un punto particular del programa. Estos contextos son:

Para obtener más detalles sobre primarios, secundarios, terciarios y cuaternarios, consulte Prioridad de operadores.

Los pragmats son directivas en el programa, típicamente sugerencias para el compilador; en lenguajes más nuevos se les llama "pragmas" (sin 't'). p. ej.

PRAGMAT montón=32 PRAGMAT PR montón=32 PR

Los comentarios se pueden insertar de varias maneras:

¢ La forma original de agregar tus 2 centavos a un programa ¢ COMENTARIO Comentario "negrita" COMENTARIO Estilo i comentario CO# Comentario de estilo ii #£ Este es un comentario en almohadilla/libra para un teclado del Reino Unido £

Normalmente, los comentarios no se pueden anidar en ALGOL 68. Esta restricción se puede eludir utilizando delimitadores de comentarios diferentes (por ejemplo, utilizar hash sólo para eliminaciones temporales de código).

ALGOL 68 es un lenguaje de programación orientado a expresiones , por lo que el valor devuelto por una sentencia de asignación es una referencia al destino. Por lo tanto, el siguiente código ALGOL 68 es válido:

 REAL medio pi, un pi; un pi := 2 * ( medio pi := 2 * arc tan(1) )

Esta noción está presente en C y Perl , entre otros. Nótese que, al igual que en lenguajes anteriores como Algol 60 y FORTRAN , se permiten espacios en los identificadores, de modo que half pise trata de un identificador único (evitando así los problemas de guiones bajos , camel case y minúsculas).

Como otro ejemplo, para expresar la idea matemática de una suma de f(i)i = 1 a n, basta la siguiente expresión entera de ALGOL 68 :

( INT suma := 0; PARA i A n HACER suma +:= f(i) OD ; suma)

Tenga en cuenta que, al ser una expresión entera, el primer bloque de código se puede utilizar en cualquier contexto en el que se pueda utilizar un valor entero . Un bloque de código devuelve el valor de la última expresión que evaluó; esta idea está presente en Lisp , entre otros lenguajes.

Las declaraciones compuestas terminan todas con corchetes de cierre distintivos:

• Cláusulas de elección IF :

 Condición IF declaraciones THEN [ declaraciones ELSE ] FI forma "breve": ( condición | declaraciones | enunciados )

 IF condición1 THEN declaraciones ELIF condición2 THEN declaraciones [ ELSE declaraciones ] FI formato "breve": ( condición1 | declaraciones |: condición2 | declaraciones | declaraciones )

Este esquema no solo evita el problema del else pendiente sino que también evita tener que usar BEGINand ENDen secuencias de declaraciones integradas .

• Cláusulas de elección de CASO :

 CASE switch IN declaraciones, declaraciones,... [ declaraciones OUT ] ESAC forma "breve": ( switch | declaraciones, declaraciones,... | declaraciones )

 CASE switch1 IN declaraciones, declaraciones,... OUSE switch2 IN declaraciones, declaraciones,... [ declaraciones OUT ] Forma "breve" de la declaración CASE de ESAC : ( switch1 | declaraciones, declaraciones,... |: switch2 | declaraciones, declaraciones,... | declaraciones )

Ejemplo de cláusula de elección con símbolos breves :

PROC días en el mes = ( INT año, mes) INT : (mes| 31, (año÷×4=0 ∧ año÷×100≠0 ∨ año÷×400=0 | 29 | 28 ), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );

Ejemplo de cláusula de elección con símbolos en negrita :

PROC días en mes = ( INT año, mes) INT : CASE mes IN 31, SI año MOD 4 EQ 0 Y año MOD 100 NE 0 O año MOD 400 EQ 0 ENTONCES 29 SI NO 28 FI , 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 Sociedad Anónima Europea ;

Ejemplo de cláusula de elección que combina símbolos en negrita y breve :

PROC días en mes = ( INT año, mes) INT : CASE mes IN31 de enero de 2018¢Feb¢ ( año MOD 4 = 0 Y año MOD 100 ≠ 0 O año MOD 400 = 0 | 29 | 28 ),¢Mar¢ 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ¢ a Dic. ¢ Sociedad Anónima Europea ;

Algol68 permitió que el conmutador fuera de tipo INT o (exclusivamente) UNION . Este último permite aplicar tipado estricto a las variables UNION . Véase union a continuación como ejemplo.

• cláusula de bucle:

[ FOR índice ] [ FROM primero ] [ BY incremento ] [ TO último ] [ WHILE condición ] Sentencias DO OD La forma mínima de una "cláusula de bucle" es así: Sentencias DO OD

Este se consideró el bucle "universal", la sintaxis completa es:

PARA i DESDE 1 HASTA -22 -333 MIENTRAS i×i≠ 4444 HACER ~ OD

El constructo presenta varios aspectos inusuales:

• solo la parte DO ~ OD era obligatoria, en cuyo caso el bucle se iteraría indefinidamente.
• Por lo tanto, la cláusula TO 100 DO ~ OD se iterará solo 100 veces.
• El "elemento sintáctico" WHILE permitía a un programador salir de un bucle FOR antes de tiempo. p. ej.

INT suma sq:=0; PARA i MIENTRAS print(("Hasta ahora:",i,nueva línea)); suma sq≠70↑2HACER suma sq+:=i↑2sobredosis

Las "extensiones" posteriores del estándar Algol68 permitieron reemplazar el elemento sintáctico TO por UPTO y DOWNTO para lograr una pequeña optimización. Los mismos compiladores también incorporaron:

• HASTA ^(C) – para la terminación tardía del bucle.
• FOREACH ^(S) – para trabajar con matrices en paralelo .

Puede encontrar más ejemplos en los ejemplos de código que aparecen a continuación.

ALGOL 68 admite matrices con cualquier número de dimensiones y permite la división de filas o columnas completas o parciales.

 MODE  VECTOR = [1:3] REAL ; # vector declaración MODE (typedef) #  MODE  MATRIX = [1:3,1:3] REAL ; # matriz declaración MODE  (typedef) # VECTOR v1 := (1,2,3); # variable de matriz inicialmente (1,2,3) # [] REAL v2 = (4,5,6); # matriz constante, tipo equivalente a VECTOR , los límites están implícitos #  OP + = ( VECTOR a,b) VECTOR : # definición de operador binario # ( VECTOR out ; FOR i FROM ⌊a TO ⌈a DO out [i] := a[i]+b[i] OD ; out); MATRIX m := (v1, v2, v1+v2); print ((m[,2:])); # una porción de la 2da y 3ra columna #

Las matrices se pueden cortar en ambos sentidos, por ejemplo:

 REF  VECTOR row = m[2,]; # define un REF (puntero) a la 2da fila #  REF  VECTOR col = m[,2]; # define un REF (puntero) a la 2da columna #

ALGOL 68 admite estructuras de campos múltiples ( STRUCT ) y modos unificados . Las variables de referencia pueden apuntar a cualquier MODO, incluidas las porciones de matriz y los campos de estructura.

Para un ejemplo de todo esto, aquí está la declaración de lista enlazada tradicional:

 MODO  NODO = UNIÓN ( VOID , REAL , INT , COMPL , CADENA ), LISTA = ESTRUCTURA ( NODO val, REF  LISTA siguiente);

Ejemplo de uso para UNION CASE de NODE :

 NODO n := "1234"; REAL r; INT i; COMPL c; CADENA s CASO r,i,c,s::=n EN imprimir(("real:", r)), imprimir(("int:", i)), imprimir(("compl:", c)), imprimir(("cadena:", s)) FUERA imprimir(("?:", n)) ESAC

 NODO n := "1234"; # o n := VACÍO; # CASO n EN ( VOID ): print(("void:", "VACÍO")), ( REAL r): imprimir(("real:", r)), ( INT i): imprimir(("int:", i)), ( COMPL c ): imprimir(("compl:", c)), ( CADENA s): imprimir(("cadena:", s)) SALIDA imprimir(("?:", n)) ESAC

Las declaraciones de procedimiento ( PROC ) requieren especificaciones de tipo tanto para los parámetros como para el resultado ( VOID si no hay ninguno):

 PROC máx. de real = ( REAL a, b) REAL : SI a > b ENTONCES a SI NO b FI ;

o, utilizando la forma "breve" de la declaración condicional:

 PROC máx. de real = ( REAL a, b) REAL : (a>b | a | b);

El valor de retorno de a proces el valor de la última expresión evaluada en el procedimiento. También se permiten referencias a procedimientos ( ref proc ). Los parámetros de llamada por referencia se proporcionan especificando referencias (como ref real) en la lista de argumentos formales. El siguiente ejemplo define un procedimiento que aplica una función (especificada como parámetro) a cada elemento de una matriz:

 PROC aplicar = ( REF [] REAL a, PROC ( REAL ) REAL f):   PARA i DE  LWB a A  UPB a HACER a[i] := f(a[i]) OD

Esta simplicidad de código era inalcanzable en el predecesor de ALGOL 68, ALGOL 60 .

El programador puede definir nuevos operadores , y tanto estos como los predefinidos pueden sobrecargarse y sus prioridades pueden ser modificadas por el codificador. El siguiente ejemplo define un operador MAXcon versiones tanto diádicas como monádicas (exploración de los elementos de una matriz).

 PRIO  MÁXIMO = 9;   OP  MÁXIMO = ( INT a,b) INT : ( a>b | a | b ); OP  MÁXIMO = ( REAL a,b) REAL : ( a>b | a | b ); OP  MÁXIMO = ( COMPL a,b) COMPL : ( ABS a > ABS b | a | b );   OP  MAX = ([] REAL a) REAL : ( REAL salida := a[ LWB a]; PARA i DESDE  LWB a + 1 HASTA  UPB a HACER ( a[i]>salida | salida:=a[i] ) OD ; afuera)

Técnicamente no son operadores, sino que se consideran "unidades asociadas con nombres".

Detalles específicos:

• Los terciarios incluyen los nombres NIL y ○.
• LWS : En Algol68 ^r0, los operadores LWS y ⎩ ... ambos devuelven VERDADERO si el estado inferior de la dimensión de una matriz es fijo.
• Los operadores UPS y ⎧ son similares en el estado superior .
• Los operadores LWB y UPB están disponibles automáticamente en los UNION de diferentes órdenes (y MODE ) de matrices, p. ej. UPB deunion([]int, [,]real, flex[,,,]char)

Técnicamente no son operadores, sino que se consideran "unidades asociadas con nombres".

Nota: Los cuaternarios incluyen los nombres SKIP y ~.

:=:(alternativamente IS ) prueba si dos punteros son iguales; (alternativamente ISNT ) prueba si son desiguales.:/=:

Considere intentar comparar dos valores de puntero, como las siguientes variables, declaradas como punteros a enteros:

REF INT ip, jp

Ahora, pensemos en cómo decidir si estos dos apuntan a la misma ubicación o si uno de ellos apunta a NIL . La siguiente expresión

ip = jp

desreferenciará ambos punteros a valores de tipo INT y los comparará, ya que el operador = está definido para INT , pero no para REF INT . No es legal definir = para operandos de tipo REF INT e INT al mismo tiempo, porque entonces las llamadas se vuelven ambiguas, debido a las coerciones implícitas que se pueden aplicar: ¿deberían dejarse los operandos como REF INT y llamarse a esa versión del operador? ¿O deberían desreferenciarse aún más a INT y usar esa versión en su lugar? Por lo tanto, la siguiente expresión nunca puede hacerse legal:

ip = NIL

De ahí la necesidad de construcciones separadas que no estén sujetas a las reglas normales de coerción de operandos a operadores. Pero hay un problema. Las siguientes expresiones:

ip :=: jp

ip :=: NIL

Si bien son legales, probablemente no harán lo que se podría esperar. Siempre devolverán FALSE , porque están comparando las direcciones reales de las variables y , en lugar de lo que apuntan . Para lograr el efecto correcto, uno tendría que escribiripjp

ip :=: REF INT(jp)

ip :=: REF INT(NIL)

La mayoría de los caracteres "especiales" de Algol (⊂, ≡, ␣, ×, ÷, ≤, ≥, ≠, ¬, ⊃, ≡, ∨, ∧, →, ↓, ↑, ⌊, ⌈, ⎩, ⎧, ⊥, ⏨, ¢, ○ y □) se pueden encontrar en el teclado IBM 2741 con el cabezal de impresión "pelota de golf" APL insertado; estos se volvieron disponibles a mediados de la década de 1960 mientras se redactaba ALGOL 68. Estos caracteres también son parte del estándar Unicode y la mayoría de ellos están disponibles en varias fuentes populares .

Transput es el término utilizado para referirse a las funciones de entrada y salida de ALGOL 68. Incluye procedimientos predefinidos para la transput sin formato, con formato y binaria. Los archivos y otros dispositivos de transput se manejan de manera consistente e independiente de la máquina. El siguiente ejemplo imprime una salida sin formato en el dispositivo de salida estándar :

 imprimir ((nueva página, "Título", nueva línea, "El valor de i es ", i, "y x[i] es ", x[i], nueva línea))

Tenga en cuenta los procedimientos predefinidos newpagey newlinepasados ​​como argumentos.

El TRANSPORTE se considera de LIBROS , CANALES y ARCHIVOS :

• Los libros se componen de páginas, líneas y caracteres, y pueden estar respaldados por archivos.
  • Se puede localizar un libro específico por nombre con una llamada a match.
• Los CANALES corresponden a dispositivos físicos, por ejemplo, perforadoras de tarjetas e impresoras.
  • Se distinguen tres canales estándar: canal de entrada , canal de salida y canal de retroceso .
• Un ARCHIVO es un medio de comunicación entre un programa y un libro que se ha abierto a través de algún canal.
  • El MODO de un archivo puede ser lectura, escritura, char, bin y apertura.
  • Los procedimientos de transporte incluyen: establish, create, open, associate, lock, close, scratch.
  • Consultas de posición: char number, line number, page number.
  • Las rutinas de diseño incluyen:
    • space, backspace, newline, newpage.
    • get good line, get good page, get good book, yPROC set=(REF FILE f, INT page,line,char)VOID:
  • Un archivo tiene rutinas de eventos , por ejemplo on logical file end, on physical file end, on page end, on line end, on format end, on value error, on char error:

"Transput formateado" en el transput de ALGOL 68 tiene su propia sintaxis y patrones (funciones), con FORMAT incrustados entre dos caracteres $. ^[50]

Ejemplos:

printf (($2l"La suma es:"x, g(0)$, m + n)); ¢ imprime lo mismo que: ¢ imprimir ((nueva línea, nueva línea, "La suma es:", espacio, entero (m + n, 0))

ALGOL 68 admite la programación de procesamiento paralelo. Mediante la palabra clave PAR , una cláusula colateral se convierte en una cláusula paralela , donde la sincronización de acciones se controla mediante semáforos . En A68G, las acciones paralelas se asignan a subprocesos cuando están disponibles en el sistema operativo anfitrión . En A68S se implementó un paradigma diferente de procesamiento paralelo (ver a continuación).

PROC eat = VOID : ( muffins-:=1; print(("¡Mmm!",nueva línea))), hablar = VOID : ( palabras-:=1; imprimir(("Yak...",nueva línea))); INT muffins := 4, palabras := 8; SEMA boca = NIVEL 1; PAR  COMIENZA  MIENTRAS muffins > 0 HACER  ABAJO boca; comer; ARRIBA boca OD , MIENTRAS palabras > 0 HACER  ABAJO boca; hablar; Boca ARRIBA EXTREMO OD

Por sus complejidades técnicas, ALGOL 68 necesita una cornucopia de métodos para negar la existencia de algo:

SKIP , "~" o "?" C – un valor indefinido siempre sintácticamente válido, EMPTY – el único valor admisible para VOID , necesario para seleccionar VOID en una UNION , VOID – sintácticamente como un MODE , pero no uno, NIL o "○" – un nombre que no denota nada, de un modo de referencia no especificado,() o específicamente [1:0] INT : un vacío es una matriz vacía (aquí específicamente de MODE [] INT ). undefined : un procedimiento de informes estándar que genera una excepción en el sistema de tiempo de ejecución.ℵ – Se utiliza en el informe de normas para inhibir la introspección de ciertos tipos, por ejemplo, SEMA

El término NIL IS var siempre se evalúa como VERDADERO para cualquier variable (pero vea más arriba el uso correcto de IS  :/=:), mientras que no se sabe a qué valor se evalúa una comparación x < SKIP para cualquier entero x .

ALGOL 68 deja intencionalmente sin definir lo que sucede en caso de desbordamiento de entero , la representación del bit entero y el grado de precisión numérica para el punto flotante.

Ambos informes oficiales incluían algunas características avanzadas que no formaban parte del lenguaje estándar. Estas se indicaban con una ℵ y se consideraban efectivamente privadas. Algunos ejemplos incluyen "≮" y "≯" para plantillas, OUTTYPE / INTYPE para tipado rudimentario y los operadores STRAIGHTOUT y STRAIGHTIN para "enderezar" matrices y estructuras anidadas.

Este programa de ejemplo implementa la Criba de Eratóstenes para encontrar todos los números primos menores que 100. NIL es el análogo de ALGOL 68 del puntero nulo en otros lenguajes. La notación x OF y accede a un miembro x de un STRUCT y .

COMIENZO # Tamiz de números primos Algol-68, estilo funcional #   Error de PROC = ( CADENA s) VACÍO : (print((nueva línea, "error:", s, nueva línea)); GOTO stop); PROC uno a = ( INT n) LISTA : ( PROC f = ( INT m,n) LISTA : (m>n | NIL | cons(m, f(m+1,n))); f(1,n));    LISTA DE MODOS = NODO REF ; NODO DE MODOS = ESTRUCTURA ( INT h, LISTA t); PROC cons = ( INT n , LISTA l) LISTA : NODO HEAP  := (n,l); PROC hd = ( LISTA l) INT : ( l ES NULO | error("hd NIL "); SALTAR | h DE l ); PROC tl = ( LISTA l) LISTA : ( l ES NULO | error("tl NIL "); SALTAR | t DE l ); PROC mostrar = ( LISTA l) VOID : ( l NO ES NULO | print((" ",whole(hd(l),0))); mostrar(tl(l)));        PROC filtro = ( PROC ( INT ) BOOL p, LISTA l) LISTA : SI l ES  NULO  ENTONCES  NULO  ELIF p(hd(l)) ENTONCES cons(hd(l), filtro(p,tl(l))) DE LO CONTRARIO filtro(p, tl(l)) FI ;   PROC tamiz = ( LISTA l) LISTA : SI l ES  NULO  ENTONCES  NULO  DE LO CONTRARIO  PROC no múltiple = ( INT n) BOOL : n MOD hd(l) ~= 0; cons(hd(l), sieve( filter( no múltiple, tl(l) ))) ES ;   PROC primos = ( INT n) LISTA : tamiz( tl( uno a(n) ));   mostrar( primos(100) )FIN

• Computadora CAP de Cambridge : todos los procedimientos que constituyen el sistema operativo fueron escritos en ALGOL 68C , aunque varios otros procedimientos protegidos estrechamente asociados, como un paginador, están escritos en BCPL . ^[51]
• Eldon 3 – Desarrollado en la Universidad de Leeds para el ICL 1900 fue escrito en ALGOL 68-R . ^[52]
• Máquina flexible : el hardware era personalizado y microprogramable, con un sistema operativo, un compilador (modular), un editor, un recolector de basura y un sistema de archivos escritos en ALGOL 68RS . El shell de comandos Curt ^[53] fue diseñado para acceder a datos tipificados de manera similar a los modos de Algol-68.
• VME – S3 fue el lenguaje de implementación del sistema operativo VME. S3 estaba basado en ALGOL 68 pero con tipos de datos y operadores alineados con los ofrecidos por la Serie ICL 2900 .

Nota: Las computadoras de la era soviética Elbrus-1 (Elbrus-1) y Elbrus-2 se crearon utilizando el lenguaje de alto nivel Elbrus-76 (AL-76), en lugar del lenguaje ensamblador tradicional. El Elbrus-76 se parece al Algol-68, la principal diferencia son los tipos de enlace dinámicos en Elbrus-76 admitidos a nivel de hardware. El Elbrus-76 se utiliza para aplicaciones, control de trabajos y programación del sistema. ^[54]

Tanto ALGOL 68C como ALGOL 68-R están escritos en ALGOL 68, lo que convierte a ALGOL 68 en una aplicación en sí misma. Otras aplicaciones incluyen:

• ELLA : lenguaje de descripción de hardware y conjunto de herramientas de soporte. Desarrollado por el Royal Signals and Radar Establishment durante los años 1980 y 1990.
• Sistema de mando de ataque de la RAF : "... Se produjeron 400 000 códigos ALGOL 68-RT sin errores con tres años-hombre de trabajo..." ^[55]

• Bibliotecas numéricas NAG : biblioteca de software de rutinas de análisis numérico . Se incluyó en ALGOL 68 durante la década de 1980.
• TORRIX – un sistema de programación para operaciones con vectores y matrices sobre campos arbitrarios y de tamaño variable por SG van der Meulen y M. Veldhorst. ^[56]

Una característica de ALGOL 68, heredada de la tradición ALGOL , son sus diferentes representaciones. Hay un lenguaje de representación utilizado para describir algoritmos en trabajos impresos, un lenguaje estricto (definido rigurosamente en el Informe) y un lenguaje de referencia oficial destinado a ser utilizado en la entrada del compilador. Los ejemplos contienen palabras en NEGRITA , este es el lenguaje ESTRICTO . Las palabras reservadas de ALGOL 68 están efectivamente en un espacio de nombres diferente al de los identificadores, y se permiten espacios en los identificadores, por lo que el siguiente fragmento es legal:

 INT un int real = 3;

El programador que escribe código ejecutable no siempre tiene la opción de usar la tipografía BOLD o subrayar el código, ya que esto puede depender del hardware y de cuestiones culturales. Se han ideado diferentes métodos para indicar estos identificadores. Esto se denomina régimen de stropping . Por ejemplo, todas o algunas de las siguientes pueden ser representaciones de programación disponibles :

 INT un int real = 3; # el lenguaje ESTRICTO #'INT'A REAL INT = 3; # estilo de alineación de QUOTE #.INT UN INT REAL = 3; # estilo de alineación de PUNTO # INT un int real = 3; # estilo de alineación SUPERIOR # int a_real_int = 3; # Estilo de corrección de RES, hay 61 palabras reservadas aceptadas #

Todas las implementaciones deben reconocer al menos POINT, UPPER y RES dentro de las secciones PRAGMAT. De estos, el uso de POINT y UPPER es bastante común, mientras que el uso de RES es una contradicción con la especificación (ya que no hay palabras reservadas). QUOTE (entrecomillado con apóstrofo simple) fue la recomendación original, mientras que el uso de entrecomillado con apóstrofo coincidente, común en ALGOL 60, no se usa mucho en ALGOL 68. ^[57]

Los siguientes caracteres fueron recomendados para portabilidad y denominados "caracteres valiosos" en el Informe sobre la representación de hardware estándar de Algol 68 Archivado el 2 de enero de 2014 en Wayback Machine :

• ^ Personajes dignos: ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "#$%'()*+,-./:;<=>@[ ]_|

Esto reflejaba un problema en la década de 1960, cuando algunos equipos no soportaban minúsculas ni otros caracteres no ASCII ; de hecho, en el informe de 1973 se escribió: "Cuatro caracteres valiosos —"|", "_", "[" y "]" — a menudo se codifican de forma diferente, incluso en instalaciones que nominalmente usan el mismo conjunto de caracteres".

• Personajes base: Los "personajes dignos" son un subconjunto de los "personajes base".

¢ subrayado o  tipo de letra en negrita ¢  MODE  XINT = INT ; XINT suma sq:=0; FOR i WHILE suma cuadrada ≠ 70 × 70 HACER suma sq+:=i↑2 sobredosis

cita 'pr''modo' 'xint' = 'int';'xint' suma sq:=0;'por' yo 'mientras' suma cuadrada ≠ 70 × 70'hacer' suma sq+:=i↑2'sobredosis'

. PR  SUPERIOR  . PRMODO XINT = INT;XINT suma sq:=0;POR YO MIENTRAS suma al cuadrado = 70*70HACER suma sq+:=i**2sobredosis

. PUNTO PR  .PR
. MODO .XINT = .INT;
. XINT SUM SQ:=0;
. POR YO .MIENTRAS         SUMA CUADRADA .NE 70*70. HACER SUMA CUADRADA .PLUSAB I .UP 2Sobredosis​

.PR RES.PR​ ​ modo .xint = int;. xint  suma  sq:=0;por un tiempo suma cuadrada ≠ 70 × 70hacer suma sq+:=i↑2sobredosis

ALGOL 68 permite que cada lenguaje natural defina su propio conjunto de palabras clave Algol-68. Como resultado, los programadores pueden escribir programas utilizando palabras clave de su idioma nativo. A continuación se muestra un ejemplo de un procedimiento simple que calcula "el día siguiente", el código está en dos idiomas: inglés y alemán. ^{[ cita requerida ]}

# Fecha del día siguiente - Variante en inglés # MODE  DATE = STRUCT ( INT día, STRING mes, INT año); PROC el día siguiente = ( DATE x) DATE : IF día OF x < longitud del mes (mes OF x, año OF x) THEN (día OF x + 1, mes OF x, año OF x) ELIF mes OF x = "diciembre" THEN (1, "enero", año OF x + 1) ELSE (1, sucesor del mes (mes OF x), año OF x) FI ;

# Nachfolgetag - Deutsche Variante # MENGE  DATUM = TUPEL ( etiqueta GANZ , WORT monat, GANZ jahr); FUNKTION naechster tag nach = ( DATUM x) DATUM : WENN tag VON x < monatslaenge(monat VON x, jahr VON x) DANN (tag VON x + 1, monat VON x, jahr VON x) WENNABER monat VON x = "diciembre" DANN (1, "enero", jahr VON x + 1) ANSONSTEN (1, nachfolgemonat(monat VON x), jahr VON x) ENDEWENN ;

Ejemplo ruso/soviético: en inglés, la declaración de caso de Algol68 se lee CASE ~ IN ~ OUT ~ ESAC , en cirílico se lee выб ~ в ~ либо ~ быв .

Salvo que se indique lo contrario (con un ^superíndice ), el lenguaje descrito anteriormente es el del "Informe Revisado ^(r1) ".

El lenguaje original (según el "Informe final" ^r0 ) difiere en la sintaxis del modo cast y tenía la característica de proceduring , es decir, forzar el valor de un término a un procedimiento que evalúa el término. Proceduring estaría destinado a hacer que las evaluaciones sean perezosas . La aplicación más útil podría haber sido la evaluación en cortocircuito de los operadores booleanos. En:

OP  ANDF = ( BOOL a, PROC  BOOL b) BOOL :(a | b | FALSO ); OP  ORF = ( BOOL a, PROC  BOOL b) BOOL :(a | VERDADERO | b);

b sólo se evalúa si a es verdadero.

Como se define en ALGOL 68, no funcionó como se esperaba, por ejemplo en el código:

SI  FALSO  ANDF  CO proc bool: CO ( print ("No debe ejecutarse"); VERDADERO ) ENTONCES ...

En contra de las expectativas ingenuas de los programadores, se ejecutaría la impresión , ya que solo se procesó el valor de la cláusula incluida elaborada después de ANDF . La inserción textual del PROC BOOL comentado : hace que funcione.

Algunas implementaciones emulan el comportamiento esperado para este caso especial por extensión del lenguaje.

Antes de la revisión, el programador podría decidir que los argumentos de un procedimiento se evalúen en serie en lugar de colateralmente utilizando punto y coma en lugar de comas ( gommas ).

Por ejemplo en:

Prueba PROC = ( REAL a; REAL b) :......prueba (x MÁS 1, x);

Se garantiza que el primer argumento a probar se evaluará antes que el segundo, pero de la manera habitual:

Prueba PROC = ( REAL a, b) :......prueba (x MÁS 1, x);

entonces el compilador podría evaluar los argumentos en el orden que quisiera.

Tras la revisión del informe, se han propuesto algunas ampliaciones del lenguaje para ampliar su aplicabilidad:

• parametrización parcial (también conocida como Currying ): creación de funciones (con menos parámetros) mediante la especificación de algunos, pero no todos los parámetros para una llamada, p. ej., una función logarítmica de dos parámetros, base y argumento, podría especializarse en logaritmo natural, binario o decádico, ^[58]
• Extensión del módulo : para apoyar el enlace externo, se propusieron dos mecanismos: módulos de definición de abajo hacia arriba , una versión más potente de las facilidades de ALGOL 68-R y agujeros de arriba hacia abajo , similares a las cláusulas ENVIRONy de ALGOL 68C ^[59]USING
• Parámetros de modo : para la implementación de polimorfismo paramétrico limitado (la mayoría de las operaciones en estructuras de datos como listas, árboles u otros contenedores de datos se pueden especificar sin tocar la carga útil). ^[60]

Hasta ahora, solo se ha implementado una parametrización parcial en Algol 68 Genie.

Nombre	Año	Objetivo	Estado	Descripción	CPU de destino	Licencias	Lenguaje de implementación
ALGOL generalizado	1962	Científico	LND (Lenguaje Nacional Democrático)	ALGOL para gramáticas generalizadas
ALGOL Y Y	1966	Proyecto de propuesta	Internacional	Primera versión de Algol 68	Especificación	ACM
ALGOL 68 DR	1968	Proyecto de propuesta	Internacional	Informe preliminar del grupo de trabajo 2.1 del IFIP	Especificación – Marzo	ACM
ALGOL 68 r0	1968	Estándar	Internacional	Informe final del grupo de trabajo 2.1 del IFIP	Especificación – Agosto	ACM
ALGOL 68- R	1970	Militar	Reino Unido		CIE 1900		ALGOL 60
ALGOL EPOS	1971	Científico
ALGOL 68RS RS	1972	Militar	Reino Unido	Sistema compilador portátil	ICL 2900/Serie 39, Multics, generador VMS y C (1993)	Derechos de autor de la Corona	ALGOL 68RS
Algol 68 con áreas	1972	Experimental y otros	Reino Unido	Adición de áreas a Algol 68
Mini ALGOL 68	1973	Investigación	LND (Lenguaje Nacional Democrático)	"Un intérprete para programas sencillos de Algol 68" Archivado el 18 de julio de 2011 en Wayback Machine	Intérprete portátil	Centro matemático	ALGOL 60
ORÉGANO	1973	Investigación	A NOSOTROS	"La importancia de los modelos de implementación".		Universidad de California en Los Ángeles (UCLA)
ALGOL 68C C	1975	Científico	Reino Unido	Cambridge Algol 68	ICL , IBM 360, PDP 10 y Unix, Telefunken , Tesla y Z80 (1980) [61]	Cambridge	ALGOL 68C
Informe revisado ALGOL 68 r1	1975	Estándar	Internacional	Informe revisado del grupo de trabajo 2.1 del IFIP	Especificación	ACM
Algol H H	1975	Experimental y otros	Reino Unido	Propuestas de ampliación del sistema de modos de Algol 68	Especificación		ALGOL W
Odra Algol 68	1976	usos prácticos	Unión Soviética / Polonia		Odra 1204/IL	soviet	ALGOL 60
Oklahoma ALGOL 68	1976	instrucción de programación	EE.UU	Implementación de la Universidad Estatal de Oklahoma [62]	IBM 1130 y Sistema/370 /158	Desconocido	Norma ANSI Fortran 66 .
Berlín ALGOL 68	1977	Investigación	Delaware	"La implementación del ALGOL 68 en Berlín" y [63]	Una máquina ALGOL 68 abstracta: compilador independiente de la máquina	Universidad Técnica de Berlín	Licencia de conducir comercial 2
FLACSO F	1977	De múltiples fines	PODER	Informe revisado de implementación completa con funciones de depuración	Sistema/370	arrendamiento, Corporación Chion	Ensamblador
ALGOL 68-RT RT	1979	Científico	Reino Unido	ALGOL 68-R paralelo
RS Algol rs	1979	Científico	Reino Unido
ALGOL68+	1980	Científico	LND (Lenguaje Nacional Democrático)	Propuesta de superlenguaje de ALGOL 68 [64]
M-220 ALGOL 68			Unión Soviética		M-220	soviet	Épsilon
Leningrado ALGOL 68 L	1980	Telecomunicaciones	Unión Soviética	Idioma completo + módulos	IBM, DEC, CAMCOH, PS 1001 y PC	soviet
ALGOL 68 I interactivo	1983		Reino Unido	Compilación incremental	ordenador personal	Shareware no comercial
ALGOL 68S S	1985	Científico	Internacional	Versión solar de ALGOL 68	Sun-3 , Sun SPARC (bajo SunOS 4.1 y Solaris 2), Atari ST (bajo GEMDOS ), Acorn Archimedes (bajo RISC OS ), VAX-11 bajo Ultrix-32
Algol68toC [65] (ctrans)	1985	Electrónica	Reino Unido	ctrans de ELLA ALGOL 68RS	Generador C portátil	Software de código abierto 1995	ALGOL 68RS
MK2 interactivo ALGOL 68	1992		Reino Unido	Compilación incremental	ordenador personal	Shareware no comercial [66]
Algol 68 Genie G	2001	Idioma completo	LND (Lenguaje Nacional Democrático)	Incluye cláusula de garantía estándar	Intérprete portátil	Licencia Pública General de GNU	do
Algol 68 Genie versión 2.0.0	2010	Idioma completo	LND (Lenguaje Nacional Democrático)		Intérprete portátil; compilación opcional de unidades seleccionadas	Licencia Pública General de GNU	do

El lenguaje S3 que se utilizó para escribir el sistema operativo ICL VME y mucho otro software del sistema en la Serie ICL 2900 fue un derivado directo de Algol 68. Sin embargo, omitió muchas de las características más complejas y reemplazó los modos básicos con un conjunto de tipos de datos que se asignaban directamente a la arquitectura de hardware de la Serie 2900.

ALGOL 68R de RRE fue la primera implementación de subconjunto de ALGOL 68, que se ejecutó en el ICL 1900. Basado en el lenguaje original, las principales restricciones del subconjunto fueron la definición antes del uso y la ausencia de procesamiento en paralelo. Este compilador fue popular en las universidades del Reino Unido en la década de 1970, donde muchos estudiantes de informática aprendieron ALGOL 68 como su primer lenguaje de programación; el compilador era famoso por sus buenos mensajes de error.

ALGOL 68RS ^(RS) de RSRE era un sistema de compilación portátil escrito en ALGOL 68RS (arrancado a partir de ALGOL 68R) e implementado en una variedad de sistemas, incluidos ICL 2900 / Serie 39 , Multics y DEC VAX/VMS . El lenguaje se basaba en el Informe revisado, pero con restricciones de subconjunto similares a las de ALGOL 68R. Este compilador sobrevive en forma de un compilador de Algol68 a C.

En ALGOL 68S ^(S) de la Universidad Carnegie Mellon, se mejoró la potencia del procesamiento paralelo añadiendo una extensión ortogonal, eventing . Toda declaración de variable que contuviera la palabra clave EVENT hacía que las asignaciones a esta variable fueran elegibles para la evaluación paralela, es decir, el lado derecho se convertía en un procedimiento que se trasladaba a uno de los procesadores del sistema multiprocesador C.mmp . Los accesos a dichas variables se retrasaban después de la finalización de la asignación.

Cambridge ALGOL 68C ^(C) fue un compilador portátil que implementó un subconjunto de ALGOL 68, restringiendo las definiciones de operadores y omitiendo la recolección de basura, las filas flexibles y el transporte formateado.

Algol 68 Genie ^(G) de M. van der Veer es una implementación de ALGOL 68 para las computadoras y sistemas operativos actuales.

"A pesar de las buenas intenciones, un programador puede violar la portabilidad al emplear inadvertidamente una extensión local. Para protegerse contra esto, cada implementación debe proporcionar una opción pragmática PORTCHECK. Mientras esta opción esté vigente, el compilador imprime un mensaje para cada construcción que reconoce como violadora de alguna restricción de portabilidad". ^[67]

• ... El esquema de composición de tipos adoptado por C debe mucho a Algol 68, aunque quizás no surgió en una forma que los partidarios de Algol aprobarían. La noción central que capté de Algol fue una estructura de tipos basada en tipos atómicos (incluidas las estructuras), compuestas en matrices, punteros (referencias) y funciones (procedimientos). El concepto de uniones y conversiones de Algol 68 también tuvo una influencia que apareció más tarde. Dennis Ritchie , abril de 1993. ^[2]
• ... C no desciende de Algol 68, es cierto, pero hubo influencia, mucha de ella tan sutil que es difícil recuperarla incluso cuando pienso mucho. En particular, el tipo de unión (una adición tardía a C) sí debe su influencia a A68, no en los detalles, sino en la idea de tener un tipo de este tipo. Más profundamente, la estructura de tipos en general e incluso, de alguna extraña manera, la sintaxis de declaración (la parte del constructor de tipos) se inspiró en A68. Y sí, por supuesto, "long". Dennis Ritchie , 18 de junio de 1988 ^[4]
• "Enhorabuena, vuestro Maestro lo ha conseguido" – Niklaus Wirth ^[68]
• Cuanto más lo veo, más infeliz me siento – EW Dijkstra, 1968 ^[69]
• [...] se decía que la popularidad de la A68 era inversamente proporcional a [...] la distancia desde Ámsterdam – Guido van Rossum ^[70]
• [...] Lo mejor que pudimos hacer fue enviar junto con él un informe minoritario, en el que se establecía nuestra opinión de que "... como herramienta para la creación fiable de programas sofisticados, el lenguaje era un fracaso". [...] – CAR Hoare en su conferencia del Premio Turing de octubre de 1980 ^[71]
• "[...] Más que nunca, se exigirá a una herramienta de programación adecuada que ayude, mediante su estructura, al programador en los aspectos más difíciles de su trabajo, es decir, en la creación fiable de programas sofisticados. En este sentido, no vemos en qué sentido el lenguaje propuesto aquí supone un avance significativo: por el contrario, creemos que su visión implícita de la tarea del programador es muy similar a la de, digamos, hace diez años. Esto nos obliga a concluir que, considerado como una herramienta de programación, el lenguaje debe considerarse obsoleto. [...]" Informe de la minoría del Grupo de Trabajo de 1968, de 23 de diciembre de 1968. ^[72]

• Informe revisado sobre el lenguaje algorítmico ALGOL 68 La referencia oficial para usuarios e implementadores del lenguaje (archivo pdf grande, escaneado desde el Boletín Algol)
• Informe revisado sobre el lenguaje algorítmico ALGOL 68 Versión HTML con hipervínculos del Informe revisado
• Un tutorial sobre Algol 68, por Andrew S. Tanenbaum , en Computing Surveys , vol. 8, n.º 2, junio de 1976, con correcciones (vol. 9, n.º 3, septiembre de 1977)
• Algol 68 Genie: un compilador-intérprete GNU GPL Algol 68
• Implementaciones de código abierto de ALGOL 68 en SourceForge
• Representación de hardware estándar de Algol68 (.pdf) Archivado el 2 de enero de 2014 en Wayback Machine.
• Esta historia está compilada con Algol 68
• Algol 68 – 25 años en la URSS
• Programa de sistema de potencia dinámica para el traductor con algoritmo 68
• Historia de C con herencia de Algol68
• McJones, Paul, "Implementaciones y dialectos de Algol 68", Software Preservation Group , Computer History Museum , 5 de julio de 2011
• Compilador ALGOL 68 habilitado para web para pequeños experimentos