Автор Тема: Component Pascal vs Oberon-07  (Прочитано 7904 раз)

X512

  • Newbie
  • *
  • Сообщений: 45
    • Просмотр профиля
Component Pascal vs Oberon-07
« : Январь 14, 2013, 12:25:13 am »

valexey_u

  • Hero Member
  • *****
  • Сообщений: 3013
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #1 : Январь 14, 2013, 12:55:39 am »
Нет. У КП гвоздями прибиты типы к jvm. Как оно будет жить на 64битной машине? А на 16ти битной?
А в чём проблема? В документации чётко определено что BYTE, SHORTINT, INTEGER и LONGINT - это знаковые целые числа с размером 1, 2, 4 и 8 байт соответственно. Следовательно основной целый тип INTEGER будет 4-байтным на любой машине. Насколько мне известно даже 16 битный x86 его поддерживает. Не поддерживаемые типы придётся эмулировать, тут ничего не поделаешь. Без это логика программы может просто сломаться от переполнения.

Если использование 4-ёх байтного INTEGER'а неэффективно, то можно сделать специальный модуль HostCpu и объявить в нём HostCpu.Int наиболее эффективный для данной платформы.
Гм. Проблема наверно больше в модели программирования, в тех умолчаниях которые люди используют в своих программах.

То есть по умолчанию для ВСЕХ целочисленных переменных скорее всего будет использован всегда INTEGER, просто потому что это наиболее естественно. Скажем в Aде это будет не так, там принято под каждый тип переменных создавать свой диапазонной целочисленный тип.

Таким образом КП-программа оказывается эффективной только на 32битной машине. Работа с 32битами не эффективна на машинах с меньшей битностью, и на ряде машин с бОльшей битностью.

Спорное утверждение. ООП Component Pascal'я обладает уникальными преимуществами перед ООП других ЯП. Например возможность определять как можно расширять запись и связанные с ней процедуры (так называются методы в оберонах).
Это есть и в java и в С++. Подозреваю, что в C# тоже есть.

Засчёт отсутствия множественного наследования в Runtime'е BlackBox'а реализована быстрая и эффективная проверка типов, позволяющая писать шины сообщений и расширяемый код.
Ну, во-первых в java проверка тоже весьма шустрая. Ну, то есть я видел промышленный код на java где в каждой функции шла проверка и приведение типов (аргументы функций были типа Object). Насколько я понимаю, из за этого проблем с производительностью не было. Это довольно старый код, кстати.

Ну а пример наглядный - akka (java & scala), это такой erlang-style message bus в том числе распределенный. Проверка типов в каждом приемника сообщений. То есть в java это точно не проблема.

В плюсах, при желании, проверка типа также реализуется библиотекой для подобного случая либо также по эффективности, либо эффективней. Что в свое время демонстрировал vlad.

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

Где можно взять компилятор под Windows без эмуляции ОС? Желательно без .NET .
Компилятор ActiveOberon'a можно взять у Kemet'a, он как раз в работе это дело использует.

Дизайн их ОС ужасный, немедленно вызывает рвотный рефлекс. И название "Bluebottle" соответствующее. Управление тоже очень неудобное.
Название у этой ОС давно другое :-)

Как раз грань очень чёткая: микроконтроллер - это обычно 8-ми или 16-ти разрядный процессор с интегрированными ОЗУ и ПЗУ небольших объёмов. Код и данные обычно адресуются независимо. Примеры: PIC, AVR.
Контрпример: msp430, ARM (Cortex-M например)

ARM'ы - это уже полноценные процессоры и на них уже можно использовать все возможности Component Pascal в том числе сборку мусора (она будет быстрой на небольшом объёме памяти).
А скажи пожалуйста, чем микроконтроллер на MSP430 с ОЗУ в 18 Кб менее полноценен, чем ARM (ARM7TDMI) с 8 Кб ОЗУ?

C++11 также можно использовать при программировании софта для микроконтроллеров в очень небольшом (1%) подмножестве. STL использовать нельзя.
stl, без заточки напильником, использовать действительно нельзя (но если обработать напильноком, то можно).

А вот на счет 1% ты очень и очень сильно загнул. Без допиливания напильником там не работает всего лишь new и исключения (и кстати, именно поэтому stl не выходит без напильника использовать), и rtti. Все остальное - работает. Лямбды, виртуальное наследование - все языковые возможности никуда не деваются. Проверял лично.


Теперь про преимущества Oberon-07/11, то есть не в плане микроконтроллеров, а в принципе. Говорить буду за себя: дело в том, что текущая сфера где работает КП (в основном Windows) мне не слишком интересна, и я не вижу там особых прорывных перспектив. Мне интересны новые области, где Оберонов пока нет вообще, кроме того, там нет или почти нет и конкурентов на дОлжном уровне. С Обероном-07/11 туда взобраться намного проще, просто за счет того, что он легче в реализации. После того, как и если туда заберется Оберон-07, можно потихоньку туда же подтянуть и КП например.

Кроме того Оберон-07 много приятней в качестве объекта исследований всевозможных в области грамматик и языков.
Y = λf.(λx.f (x x)) (λx.f (x x))

