Оберон — язык программирования высокого уровня , разработанный Никлаусом Виртом и предназначенный для исполнения программ на одноимённой операционной системе, авторами которой являются Никлаус Вирт и .

В семейство языков Оберон так же входят: Оберон-2 , , Компонентный Паскаль , Активный Оберон и .

Системы и среды

Программы, написанные на языке программирования Оберон, требуют определённой поддержки во время выполнения — им необходим динамический загрузчик и централизованно выполняемый автоматический сборщик мусора, для этого программам на языке Оберон нужна специальная операционная среда. Обычным способом её реализации является добавление в систему набора библиотек, реализующих необходимые компоненты, хотя, вообще говоря, операционной среде вовсе не обязательно нужна отдельная операционная система: она сама по себе может представлять собой операционную систему. Таковы системы Native Oberon для первоначального Оберона и A2 для Активного Оберона . На данный момент существуют компиляторы Оберон в байт-код виртуальной Java-машины и CLI для виртуальной машины .NET .

Операционные системы и среды для исполнения программ на языках семейства Оберон, развившихся из первоначальной Системы Оберон, являются ETH Oberon, BlackBox Component Builder , , A2 и др.

На основе Оберона были разработаны проекты Оберон-0, Оберон-X и другие . Простота Оберона и наличие исходных текстов оригинальной реализации позволяют легко адаптировать его для специальных классов задач. Но все эти Обероны очень близки между собой, поскольку и первоначальный Оберон очень прост.

История

Язык программирования Oberon создан Никлаусом Виртом в 1988 году на основе языков программирования Modula-2 , Pascal и Algol-60 .

По словам Вирта, первоначально систему хотели писать непосредственно на Модуле, но пришли к выводу о необходимости её доработки и сокращения, что и привело к появлению Оберона .

Целью проекта ( англ. Project Oberon ) Никлауса Вирта и Юрга Гуткнехта в 1986—1989 годы было создание с нуля обозримой и надёжной операционной системы для однопользовательской рабочей станции.

Для реализации этого проекта в 1988 году Никлаусом Виртом был спроектирован язык программирования высокого уровня общего назначения, также названный Оберон .

В 1989 году в Швейцарской высшей технической школе Цюриха (ETH) была выпущена первая реализация Оберона для процессоров семейства NS32000. Он был создан в качестве компонента операционной среды Оберон. Этот компилятор требует менее 50 Кбайт памяти, состоит из 6 модулей общим объёмом около 4000 строк и сам себя компилирует за 15 секунд на компьютере с процессором NS32532 (тактовая частота — 25 МГц). ^{[ источник не указан 649 дней ]}

Нововведения

Язык сохранил основные черты синтаксиса Модулы и был объектным расширением. Это позволило отказаться от механизма вариантных записей Модулы, являющихся отступлением от первоначальной строгой статической типизации , что дало возможность ввести механизм автоматического управления памятью — сборку мусора : из языка исключена возможность освобождения динамически выделенной памяти с помощью особого оператора, а вместо него сама среда исполнения содержит модуль, возвращающий неиспользуемую память системе. Автоматическое управление памятью является средством повышения надёжности программ с динамическими структурами данных, так как исключает человеческие ошибки, свойственные, например, таким языкам, как С / C++ .

Упрощение синтаксиса

Чтобы добиться наибольшей надёжности и производительности трансляции, было предпринято значительное упрощение языка за счёт его отказа от средств, которые были сочтены ненужными (исходя из опыта разработки, реализации и применения других языков), либо усложняли компилятор без достаточного оправдания с точки зрения производительности, либо были достаточно сложны, чтобы быть отправленными во внешние библиотеки, либо плохо совмещались с механизмами модульности и автоматического управления памятью: записи с вариантами , перечислимые типы , , множества общего вида , беззнаковый целый тип, локальные модули, модули определений, списки экспорта, оператор for, прежний вариант оператора with, специальный синтаксис определения главной программы. Рудиментарные средства поддержки параллельного программирования, имевшиеся в Модуле-2, не вошли в язык, так как он обслуживал однопользовательскую операционную систему. В целях упрощения отказались от обработки исключений .

