Ответ на »сообщение 156« (Сергей Перовский)
___________________________


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


Кажется, Вы решили поведать об азах ООП. :)
Но описываемая ситуация имеет место уже внутри виртуального метода.
В данном случае мы имеем дело с чем-то вроде двойной диспетчеризации, а это, IMHO, существенно более сложная тема.

Ответ на »сообщение 163« (11bis)
___________________________


В сотый раз хочу узнать - в какой ОС Оберон?


Я имел в виду оригинальную ОС Оберон, созданную Виртом и Гуткнехтом.
Большинство последующих систем -- прямые потомки этой исходной версии.

Ответ на »сообщение 162« (ASU)

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

Так всё же наоборот!!! Использование сообщений вместо вызова (виртуальных) методов позволяет не перекомпилировать старые модули (и не выгружать их; и не останавливать работающую систему) при динамическом добавлении (загрузке) в систему нового модуля с новыми типами сообщений.

Не останавливая систему, не выгружая старые модули:

1) Загружаем в систему новый (только что написанный модуль) с новыми типами сообщений:

MODULE NewMessages;

  IMPORT BasicMessages;

  TYPE
    Msg1* = RECORD (BasicMessages.Message)
      (* ... *)
    END;

    Msg2* = RECORD (BasicMessages.Message)
      (* ... *)
    END;

END NewMessages.

2) Загружаем в систему новые модули умеющие посылать и обрабатывать эти новые сообщения.

3) Далее возможны варианты от тривиального: старые объекты/модули просто игнорируют новые типы сообщений, до нетривиального - когда новые объекты/модули "прописывают/внедряют/регистрируют" свои новые обработчики "внутрь" старых объектов и, тем самым, "старые" объекты динамически преобретают способность реагировать на новые типы сообщений.

Ответ на »сообщение 152« (AVC)
___________________________
В сотый раз хочу узнать - в какой ОС Оберон?

Ответ на »сообщение 158« (Сергей Губанов)
___________________________
И как переменная типа:

(* Сообщение посылается когда пользователь прокручивает колесо мыши *)
WheelMsg = RECORD (CursorMessage)
  done: BOOLEAN;
  op, nofLines: INTEGER
END;
может отвечать за перерисовку моего собственного View?
Не составляет труда показать порочность данного конкретного примера... Все дело в том, что получение сообщения и его обработка - это совсем разные задачи. Давайте сформулируем общую задачу. Есть некая сущность (объект), который должен как-то реагировать на внешние и внутренние возмущения (поступающие сообщения). Если эта сущность является агрегатом/комплексом/системой, то возмущения (поступающие к нему сообщения) передаются на вложенные сущности (объекты) для выработки реакции и/или изменения состояния. Если сущность (объект) простые, то есть, не имеют вложенных сущностей (объектов), то возмущение обрабатывается по правилам данной сущности (методами данного объекта). И в случае комплексной, и в случае простой сущности (объекта) было бы правильно говорить о том, что на каждое внешнее и внутреннее возмущения должна существовать схема его обработки (разные возмущения могут обрабатываться одинаково и одно и тоже возмущение может обрабатываться различно, например при разных состояниях).
Что из всего этого следует? Давайте посмотрим...
а) Есть код обработчиков (методов или объектов) - это один логический уровень;
б) Есть логика сущности (объекта) - это совершенно иной логический уровень;
в) Должен быть интерфейс между этими уровнями.
Вы предлагаете и тот и другой уровни написать монолитно и на одном языке. Хорошо... Но я бы предпочел иной подход. Для агрегата/системы я бы выбрал декларативный или скриптовый язык описания и взаимодействия, простой и известный пример: файлы ресурсов в Windows. На этом языке просто создавать и видоизменять сущности даже при работе агрегата/системы. Для больших систем скриптового языка будет маловато, поскольку там необходимо учитывать множество состояний сущностей (объектов). Здесь больше подойдут языки логического программирования...
Для создания правил (методов) и/или вложенных сущностей уровень языка должен быть ниже, чтобы обеспечить нужную скорость обработки сообщений и легкую реализацию алгоритмов обработки. То есть, здесь решаются алгоритмические задачи, для чего хорошо подходят алгоритмические языки (3GL+OOP).
Наконец, для реализации межуровнего интерфейса (сообщений) удобно использовать декларативные языки, "понятные" каждому из уровней.
Что мы получаем в результате? Возможность перекомбинировать систему непосредственно при ее работе, менять в ней состав сущностей и схемы обработки сообщений, менять количество и типы сообщений и т.д...
А что предлагаете Вы? Перекомпилировать программу каждый раз, когда появляются новые требования (новые виды возмущений, логики их обработки, изменения структуры)?.. Вот она прелесть моноязычности: гарантированная корка черствого хлеба... :)

