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

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

Этого я не понял... Ресурс берет и отдает тот, кто вызывает. В этом случае, кем бы (подпрограммой, объектом, библиотекой, модулем) и где бы (в том же или другом адресном пространстве, на другом компьютере или сети) не был вызываемый, ошибки не произойдет. Вы об этом?

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

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

MODULE Share;

  VAR
    dir*: Directory;

END Share.

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

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

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

Ответ на »сообщение 150« (AVC)
___________________________
ASU> Да, существуют... то же "множественное наследование" (знак минус), наличие шаблонов (знак плюс), разнообразие доступных (бесплатных) библиотек, классов, легкость освоения, распространненность (популярность в среде разработчиков) и пр.

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

Насколько я понял, Вы ставите плюсы полезным для Вас свойствам языка и минусы -- вредным.
Совершенно верно.

Но свойства языка взаимодействуют друг с другом.
Иногда вредят друг другу. :)
Совершенно верно.

Одно полезное свойство может прийти в конфликт с другим.
В ТРИЗ это называется "техническим противоречием"
Это свойственно любой сущности/явлению...

Множественное наследование затрудняет автоматическую сборку мусора.
Не только...

Шаблоны (в том виде, как они реализованы в Си++) несовместимы с динамической модульной системой
Они полезны/удобны сами по себе безотносительно модульности... IMHO.

На мой взгляд, наивна как точка зрения, что все языки одинаковы, так и точка зрения, что особенности языка сводятся к перечислению его свойств по отдельности.
Хм... Функционально большинство 3GL+OOP близки. У каждого есть свои плюсы и свои минусы. Создавать большой проект "с нуля" на языке, который не имеет библиотек/модулей/классов настроенных на решение данного класса задач, который не знают разработчики, который не имеет постоянной (надежной) команды разработчика транслятора и пр. ... глупость, если не сказать хуже... Думаю, Вы со мной согласитесь.

Ответ на »сообщение 150« (AVC)
___________________________


Опять же, собственно к языкам, IMHO, имеют отношение только два первых пункта.


Поправлюсь: легкость освоения -- тоже свойство языка. :)

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


Наборот, многократно затрудняет разработку, отладку, развертывание и сопровождение. Попробуйте, например, "забыть" SQL... и почувствуйте все "прелести" моноязычности... Или представьте обратную ситуацию, когда можно на скриптовом языке быстро связать разные компаненты прямо у заказчика... Или попробуйте "разработать" декларативный язык для работы с сетью, почувствуйте, насколько проще станет разрабатывать программы...

Ничто не мешает использовать в Оберон-системе SQL, скриптовые или декларативные языки.
В ОС Оберон не могут использоваться только ненадежные императивные языки вроде Си++.

Ответ на »сообщение 147« (10)
___________________________
ASU> Так, зачем все реализовывать на одном языке?.. Какой в этом смысл?
Теоретический. Отсутствие множества языков реализации упрощает конфигурирование системы
Наборот, многократно затрудняет разработку, отладку, развертывание и сопровождение. Попробуйте, например, "забыть" SQL... и почувствуйте все "прелести" моноязычности... Или представьте обратную ситуацию, когда можно на скриптовом языке быстро связать разные компаненты прямо у заказчика... Или попробуйте "разработать" декларативный язык для работы с сетью, почувствуйте, насколько проще станет разрабатывать программы...

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


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


Опять же, собственно к языкам, IMHO, имеют отношение только два первых пункта.
Насколько я понял, Вы ставите плюсы полезным для Вас свойствам языка и минусы -- вредным.
Но свойства языка взаимодействуют друг с другом.
Иногда вредят друг другу. :)
Одно полезное свойство может прийти в конфликт с другим.
В ТРИЗ это называется "техническим противоречием".
Множественное наследование затрудняет автоматическую сборку мусора.
Шаблоны (в том виде, как они реализованы в Си++) несовместимы с динамической модульной системой.
На мой взгляд, наивна как точка зрения, что все языки одинаковы, так и точка зрения, что особенности языка сводятся к перечислению его свойств по отдельности.

Ответ на »сообщение 146« (AVC)
___________________________
Но если уж говорить совсем серьезно, существуют ли, с Вашей точки зрения, вообще какие-либо существенные различия между императивными языками с поддержкой ООП?
Да, существуют... то же "множественное наследование" (знак минус), наличие шаблонов (знак плюс), разнообразие доступных (бесплатных) библиотек, классов, легкость освоения, распространненность (популярность в среде разработчиков) и пр.

Ответ на »сообщение 145« (Сергей Губанов)
___________________________
ASU> Может быть проще и правильнее научить разработчиков простому правилу: "взял-отдай"?

В монолитных программах - конечно!
А в динамически расширяемых модульных системах на момент компиляции модуля не известно когда "отдавать". Такое решение можно принять только динамически, во время выполнения.
Этого я не понял... Ресурс берет и отдает тот, кто вызывает. В этом случае, кем бы (подпрограммой, объектом, библиотекой, модулем) и где бы (в том же или другом адресном пространстве, на другом компьютере или сети) не был вызываемый, ошибки не произойдет. Вы об этом?