Oberón (lenguaje de programación)

Oberon es un lenguaje de programación de propósito general publicado por primera vez en 1987 por Niklaus Wirth y el último miembro de la familia Wirthiana de lenguajes similares a ALGOL (Euler, ALGOL W, Pascal, Modula y Modula -2). Oberon fue el resultado de un esfuerzo concentrado para aumentar la potencia de Modula-2, el sucesor directo de Pascal, y al mismo tiempo reducir su complejidad. Su principal novedad es el concepto de extensión de tipo de tipos de registro. Permite construir nuevos tipos de datos a partir de los existentes y relacionarlos, desviándose del dogma de la tipificación estrictamente estática de datos. La extensión de tipo es la forma de herencia de Wirth que refleja el punto de vista del sitio principal. Oberon fue desarrollado como parte de la implementación de un sistema operativo, también llamado Oberon en ETH Zurich en Suiza. El nombre proviene de la luna del planeta Urano, llamada Oberón.

Oberon aún es mantenido por Wirth y la última actualización del compilador de Project Oberon tiene fecha del 6 de marzo de 2020.

Diseño

Oberon está diseñado con un lema atribuido a Albert Einstein en mente: "Haz las cosas lo más simples posible, pero no más". La pauta principal fue concentrarse en las características básicas y esenciales y omitir los temas efímeros. Otro factor fue el reconocimiento del crecimiento de la complejidad en lenguajes como C++ y Ada. En contraste con estos, Oberon enfatiza el uso del concepto de biblioteca para extender el lenguaje. Se omitieron los tipos de enumeración y subrango, que estaban presentes en Modula-2, y los tipos de conjunto se limitan a conjuntos de números enteros. Todos los artículos importados deben estar calificados por el nombre del módulo donde se declaran. Las instalaciones de bajo nivel se destacan al permitir su uso solo en un módulo que incluye el identificador SISTEMA en su lista de importación. La verificación estricta de tipos, incluso entre módulos, y la verificación de índices en tiempo de ejecución, la verificación de punteros nulos y el concepto de extensión de tipo seguro permiten en gran medida que la programación se base únicamente en las reglas del lenguaje.

La intención de esta estrategia era producir un lenguaje que fuera más fácil de aprender, más simple de implementar y muy eficiente. Los compiladores de Oberon han sido vistos como compactos y rápidos, al tiempo que proporcionan una calidad de código comparable a la de los compiladores comerciales.

Características

Las características que caracterizan el idioma Oberon incluyen:

• Sintaxis sensible de caso con palabras clave de mayúsculas
• Tipo-extensión con prueba tipo
• Módulos y compilación separada
• Operaciones de enlace
• Isolating unsafe code
• Apoyo a la programación del sistema

Orientación de objetos

Oberon admite la extensión de tipos de registro para la construcción de abstracciones y estructuras heterogéneas. A diferencia de los dialectos posteriores, Oberon-2 y Active Oberon, el Oberon original carece de un mecanismo de envío como característica del lenguaje, pero lo tiene como técnica de programación o patrón de diseño. Esto da una gran flexibilidad en OOP. En el sistema operativo Oberon, se utilizan juntas dos técnicas de programación para la llamada de despacho: el conjunto de métodos y el controlador de mensajes.

Conjunto de métodos

En esta técnica, se define una tabla de variables de procedimiento y una variable global de este tipo se declara en el módulo extendido y se vuelve a asignar en el módulo genérico:

MODULO Gráficos; (* Módulo abstracto *)TYPEGráfico* POINTER TO Gráfico Desc;
Interfaz* POINTER TO InterfaceDesc;

InterfaceDesc* = RECORDsorteo* PROCEDURE f: Figura);
claro* PROCEDURE f: Figura);
marca*: PROCEDURE f: Figura);
move*: PROCEDURE (f: Figura; dx, dy: INTEGER);
 FIN;

FigureDesc* = RECORDsi... Interfaz;
 FIN;

PROCEDURE Init* (f: Figure; if: Interface);
BEGINf.if:= si
FIN Init;

PROCEDURE Dibujo* (f: Figura);
BEGINf.if.draw(f)
FIN Dibuja;

(* Otros procedimientos aquí *)FIN Figuras.

Extendemos el tipo genérico Figura a una forma específica:

MODULO Rectángulos;

IMPORT Gráficos;

TYPERectángulo* = POINTER TO Rectángulo Desc;

Rectángulo Desc* RECORD(Figuras.FiguraDesc)
x, y, w, h: INTEGER;
 FIN;

VARsi: Figuras. Interfaz;