valexey_u

  • Hero Member
  • *****
  • Сообщений: 3013
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #2 : Январь 14, 2013, 01:01:48 am »
Начало обсуждения: http://oberspace.dyndns.org/index.php/topic,427.msg13181.html#msg13181.
Да, но для реальной юзабельности КП жутко не хватает способа создавать нормальные контейнеры. То есть там шаблонов, дженериков, модулей с параметрами-типами или чего-то еще подобного. Скажем в Go этого тоже нет и это ЖУТКО не удобно. И у них в TODO стоит решить эту проблему. У всех остальных современных языков со статической типизацией эта проблема решена (так или иначе).
Y = λf.(λx.f (x x)) (λx.f (x x))

X512

  • Newbie
  • *
  • Сообщений: 45
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #3 : Январь 14, 2013, 01:53:36 am »
Гм. Проблема наверно больше в модели программирования, в тех умолчаниях которые люди используют в своих программах.
То есть по умолчанию для ВСЕХ целочисленных переменных скорее всего будет использован всегда INTEGER, просто потому что это наиболее естественно. Скажем в Aде это будет не так, там принято под каждый тип переменных создавать свой диапазонной целочисленный тип.
Большинство современных программ в здравом уме сейчас на 16-битных процессорах запускать не будет. К тому же размеры целых типов - не единственная проблема. На таких процессорах кардинально другая система управления памятью с сегментами и дескрипторами.

Указывать диапазоны это конечно выглядит правильно, но довольно неприятно для всякой переменной указывать размер. Пусть лучше будет 4 байта, всё равно новый врятли будут запускать на 8-и и 16-ти битной машине. К тому же вероятно для таких машин могут потребоваться и другие изменения.

Подход Си в неопределённости размеров целых чисел неудачен, т. к. может нарушить логику работы программы на разных процессорах.

Таким образом КП-программа оказывается эффективной только на 32битной машине. Работа с 32битами не эффективна на машинах с меньшей битностью, и на ряде машин с бОльшей битностью.
В чём проблема с 4-х байтными целыми на AMD64?
Это есть и в java и в С++. Подозреваю, что в C# тоже есть.
В них можно получать полный доступ ко всем переменным внутри модуля (безо всяких friend и прочих костылей)? В них можно объявить класс, который может создать только модуль, который его объявил (безо всяких костылей типа объявления пустого класса и его расширения неэкспортированным классом). В С++ модульности вообще нет. Экспортируется всё. Инкапсуляция только на уровне классов.
Также в Component Pascal'е очень удобно, то, что не надо писать никаких definition'ов и header'ов. Компилятор это делает автоматически. Некоторые почему-то видят в этом недостаток, не знаю почему. Удобен метод экспортирования символов - просто ставишь "*" и всё. и никаких длинных слов вроде "public".
Ещё Java не умеет работать с неуказательныим классами, там они все только POINTER TO RECORD. Это повышает нагрузку на сборщик мусора и снижает эффективность работы. Для Component Pascal'я сборщик мусора с поколениями не нужен, поэтому память работает быстрее.

Но опять же, нужно очень сильно постараться, чтобы именно проверка типов в message bus'e стала бутылочным горлышком. Пожалуй такое возможно только на синтетических тестах.
Для микроконтроллеров вполне себе может стать. Высокая эффективность проверки типа позволяет использовать RTTI даже на микроконтроллерах.

А скажи пожалуйста, чем микроконтроллер на MSP430 с ОЗУ в 18 Кб менее полноценен, чем ARM (ARM7TDMI) с 8 Кб ОЗУ?
Если и там и там можно динамически загрузить модуль в ОЗУ и исполнить его оттуда, то ничем. Для меня загрузка модулей - один из основных критериев "полноценности" процессора.

Теперь про преимущества Oberon-07/11, то есть не в плане микроконтроллеров, а в принципе. Говорить буду за себя: дело в том, что текущая сфера где работает КП (в основном Windows) мне не слишком интересна, и я не вижу там особых прорывных перспектив. Мне интересны новые области, где Оберонов пока нет вообще, кроме того, там нет или почти нет и конкурентов на дОлжном уровне. С Обероном-07/11 туда взобраться намного проще, просто за счет того, что он легче в реализации. После того, как и если туда заберется Оберон-07, можно потихоньку туда же подтянуть и КП например.
Какие преимущества у Oberon-07/11 перед C/C++ кроме идеологии и простоты построения компилятора? Си же вроде для любого микроконтроллера есть...

Да, но для реальной юзабельности КП жутко не хватает способа создавать нормальные контейнеры. То есть там шаблонов, дженериков, модулей с параметрами-типами или чего-то еще подобного. Скажем в Go этого тоже нет и это ЖУТКО не удобно. И у них в TODO стоит решить эту проблему. У всех остальных современных языков со статической типизацией эта проблема решена (так или иначе).
Смотрю я код BlackBox'а и думаю: видимо это идеология оберона такая писать контейнеры каждый раз свои для каждого объекта. Принципе это не сложно организовывать связные списки и т.п.. К тому же это позволяет адаптировать контейнеры под применение объектов и повысить эффективность. При использовании шаблонов можно запросто написать крайне неэффективный код, не зная особенностей реализации (например один раз открывал большой RTF в Haiku и так и не дождался пока он откроется; оказывается там строковой буфер очищался удалением каждого символа с начала; у себя локально исправил проблему).

