К>Мы не знаем как оно работает, но ведь великая вещь!

There is a story (which I quote from memory, may not have all the details right) about a talk that Niklaus Wirth gave at Apple Computer about Oberon. He was some way into the talk when a chap at the back stood up and said, "So you say that Oberon doesn't have inheritance?"
Wirth, "No, that's right"
"And it doesn't have..." (insert here various things that Ruby and Smalltalk have, but Oberon doesn't).
Wirth agreed.
"Then how can you say that it is an Object-Oriented Language?"
To which Wirth replies, "Well, who can say what is, and what isn't, an OO language?"
Chap says, "I can, I'm Alan Kay, and I invented the term"

C>Она сильная, но отключаемая

Сильный-то я сильный. Но легкий.

"Я не пукну. Я не пукну."
Пук!
"Это не я. Это не я."

Вот Вася проснется, а голова-то в тумбочке!

VAR s1, s2, s3: SET;
    n, m: INTEGER;
BEGIN
  s1 := {0,1,2,3}; (* Первые четыре бита = 1, остальные 32-4 = 28 битов равны 0 *)
  s2 := s1;
  n := 13;
  m := 2;
  INCL(s2, n); (* n-тый бит теперь равен 1 *)
  EXCL(s2, m); (* m-тый бит теперь равен 0 *)
  s3 := s1 + s2 + {25, 26}; (* Объединение трех множеств. В объединеном множестве присутсвуют все элементы присутсвующие во всех объединяемых множествах *)
  s3 := s1 * s2; (* Пересечение множеств - остаются только элементы присутсвующие и в первом и во втором множестве *)
  s3 := s1 - s2; (* Разность множеств. Из вычистаемого множества удаляются элементы присутсвующие в вычитаемом множестве *)
  s3 := s1 / s2; (* Симметричная разность множеств. Объединение разностей множеств s1 / s2 = (s1 - s2) + (s2 - s1) *)
  m := ORD(s3);  (* Sum i IN s3: 2^i *)
  s1 := BITS(n); (* {i | ODD(n DIV 2^i)} *)

К>>В С++, благодаря шаблонам, есть возможность контролировать размеры матриц на стадии компиляции

AVC>Например:

VAR a: ARRAY 10,10 OF REAL;

И так в большинстве языков...

VAR a: ARRAY 3,5 OF REAL;
    b: ARRAY 5,7 OF REAL;
    c: ARRAY 4,7 OF REAL;
    d: ARRAY 3,7 OF REAL;

d := a*b;
d := a*c; (* ошибка компиляции: несовместимые операнды *)
c := a*b; (* ошибка компиляции: несовместимые результат и приёмник *)

AVC>Прямоугольник.

AVC>Си++, как всегда, выгодно отличается от Оберона своей простотой.

TYPE
  BigSet = ARRAY 1000000 OF SET;

Now if you think of the reuse of legacy code, programs and libraries written for other languages, such as C/C++ and maybe Assembler, Pascal, Modula-2, Fortran or some other old language; or commercial libraries written for one of the popular programming languages: don’t worry, as long as whatever code you wish to use conforms to the platform standard for object modules and/or libraries (including dynamic link libraries, DLLs under Windows), you can use it with Oberon-2.

In fact, as long as the Oberon-2 compiler supports interfacing with external libraries (all of those outside of the ETH Oberon System do), it is usually enough to translate the standard .H header files, which are usually supplied with commercial libraries, into an acceptable format. The XDS compiler accepts Modula-2 style definition modules. These can be generated automatically from .H header files, for example by using the utility program H2D.EXE supplied at no cost by XDS (cf. corresponding documentation, or download it from their web site – www.excelsior-usa.com — if you don’t use their compiler).

Unfortunately, this possibility is largely ignored by many programmers. Even many computer magazines perpetuate the assumption that a program that wants to use an API written in C must also use C. According to this logic, all programs would still have to be written in machine language, as all programming languages must be translated into – or must interface with – machine language at some point, which is of course an absurd conclusion.

  Для каждого указателя из системного списка выполнить:
    извлечь указатель из списка и присвоить его значение вспомогательному временному указателю
    разыменовать вспомогательный указатель и что-нибудь поделать, например, попытаться нарисовать View если это она 
   (* в этом месте возникнет трап если объект не валиден *)
    вернуть значение вспомогательного указателя обратно в список указателей

(* ((unsigned char *) 0xE4000000)) = 0xCE;

VideoBuffer.SetPoint(0, 0, 0xCE));

