interface Sequence<T>
{
   class Pos;

   uint size();
   bool is_empty();

   Pos begin();
   Pos end();
   Pos next(Pos);

   Pos insert(Pos, T);
   void remove(Pos);
   void clear();
};

interface RandomAccessibleSequence<T> : Sequence<T>
{
   T operator[](int index);
   Pos pos_by_index(int index);
};

class List<T> : Sequence<T>
{
};

class Array<T> : RandomAccessibleSequence<T>
{
};

> Не, ну, нужно вообще потерять чувство реальности, чтобы просить в качестве коментария написать небольшую книгу (ну, страниц так на 400).

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

For I=1 To 10
Next

for i:=1 to 10 do
begin
end;

for(int i = 0; i < 10; ++i)
{
}

VD>Киборги?

Делегирование

В первоначальном проекте множественного наследования, который был представлен на Европейской конференции группы пользователей UNIX, состоявшейся в Хельсинки в мае 1987 г. [Stroustrup, 1987], фигурировало понятие делегирования [Agha, 1986].

Пользователю разрешалось задать указатель на некоторый класс вместе с именами базовых классов в объявлении класса. Описанный таким образом объект использовался точно так же, как если бы это был объект, представляющий базовый класс. Например:

class B { int b; void f(); };
class C : *p { B* p; int c; };

Нотация : *p означает, что объект, на который указывает p, будет использоваться так, будто он представляет базовый класс для C.

void f(C* q)
{
   a->f(); // означает q->p->f()
}

<...>

Концепция выглядела многообещающей для представления структур, требующих большей гибкости, чем может дать обычное наследование. В частности, присваивание делегирующему указателю могло бы использоваться для изменения конфигурации объекта во время исполнения. Реализация была бы тривиальной, затраты — минимальными. Поэтому данную идею испытали несколько пользователей. Много времени и сил здесь пололжил Билл Хопкинс (Bill Hopkins). К сожалению, все пользователи, применившие механизм делегирования, пострадали от серьезных ошибок и путаницы. Из-за этого возможность была исключена как из проекта, так и из Cfront версии 2.0.

Причины ошибок:

функции в делегирующем классе не замещают функции в классе, которому операция делегируется;

функция, которой передается управление, не может воспольозваться функциями из делегирующего класса или каким-то иным способом "вернуться" в делегирующий объект.

Ясно, что две эти проблемы взаимосвязаны. Разумеется, пользователи были предупреждены. Предостережения не помогли. Более того, я сам забыл собственные правила, и попался в ловушку. Таким образом, проблему нельзя было назвать мелким огрехом, который исправляется с помощью обучения и предупреждений компилятора. В то время она казалась непреодолимой.

Сегодня мне кажется, что указанные проблемы имеют фундаментальный характер. Для решения первой потребовалось бы изменять таблицу виртуальных функций объекта, которому делегируется управление, если он связан с делегирующим объектом. Это плохо согласуется с языком в целом и с большим трудом поддается разумному определению. Кроме того, обнаружились примеры, когда мы хотели, чтобы два разных объекта делегировали управление одному и тому же "разделяемому" объекту. Нашлись и такие задачи, в которых нужно было делегировать управление через B* объекту производного класса D.

VD>И кстати, что тебе не нравится в Шарпе с точки зрения ООП?

То же, что и в Яве, то, что в нем объектом приходится делать даже то, что объектом не является.

Во как интересно. Например, что?

Например, я не вполне понимаю, зачем обобщенные алгоритмы типа сортировки делать методами классов Вот пример такого, с позволения сказать, класса: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Arrays.html — ни состояния, ни поведения, ни инвариантов

если все методы (пусть и статические) помещать в класс к которому они относятся, то любой дурак нажав точку в IDE получит их список.

ПК>Например, я не вполне понимаю, зачем обобщенные алгоритмы типа сортировки делать методами классов Вот пример такого, с позволения сказать, класса: http://java.sun.com/j2se/1.4.2/docs/api/java/util/Arrays.html — ни состояния, ни поведения, ни инвариантов

public interface ISort {
  public ISequentiallyAccessibleCollection Sort(IArbitraryAccessCollection source);
}

public class HeapSort: ISort {
  public HeapSort(); // инициализация не нужна
  public ISequentiallyAccessibleCollection Sort(IArbitraryAccessCollection source);
}
public class QuickSort: ISort  {
  public QuickSort(); // инициализация не нужна
  public ISequentiallyAccessibleCollection Sort(IArbitraryAccessCollection source);
}

1. Изменить язык и дать возможность вносить фиксированные реализации методов в интерфейсы. Хотя бы статиков. Тогда мы могли бы записать все, что нам нужно, в интерфейс для source, и жить себе не тужить.
   
