К>А я знаю, как популяризировать Оберон: написать компилятор Oberon.Net

System.Console.Write{System.String}("Hello, world!"); (*в фигурных скобках указана сигнатура перегруженного метода, чтобы компилятор знал, что вызывать*)

A possible solution is to require computationally intensive active objects
to release the processor voluntarily by calling a runtime procedure
from time to time. However, this solution is not satisfactory; experience
with tasks in Oberon have shown that this is difficult to coordinate, especially
when active objects make use of other objects to perform their
work. It can also be inefficient, as releasing the processor too often
causes unnecessary overhead, and releasing it too seldom restricts the
progress of other active objects.

A better solution is to use time-slicing, i.e., let the system automatically
preempt long-running processes by setting a timer to interrupt
them. In this way the system is in control of the frequency of process
switches and the active object programmer does not have to worry
about releasing the processor.

To make the Aos runtime system viable for realtime environments
and responsive in interactive use, a facility must be provided to allow
more important processes to run before less important ones. Therefore
the assignment of relative priorities to processes is foreseen. At any
time, the processes executing will have a priority not lower than that of
all other runnable processes.

There are basically two approaches to scheduling multiple processors:
either each processor is responsible for its own scheduling, or one
processor is responsible for scheduling on all the processors [112]. The
first approach is preferred for its simplicity, symmetry and scalability.

void Func1()
{
  try
  {
    Func2();
  }
  catch(SomeException e)
  {
     // обрабатываем исключение при этом у нас есть доступ к someData
  }
}

void Func2() { Func3(); } // исключения не требуют написания какого либо кода на всех уровнях вызова.

void Func3()
{
  ...
  if(someConditions)
    throw new SomeException(someData);
  ...
}

PROCEDURE Main;
  PROCEDURE Handler (VAR e: SomeException);
  BEGIN
      IF … the failure can be repaired … THEN
       …Repair it…;
      Exceptions.Resume (* return using resume semantics*)
      END;
      (* return using terminate semantics*)
   END Handler;
BEGIN
  ...
  Exceptions.Raise(e);
  ...
END.

Canada and the UK (and probably other countries as well) strictly prohibit the use of C and C++ for developments related to any nuclear application. The only languages which were accepted were Ada and Modula-2, thanks to the fact that it had become the only programming language with full ISO standardisation (a very complex process) and certified compilers.

How important is NOTATION?
Fundamental !!!
Try using Roman Numerals for arithmetic calculations.

According to the director of technology of a large US corporation, the average time to train a new C++ programmer is about 3 years, "Which is kind of embarrassing" he added, "since NASA only takes 18 months to train an astronaut."

Some time ago, I did some consulting work for Deutsche Bank and had a chance to work with their development team. When I browsed through the code of their main trading application, it took me a while to figure out that it was actually C++. It looked more like Java or in fact Modula-2, apart from the accolades. Talking to the project leader, I learned that they had very strict guidelines for programming:
— one instruction per line
— every instruction with comment
— NO Multiple inheritance
— NO Macros
— NO Generic modules
— NO Overloading
— NO fancy C-style expressions, only basic operators
— Naming conventions strictly enforced

ПОСТРОЕНИЕ ВНУТРЕННЕГО ЯДРА
Внутреннее ядро (Inner Core) системы Oberon состоит из файловой системы, загрузчика модулей и средств распределения памяти. Его пять модулей связываются воедино в так называемый файл загрузки (boot file). Здесь мы опишем те шаги, которые позволили сформировать внутренее ядро.

Вряд ли можно поспорить с тем, что началом всех начал для любого программного обеспечения на «голой» машине является начальный загрузчик (boot loader). Поскольку он размещается в ROM-памяти и не может изменяться, он должен быть как можно более компактным. Добиться этого не столь сложно, ведь цель загрузчика проста и хорошо определена. Файл загрузки рабочей станции Ceres состоит из последовательности блоков данных, каждому из которых предшествует его размер и адрес, по которому он должен быть размещен. Формат файла в нотации EBNF выглядит следующим образом:

файл_загрузки = {блок} ноль стартовый_адрес.
блок = размер адрес {байт}.