Ответ на »сообщение 159« (ASU)

счетчик

Хе-хе-хе... ;-)

Так счётчик - это и есть сборщик мусора!!! Правда очень простой и самодельный, но бывают посложнее и встроенные. Но без них-то, простых или сложных, и не туды и не сюды...

В остальном я с Вами согласен.

Ответ на »сообщение 155« (Сергей Губанов)
___________________________
ASU> Этого я не понял... Ресурс берет и отдает тот, кто вызывает. В этом случае, кем бы (подпрограммой, объектом, библиотекой, модулем) и где бы (в том же или другом адресном пространстве, на другом компьютере или сети) не был вызываемый, ошибки не произойдет. Вы об этом?

При такой стратегии, конечно, ошибок не будет. Но не слишком ли такая стратегия ограничивает класс возможных, так сказать, проектных решений?
Ограничивает?.. Хм... Можно рассматривать, конечно, хорошие стиль, тон, манеры, как некое ограничение, но... надо ли так делать?

Предлагаю рассмотреть такой пример. Пусть есть "расшаренный" объект:
MODULE Share;

  VAR
    dir*: Directory;

END Share.
1) В какой-то момент времени, кто-то эту переменную инициализировал: Share.dir := d1;
2) Потом в систему загружались и выгружались некие модули (сторонних производителей) которые эту переменную могли использовать (скопировать ссылку на неё к себе).
3) Потом кто-то инициализировал переменную Share.dir новым значением: Share.dir := d2; Таким образом глобальный доступ к объекту d1 теперь отсутствует, но этот объект может всё ещё использоваться какими-то другими модулями (которые успели скопировать ссылку на него к себе), а может и не использоваться, но тогда объект d1 надо удалить
Простите, но так программное взаимодействие не проектируют... Посмотрите на досуге, например, требования ACID предъявляемые к транзакциям, работающим с базами данных. Это не идеал, но все же дает представление о некоторых механизмах межпрограммного (межмодульного) взаимодействия, использования общих ресурсов и т.д.

Учитывая то, что другие модули (сторонних производителей) загружались и выгружались динамически и каждый из них мог скопировать ссылку на объект из переменной Share.dir к себе, мы не можем на момент написания (и компиляции) модуля Share знать когда надо удалять объекты. Этого не может знать и каждый по отдельности производитель сторонних модулей. Этого не может знать и сам создатель объекта - он расшарил [Share.dir := d] созданный им объект и "умыл руки", мол, делайте с этим объектом что хотите
Уберите разделяемую переменную, поставив на ее место подпрограммы. Пусть эти подпрограммы фиксируют обращения новых "пользователей", увеличивая счетчик. Пусть эти подпрограммы фиксируют отключения, уменьшая значения счетчика. Пусть при наступлении нулевого значения счетчика происходит высвобождение общего ресурса. Пусть счетчик, наряду с переменной dir никогда не будет разделяемым (видимым/доступным из-вне) ресурсом! Это очень простое решение, для других ситуаций решения могут быть более комплексные...

В случае монолитной программы "создатель", "публикатор" и "клиенты" объекта могут "договориться" друг с другом когда удалять объекты. А в случае модульной динамически расширяемой системы "создатель", "публикатор" и "клиенты" удалены друг от друга в пространстве и во времени. Друг друга никогда не видели (кто-то из них давно состарился и умер, кто-то давно сменил род деятельности и уже забыл как программировать). Договориться не могут. Посему удалением более не нужных объектов должна заниматься сама система (т.е. сборщик мусора), а не кто-то конкретный из компании: "создатель", "публикатор", "клиенты"
Любую программу, модуль, библиотеку, иерархию классов, систему сначала нужно проектировать... Это очень простое правило :)

Ответ на »сообщение 156« (Сергей Перовский)

И тут мы приходим к невозможности расширения списка типов без переписывания практически всех модулей.
И начинаем мечтать о виртуальных методах, которые превращают оператор WITH или TYPE в простой вызов метода.

Ничего подобного.

Очень простая идея: если некоторое действие зависит от того, к какому типу пренадлежит переменная, то она сама и должна отвечать за это действие.


И как переменная типа:

(* Сообщение посылается когда пользователь прокручивает колесо мыши *)
WheelMsg = RECORD (CursorMessage)
  done: BOOLEAN;
  op, nofLines: INTEGER
END;

может отвечать за перерисовку моего собственного View?

В случае монолитной программы "создатель", "публикатор" и "клиенты" объекта могут "договориться" друг с другом когда удалять объекты.

Добавка: они договариваются об этом до момента компиляции монолитной программы. (После компиляции договариваться уже поздно ;-) )