2. Оставить язык в покое и сделать более продвинутый редактор. Например, при помощи атрибутов расширять CodeCompletion. Примерно так:
   public class Algorithms{
   [ExtendCodeCompletionFor(typeof(IArbitraryAccessCollection))]
   public static ISequentiallyAccessibleCollection HeapSort(IArbitraryAccessCollection source);
   [ExtendCodeCompletionFor(typeof(IArbitraryAccessCollection))]
   public static ISequentiallyAccessibleCollection QuickSort(IArbitraryAccessCollection source);
   }

>>> a = 1
>>> b = "строка"
>>> # - вот ребята, сейчас мы с вами объявили свои первые переменные
>>> # давайте посмотрим, добавились ли они в глобальную область имен:
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'b']
>>> # - Видите! Добавились!
>>> # Обратите внимание, что кроме наших переменных в ней уже присутствовали 
>>> # несколько встроенных системных имен.
>>> # Ну, что такое __name__ и __doc__ я вам рассказывал на предыдущм занятии,
>>> # а сейчас давайте посмотрим на __builtins__ - это модуль содержащий все 
>>> # встроенные функции и переменные.
>>> # Давайте посмотрим, что он содержит:
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning', 'E
OFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointEr
ror', 'FutureWarning', 'IOError', 'ImportError', 'IndentationError', 'IndexError
', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', '
None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'Ove
rflowWarning', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'R
untimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning'
, 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalErr
or', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTransla
teError', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionE
rror', '_', '__debug__', '__doc__', '__import__', '__name__', 'abs', 'apply', 'b
asestring', 'bool', 'buffer', 'callable', 'chr', 'classmethod', 'cmp', 'coerce',
 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod
', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'getattr'
, 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', '
isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', '
map', 'max', 'min', 'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', '
range', 'raw_input', 'reduce', 'reload', 'repr', 'round', 'setattr', 'slice', 's
taticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars
', 'xrange', 'zip']
>>> # - Воо-о-от. Постепенно мы с вами изучим, что все они означают.
>>> # Начнем, пожалуй, с функции dir(), которую я только что использовал.
>>> # Давайте помотрим, что нам скажет про неё другая встроенная функция (help)
>>> help(dir)
Help on built-in function dir:

dir(...)
    dir([object]) -> list of strings

    Return an alphabetized list of names comprising (some of) the attributes
    of the given object, and of attributes reachable from it:

    No argument:  the names in the current scope.
    Module object:  the module attributes.
    Type or class object:  its attributes, and recursively the attributes of
        its bases.
    Otherwise:  its attributes, its class's attributes, and recursively the
        attributes of its class's base classes.
                
>>> # ну и т.д.

MODULE MyModule;

IMPORT StdLog;

BEGIN
  StdLog.String("Здравствуй мир!");

END MyModule;

using System;
class Class1
{
    static void Main()
    {
        Console.WriteLine("Hello World");
    }
}

VD>Не дай бог.

VD>Где бы нарыть смайлик плюющий через плече и рестящийся?

VD>В общем, за такое нужно

foreach(int each in Range(1, 10))
{
  Transcript.Show(each);
}

public void PrintNonDividable(Range r, int divisor)
{
   Print(r.Filter(delegate(int item){return (item % divisor) != 0;}));
}

public void PrintNonDividable(Range r, int divisor)
{
  Range r2 = new Range();
  foreach(int item in r)
    {
      if ((item % divisor) != 0)
          r2.Append(item);
    }
  Print(r2);
}

set     := BITS(integer);
integer := ORD(set);

Juice-технология

Летом 1996 года профессором Калифорнийского университета в Ирвине, учеником Н.Вирта Михаэлем Францем и его аспирантом Томасом Кистлером была представлена технология распространения исполнимого кода в Интернет, названная авторами Juice (по-русски — сок). Juice основан на использовании Оберона и влючает с одной стороны инструментальную компоненту для Оберон-системы Oberon System 3, обеспечивающую компиляцию написанных на Обероне модулей в платформно-независимое представление. Второй частью Juice является дополнение (plug-in) к Интернет-браузерам, обеспечивающее компиляцию получаемого Juice-кода "на лету" в родной код, его загрузку и исполнение.

Juice превосходит Java-технологию во всем кроме величины затрат на рекламу:

1) Основан на более простом и совершенном языке
2) Обеспечивает существенно большую скорость исполнения аплетов
3) Код Juice-аплета компактнее байт-кода Java

# начали с калкулятора
>>> 2+2
4

# перешли к функции
>>> def sum(a,b) : return a+b

# заюзали функцию
>>> sum(2,2)
4

# теперь к классу:
>>> class Summator:
    a = 0
    b = 0
    def sum(self):
        return self.a + self.b

# сразу заюзали класс:    
>>> s = Summator()
>>> s.a = 1
>>> s.b = 2
>>> s.sum()
3
>>>

