Оберон-2

Оберон — язык программирования высокого уровня, разработанный Никлаусом Виртом, а также одноимённая операционная система, разработанная Виртом и Юргом Гуткнехтом. Это также родовое имя для всего семейства близкородственных языков, производных от Оберона (Оберон, Оберон-07, Оберон-2, Component Pascal (Компонентный Паскаль), Active Oberon, OberonScript и др.), а также операционных систем и сред для исполнения программ на этих языках, развившихся из первоначальной Системы Оберон, в частности, ETH Oberon, BlackBox Component Builder, WinOberon, Bluebottle и др.

История

Семейство языков и систем, имеющее сейчас общее наименование «Оберон», родилось в проекте Оберон (Project Oberon) Никлауса Вирта и Юрга Гуткнехта (Jurg Gutknecht) в 1986-89 гг.^[1] Целью проекта было создание с нуля обозримой и надежной операционной системы однопользовательской рабочей станции. Для реализации этого проекта в 1988 году Никлаусом Виртом был спроектирован язык программирования высокого уровня общего назначения, также названный Оберон.^[2]

Основой для Оберона послужил язык Модула-2 (по словам Вирта^[3], первоначально систему хотели писать непосредственно на Модуле, но пришли к выводу о необходимости её доработки и сокращения, что и привело к появлению Оберона).

Язык сохранил основные черты синтаксиса Модулы и был дополнен ключевым механизмом объектно-ориентированного программирования — расширением типов (наследование и полиморфизм). Расширение типов позволило отказаться от механизма вариантных записей Модулы, составлявшего брешь в ее системе строгой статической типизации. Такая «герметизация» системы типов позволила ввести важнейший механизм автоматического управления памятью («сборка мусора»): из языка исключён «ручной» механизм освобождения динамически выделенной памяти с помощью особого оператора, а вместо него среда исполнения содержит сборщик мусора, который автоматически освобождает память после того, как она перестаёт использоваться. Автоматическое управление памятью является мощным средством повышения надёжности программ с динамическими структурами данных.

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

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

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

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

В 1992 году Никлаус Вирт и его ученик Ханспетер Мёссенбёк (Hanspeter Moessenboek) — ныне профессор Университета им. Иоганна Кеплера в Линце — опубликовали описание дополненного варианта Оберона, получившего название Оберон-2. Хотя Оберон-2 сразу после опубликования в 1992 году рассматривался как кандидат на роль стандарта языка (конференция Oakwood Conference, Croydon, 1993), но практический опыт, накопленный при создании больших программных комплексов, выявил некоторые слабости нововведений и желательность дальнейших уточнений (что лишний раз подчёркивает мудрость консерватизма, проявленного Виртом в определении первоначального Оберона).

Такие дальнейшие уточнения были предприняты в варианте Оберона-2, названном Компонентный Паскаль и опубликованном в 1999, компанией Oberon microsystems, образованной в 1992 году учениками Вирта (сам Вирт — член совета директоров). Как и при переходе от Оберона к Оберону-2, эти уточнения сделаны максимально экономно ^[4]. В частности, теперь язык полностью поддерживает методологию компонентно-ориентированного программирования. Благодаря последнему обстоятельству, Компонентный Паскаль на данный момент является, по-видимому, наиболее совершенным вариантом «классических» Оберонов. Однако он может быть редуцирован не только к подмножеству, эквивалентному первоначальному Оберону, но и к другому полноценному мимималистичному подмножеству, в котором наследование и переопределение методов допускается только для чисто интерфейсных типов и методов (определенных с атрибутом ABSTRACT). Это обстоятельство выявляет несколько промежуточный характер Оберона-2.

В 2007 году Вирт, основываясь на опыте работы с архитектурами ARM, пересмотрел язык Оберон. Новый язык получил название Оберон 2007.^[5] Стоит подчеркнуть, что за основу был взят именно первоначальный Оберон^[6], а не, скажем, Оберон-2, причины чего должны быть ясны из вышесказанного.

Существует группа экспериментальных языков, родственных Оберону, но отклоняющихся от линии Оберон/Оберон-2/Компонентный Паскаль. Это Active Oberon и

По утверждению Вирта[7], разработчики языка

Синтаксис языка

Синтаксис «Оберона-2» отличается компактностью. Он определён в следующих 33 предложениях РБНФ (даётся по Х. Мёссенбёк, Н. Вирт, 1996):

Модуль           = 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 Выраж
  | FOR идент ":=" Выраж TO Выраж [BY КонстВыраж] DO ПослОператоров END
  | LOOP ПослОператоров END
  | WITH Охрана DO ПослОператоров {"|" Охрана DO ПослОператоров} [ELSE ПослОператоров] 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, со счётчиком — FOR). Подобно Модуле-2, прописные и строчные буквы в идентификаторах различаются, все зарезервированные слова пишутся большими буквами. Все языковые конструкции, кроме цикла REPEAT..UNTIL заканчиваются ключевым словом END и допускают расположение внутри нескольких операторов без использования составного оператора BEGIN..END. Естественно, как и в Модуле-2 нет безусловных переходов.

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

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

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

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

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

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

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

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

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

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

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