valexey_u

  • Hero Member
  • *****
  • Сообщений: 3013
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #4 : Январь 14, 2013, 02:45:14 am »
Большинство современных программ в здравом уме сейчас на 16-битных процессорах запускать не будет. К тому же размеры целых типов - не единственная проблема. На таких процессорах кардинально другая система управления памятью с сегментами и дескрипторами.
Нет. Ты ведь, надеюсь, не исключительно x86 под 16ти битами подразумеваешь?
Скажем у msp430 плоская модель памяти. Никаких сегментов вообще.

Кстати, а какая разница с точки зрения языка, какая там модель памяти у машинки внизу? Вроде бы в сообщении о языке ничего об этом не говорится.

Указывать диапазоны это конечно выглядит правильно, но довольно неприятно для всякой переменной указывать размер. Пусть лучше будет 4 байта, всё равно новый врятли будут запускать на 8-и и 16-ти битной машине. К тому же вероятно для таких машин могут потребоваться и другие изменения.
Не для всякой переменной, а создавая свои типы. Переменных одного типа, как понимаешь, может быть множество.

Подход Си в неопределённости размеров целых чисел неудачен, т. к. может нарушить логику работы программы на разных процессорах.
У Си, равно как и у С++,  давно уже другой подход. И он лучше чем в КП, и тем более чем в Oberon-07/11.

Таким образом КП-программа оказывается эффективной только на 32битной машине. Работа с 32битами не эффективна на машинах с меньшей битностью, и на ряде машин с бОльшей битностью.
В чём проблема с 4-х байтными целыми на AMD64?
Затрудняюсь ответить (то есть прямо сейчас по полочкам не разложу). Но в принципе, могу сказать какие проблемы бывают на АРМе с 16тью битами - выравнивание. Данные должны быть выровнены, и доступ к 16ти битной переменной идет медленней чем к 32битной. Соответственно на 64битах относительно 32бит может быть то же самое.

Кстати, вот, нашел. На самом деле выравнивание хорошо бы иметь 128битное (http://en.wikipedia.org/wiki/Data_structure_alignment#x86):
Цитировать
While the x86 architecture originally did not require aligned memory access and still works without it, SSE2 instructions on x86 CPUs do require the data to be 128-bit (16-byte) aligned and there can be substantial performance advantages from using aligned data on these architectures. However, there are also instructions for unaligned access such as MOVDQU.

Ну и советую посмотреть что там с RISC'ами.


Это есть и в java и в С++. Подозреваю, что в C# тоже есть.
В них можно получать полный доступ ко всем переменным внутри модуля (безо всяких friend и прочих костылей)?
Доступ кого к кому? И какое отношение это имеет к обсуждаемому ограничению на наследование?

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

В С++ модульности вообще нет. Экспортируется всё. Инкапсуляция только на уровне классов.
Нет. То есть модулей конечно же нет в явном виде. Но попробуй, пожалуйста, получить вот в данной программе из другой единицы компиляции к переменной foo:
// Foo.c
static int foo = 42;

Замечу, что это даже не С++, а просто Си.

Также в Component Pascal'е очень удобно, то, что не надо писать никаких definition'ов и header'ов. Компилятор это делает автоматически. Некоторые почему-то видят в этом недостаток, не знаю почему.
Потому, что становится невозможным specification driven development. Что бывает очень полезно. Особенно в больших проектах. Да и библиотеки которые написаны в таком стиле читать/разбираться намного приятней.

Побыстрому что-то накидать конечно удобней в стиле без спецификации отдельно.

Впрочем, этим грешат многие (чуть ли не все) новоделы. Та же java например, с#, go, D и так далее. Свет в окошке только Ада да Haskell.

Но в java,c# и Go это все частично компенсируется IDE, а вот в КП и D - нет. Увы-с. С таким работать не приятно.

Удобен метод экспортирования символов - просто ставишь "*" и всё. и никаких длинных слов вроде "public".
А потом высматривай эти звездочки, ога. Причем по всему тексту. То есть для пишущего это конечно удобно, для читающего - нет. А читатель в плане программирования имеет бОльший приоритет чем писатель.

Да, к тому же, длинное слово вроде public в С++ не требуется писать перед КАЖДОЙ сущность в структуре/классе. Таким образом, если у нас есть группа экспортируемых сущностей числом больше шести, то по лаконичности С++ начинает выигрывать. А по наглядности он выигрывает сразу.

Ещё Java не умеет работать с неуказательныим классами, там они все только POINTER TO RECORD. Это повышает нагрузку на сборщик мусора и снижает эффективность работы. Для Component Pascal'я сборщик мусора с поколениями не нужен, поэтому память работает быстрее.
Оно бы нагружало сборщик мусора, если бы реализация была бы наивной. Но она не такова, и в ряде случаев "объекты" будут на стеке. А сборщик мусора c поколениями в КП настолько не нужен, что народ аж переходит на ручное управление памятью :-) Как раз вот свеженькая темка в тему:  http://forum.oberoncore.ru/viewtopic.php?f=23&p=77104

Которое повышает вероятность утечек, ведь это не С++ и умный указатель тут не сделаешь.

Для микроконтроллеров вполне себе может стать. Высокая эффективность проверки типа позволяет использовать RTTI даже на микроконтроллерах.
Наврятли. На микроконтроллерах обычно тормозит например умножение и работа с плавающей точкой. А RTTI там противопоказан не из соображений производительности обычно, а из соображений экономии ОЗУ. На минуточку - у тебя 8 КБ на ВСЁ. Вообще все! Причем 8 Кб ОЗУ - это достаточно жирный микроконтроллер.