Почитал несколько веток с Вашим участием...
У каждой такой "тусовки" есть своя специфика, со своим контИнгентом участников... RSDN в этом отношении — ярчайший и показательный пример. Волею судеб, я оказался вовлечён в работу харьковского семинара по QNX ( http://qnxclub.net ). Наиболее активный наш участник, Olej, захаживал как-то на RSDN, в ветки, посвящённые Юникс-системам и ОСРВ. То, с чем он там столкнулся (уровень знаний, информированность в "сопредельных с виндой областях", а главное — просто-таки параноидальная вера в собственную "правильность" и непогрешимость практически во всех поднимаемых на форуме вопросах), заставило Olej высказать несколько замечаний "по делу". С момента, когда RSDNовские ребята поняли, что их макают носиком в собственные примеры некомпетентности, нас забанили...

В Вашем случае от них "аж прэ" не то, что не понимание поднимаемых вопросов, а нет даже желания вынырнуть из собственного мирка...
Вот на это Вы и должны делать "поправку"...
Вам разве не ясно, что они уже всё в этой жизни поняли? :о)

Просто делайте своё дело. Всё остальное оно само сделает (и скажет) за Вас.

• Речь шла как раз о частном случае и больше ни о чем.
  
• Речь не шла о простоте освоения какого-либо языка.
  
• Речь не шла об Обероне.

• купленном в магазине бумажном учебнике
  
• распечатанном на бумаге и взятым домой для просмотра на диване примере программы
  
• по F3 в Far-e или Total Commander-е

bool
byte
char
DateTime
decimal
double
short
int
long
sbyte
single
string
Type
ushort
uint
ulong

using System;
class Class1
{
    static void Main()
    {
        Console.WriteLine("Hello World");
    }
}

In Ruby, classes are never closed: you can always add methods to an existing class.

VD>>Это конечно несколько лучше чем в Паскале/Дельфи. Но все же я не понимаю на фиг так извращаться.

СГ>i := ORD( BITS(i) - {28,29,30,31} );
СГ>

i := ORD(BITS(i) AND BITS (0,0,0,0, 1,1,1,1, 1,1,1,1, 1,1,1,1,)

1 to: 10 do: [:each | Transcript show: each]

Transcript = new TextCollector();
foreach(int each in Range(1, 10))
{
  Transcript.Show(each);
}

Transcript = new TextCollector();
Range(1, 10).Do(delegate(int each) { Transcript.Show(each); });

1.ToDo(10, delegate(int each) { Transcript.Show(each); });

MODULE MyModule;

IMPORT StdLog;

BEGIN
  StdLog.String("Здравствуй мир!");

END MyModule;

Вопрос: Почему столь важный продукт, как операционная система, используемая на сотне миллионов компьютеров во всем мире, строится на столь гнилом фундаменте, как язык программирования, для которого нельзя написать компилятор, генерирующий эффективный и безопасный код, с тем чтобы переложить тривиальный механический труд по нудной проверке индексов массивов с человека, которому свойственно ошибаться при выполнении механических процедур, на компьютер, который именно для таких процедур и придуман?
Ответ: Потому что подавляющее большинство программистов Майкрософт, начиная с Билла Гейтса, — как бы хорошо ни была организована их работа и какими бы талантливыми индивидуумами они ни были сами по себе — классические программисты-самоучки, втянутые в круговорот компьютерной революции большими деньгами и задумывающиеся о методологии программирования только под сильной угрозой со стороны конкурентов.

В начале 2002 г. Майкрософт на месяц приостановила нормальную работу, чтобы программистский персонал мог специально сосредоточиться на проблемах безопасности и надежности программ. Если оценить количество программистов Майкрософт в 20 тысяч человек при зарплате от $150 тыс. в год и выше, то стоимость месячника повышения квалификации выйдет не меньше 250 миллионов долларов. Майкрософт в состоянии это себе позволить. Остальным, видимо, все же дешевле перейти на инструменты программирования, где проверки индексов массивов не отключаются. Впрочем, и сама компания Майкрософт в настоящее время переходит на платформу .NET, в которой главный язык программирования — т.наз. C# — смоделирован во многом, в том числе и в отношении безопасности программирования, по образцу Оберона.

>>> for i in range(10) : print i

0
1
2
3
4
5
6
7
8
9
>>>

Цели проекта

Помочь преподавателям вузов и школьным учителям информатики поднять обучение программированию до уровня сформировавшейся к началу XXI века стандартной парадигмы программирования, представленной системами Оберон/Компонентный Паскаль, Java и C#.

Предоставить программистам (прежде всего "непрофессионалам": физикам, математикам, химикам, экономистам, лингвистам ...) ультра-современные — простые, эффективные и мощные — средства программирования для создания программ от процедур в 15 строк до комплексов с современными графическими интерфейсами.

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