Начальный загрузчик инициализирует регистры компьютера, очищает память и считывает файл загрузки. Наша первая версия осуществляла считывание через последовательный интерфейс RS-232 и состояла менее, чем из 200 байтов кода. Она была запрограммирована с помощью техники кросс-ассемблирования на компьютере Lilith. Более поздние версии позволяли уже выбирать источник загрузки: винчестер, флоппи-диск или же последовательный канал. Сам файл загрузки создавался загрузочным компоновщиком (boot linker), который также работал на Lilith.

PROCEDURE guardinsert(p: ANYPTR);
BEGIN
    IF p IS CorrectPtr THEN insert(p) END
END guardinsert;

/*
* To reduce the famous code bloat trouble due to the use of templates STLport grant
* a specialization of the vector container for pointer types. So all instanciations
* of vector with a pointer type will use the same implementation based on a vector
* of void*. If you prefer systematical instanciation turn on this macro.
* Remark: This feature is only implemented for compilers supporting partial template
* specialization.
*/

// #define _STLP_DONT_USE_PTR_SPECIALIZATIONS 1

AVC>PROCEDURE guardinsert(p: ANYPTR);
AVC>BEGIN
AVC>    IF p IS CorrectPtr THEN insert(p) END
AVC>END guardinsert;
AVC>

PROCEDURE guardinsert(p: ANYPTR);
BEGIN
   ASSERT(p IS CorrectPtr); insert(p)
END guardinsert;

PROCEDURE guardinsert(p: ANYPTR);
BEGIN
   WITH p: CorrectPtr DO insert(p) END
END guardinsert;

TYPE 
  TBytes    = ARRAY OF BYTE;

PROCEDURE LoadMemoryFromFile(CONST FileName: STRING; OUT Memory: TBytes);
VAR  FileHandle, MapHandle: THandle;
     FileSize, i: INTEGER;
     StartingAddressOfTheMappedView, p: PByte;
BEGIN
  Memory := NIL;
  StartingAddressOfTheMappedView := NIL;
  FileHandle := SysUtils.FileOpen(FileName, SysUtils.fmOpenRead);
  IF FileHandle = WINDOWS.INVALID_HANDLE_VALUE THEN EXIT;
  TRY
    FileSize := WINDOWS.GetFileSize(FileHandle, nil);
    MapHandle := WINDOWS.CreateFileMapping(FileHandle, nil, PAGE_READONLY, 0, FileSize, nil);
    IF MapHandle = 0 THEN RAISE Exception.Create('Failed to create file mapping!!!');
  FINALLY
    WINDOWS.CloseHandle(FileHandle);
  END;
  TRY
    TRY
      StartingAddressOfTheMappedView := WINDOWS.MapViewOfFile(MapHandle, WINDOWS.FILE_MAP_READ, 0, 0, FileSize);
      IF StartingAddressOfTheMappedView = NIL THEN EXIT;
    FINALLY
      WINDOWS.CloseHandle(MapHandle);
    END;
    SYSTEM.SetLength(Memory, FileSize);
    p := StartingAddressOfTheMappedView;
    FOR i := 0 TO FileSize - 1 DO BEGIN
      Memory[i] := p^;
      INC(p);
    END;
  FINALLY
    WINDOWS.UnmapViewOfFile(StartingAddressOfTheMappedView);
  END;
END;