Я гонял приложение на c++11 (с лямбдами и прочим) на микроконтроллере с 512 байтами ОЗУ.

А скажи пожалуйста, чем микроконтроллер на MSP430 с ОЗУ в 18 Кб менее полноценен, чем ARM (ARM7TDMI) с 8 Кб ОЗУ?
Если и там и там можно динамически загрузить модуль в ОЗУ и исполнить его оттуда, то ничем. Для меня загрузка модулей - один из основных критериев "полноценности" процессора.
Если ты имеешь ввиду гарвард там или фоннейман, то там да, фоннейман.

Какие преимущества у Oberon-07/11 перед C/C++ кроме идеологии и простоты построения компилятора? Си же вроде для любого микроконтроллера есть...
Oberon-07/11 хорош для системного программиста. То есть не для того, который битиками оперирует - битиками и прерываниями оперирует все же прикладной программист, а тот который создает инструментарий для прикладного программиста. В этом плане у Oberon-07/11 пожалуй конкурентов мало. На базе него можно много быстрее и качественнее сделать нужный инструмент. Другое дело, что, вполне вероятно, на выходе будет уже не Oberon-07/11.

Ну, например для Oberon-07/11 (даже если не менять язык) намного проще построить вменяемую IDE чем для C++ или даже Си.

Ну и начинающий программист (но матерый электронщик) Оберон пожалуй быстрее освоит. Да, и мое IMHO, что народ учить программировать следует на базе именно микроконтроллеров, а не больших персоналок. Во первых это фан, ибо робототехника и вообще реальное взаимодействие с окружающим миром. Во-вторых если взять кошерный микроконтроллер (например msp430), то система команд и устройство памяти там очень-очень простое (проще чем у Виртовского недоАРМа из книжки) + вся память (все 512 байт скажем) будут на виду (на одном экране поместится вся карта памяти).

Смотрю я код BlackBox'а и думаю: видимо это идеология оберона такая писать контейнеры каждый раз свои для каждого объекта. Принципе это не сложно организовывать связные списки и т.п..
А что-то хитрее тоже не сложно организовать? Скажем B-tree?
И да, это не идеалогия такая, это вынужденая мера такая, потому что с таким языком иначе не получится вообще никак.

К тому же это позволяет адаптировать контейнеры под применение объектов и повысить эффективность.
А также насажать ошибок либо при копипасте, либо при ручной реализации велосипеда. А поскольку велосипеды приходится реализовывать постоянно, и нужно быстрее, то на вылизывание производительности, сколь-нибудь не тривиальные оптимизации и алгоритмы времени уже не хватает. Абы работало.

При использовании шаблонов можно запросто написать крайне неэффективный код, не зная особенностей реализации (например один раз открывал большой RTF в Haiku и так и не дождался пока он откроется; оказывается там строковой буфер очищался удалением каждого символа с начала; у себя локально исправил проблему).
Какое отношение приведенный пример имеет к шаблонам? По моему - никакого.
Y = λf.(λx.f (x x)) (λx.f (x x))

valexey_u

  • Hero Member
  • *****
  • Сообщений: 3013
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #5 : Январь 14, 2013, 03:40:08 am »
На всякий случай: я не утверждаю что КП никому нигде никогда не нужен. У КП безусловно есть своя ниша - написание небольших программ непрофессионалами. Особенно это хорошо сочетается с ББ например. GPCP тут конечно не особо в тему.
Y = λf.(λx.f (x x)) (λx.f (x x))

X512

  • Newbie
  • *
  • Сообщений: 45
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #6 : Январь 14, 2013, 04:27:02 am »
Кстати, а какая разница с точки зрения языка, какая там модель памяти у машинки внизу? Вроде бы в сообщении о языке ничего об этом не говорится.
Проблема в том, что адресуемой 16-ю битами памятью не достаточно для сложных приложений (ОС, GUI). Поэтому для реализации Component Pascal для 16bit x86 потребуется специальный runtime, который будет подгружать и отгружать неиспользуемые сегменты, код; управлять дескрипторами и т.д. (см. описание работы Windows 1.0 - 2.0). Многие указатели будут на самом деле дескрипторами. Без всего этого BlackBox'у просто не хватит памяти.

Понятно, что если не стоит цели запустить BlackBox, или программы пишутся для микроконтроллеров, то можно так не мудрить.

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

У Си, равно как и у С++,  давно уже другой подход. И он лучше чем в КП, и тем более чем в Oberon-07/11.
Всё равно большинство программ этим не пользуются. При портировании код придётся тщательно тестировать и править при необходимости. Обероновский же код будет гарантированно работать везде и везде одинаково.

Затрудняюсь ответить (то есть прямо сейчас по полочкам не разложу). Но в принципе, могу сказать какие проблемы бывают на АРМе с 16тью битами - выравнивание. Данные должны быть выровнены, и доступ к 16ти битной переменной идет медленней чем к 32битной. Соответственно на 64битах относительно 32бит может быть то же самое.
Кто мешает выравнивать 4-х байтные целые до 8-ми байт? Спецификация языка не требует, чтобы размер записей был равен сумме содержимого.
Кстати у компиляторов Microsoft'а для AMD64 стандартный размер int равен 4-ём байтам.

Нет. То есть модулей конечно же нет в явном виде. Но попробуй, пожалуйста, получить вот в данной программе из другой единицы компиляции к переменной foo:
// Foo.c
static int foo = 42;