Было упрощено описание массивов (индексы массивов могут быть только целочисленными и всегда начинаются с нуля, подобно языку Си), ограничено использование указателей — указатели могут существовать только на записи и массивы, в списках импорта указывается только импортируемый модуль, а при использовании импортированных имён требуется обязательная квалификация (явное указание имени модуля-экспортёра). В статье «От Модулы к Оберону» Вирт подробно пояснил причины удаления каждого из элементов.

Из соображений «достаточного минимума» в язык не были включены в качестве явного синтаксического понятия методы (процедуры и функции, связанные с типом), так как этот механизм в самом общем виде легко смоделировать, создавая в объектах (записях в языке Оберон) поля процедурного типа и присваивая им процедуры, соответствующие методам. Таким образом, в Обероне минимальными средствами поддерживается объектно-ориентированное программирование для упрощения процесса трансляции кода и ускорения этого процесса.

Благодаря внесённым изменениям, Оберон стал синтаксически проще. Описание его синтаксиса поместилось на одной странице, полное описание языка занимает около 20 страниц, что вдвое меньше, чем описание Модулы-2 . Оберон является если не минимальным, то, во всяком случае, одним из самых малых по объёму универсальных языков программирования высокого уровня.

Эпиграфом к описанию оригинального Оберона было выбрано высказывание Эйнштейна: «Делай настолько просто, насколько возможно, но не проще этого» .

Синтаксис в РБНФ

Определён в следующих предложениях РБНФ :

Модуль           = MODULE идент ";" [СписокИмпорта] ПослОбъявл [BEGIN ПослОператоров] END идент ".".
СписокИмпорта    = IMPORT [идент ":="] идент {"," [идент ":="] идент} ";".
ПослОбъявл       = { CONST {ОбъявлКонст ";" } | TYPE {ОбъявлТипа ";" } | VAR {ОбъявлПерем ";" }}
  {ОбъявлПроц ";" | ОпережающееОбъяв";"}.
ОбъявлКонст      = ИдентОпр "=" КонстВыраж.
ОбъявлТипа       = ИдентОпр "=" Тип.
ОбъявлПерем      = СписокИдент ":" Тип.
ОбъявлПроц       = PROCEDURE [Приемник] ИдентОпр [ФормальныеПарам]";" ПослОбъявл [BEGIN ПослОператоров] END идент.
ОпережающееОбъяв = PROCEDURE "^" [Приемник] ИдентОпр [ФормальныеПарам].
ФормальныеПарам  = "(" [СекцияФП {";" СекцияФП}] ")" [":" УточнИдент].
СекцияФП         = [VAR] идент {"," идент} ":" Тип.
Приемник         = "(" [VAR] идент ":" идент ")".
Тип              = УточнИдент | ARRAY [КонстВыраж {"," КонстВыраж}] OF Тип
  | RECORD ["("УточнИдент")"] СписокПолей {";" СписокПолей} END | POINTER TO Тип | PROCEDURE [ФормальныеПарам].
СписокПолей      = [СписокИдент ":" Тип].
ПослОператоров   = Оператор {";" Оператор}.
Оператор         = [ Обозначение ":=" Выраж
  | Обозначение ["(" [СписокВыраж] ")"]
  | IF Выраж THEN ПослОператоров {ELSIF Выраж THEN ПослОператоров} [ELSE ПослОператоров] END
  | CASE Выраж OF Вариант {"|" Вариант} [ELSE ПослОператоров] END
  | WHILE Выраж DO ПослОператоров END
  | REPEAT ПослОператоров UNTIL Выраж
  | LOOP ПослОператоров END
  | WITH Охрана DO ПослОператоров END
  | EXIT
  | RETURN [Выраж] ].
Вариант          = [МеткиВарианта {"," МеткиВарианта} ":" ПослОператоров].
МеткиВарианта    = КонстВыраж [".." КонстВыраж].
Охрана           = УточнИдент ":" УточнИдент.
КонстВыраж       = Выраж.
Выраж            = ПростоеВыраж [Отношение ПростоеВыраж].
ПростоеВыраж     = ["+" | "-"] Слагаемое {ОперСлож Слагаемое}.
Слагаемое        = Множитель {ОперУмн Множитель}.
Множитель        = Обозначение ["(" [СписокВыраж] ")"] | число | символ | строка | NIL | Множество
  | "(" Выраж ")" | " ~ " Множитель.