Операционная среда

Программы, написанные на языке программирования Оберон, требуют определённой поддержки во время выполнения — им необходим динамический загрузчик и централизованно выполняемый автоматический сборщик мусора. Поэтому Оберон-программам нужна специальная операционная среда. Обычным способом её реализации является добавление в систему набора библиотек, реализующих необходимые компоненты, хотя, вообще говоря, операционной среде вовсе не обязательно нужна отдельная операционная система: она сама по себе может представлять собой операционную систему. Таковы системы Native Oberon для первоначального Оберона и Bluebottle для Active Oberon. В качестве операционной среды Оберон-программ может быть использована операционная среда платформы .NET компании Майкрософт, в которой реализовано автоматическое управление памятью. Под .NET работают Oberon.NET и

Hello, World!

Вариант Hello, World! на Обероне/Обероне-2/Компонентном Паскале. Помимо прочего, демонстрирует возможность использования Кириллических идентификаторов. Вывод текста производится в окно «рабочего журнала» (Log) средствами одноименного модуля.

 MODULE ПриветМир;
   IMPORT Log;
   PROCEDURE Сделать*;
   BEGIN
     Log.String("Привет, мир!"); 
     Log.Ln	(* запись "Привет, мир!" в окно лога *)
   END Сделать;
 END ПриветМир.

Варианты и языки-потомки

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

Oberon-2

Уточнённая версия исходного Оберона, разработанная Виртом и Мёссенбёком. Дополнения, внесённые в Оберон-2 и оформленные очень экономно, заключаются в следующем:

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

Любопытно, что несмотря на расширение языка, объём формального описания синтаксиса Оберона-2 меньше, чем у исходного Оберона. Это произошло в результате оптимизации описания синтаксиса.

Component Pascal

Дальнейшее развитие Оберона-2, в котором добавлены средства, позволяющие разработчику полностью контролировать расширение экспортируемых типов и переопределение методов (атрибуты EXTENSIBLE, ABSTRACT, NEW, EMPTY, а также возможность ограниченного экспорта метода «только для реализации»). Добавлен блок завершения тела модуля (ключевое слово CLOSE) и предопределенный пустой метод FINALIZE. Система основных (элементарных) типов приведена в соответствие с типами Java. Введён неявный строковый тип.

Active Oberon и Zonnon

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

Oberon-07

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

Глагол

В России был разработан язык Глагол, структурно очень близкий к Оберону-2. Главное его отличие состоит в использовании русских служебных слов.^[10][11] Помимо этого, язык имеет ещё ряд отличий от Оберона-2:

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

Язык поддерживает Юникод. Реализован компилятор (называемый преобразователем) для платформ Windows и PocketPC, а также среда разработки (также под Windows).

Реализации

И Оберон, и Оберон-2 были реализованы в ETH. Первая реализация Оберона выпущена в 1989 году для процессоров семейства NS32000. Он был создан в качестве компонента операционной среды Оберон. Этот компилятор требует менее 50 Кбайт памяти, состоит из 6 модулей общим объёмом около 4000 строк и сам себя компилирует за 15 секунд на компьютере с процессором NS32532 (тактовая частота — 25 МГц). Компания Oberon Microsystems, выпустившая Компонентный Паскаль, выпустила также библиотеку BlackBox Component Framework и среду разработки BlackBox Component Builder — небольшой по объёму и нетребовательный к ресурсам

Впоследствии BlackBox был расширен средой кросс-программирования Denia, позволяющей выполнять кросс-программирование для ОСРВ JBed (которая тоже полностью реализована на Компонентном Паскале). JBed предназначена для встроенных систем, работающих в реальном времени, например, для промышленных автоматов.

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

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

Есть несколько систем разработки программ для различных вариантов языка Оберон:

• ETH Oberon, доступная для многих вычислительных платформ;
• оптимизирующий компилятор XDS для Oberon-2;
• Блэкбокс (BlackBox Component Builder) для Компонентного Паскаля.
• Oberon SA — Версия языка Oberon, доработанная для эффективного программирования процессоров Strong-ARM, в частости, для использования в управляющих системах беспилотных летательных аппаратов. На основе опыта разработки Oberon SA Н. Вирт подготовил изменения и дополнения к первоначальному стандарту языка Oberon. Новая версия языка получила название Oberon-07.

Интересные факты