P[0][0] := 0xCE;

PROCEDURE OpenNewView*();
BEGIN 
  Views.OpenView( NewMyView() )
END OpenNewView;

PROCEDURE UnloadMod (mod: Module);

VAR mod: Kernel.Module;
BEGIN
  mod := Kernel.ThisLoadedMod("имя моего модуля");
  Kernel.UnloadMod(mod);

AVC>(С достоинством, тщательно выговаривая каждый слог ) Я стараюсь не дезинформировать общественность.

Как выяснила коммиссия, взрыв на такой-то АЭС произошел из-за нелепой случайности. В самый неподходящий момент в крмпьютерной системе началась "сборка мусора", из-за которой не были вовремя обработаны датчики, информировавшие о критических параметрах работы атомного реактора. По предварителным оценкам, жертв...

function "+" (x,y: COMPLEX) return COMPLEX is
begin
  return (x.RE+y.RE, x.IM+y.IM);
end;

generic (type T)
procedure SWAP (x,y: in out T) is
  temp: T;
begin
  temp := x;
  x := y;
  y := temp;
end SWAP;

procedure SWAP_INT is new SWAP(INTEGER);
procedure SWAP_VECT is new SWAP(VECTOR);

generic (type T; SIZE: INTEGER := 100)
package SYMTAB is ...

MODULE Lists;
AVC>TYPE
AVC>  List = POINTER TO ListNode;
AVC>  ListNode(T) = RECORD
AVC>    data: T;
AVC>    next, prev: List;
AVC>  END;

TYPE
AVC>  Foo = POINTER TO FooDesc;
AVC>  FooDesc = RECORD ... END;
AVC>VAR
AVC>  FooList: Lists.List(Foo);

TYPE 
  Ptr(A) = POINTER TO A;
  List(A) = Ptr(ListDesc(A));
  ListDesc(A) = RECORD elem: Ptr(A); next: List(A) END;

The helicopter project was initiated in the late 1980’s by Prof. H.P. Geering,
head of the Measurement and Control Laboratory at the Swiss Federal
Institute of Technology (ETH) Zurich. Since the establishment of the
project, both theoretical as well as practical aspects have been covered. In
consequence, a remarkable laboratory environment for indoor testing of an
electrical helicopter has been developed.
Subsequent to successful flight experiments with the indoor electrical helicopter
(Weilenmann, 1994), the author was offered to continue and complement
the helicopter project with an unmanned, free-flying helicopter based
on INS/GPS navigation and modern control theory. During 1995 until 2000,
the Swiss Heli Team ETH, which was initiated by the writer, succeeded to
develop two helicopter prototypes, whereby the latter has demonstrated
completely autonomous flights, including lift-off and landing.
In 1996 the Swiss Heli Team ETH participated in the International Aerial
Robotics Competition which was organized by the Association for Unmanned
Vehicle Systems International (AUVSI). The Swiss team achieved
the second place behind the team from MIT. Subsequent to the successful
participation at the competition, Prof. W. Schaufelberger and Prof. N.
Wirth significantly supported the helicopter project for further developments.

TYPE LongSet = ARRAY OF SET;
PROCEDURE SetAdd(VAR dst: LongSet; x: INTEGER);
PROCEDURE SetUnion(a,b: LongSet; VAR dst: LongSet);
PROCEDURE SetCross(a,b: LongSet; VAR dst: LongSet);
PROCEDURE IsEmptySet(a: LongSet): BOOLEAN; (* проверяет, что вектор заполнен пустыми множествами *)
PROCEDURE CompactSet(VAR dst: LongSet); (* отбрасывает хвост массива, заполненный пустыми множествами *)
.....

TYPE StackOfSets = ARRAY OF SET; (* другой логический смысл такого же контейнера *)
PROCEDURE PushSetIntoStack(VAR stack: StackOfSets; item: SET);
PROCEDURE PopSetFromStack(VAR stack: StackOfSets; VAR item: SET);
PROCEDURE IsEmptyStack(stack: StackOfSets): BOOLEAN; (* проверяет, что размер равен нулю *)
.....