Множество        = "{" [Элемент {"," Элемент}] "}".
Элемент          = Выраж [".." Выраж].
Отношение        = "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.
ОперСлож         = "+" | "-" | OR.
ОперУмн          = "*" | "/" | DIV | MOD | "&".
Обозначение      = УточнИдент {"." идент | "[" СписокВыраж "]" | "^" | "(" УточнИдент ")"}.
СписокВыраж      = Выраж {"," Выраж}.
СписокИдент      = ИдентОпр {"," ИдентОпр}.
УточнИдент       = [идент "."] идент.
ИдентОпр         = идент [ "*" | "-" ].

Основные элементы

Программа на Обероне представляет собой набор модулей. В общем виде модуль имеет вид:

  MODULE Имя;
    IMPORT СписокИмпорта;
    Определения;
  BEGIN
    Операторы
  END Имя.

Список импорта определяет, из каких модулей будут импортированы внешние имена . Определения включают определения типов, процедур, функций, переменных, констант. При этом определения имён, отмеченных звёздочкой, экспортируются данным модулем, то есть будут видны другим модулям, импортирующим данный. В Обероне-2 допустимо также помечать имена знаком минус, в этом случае они экспортируются в режиме «только для чтения».

Тело модуля исполняется при его загрузке. В Компонентном Паскале внутри тела модуля (в разделе BEGIN..END ) появилась возможность добавить секцию CLOSE :

  BEGIN
    Операторы
  CLOSE
    Операторы
  END Имя.

Здесь операторы, расположенные между BEGIN и CLOSE , выполняются при загрузке модуля, а операторы, расположенные между CLOSE и END — при выгрузке его из памяти. Такое расширение было сочтено полезным для компонентных программ, которые загружают и выгружают модули динамически .

Создаваемые программистом типы данных ограничены следующим набором: типы-массивы ARRAY , типы-записи RECORD , процедурные типы PROCEDURE , типы-указатели POINTER . Указатель может быть объявлен только на массив или запись.

Синтаксис внутренней части программы достаточно традиционен и прост. Язык поддерживает традиционный набор конструкций: условный оператор IF , оператор выбора CASE , циклы (с предусловием — WHILE , с постусловием REPEAT..UNTIL , безусловный — LOOP ). Подобно Модуле-2, прописные и строчные буквы в идентификаторах различаются, все зарезервированные слова пишутся большими буквами. Все языковые конструкции, кроме цикла REPEAT..UNTIL заканчиваются ключевым словом END и допускают расположение внутри нескольких операторов без использования составного оператора BEGIN..END . Естественно, как и в Модуле-2 нет безусловных переходов.

Парадигма объектно-ориентированного программирования поддерживается механизмом расширения записей (в языке нет отдельного ключевого слова для описания классов, вроде «class» или «object», сочтено, что обычного понятия «тип запись» вполне достаточно). По сути, каждый тип запись — это описание класса, а поля записи — это данные-члены класса.

В исходном Обероне методов (процедур и функций, связанных с классом ) нет вообще. Механизм методов может быть использован путём объявления в записи полей процедурного типа, которым при создании экземпляра класса присваиваются конкретные процедуры. Вызов таких процедур производится традиционным способом обращения к полю записи, по умолчанию процедура не знает об экземпляре класса, для которого она была вызвана (нет механизма, аналогичного this в C++ или Java), и если такие сведения ей необходимы, ссылка на экземпляр должна быть передана явно (например, через параметр ). Отсутствие явно описываемых методов было одним из качеств исходного Оберона, вызвавшего критику привыкших к традиционным гибридным языкам программистов. С другой стороны, предлагаемый Обероном механизм позволяет реализовать всё, что реализуемо традиционными средствами языков с методами, и даже более того — в Обероне каждый экземпляр класса может иметь собственный вариант метода (значение поля процедурного типа), тогда как при описании методов как части класса все экземпляры работают с одним вариантом метода. В Обероне-2 методы были всё-таки введены. Методы описываются отдельно от типа запись, с указанием типа, с которым они связаны.