• По подсчётам, опубликованным в статье Сергея Свердлова «Арифметика синтаксиса», «линия Вирта», как он её назвал — линия, включающая Паскаль, Модулу-2, Оберон и Оберон2 — это единственный пример «генетической линии» языков-потомков Алгола-60, в которой сложность языка, определённая с необходимыми оговорками как количество лексем в его описании, стабильно снижалась и в настоящее время оказывается ниже, чем у общего «прародителя» — Алгола-60. Все языки «линии Вирта» проще Алгола-60, и каждый следующий язык в этой линии проще предыдущего. В то же время Ада более чем вдвое сложнее своего предшественника — Паскаля, C++ приблизительно в 1,7 раза сложнее Си, а в линейке Паскаль — Турбо Паскаль разных версий — Object Pascal сложность экспоненциально растёт от версии к версии.
• Эпиграфом к описанию оригинального Оберона была выбрана фраза Эйнштейна: «Делай настолько просто, насколько возможно, но не проще этого». В описании Оберона-2 этого эпиграфа нет.

Литература по Оберону

Книги по Оберону на русском языке пока не издавались. Однако на русский язык переведены и доступны в Интернете определяющие документы по языкам Оберон-2 и Компонентный Паскаль (краткие, но исчерпывающие описания):

• Х. Мёссенбёк, Н. Вирт «Язык программирования Оберон-2» Перевод С. З. Свердлова (pdf, html)

• Компания Oberon microsystems. «Сообщение о языке Компонентный Паскаль». Перевод Ф. В. Ткачева ([1])

Также был выполнен полный перевод документации по Блэкбоксу — наиболее интересной, с практической точки зрения, реализации языка. Полный комплект документации включен в состав учебных сборок Блэкбокса, в том числе для средних школ, подготовленных в рамках проекта Информатика-21; материалы проекта можно использовать в качестве введения в Блэкбокс:

• «Система BlackBox. Компонентный Паскаль», 108 сс., 1.8Mb, PDF

Можно посоветовать уроки по Блэкбоксу И. Е. Ермакова из города Орёл:

1. «Знакомство со средой»
2. «Пишем свой первый модуль»

а также учебные материалы Хабаровской школы программистов.

На английском языке существуют следующие книги по BlackBox'у:

• Programming with BlackBox / J. Stanley Warford (2Mb rar)(англ.)
• Developing Programs with BlackBox Oberon / Brett S. Hallett (1.5Mb rar)(англ.)

Фундамент литературы по Оберону заложила «трилогия Оберона», а именно три книги от создателя языка (выложенные авторами в свободный доступ):

1. Programming in Oberon: steps beyond Pascal and Modula. / Martin Reiser, Niklaus Wirth — NY: ACM Press, 1992 — ISBN 0-201-56543-9 — (22Mb PDF)(англ.)

   Лучшее введение в язык Оберон для новичков. Учебник и описание языка.

2. Algorithms and Data Structures (Oberon Version) / N.Wirth — (1.2M PDF)(англ.)

   Программирование «в малом». Написание отдельных модулей: алгоритмы, структуры данных.

3. Project Oberon: The Design of an Operating System and Compiler / N.Wirth, J.Gutknecht — (4.2M PDF)(англ.)

   Программирование «в большом». Сборка серьёзных проектов из модулей, объектов, компонент.

Также изучающим язык Оберон полезны лекции Никлауса Вирта на английском языке:

• The Programming Language Oberon / N.Wirth — (91Kb PDF)(англ.)
• Programming in Oberon. A derivative of Programming in Modula-2 / N.Wirth — (400Kb PDF)(англ.)

Ссылки

• Оберон (домашняя страничка на английском языке)
• Российский образовательный проект, отданный языку Оберон, на сайте есть русифицированный компилятор BlackBox
• Портал, посвящённый языку Оберон
• Первый (1998) сайт на русском языке по Оберону
• Проект OberonCore, на сайте есть Форум по Компонентному Паскалю и другим языкам семейства Оберон

Примечания

1. ↑ [N. Wirth and J. Gutknecht. Project Oberon. Addison-Wesley, 1992.]
2. ↑ [N. Wirth. The Programming Language Oberon. Software — Practice and Experience, Vol.18, No.7, pp.671-690.]
3. ↑ ^{1 2} Н. Вирт. От Модулы к Оберону
4. ↑ Сообщение о языке Компонентный Паскаль
5. ↑ The Programming Language Oberon, rev. 1.12.2007
6. ↑ Difference between Oberon-07 and Oberon
7. ↑ Лекция Н. Вирта в Нижегородском государственном университете им. Н. И. Лобачевского
8. ↑ [C. Szyperski. Component Software — Beyond Object-Oriented Programming. Addison- Wesley, 1998.]
9. ↑ [Э.Дейкстра. Дисциплина программирования. Мир, Москва, 1978]
10. ↑ Разработки на Глаголе.
11. ↑ Программование по-русски.