PROCEDURE Nuevo*VAR r: Rectángulo);
BEGIN NOTICIASr);
Figuras. Init(r, if)
FIN Nuevo;

PROCEDURE Dibujo* (f: Figura);
 VARr: Rectángulo;
BEGINr:= f(Rectangle); (* f AS Rectangle *) (*... *)FIN Dibuja;

(* Otros procedimientos aquí *)BEGIN (* Iniciación del módulo *) NOTICIAS(si);
si.draw:= Dibuja;
si.clear:= Despejado;
si.mark:= Marcos;
si.move:= Muévanse.
FIN Rectángulos.

El envío dinámico solo se realiza a través de procedimientos en el módulo Figuras que es el módulo genérico.

Manejador de mensajes

Esta técnica consiste en sustituir el conjunto de métodos por un único procedimiento, que discrimina entre los distintos métodos:

MODULO Gráficos; (* Módulo abstracto *)TYPEGráfico* POINTER TO Gráfico Desc;

Mensaje* RECORD END;
DrawMsg* RECORD (Mensaje) FIN;
ClearMsg* RECORD (Mensaje) FIN;
MarkMsg* = RECORD (Mensaje) FIN;
MoveMsg* RECORD (Mensaje) dx*, dy*: INTEGER FIN;

Handler* = PROCEDURE f: Figura; VAR msg: Mensaje);

FigureDesc* = RECORD (* Resumen *)mango: Handler;
 FIN;

PROCEDURE Handle* (f: Figure; VAR msg: Mensaje);
BEGINf.handle(f, msg)
FIN Handle;

PROCEDURE Init* (f: Figure; handle: Handler);
BEGINf.handle:= mango
FIN Init;

FIN Figuras.

Extendemos el tipo genérico Figura a una forma específica:

MODULO Rectángulos;

IMPORT Gráficos;

TYPERectángulo* = POINTER TO Rectángulo Desc;

Rectángulo Desc* RECORD(Figuras.FiguraDesc)
x, y, w, h: INTEGER;
 FIN;

PROCEDURE Dibujo* (r: Rectángulo);
BEGIN (*... *)FIN Dibuja;

(* Otros procedimientos aquí *)PROCEDURE Handle* (f: Figure; VAR msg: Figures.Message);
 VARr: Rectángulo;
BEGINr:= f(Rectangle);
 IF msg ES Figures.DrawMsg Entonces Dibujo(r)
 ELSIF msg ES Figuras.MarkMsg Entonces Mark(r)
 ELSIF msg ES Figuras.MoveMsg Entonces Move(r, msg(Figures.MoveMsg).dx, msg(Figures. MoveMsg).dy)
 ELSE (* ignore *) FINFIN Handle;

PROCEDURE Nuevo*VAR r: Rectángulo);
BEGIN NOTICIASr);
Figuras.Init(r, Handle)
FIN Nuevo;

FIN Rectángulos.

En el sistema operativo Oberon, ambas técnicas se utilizan para el despacho dinámico. El primero se usa para un conjunto conocido de métodos; el segundo se usa para cualquier método nuevo declarado en el módulo de extensión. Por ejemplo, si el módulo de extensión Rectángulos implementara un nuevo procedimiento Rotar(), dentro del módulo Figuras solo se podría llamar a través de un controlador de mensajes.

Implementaciones y variantes

Oberón

Las implementaciones sin costo de Oberon (el idioma) y Oberon (el sistema operativo) se pueden encontrar en Internet (varias son de la propia ETHZ).

Oberón-2

Se realizaron algunos cambios en la primera especificación publicada. Por ejemplo, se agregaron funciones de programación orientada a objetos (POO), se restableció el bucle FOR. El resultado fue Oberon-2. Una versión, denominada Native Oberon, que incluye un sistema operativo y puede arrancar directamente en hardware de clase compatible con IBM PC. En ETHZ también se desarrolló una implementación.NET de Oberon con la adición de algunas extensiones menores relacionadas con.NET. En 1993, una empresa derivada de ETHZ introdujo en el mercado un dialecto de Oberon-2 llamado Oberon-L. En 1997, pasó a llamarse Component Pascal.

Los compiladores Oberon-2 desarrollados por ETH incluyen versiones para Microsoft Windows, Linux, Solaris y Mac OS clásico. Existen implementaciones de otras fuentes para algunos otros sistemas operativos, incluidos Atari TOS y AmigaOS.

Hay un escáner Oberon-2 Lex y un analizador Yacc de Stephen J Bevan de la Universidad de Manchester, Reino Unido, basado en el de la referencia de Mössenböck y Wirth. Está en la versión 1.4.