Новый тип запись может быть объявлен как расширение существующего. В этом случае тип, который расширяется, указывается в описании записи в скобках после ключевого слова RECORD . Расширенный тип автоматически получает все поля расширяемого типа и (в Обероне-2) связывается со всеми процедурами, связанными с расширяемым типом. Процедуры, связанные с новым типом, могут иметь ту же сигнатуру , что и процедуры, связанные с расширяемым типом — таким образом обеспечивается переопределение методов в порождённых типах. В Компонентном Паскале , с целью обеспечения полного статического контроля за согласованностью иерархий наследования (и этим восстанавливая принцип тотальной статической типизации, отличающий первоначальный Оберон), записи по умолчанию не являются расширяемыми, а методы не могут быть переопределены. Чтобы контролировать расширение записей и переопределение методов, используются специально введённые ключевые слова EXTENSIBLE, ABSTRACT, LIMITED, EMPTY . При этом вновь вводимые методы должны маркироваться ключевым словом NEW (ср. обязательное определение вновь вводимых переменных).

Концепции программирования

Компонентное программирование

Оберон нацелен на компонентно-ориентированную разработку программного обеспечения . Инкапсуляция поддерживается исключительно на уровне модуля — все типы, объявленные внутри модуля, друг для друга абсолютно прозрачны. Из других модулей доступно то, что объявлено при определении как экспортируемое.

Полиморфизм обеспечивается за счёт механизма методов (и процедурные поля в Обероне, и методы в Обероне-2 ведут себя как виртуальные , в терминологии большинства гибридных объектно-ориентированных языков), а также расширенной конструкцией WITH, позволяющей выполнять различные группы операторов в зависимости от того, к какому из расширенных типов относится её аргумент.

В языке отсутствует специальный механизм конструкторов. Рекомендуемым методом создания и инициализации объектов является описание порождающих модулей и процедур (в традиционной терминологии ООП — factory).

Программа в такой технологии представляет собой набор относительно самостоятельных компонентов (в данном случае — модулей), имеющих скрытую от внешнего мира внутреннюю структуру и чётко определённый интерфейс. Модули могут загружаться и выгружаться динамически, во время работы программы, система предоставляет развитые средства контроля типов во время выполнения, которые позволяют писать универсальные алгоритмы обработки данных, не зависящие от конкретных типов этих данных (например, библиотека для работы с СУБД может предоставлять методы, записывающие результат запроса из базы в запись произвольной структуры, если набор и типы полей этой записи соответствуют набору и типам полей в БД).

В компонентной парадигме считается неудачным архитектурное решение, связанное с широким использованием наследования реализации от типов, объявленных в другом компоненте, поскольку это приводит к явлению, известному как «хрупкость базового типа» — после того, как от базового типа порождено большое количество типов-наследников (причём часть из них может быть даже неизвестна разработчику базового типа), любые изменения в реализации базового типа становятся крайне рискованными, так как они могут непредсказуемым образом отразиться на типах-потомках.

Известно, что одной из проблем применения объектно-ориентированного программирования в системном программировании является необходимость иметь группы маленьких классов, которые могли бы взаимодействовать без дополнительных накладных расходов. В Обероне этой проблемы нет — все типы, определённые в одном модуле, видят друг друга, а проблем с надёжностью это не создаёт, так как модуль всё равно разрабатывается, тестируется и сопровождается как единое целое.

Типичная система, разработанная на Обероне, представляет собой набор модулей с процедурными интерфейсами, через которые модули обмениваются данными, в том числе и объектами. При этом все средства инкапсуляции действуют только в межмодульном взаимодействии, что делает удобным системное программирование с использованием объектов.

Объектно-ориентированное программирование