Замечу, что это даже не С++, а просто Си.
Если бы не static, то можно было бы через extern... Но всё же такая система модулей однозначно хуже обероновской.
Потому, что становится невозможным specification driven development. Что бывает очень полезно. Особенно в больших проектах. Да и библиотеки которые написаны в таком стиле читать/разбираться намного приятней.

Побыстрому что-то накидать конечно удобней в стиле без спецификации отдельно.

Впрочем, этим грешат многие (чуть ли не все) новоделы. Та же java например, с#, go, D и так далее. Свет в окошке только Ада да Haskell.
Во-первых в BlackBox можно просматривать экспорт любого модуля, а во-вторых для specification driven development есть документация на модуль. В её начале есть definition модуля, потом общее описание и описание экспортированных символов. По-хорошему нужно писать документацию для каждого модуля; в ряде случаев выгоднее писать сначала документацию, потом реализацию. Из BlackBox'а легко смотреть описание на символ, достаточно его выделить и нажать Alt I, D.

Но в java,c# и Go это все частично компенсируется IDE, а вот в КП и D - нет. Увы-с. С таким работать не приятно.
И какие конкретно функции там есть?

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

Да, к тому же, длинное слово вроде public в С++ не требуется писать перед КАЖДОЙ сущность в структуре/классе. Таким образом, если у нас есть группа экспортируемых сущностей числом больше шести, то по лаконичности С++ начинает выигрывать. А по наглядности он выигрывает сразу.
Я про Java'у думал. Там public static final в порядке вещей (мог что-то напутать).

Оно бы нагружало сборщик мусора, если бы реализация была бы наивной. Но она не такова, и в ряде случаев "объекты" будут на стеке. А сборщик мусора c поколениями в КП настолько не нужен, что народ аж переходит на ручное управление памятью :-) Как раз вот свеженькая темка в тему:  http://forum.oberoncore.ru/viewtopic.php?f=23&p=77104

Которое повышает вероятность утечек, ведь это не С++ и умный указатель тут не сделаешь.
Чего-то не понял, что они там делают.
Относительно оптимизаций: они работают не стабильно, иногда они не возможны, у каждой JVM свои. Оптимизации во время исполнения снижают скорость исполнения кода, в результате чего программы на Java'е полторы минуты грузятся.

Да, текущая система размещения записей не через NEW() не идеальна, но похоже это лучшее, что есть в безопасных ЯП.

Наврятли. На микроконтроллерах обычно тормозит например умножение и работа с плавающей точкой. А RTTI там противопоказан не из соображений производительности обычно, а из соображений экономии ОЗУ. На минуточку - у тебя 8 КБ на ВСЁ. Вообще все! Причем 8 Кб ОЗУ - это достаточно жирный микроконтроллер.

Я гонял приложение на c++11 (с лямбдами и прочим) на микроконтроллере с 512 байтами ОЗУ.
Дескрипторы типов не такие уж и большие, к тому же их можно урезать в конкретной реализации (например до 4-х уровней наследования). Естественно не генерировать никаких дескрипторов, если тип не расширяемый или известен во время компиляции. Если не нужен модуль Meta (доступ к символам во время выполнения), то можно не сохранять имена символов и типы полей записей.

А что-то хитрее тоже не сложно организовать? Скажем B-tree?
Здесь как раз обероновский подход оправдан. B tree - это специфическая дисковая структура данных для ускорения доступа к большому объёму данных по ключу. Её реализация будет только в каком-то одном внутреннем модуле БД и она будет оптимизирована под структуру этой БД. К тому же формат БД публичен и требуется работать с определённым форматом.

valexey_u

  • Hero Member
  • *****
  • Сообщений: 3013
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #7 : Январь 14, 2013, 06:11:35 am »
Кстати, а какая разница с точки зрения языка, какая там модель памяти у машинки внизу? Вроде бы в сообщении о языке ничего об этом не говорится.
Проблема в том, что адресуемой 16-ю битами памятью не достаточно для сложных приложений (ОС, GUI). Поэтому для реализации Component Pascal для 16bit x86 потребуется специальный runtime, который будет подгружать и отгружать неиспользуемые сегменты, код; управлять дескрипторами и т.д. (см. описание работы Windows 1.0 - 2.0). Многие указатели будут на самом деле дескрипторами. Без всего этого BlackBox'у просто не хватит памяти.
Ну, во-первых зачем BlackBox? Мы ведь про КП говорим, а не про ББ.
Во-вторых у того же msp430 есть 20ти битная адресация памяти. Память остается плоской. Мегабайт ннада? :-)

Не для всякой переменной, а создавая свои типы. Переменных одного типа, как понимаешь, может быть множество.
Что мне выбрать для счётчика массива?
Ну, это то как раз совсем просто:
for Count in MyCoolArray'Range loop
...
end loop
Это будет гарантированно работать везде и всегда. А вот что выбрать в КП? :-)

Всё равно большинство программ этим не пользуются. При портировании код придётся тщательно тестировать и править при необходимости. Обероновский же код будет гарантированно работать везде и везде одинаково.
Большенство программ пользуется автотулзами например, которые проверяют при configure параметры платформы, наличие нужных библиотек, свойств ОС и так далее. Если configure отработало нормально, значит с очень большой вероятностью, все будет ОК.

Так что давай таки говорить про язык :-) В языке это есть. И если есть цель обойтись без системы сборки, то, как говорится, велком. Проблем не будет.