Otros compiladores incluyen Oxford Oberon-2, que también comprende Oberon-07, y Vishap Oberon. Este último se basa en el compilador de fuente a fuente (transpiler) Oberon to C de Josef Templ llamado Ofront, que a su vez se basa en el compilador OP2 desarrollado por Regis Crelier en ETHZ.

Oberón-07

Oberon-07, definido por Niklaus Wirth en 2007 y revisado en 2008, 2011, 2013, 2014, 2015 y 2016, se basa en la versión original de Oberon en lugar de Oberon-2. Los cambios principales son: se deben usar funciones de conversión numérica explícitas (por ejemplo, FLOOR y FLT), WITH, LOOP y EXIT, se ampliaron las sentencias WHILE, se pueden usar las sentencias CASE para las pruebas de extensión de tipo, RETURN solo se pueden conectar al final de una función, las variables importadas y los parámetros de valor estructurado son de solo lectura y las matrices se pueden asignar sin usar COPY.

Los compiladores Oberon-07 se han desarrollado para su uso con muchos sistemas informáticos diferentes. El compilador de Wirth apunta a un procesador de computadora con conjunto de instrucciones reducido (RISC) de su propio diseño que se usó para implementar la versión 2013 del sistema operativo Project Oberon en una placa Spartan-3 de matriz de puertas programables en campo (FPGA) de Xilinx. También existen puertos del procesador RISC a FPGA Spartan-6, Spartan-7, Artix-7 y un emulador RISC para Windows (compilable en Linux y macOS, y binarios disponibles para Windows). OBNC se compila a través de C y se puede utilizar en cualquier sistema operativo compatible con la interfaz de sistema operativo portátil (POSIX). La implementación comercial de Astrobe apunta a los microcontroladores ARM Cortex-M3, M4 y M7 de 32 bits. El compilador Patchouli produce binarios de Windows de 64 bits. Oberon-07M produce binarios de Windows de 32 bits e implementa la revisión 2008 del lenguaje. Akron's produce binarios para Windows y Linux. OberonJS traduce Oberon a JavaScript. Hay IDE en línea para Oberon. oberonc es una implementación para la máquina virtual Java.

Oberón activo

Active Oberon es otra variante de Oberon, que agrega objetos (con protección de acceso centrada en objetos y control de actividad local), aserciones protegidas por el sistema, programación de prioridad preventiva y una sintaxis modificada para los métodos (llamados type-bound procedimientos en el vocabulario de Oberon). Los objetos pueden estar activos, lo que significa que pueden ser subprocesos o procesos. Además, Active Oberon tiene una forma de implementar operadores (incluida la sobrecarga), una sintaxis avanzada para usar matrices (consulte las extensiones de lenguaje OberonX y las Actas de la 7.ª Conferencia conjunta de lenguajes modulares 2006 Oxford, Reino Unido) y conoce los espacios de nombres. El sistema operativo A2 (anteriormente Active Object System (AOS), luego Bluebottle), especialmente el kernel, sincroniza y coordina diferentes objetos activos.

ETHZ ha lanzado Active Oberon que admite objetos activos y los sistemas operativos basados en ellos (Active Object System (AOS), Bluebottle, A2) y el entorno (JDK, HTTP, FTP, etc.) para el idioma. Al igual que con muchos diseños anteriores de ETHZ, las versiones de ambos están disponibles para descargar en Internet. A partir de 2003, las unidades centrales de procesamiento (CPU) admitidas incluyen x86 de núcleo único y doble, y StrongARM.

Idiomas relacionados

Continuó el desarrollo de los idiomas de esta familia. Una extensión adicional de Oberon-2 se llamó originalmente Oberon/L pero luego se renombró a Component Pascal (CP). CP fue desarrollado para Windows y Mac OS clásico por Oberon microsystems, una empresa derivada comercial de ETHZ, y para.NET por la Universidad Tecnológica de Queensland. Además, los lenguajes Lagoona y Obliq llevan los métodos de Oberon a áreas especializadas.

Los esfuerzos de desarrollo de Later.NET en ETHZ se centraron en un nuevo lenguaje llamado Zonnon. Esto incluye las características de Oberon y restaura algunas de Pascal (tipos enumerados, IO incorporado) pero tiene algunas diferencias sintácticas. Otras características incluyen soporte para objetos activos, sobrecarga de operadores y manejo de excepciones.

Oberon-V (originalmente llamado Seneca, en honor a Seneca the Younger) es un descendiente de Oberon diseñado para aplicaciones numéricas en supercomputadoras, especialmente arquitecturas vectoriales o segmentadas. Incluye constructores de matrices y una instrucción ALL.

Recursos

Generales