Средства объектного программирования интерпретируются в Обероне как естественное развитие средств работы с записями в модульной системе, точнее, как технический инструментарий для решения конкретной архитектурной задачи: обеспечить эффективное «разделение труда» между различными модулями при работе с динамическими типами и структурами данных: например, работа с указателями в списке может быть скрыта (вместе с соответствующими полями) в одном модуле, а определение и работа с конкретным «наполнением» элементов списка — задаваться в другом (или, чаще, других). В этом смысле технология объектного программирования в Обероне подчинена концепции модульности: она здесь является, скорее, средством описания данных, чем средством построения архитектуры приложения в целом.

Влияние на другие языки

По утверждению Вирта , разработчики языка Java за несколько лет до её создания «изучили исходные коды Оберона и, в частности, исходные коды обероновских сборщиков мусора. Потом они испортили Оберон синтаксисом Си и назвали получившееся словом Java». Хотя от устного выступления нельзя требовать абсолютной точности формулировок, но во всяком случае несомненное сходство идеологий Оберона и Java (стремление к минимализму и строгой типизации, ограничение множественного наследования, автоматическое управление памятью) говорит о том, что здесь имеет место определённый консенсус относительно того, какие средства должны составлять ядро современного языка программирования общего назначения. Однако если в Обероне и его прямых наследниках минимализм остаётся во главе угла, разработчики Java пошли по пути экстенсивного наращивания возможностей языка.

Версии языка

Исходная версия Оберона («классический Оберон») — наиболее краткая, с наименьшим количеством ключевых слов и синтаксических конструкций. Она была использована в качестве базы для создания семейства языков, каждый из которых расширяет классический в каком-либо направлении либо отличается от него некоторыми деталями.

Оберон-2

В 1992 году Никлаус Вирт и его ученик — ныне профессор Университета им. Иоганна Кеплера в Линце — опубликовали описание дополненного варианта Оберона, получившего название Оберон-2 . Он представляет собой уточнённую версию классического Оберона. Дополнения, внесённые в Оберон-2 и оформленные очень экономно, заключаются в следующем:

• добавлены процедуры, связанные с типом, допускающие переопределение для порождённых типов (приблизительный аналог виртуальных методов в других объектно-ориентированных языках);
• в язык возвращён оператор цикла с шагом FOR ;
• добавлена возможность экспорта описаний в режиме «только для чтения» .

Несмотря на расширение языка, объём формального описания синтаксиса Оберона-2 меньше, чем у классического Оберона за счёт оптимизации описания синтаксиса. Существует оптимизирующий компилятор для Оберона-2; есть также компилятор в байт-код Java .

ETH Oberon

ETH Oberon , реализации которого имеются для многих вычислительных платформ.

Oberon SA

Oberon SA — это версия языка Оберон, разработанная Н. Виртом для процессора , используемого в беспилотном вертолете .

На основе опыта разработки Oberon SA Н. Вирт в 2007 году подготовил изменения и дополнения к классическому Оберону для более строгой поддержки структурного программирования, чем, например, в Oberon-2 или Компонентном Паскале. Новая версия языка получила название Oberon-07 . Имеется перевод «The Programming Language Oberon, Revision 1.11.2008» на русский язык . Но в отношении поддержки объектно-ориентированного программирования язык Oberon-07 не следует за Обероном-2, а продолжает минималистичную линию классического Оберона, включая отсутствие поддержки процедур, привязанных к типам записей.

Oberon-07

Oberon-07 имеет следующие основные отличия от классического Оберона:

• в цикле WHILE разрешены несколько охраняемых ветвей (ELSIF … DO). Тем самым обеспечена полная явная поддержка цикла Дейкстры . Ранее цикл Дейкстры моделировался при помощи цикла LOOP;
• соответственно, исключен неструктурированный цикл LOOP вместе с оператором EXIT (выход из цикла);
• в процедуре теперь может быть только одна точка выхода, фиксированная в конце тела процедуры: RETURN, в сущности, перестал быть оператором, превратившись в такую же синтаксическую часть описания процедуры, как ключевое слово PROCEDURE и т. д.;
• добавлен оператор цикла FOR;
• исключено неявное приведение типа INTEGER к REAL и типов с различной разрядностью друг к другу;
• разрешены ссылки только на записи;
• определены процедурные переменные—могут ссылаться только на процедуры;
• уточнено правило импорта/экспорта: экспорт переменных разрешён только для чтения, спецификатор экспорта один — «*»;
• уточнены типы данных — CHAR поддерживает множество Latin-1, INTEGER — −2^31 — +2^31-1, REAL и LONGREAL — IEEE Standard, 32 и 64 бита соответственно, SET — множество целых между 0 и 31. В последнем описании языка Вирт отказался от указания конкретного диапазона значений для базовых типов: множество значений типов INTEGER, REAL, LONGREAL и SET теперь определяется реализацией, тип CHAR содержит «стандартный набор символов» («a standard character set»).