А теперь я прошу доказать тезис, что любой Обероновский (в том числе любого Оберона) код будет гарантированно работать и работать везде одинаково.

Затрудняюсь ответить (то есть прямо сейчас по полочкам не разложу). Но в принципе, могу сказать какие проблемы бывают на АРМе с 16тью битами - выравнивание. Данные должны быть выровнены, и доступ к 16ти битной переменной идет медленней чем к 32битной. Соответственно на 64битах относительно 32бит может быть то же самое.
Кто мешает выравнивать 4-х байтные целые до 8-ми байт? Спецификация языка не требует, чтобы размер записей был равен сумме содержимого.
Кстати у компиляторов Microsoft'а для AMD64 стандартный размер int равен 4-ём байтам.
Никто не мешает. Просто жалко памяти :-) КПД 50, а тои 25% это как-то маловато будет.

Нет. То есть модулей конечно же нет в явном виде. Но попробуй, пожалуйста, получить вот в данной программе из другой единицы компиляции к переменной foo:
// Foo.c
static int foo = 42;

Замечу, что это даже не С++, а просто Си.
Если бы не static, то можно было бы через extern... Но всё же такая система модулей однозначно хуже обероновской.
А если бы не отсутствие звездочки в КП, то там тоже можно было бы откуда угодно достать эту переменную! :-D


Во-первых в BlackBox можно просматривать экспорт любого модуля, а во-вторых для specification driven development есть документация на модуль.
Ни то ни другое не является вменяемой заменой. Просмотреть экспорт - там не будет комментариев и некоторых милых нюансов, которые в рукописной спеке всегда видны. То есть это тупо машинная выдача. С тем же успехом я могу просматривать експорты dll и на основе этого пытаться писать приложение.

А документация на модуль (писаная человеком) во-первых не всегда есть, во-вторых устаревает, в-третьих она НИКАК не согласована с реальной реализацией. Очередной источник ошибок. Спасибо, я как-нибудь с хедерами (а лучше - с Адскими спеками на пакет)


Но в java,c# и Go это все частично компенсируется IDE, а вот в КП и D - нет. Увы-с. С таким работать не приятно.
И какие конкретно функции там есть?
Да обычные. Ходить по символам (переменным, типам, функциоям и так далее) как по гиперссылкам. Посмотреть не отходя от кассы, и не открывая новых окошек, тип и определение. Построить без запуска программы callstack (точнее возможное дерево использования данной функции например). Посмотреть там документацию здесь же (то есть человеком писанную).

Ну и рефакторинги всякие обычные же, выделил поле скажем, нажал на кнопку, и оно стало скажем public. Rename есть. Ну и всякое прочее, более интересное - например вместо литерала сделать константу. Выделить выделенный код в отдельную функцию (с заменой этого блока на вызов оной функции, сигнатуру функции оно вычисляет автоматически, множество локальных переменных тоже). Ну и т.д. и т.п.

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

Да, к тому же, длинное слово вроде public в С++ не требуется писать перед КАЖДОЙ сущность в структуре/классе. Таким образом, если у нас есть группа экспортируемых сущностей числом больше шести, то по лаконичности С++ начинает выигрывать. А по наглядности он выигрывает сразу.
Я про Java'у думал. Там public static final в порядке вещей (мог что-то напутать).
Ну, поэтому и появилась например scala и kotlin. Особенно прекрасен последний (ибо скала все же тяжеловата для восприятия).

Чего-то не понял, что они там делают.
Они там по сути пулы делают. С рукопашным убиением пулов.

Относительно оптимизаций: они работают не стабильно, иногда они не возможны, у каждой JVM свои. Оптимизации во время исполнения снижают скорость исполнения кода, в результате чего программы на Java'е полторы минуты грузятся.
java-приложения грузятся во-первых не полторы минуты (консольные вообще мгновенно), а во-вторых медленная загрузка бывает не из за этого соврешенно.

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

Да, текущая система размещения записей не через NEW() не идеальна, но похоже это лучшее, что есть в безопасных ЯП.
Обероны вообще и КП в частности, в наше время не являются безопасными языками. Безопасный это haskell например. А лучше - Agda.

Если ходить на уровне Оберона в плане безопасности, то в Аде все с этим все же лучше (там есть пулы), и в D тоже. Да и в С++, если нужно безопасно, то можно сделать безопасней чем в Обероне. Про какой-нибудь Rust я вообще молчу :-)

Дескрипторы типов не такие уж и большие, к тому же их можно урезать в конкретной реализации (например до 4-х уровней наследования). Естественно не генерировать никаких дескрипторов, если тип не расширяемый или известен во время компиляции. Если не нужен модуль Meta (доступ к символам во время выполнения), то можно не сохранять имена символов и типы полей записей.
Насколько я помню, в КП нет модуля Meta. Так что и проблемы нет :-)

Здесь как раз обероновский подход оправдан. B tree - это специфическая дисковая структура данных для ускорения доступа к большому объёму данных по ключу. Её реализация будет только в каком-то одном внутреннем модуле БД и она будет оптимизирована под структуру этой БД. К тому же формат БД публичен и требуется работать с определённым форматом.
Ну, ладно, не удачный пример. Пусть будет АВЛ-дерево. Или красно-черное.