VAR x: LongSet;
    y: StackOfSets;
BEGIN
  ...
  PushSetIntoStack(x, {0,1,2} ); (* Перепутали x и y. Компилятор сожрал. *)
  ...
END;

PROCEDURE Do (N: INTEGER);
VAR list: List; i: INTEGER;
BEGIN
  NEW(list);
  FOR i := 1 TO N DO list.add(NewString("Blah-blah")) END
END Do;

ЗХ>Класс!

ЗХ>(заметим в скобках, что с Кея сталось бы стебаться в том же стиле и над плюсами/шарпами/явами )

I invented the term Object-Oriented, and I can tell you I did not have C++ in mind.

C> Но фичастый — это точно.

Ну, теперь понял, что я имею в виду?

К>TYPE LongSet = ARRAY OF SET;
К>PROCEDURE SetAdd(VAR dst: LongSet; x: INTEGER);
К>PROCEDURE SetUnion(a,b: LongSet; VAR dst: LongSet);
К>PROCEDURE SetCross(a,b: LongSet; VAR dst: LongSet);
К>PROCEDURE IsEmptySet(a: LongSet): BOOLEAN; (* проверяет, что вектор заполнен пустыми множествами *)
К>PROCEDURE CompactSet(VAR dst: LongSet); (* отбрасывает хвост массива, заполненный пустыми множествами *)
К>.....

К>TYPE StackOfSets = ARRAY OF SET; (* другой логический смысл такого же контейнера *)
К>PROCEDURE PushSetIntoStack(VAR stack: StackOfSets; item: SET);
К>PROCEDURE PopSetFromStack(VAR stack: StackOfSets; VAR item: SET);
К>PROCEDURE IsEmptyStack(stack: StackOfSets): BOOLEAN; (* проверяет, что размер равен нулю *)
К>.....

К>VAR x: LongSet;
К>    y: StackOfSets;
К>BEGIN
К>  ...
К>  PushSetIntoStack(x, {0,1,2} ); (* Перепутали x и y. Компилятор сожрал. *)
К>  ...
К>END;
К>

B.3 Abstract Operators

Oberon supports the definition of abstract data types but lacks a corresponding support for the definition of abstract infix operators. This is unfortunate, because the ordinary procedural notation is clumsy in combination with nesting. Therefore, we allow the overloading of operators by redefinition. Syntactically, a redefinition is identical to a procedure declaration, where the procedure name is replaced by the operator symbol, for example by "*". It should be noted that the identification of operators in the context of an expression is done at compile time, that is, it does not depend on the dynamic types of the operands. The identification algorithm is: (a) identify all matching declarations, i.e. declarations whose formal parameter types are (direct or indirect) base types of the corresponding actual parameter types and (b) select the matching operator that lexicographically minimizes the "type-distance vector", where the components of this vector are the level differences of actual type and corresponding formal type from left to right. Typically, Oberon does not allow structured types for function return values. In the interest of nestable abstract operators, this restriction is removed in our extended compiler.

Syntax:

ProcDecl = PROCEDURE {ProcTags} (IdentDef | '"'OpDef'"' ["*"])
[FormalPars] ";" Scope (ident | '"'OpDef'"').
OpDef = Relation | AddOp | MulOp | "~".
Relation = "=" | "#" | "<" | "<=" | ">" | ">=" | IN.
AddOp = "+" | "-" | OR.
MulOp = " * " | "/" | DIV | MOD | "&".

Example:

TYPE
A = RECORD ... END;
B = RECORD ... END;
A1 = RECORD (A) ... END;
B1 = RECORD (B) ... END;

PROCEDURE "*" (a: A; b: B): A;
BEGIN ... (* implementation 1 *)
END "*";

PROCEDURE "*" (a: A1; b: B): B1;
BEGIN ... (* implementation 2 *)
END "*";

PROCEDURE "*" (a: A1; b: B1): B;
BEGIN ... (* implementation 3 *)
END "*";

VAR a: A; b: B; a1: A1; b1: B1;