Австралийская компания CFB Software (г. Брисбен) при Университете штата Квинсленд разработала IDE Astrobe для языка Oberon-07 для микроконтроллеров ARM7 компании NXP (Philips) и синтаксические диаграммы языка Oberon-07 , а также рекомендации по стилю программ на Oberon-07 .

Языки семейства Oberon

Компонентный Паскаль (Component Pascal)

Оберон-2 сразу после опубликования в 1992 году рассматривался как кандидат на роль стандарта языка (конференция Oakwood Conference, Croydon, 1993), но практический опыт, накопленный при создании больших программных комплексов, выявил необходимость уточнения/расширения конструкция языка. Это лишний раз подчёркивает мудрость консерватизма, проявленного Виртом в определении классического Оберона.

Эти уточнения были предприняты в расширении Оберона-2, названном Компонентный Паскаль и опубликованном в 1999 году , компанией , образованной в 1992 году учениками Вирта (сам Вирт стал членом совета директоров). Как и при переходе от Оберона к Оберону-2, эти уточнения сделаны наиболее экономно . Код на Компонентном Паскале может быть редуцирован к подмножеству, эквивалентному первоначальному Оберону или к другому полноценному минималистичному подмножеству, в котором наследование и переопределение методов допускается только для чисто интерфейсных типов и методов (определённых с атрибутом ABSTRACT).

В Компонентный Паскаль добавлены средства, позволяющие разработчику полностью контролировать расширение экспортируемых типов и переопределение методов (атрибуты EXTENSIBLE, ABSTRACT, NEW, EMPTY, а также возможность ограниченного экспорта метода «только для реализации»). Добавлен блок завершения тела модуля (ключевое слово CLOSE) и предопределённый пустой метод FINALIZE. Система основных (элементарных) типов приведена в соответствие с типами Java. Введён неявный строковый тип. Компания Oberon Microsystems, определившая Компонентный Паскаль , выпустила также фреймворк BlackBox Component Framework и среду визуального программирования BlackBox Component Builder — небольшие по размеру и нетребовательные к ресурсам, целиком построенные на Компонентном Паскале.

Впоследствии компилятор BlackBox был встроен в кросс-платформенную среду программирования , в частности для операционной системы реального времени , полностью написанной на Компонентном Паскале.

Активный Оберон, Zonnon

Эти языки уже с полным основанием можно назвать не расширениями или версиями Оберона, а самостоятельными языками. В них существенно расширен синтаксис, введены конструкции для описания классических «свойств» (property) с контролем чтения/записи, числовых типов с задаваемым размером в битах. Введена поддержка активных объектов, обменивающихся сообщениями в формате, определяемом РБНФ-описанием, обработка исключений .

Примечания

Литература

• Вирт Никлаус. Построение компиляторов, Москва, ДМК Пресс, 2010, ISBN 978-5-94074-585-3
• , Лань, 2019, ISBN 978-5-8114-3457-2

На английском языке

• — NY: ACM Press, 1992 — ISBN 0-201-56543-9 , 22Mb
• , 1.2Мб
• , 4.2Мб PDF
• (недоступная ссылка) , 91Кб
• , 400Кб

Ссылки

• (англ.)
• , Мир ПК, октябрь 2005.
• , Институт компьютерных систем, ETH, Цюрих,1996.
• , Орловский ГУ, материалы секции-семинара, 30 марта 2006 г.
• , Мир ПК, сентябрь 2005.
• (англ.)