Oberon (linguagem de programação) 📖 Wikipedia

Oberon
Paradigma	Imperativa, Estruturada, Modular, Orientada a objetos
Surgido em	1987; há 39 anos
Última versão	Oberon-07 (6 março 2020; há 6 anos)
Criado por	Niklaus Wirth
Família	Wirth Oberon
Projetado por	Niklaus Wirth
Influenciada por	Modula-2
Influenciou	Oberon-2, Oberon-07, Active Oberon, Component Pascal, Zonnon, Go, V (Vlang), Nim
Plataforma	ARM, StrongARM; IA-32, x86-64; SPARC, Ceres (NS32032)
Sistema operacional	Windows, Linux, Solaris, classic Mac OS, Atari TOS, AmigaOS
Página oficial	projectoberon.net

Oberon é uma linguagem de programação de propósitos gerais primeiramente publicada em 1987 por Niklaus Wirth e último membro da família Wirthian de linguagens tipo ALGOL(Euler, ALGOL W, Pascal, Modula e Modula-2.^[1][2][3][4] Oberon foi o resultado de esforços concentrados para aumentar o poder de Modula-2, o sucessor direto de Pascal, e ao mesmo tempo para reluzir sua complexidade. Sua principal nova característica é o conceito de extensão de tipo de dado de tipo de registros.^[5] Isso permite a construção de novos tipos de dados com base em tipos existentes e relacionados com eles, desviando do dogma de tipagem estática de dados. Extensão de tipos o forma de Wirth de herança refletindo o ponto de vista do site pai. Oberon foi desenvolvida como parte da implementação de um sistema operacional, também chamado Oberon no ETH Zurich na Suíça. O nome foi inspirado tanto pelas fotos da sonda espacial Voyager da lua do planeta Urano, nomeada Oberon, e porque Oberon é famoso como o rei dos elfos.^[6]

Oberon era mantida por Wirth a a ultima atualização do compilador do Projeto Oberon foi en 6 de março de 2020.^[7]

Oberon é projetada com o lema atribuído Albert Einstein em mente: "Make things as simple as possible, but not simpler." A diretriz principal era se concentrar em recursos que são básicos e essenciais e para omitir problemas efêmeros. Outro fator foi o reconhecimento do crescimento da complexidade me linguagens como C++ e Ada. Em contraste a essas, Oberon enfatiza o uso do conceito de bibliotecas para estender a linguagem. Tipos de enumeração e subrange, que estavam presentes em Modula-2, form omitidos, e tipos de conjunto são limitados a conjuntos de inteiros. Todos os itens importados tem de ser qualificados pelo nome do módulo em que eles foram declarados. Recursos de baixo nível são destacados por permitindo apenas ser usado em módulos que incluem o identificador SYSTEM na sua lista de imports. Checagem de tipos estrita, mesmo através de módulos, e index checking em tempo de execução, verificação de null pointer, e o conceito de extensão tipagem segura amplamente permitiram programação depender apenas das regras da linguagem. A intenção dessa estratégia era produzir uma linguagem que é mais fácil de aprender, simples de implementar e muito eficiente. Compiladores Oberon tem sido vistos como compactos e rápidos, e ainda sim provendo qualidade de código comparável a compiladores comerciais.^[8]

Atributos caracterizando a linguagem Oberon incluem:^[9]

• Sintaxe sensível a capitalização com palavras chave com letras maiúsculas
• Extensão de tipos com teste de tipo
• Módulos e compilação separada
• Operações de string
• Isolamento de código inseguro
• Suporte para programação a nível de sistema

Oberon suporta extensão de tipos de registro para construção de abrações e estruturas heterogêneas. Em contraste a dialetos posteriores, Oberon-2 e Active Oberon, Oberon original sofria da falta de mecanismos de dispatch como uma característica mas tem isso como uma técnica de programação ou padrão de design. Isso dá grande flexibilidade em OOP. No sistema operacional Oberon, duas técnicas de programação são usadas juntas para o dispatch call: Method suite e Message handler.

Nessa técnica, uma tabela a de procedimentos variáveis é definida e uma variável global desse tipo é declarada em um módulo estendido e atribuído de volta a esse módulo genérico:

MODULE Figures; (* Abstract module *)

TYPE
   Figure*    = POINTER TO FigureDesc;
   Interface* = POINTER TO InterfaceDesc;

   InterfaceDesc* = RECORD
      draw*  : PROCEDURE (f : Figure);
      clear* : PROCEDURE (f : Figure);
      mark*  : PROCEDURE (f : Figure);
      move*  : PROCEDURE (f : Figure; dx, dy : INTEGER);
   END;

   FigureDesc* = RECORD
      if : Interface;
   END;

PROCEDURE Init* (f : Figure; if : Interface);
BEGIN
   f.if := if
END Init;

PROCEDURE Draw* (f : Figure);
BEGIN
   f.if.draw(f)
END Draw;

(* Other procedures here *)

END Figures.

Nós estendemos o tipo genérico Figure para um formato específico:

MODULE Rectangles;

IMPORT Figures;

TYPE
   Rectangle* = POINTER TO RectangleDesc;

   RectangleDesc* = RECORD
      (Figures.FigureDesc)
      x, y, w, h : INTEGER;
   END;

VAR
   if : Figures.Interface;

PROCEDURE New* (VAR r : Rectangle);
BEGIN
   NEW(r);
   Figures.Init(r, if)
END New;

PROCEDURE Draw* (f : Figure);
   VAR
      r : Rectangle;
BEGIN
   r := f(Rectangle); (* f AS Rectangle *)
   (* ... *)
END Draw;

(* Other procedures here *)

BEGIN (* Module initialisation *)
   NEW(if);
   if.draw  := Draw;
   if.clear := Clear;
   if.mark  := Mark;
   if.move  := Move
END Rectangles.

Dispatch dinâmico só é feito via procedimentos em módulo Figure que é um módulo genérico.

Essa técnica consiste de substituir o conjunto de métodos com um único procedimento, que descrimina entre vários métodos:

MODULE Figures; (* Abstract module *)

TYPE
   Figure*    = POINTER TO FigureDesc;

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

   Handler*   = PROCEDURE (f : Figure; VAR msg : Message);

   FigureDesc* = RECORD
      (* Abstract *)
      handle : Handler;
   END;

PROCEDURE Handle* (f : Figure; VAR msg : Message);
BEGIN
   f.handle(f, msg)
END Handle;

PROCEDURE Init* (f : Figure; handle : Handler);
BEGIN
   f.handle := handle
END Init;

END Figures.

Nós estendemos o tipo genérico Figure para um formato específico:

MODULE Rectangles;

IMPORT Figures;

TYPE
   Rectangle* = POINTER TO RectangleDesc;

   RectangleDesc* = RECORD
      (Figures.FigureDesc)
      x, y, w, h : INTEGER;
   END;

PROCEDURE Draw* (r : Rectangle);
BEGIN
  (* ... *)
END Draw;

(* Other procedures here *)

PROCEDURE Handle* (f: Figure; VAR msg: Figures.Message);
   VAR
      r : Rectangle;
BEGIN
   r := f(Rectangle);
   IF    msg IS Figures.DrawMsg THEN Draw(r)
   ELSIF msg IS Figures.MarkMsg THEN Mark(r)
   ELSIF msg IS Figures.MoveMsg THEN Move(r, msg(Figures.MoveMsg).dx, msg(Figures.MoveMsg).dy)
   ELSE  (* ignore *)
   END
END Handle;

PROCEDURE New* (VAR r : Rectangle);
BEGIN
   NEW(r);
   Figures.Init(r, Handle)
END New;

END Rectangles.

No sistema operacional Oberon ambas essas técnicas são usadas para dispatch dinâmico. O primeiro é usado para um conjunto conhecido de métodos; o segundo é usado apenas para novos métodos declarados numa módulo de extensão. Por exemplo, se o módulo de extensão Rectangles fosse implementar um novo procedimento Rotate(), dentro o módulo Figures ele poderia somente ser chamado via um message handler.

• Oberon
• Oberon-2
• Oberon-07
• Active Oberon

O desenvolvimento continuou em linguagens nessa família. Uma extensão adicional de Oberon-2 foi originalmente chamada Oberon/L mas mais tarde renomeada Component Pascal (CP). CP foi desenvolvido para Windows e Mac OS clássico pela Oberon microsystems, um espresa spin-off comercial da ETHZ, e para .NET pela Universidade de Tecnologia de Queensland. Além disso, as linguaguagens Lagoona^[10][11][12] e Obliq levam métodos Oberon a áreas especializadas.

Mais tarde esforços de desenvolvimento .NET no ETHZ focou em uma nova linguagem nomeada Zonnon. Isso inclui as features do Oberon e restaura algumas de Pascal (tipos enumerados, built-in IO) mas tem algumas diferenças de sintaxe. Outras features incluem suporte para active objects, sobrecarga de operador e tratamento de exceções.

Oberon-V (originalmente chamada Seneca, em homenagem a Séneca) é um descendente de Oberon projetado para aplicações numéricas em supercomputadores especialmente em arquitetura vetoriais ou pipelined. Ela inclui contrutores de array e ALL statement.^[13]

• Oberon (sistema operacional)

Referências