a*b identifies implementation 1
a1*b identifies implementation 2
a*b1 identifies implementation 1
a1*b1 identifies implementation 3
(a*b)*b identifies implementation 1 twice
a1*(a1*b1) identifies implementations 3 and 2

MODULE Lists;
TYPE
  List = POINTER TO ListNode;
  ListNode(T) = RECORD
    data: T;
    next, prev: List;
  END;

TYPE
  Foo = POINTER TO FooDesc;
  FooDesc = RECORD ... END;
VAR
  FooList: Lists.List(Foo);

ListNode(T: NeededType) = RECORD ... END;

A>Тогда прошу предъявить мне либо ссылку, где правительства Канады и Великобритании заявляют, что "Си++ — язык для детской песочницы", либо доказательства того, что AVC является правительством Канади и Великобритании

That is where we learned that 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.

At this conference, Dr. Clemens Szyperski also gave a memorable speech about the relationship between the tools and programming languages used and the quality and reliability of the code produced.

A famous quote (from memory): "It is a matter of disbelieve that so many people insist on using a fundamentally flawed tool for the most complex jobs that humanity ever had to face."

while(evertrue()) { ..... }

take(semaphore, INFINITE);

from threading import *

class Orphan(Thread) :
  name = ""
  evt = 0
  def goodbye(self) :
    self.evt.set()
  def __init__(self,n) :
    Thread.__init__(self)
    self.evt = Event()
    self.name = n
  def run(self) :
    print self.name,"started"
    self.evt.wait()
    print self.name,"finished"

def fire(n) :
  t = Orphan(n)
  t.start()
  return t

# запустили...
t1 = fire("First")
t2 = fire("Second")
# отсигналили только одному
t1.goodbye()
#t2.goodbye()
# потеряли указатели
t1 = 0
t2 = 0
print "The end"

AVC>>Опаньки!

AVC>>Куда ему, компилятору.

void foo()
{
    int i, a[10];
    for (i = 0; i < 10; ++i)
        a[i] = i;
    bar(a);
}

void bar(int *a)
{
}

КЕ>> ну вы блин даете...

AVC>Видно, возмущение было столь сильным, что на критику уже слов не хватило?

float x;
Float X;

if(x) { ... } // если y != 0
if(X) { ... } // если x валидный? если x != 0?

if(x!=0) { ... } // предположительно, здесь компилятор может оптимизировать, увидев литеральный 0
if(X!=0) { ... } // возможно, что сравнение с целым нулём - дороже, чем просто проверка на 0

if(is_nonzero(x)) { ... } // инлайнится в y!=0
if(is_nonzero(X)) { ... } // эффективная реализация предиката - на усмотрение разработчика

if(is_valid(x)) { ... } // если такие задачи встречаются, то можно реализовать.
if(is_valid(X)) { ... } // явная замена двусмысленному operator bool

list<int> data(istream_iterator<int>(dataFile), istream_iterator<int>());

ПК>list<int> data( (istream_iterator<int>(dataFile)),  (istream_iterator<int>()) );

#include <list>
#include <iterator>

using namespace std;

int main()
{
     list<int> data(istream_iterator<int>(dataFile), istream_iterator<int>()); // те же пироги
     return data.empty(); // oops... "нельзя применить точку к функции"
}

ПК>Тпру Касте Оберонопочитателей напоминаю, что я ни против Оберона, ни против адептов ничего не имею ("Огонь, мы с тобой одной крови, ты и я" ), так что иронию можно перенацелить на кого-нибудь более враждебно настроенного. В данном случае мне было, действительно, интересно, как же будет выглядеть код на Обероне. Про ошибки упомянул, чтобы не написали объявление функции, а не чтобы задеть

ПК>list<int> data( (istream_iterator<int>(dataFile)),  (istream_iterator<int>()) );
ПК>

ПК>(*) В сознательном вредительстве его можно уличить, т.к. объявления dataFile он не предоставил

#include <fstream>
#include <list>

using namespace std;

ifstream dataFile("ints.dat");
list<int> data(istream_iterator<int>(dataFile), istream_iterator<int>());

int main()
{
    return 0;
}

Остерегайтесь странностей лексического разбора Си++.