Да что там, можно и по алгоритмам пройтись. Например сортировки. Обогнать стандартную шаблонную с++-сортировку очень сложно. То есть реализовав одну из стандартных сортировок (из книжки Вирта например) его не обогнать.
Y = λf.(λx.f (x x)) (λx.f (x x))

X512

  • Newbie
  • *
  • Сообщений: 45
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #8 : Январь 14, 2013, 07:27:00 am »
Во-вторых у того же msp430 есть 20ти битная адресация памяти. Память остается плоской. Мегабайт ннада? :-)
Тогда это в принципе уже можно считать 32-х битной архитектурой. Указатели там сколько бит занимают?
...кстати посмотрел я этот msp430. Набор инструкций довольно простой, думаю несложно будет компилятор написать. Только у меня этого микроконтроллера к сожалению нет, а эмулятор неинтересно.
Это будет гарантированно работать везде и всегда. А вот что выбрать в КП? :-)
INTEGER разумеется :)
Хотя возможно действительно стоит объявить тип, аналогичный size_t(как я писал ранее про Host.Int) в Си. Тогда его можно будет использовать в качестве индекса массива для гарантии полного покрытия на 64-х битных архитектурах.

Большенство программ пользуется автотулзами например, которые проверяют при configure параметры платформы, наличие нужных библиотек, свойств ОС и так далее. Если configure отработало нормально, значит с очень большой вероятностью, все будет ОК.
Не говорите мне про этот ужас. Я с ним под Haiku намучился. Если под Haiku есть проблемы, то представляю какие серьёзные будут проблемы с микроконтроллерами.

А теперь я прошу доказать тезис, что любой Обероновский (в том числе любого Оберона) код будет гарантированно работать и работать везде одинаково.
А чего тут доказывать; спецификация оберонов чётко описывает все детали, критичные для исполнения. В отличии от Си там нет "undefined behavior". Другое дело, что не каждый компилятор соответствует спецификации. Например компилятор BlackBox'а содержит несколько критичных для безопасности багов и некорректно реализует логику оператора WITH.

Никто не мешает. Просто жалко памяти :-) КПД 50, а тои 25% это как-то маловато будет.
А какая разница объявить целое как INTEGER или LONGINT если всё равно логика программы работает только в диапазоне INTEGER'а. Из-за выравнивания КПД в любом случае будет низким.

Ни то ни другое не является вменяемой заменой. Просмотреть экспорт - там не будет комментариев и некоторых милых нюансов, которые в рукописной спеке всегда видны. То есть это тупо машинная выдача.
Скопируйте эту выдачу в документацию и напишите какие хотите комментарии.

С тем же успехом я могу просматривать експорты dll и на основе этого пытаться писать приложение.
Не можете. Там нет информации о типах, именах аргументов процедур и т. д.

А документация на модуль (писаная человеком) во-первых не всегда есть
Header с комментариями - это уже по сути документация. Некоторые программы типа Doxygen'а даже умеют по ним HTML документацию с навигацией составлять.

, во-вторых устаревает, в-третьих она НИКАК не согласована с реальной реализацией. Очередной источник ошибок. Спасибо, я как-нибудь с хедерами (а лучше - с Адскими спеками на пакет)
Извините, но если вы не можете согласовать документацию с кодом, то у вас плохая организация разработки. Оберон тут не виноват. Я конечно понимаю, что у каждого свой подход к разработке, но...

Рукотворный костыль. Тем более что он работет только в ББ, а мы про язык говорим.
Если вам угодно, можете настроить выделение жирным шрифтом идентификаторов со "*" в каком-нибудь Notepad++ или как ваш любимый редактор/IDE называется.

Ну, поэтому и появилась например scala и kotlin. Особенно прекрасен последний (ибо скала все же тяжеловата для восприятия).
Т. е. синтаксис оберона всё же лучше Java?

Они там по сути пулы делают. С рукопашным убиением пулов.
Они же не так делаются...

java-приложения грузятся во-первых не полторы минуты
Лично видел. Простая графическая Java-программа в Windows грузилась очень долго. Вообще Java в Windows выглядит и работает как-то криво и инородно.

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

Обероны вообще и КП в частности, в наше время не являются безопасными языками. Безопасный это haskell например. А лучше - Agda.
Component Pascal сам по себе формально является чисто безопасным ЯП. Модуль SYSTEM - это BlackBox-специфичное расширение языка, не имеющее к Component Pascal'ю никакого отношения. Также как говорилось выше компилятор BlackBox содержит критические уязвимости, позволяющие написать эксплоит и обойти защиту.

...и в С++, если нужно безопасно, то можно сделать безопасней чем в Обероне.
В С++ не может формально считаться безопасным, т. к. там допустима арифметика указателей и небезопасное управление памятью.

Насколько я помню, в КП нет модуля Meta. Так что и проблемы нет :-)
Вообще в сообщении о языке написано:
Цитировать
Appendix D: Mandatory Requirements for Environment
...
3) Modules and at least their exported procedures (commands) and exported types must be retrievable dynamically. If necessary, this may cause modules to be loaded. The programming interface used to load modules or to access the mentioned meta information is not defined by the language, but the language compiler needs to preserve this information when generating code.
Except for fully linked applications where no modules will ever be added at run-time, a linking loader for modules is required. Embedded systems are important examples of applications that can be fully linked.
Хотя в конце сказано, что для слинкованных модулей (как раз случай для микроконтроллеров) допускается исключить эту информацию. Так что ООП и RTTI Component Pascal'я можно смело использовать в микроконтроллерах.