MODULE TestTest;

  IMPORT StdLog, Files; 

  PROCEDURE Test* ();
  VAR  L: Files.Locator; f: Files.File; r: Files.Reader; b: BYTE;
  BEGIN
    L := Files.dir.This("C:\");
    IF L # NIL THEN 
      f := Files.dir.Old(L, "New Text Document.txt", FALSE);
      IF f # NIL THEN
        r := f.NewReader(NIL);
        IF r # NIL THEN 
          WHILE ~r.eof DO r.ReadByte(b); StdLog.Char(CHR(b)) END
        END;
        f.Close();
      END
    END
  END Test;

END TestTest.

СГ>MODULE TestTest;

СГ>  IMPORT StdLog, Files; 

СГ>  PROCEDURE Test* ();
СГ>  VAR  L: Files.Locator; f: Files.File; r: Files.Reader; b: BYTE;
СГ>  BEGIN
СГ>    L := Files.dir.This("C:\");
СГ>    IF L # NIL THEN 
СГ>      f := Files.dir.Old(L, "New Text Document.txt", FALSE);
СГ>      IF f # NIL THEN
СГ>        r := f.NewReader(NIL);
СГ>        IF r # NIL THEN 
СГ>          WHILE ~r.eof DO r.ReadByte(b); StdLog.Char(CHR(b)) END

А что произойдет здесь, если скажем при чтении наткнемся на bad block?

СГ>        END;
СГ>        f.Close();
СГ>      END
СГ>    END
СГ>  END Test;

СГ>END TestTest.
СГ>

void Test
{
    try
    {
        using (StreamReader sr = new StreamReader("C:/New Text Document.txt"))
        {
            int c;
            while ((c = sr.Read()) != -1)
                Console.WriteLine((char)c)
        }
    }
    catch
    {
        // do default work
    }
}

PROCEDURE Test* ();
VAR  L: Files.Locator; f: Files.File; r: Files.Reader; b: BYTE;
BEGIN
  L := Files.dir.This("C:\");
  IF L # NIL THEN 
    f := Files.dir.Old(L, "New Text Document.txt", FALSE);
    IF f # NIL THEN
      r := f.NewReader(NIL);
      IF r # NIL THEN
        LOOP 
          r.ReadByte(b);
          IF r.eof THEN EXIT END;
          StdLog.Char(CHR(b)) 
        END;
      END;
      f.Close();
    END
  END
END Test;

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    vector<int> vi(100);
    sort(vi.begin(), vi.end());
#if 1
    vector<int> vi2(100);
    sort(vi2.begin(), vi2.end());
#else
    vector<char *> vs(100);
    sort(vs.begin(), vs.end());
#endif
    return 0;
}

AVC>>P.S. А что такое плефора?

- Рахмат!
— Что?
— Спасибо по-узбекски.
— А... Здоровеньки булы!
— Что?
— Пожалуйста по-украински.

AVK>void Test
AVK>{
AVK>    try
AVK>    {
AVK>        using (StreamReader sr = new StreamReader("C:/New Text Document.txt"))
AVK>        {
AVK>            int c;
AVK>            while ((c = sr.Read()) != -1)
AVK>                Console.WriteLine((char)c)
AVK>        }
AVK>    }
AVK>    catch
AVK>    {
AVK>        // do default work
AVK>    }
AVK>}
AVK>

type "C:/New Text Document.txt"

#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
 vector<int> vi(100);
 vector<void *> vs(100);

 __asm {int 3}

 vi.size();                          // Одна ф-ия
 vs.size();

 vi.push_back(0x666);                // Одна ф-ия
 vs.push_back((void *)0x666);

 sort(vi.begin(), vi.end());        // Разные
 sort(vs.begin(), vs.end());

 return 0;
}

СГ>>MODULE TestTest;

СГ>>  IMPORT StdLog, Files; 

СГ>>  PROCEDURE Test* ();
СГ>>  VAR  L: Files.Locator; f: Files.File; r: Files.Reader; b: BYTE;
СГ>>  BEGIN
СГ>>    L := Files.dir.This("C:\");
СГ>>    IF L # NIL THEN 
СГ>>      f := Files.dir.Old(L, "New Text Document.txt", FALSE);
СГ>>      IF f # NIL THEN
СГ>>        r := f.NewReader(NIL);
СГ>>        IF r # NIL THEN 
СГ>>          WHILE ~r.eof DO r.ReadByte(b); StdLog.Char(CHR(b)) END
СГ>>        END;
СГ>>        f.Close();
СГ>>      END
СГ>>    END
СГ>>  END Test;

СГ>>END TestTest.
СГ>>

using System;
using System.IO;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            string path = args[0];
            using (StreamReader reader = new StreamReader(path, Encoding.Default))
            {
                Console.WriteLine(reader.ReadToEnd());
            } // вот здесь файл будет закрыт даже если было исключение.
        }
        catch (IndexOutOfRangeException)
        { // Суда прийдем если args не содержит аргументов
            Console.WriteLine("Enter path to file, lease.");
        }
        catch (Exception ex)
        { // А сюда в случае любой ошибки. Так что если файла нет или еще что, 
            // то незабудем сказать об этом пользователю.
            Console.WriteLine(ex.Message);
        }
    }
}