Ну, ладно, не удачный пример. Пусть будет АВЛ-дерево. Или красно-черное.

Да что там, можно и по алгоритмам пройтись. Например сортировки. Обогнать стандартную шаблонную с++-сортировку очень сложно. То есть реализовав одну из стандартных сортировок (из книжки Вирта например) его не обогнать.
Вы часто в своём коде этим пользуетесь напрямую? В BlackBox вообще сложнее Shell-sort(сортировка ключей строковых ресурсов) да бинарного поиска(поиск имён символов при импорте) я алгоритма не нашёл. При этом BlackBox работает весьма шустро.

valexey_u

  • Hero Member
  • *****
  • Сообщений: 3013
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #9 : Январь 14, 2013, 07:46:35 am »
А теперь я прошу доказать тезис, что любой Обероновский (в том числе любого Оберона) код будет гарантированно работать и работать везде одинаково.
А чего тут доказывать; спецификация оберонов чётко описывает все детали, критичные для исполнения. В отличии от Си там нет "undefined behavior". Другое дело, что не каждый компилятор соответствует спецификации. Например компилятор BlackBox'а содержит несколько критичных для безопасности багов и некорректно реализует логику оператора WITH.
Да нифига подобного. UB в Обероне КУЧА. Ну, для примера: что будет в обероне, если поделить на ноль? А что будет если разименовать NIL? Для простоты давай возьмем Oberon-07/11.

Деталей в Обероне описан самый-самый минимум, в Си деталей критичных для исполнения описано намного больше. Все UB к тому же в Си описаны ЯВНО, а вот в Обероне - по большей части не явно.
Y = λf.(λx.f (x x)) (λx.f (x x))

X512

  • Newbie
  • *
  • Сообщений: 45
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #10 : Январь 14, 2013, 07:54:56 am »
А теперь я прошу доказать тезис, что любой Обероновский (в том числе любого Оберона) код будет гарантированно работать и работать везде одинаково.
А чего тут доказывать; спецификация оберонов чётко описывает все детали, критичные для исполнения. В отличии от Си там нет "undefined behavior". Другое дело, что не каждый компилятор соответствует спецификации. Например компилятор BlackBox'а содержит несколько критичных для безопасности багов и некорректно реализует логику оператора WITH.
Да нифига подобного. UB в Обероне КУЧА. Ну, для примера: что будет в обероне, если поделить на ноль? А что будет если разименовать NIL? Для простоты давай возьмем Oberon-07/11.
Про Oberon-07/11 не знаю, но в Component Pascal программа должна прерваться, если поделить на 0 или разыменовать NIL.
Цитировать
the result of a real operation is too large to be represented as a real number, it is changed to the predeclared value INF with the same sign as the original result. Note that this also applies to 1.0/0.0, but not to 0.0/0.0 which has no defined result at all and leads to a run-time error.

Peter Almazov

  • Sr. Member
  • ****
  • Сообщений: 482
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #11 : Январь 14, 2013, 09:32:42 am »
Да, и мое IMHO, что народ учить программировать следует на базе именно микроконтроллеров, а не больших персоналок.
Подписываюсь Под Каждым Словом.

Губанов Сергей Юрьевич

  • Hero Member
  • *****
  • Сообщений: 590
    • Просмотр профиля
    • Домашняя страница
Re: Component Pascal vs Oberon-07
« Ответ #12 : Январь 14, 2013, 12:02:50 pm »
В них можно получать полный доступ ко всем переменным внутри модуля (безо всяких friend и прочих костылей)?
Отвечу за C#. Там есть модификаторы видимости:

public = видимость везде,
internal = видимость на уровне модуля, в котором объект объявлен,
private = видимость внутри класса, в котором объект объявлен,
protected = видимость внутри класса и в расширениях этого класса,
protected internal = protected + internal (очень полезная штука при написании фреймворков).

Ответ на твой вопрос: используй модификатор видимости internal.

В них можно объявить класс, который может создать только модуль, который его объявил (безо всяких костылей...
Класс можно, для этого объяви конструктор этого класса с модификатором видимости internal. За пределами этого модуля никто объекты этого класса не сможет напрямую создать, так как конструктор не виден.

Вот структуру не очень, у структуры всегда есть дефолтный public конструктор заполняющий её нулями. Так что заполненную нулями структуру другой модуль всегда может создать. С другой стороны, зачем нужна структура заполненная нулями?

------

Чтоб два раза не вставать, модификаторы для процедур:
virtual = EXTENSIBLE,
abstract = ABSTRACT,
override = переопределение виртуальной процедуры,
sealed override = переопределение и запрет на дальнейшее переопределение.

модификаторы классов:
class = POINTER TO EXTENSIBLE RECORD
abstract class = POINTER TO ABSTRACT RECORD
sealed class = POINTER TO RECORD
static class = почти MODULE

Как видишь в C# с модификаторами ни чуть не хуже чем в Component Pascal.

X512

  • Newbie
  • *
  • Сообщений: 45
    • Просмотр профиля
Re: Component Pascal vs Oberon-07
« Ответ #13 : Январь 14, 2013, 12:25:52 pm »
Как видишь в C# с модификаторами ни чуть не хуже чем в Component Pascal.
Да, весьма неплохо... Вижу и модульность есть и контроль использования гибкий. Я на C# ничего сложнее Hello, World'а не писал, так что спасибо за информацию.