Здравствуйте, Кодёнок, Вы писали:


СГ>>Современной версией языка Pascal (1970 год) является язык Component Pascal (1997 год)

Кё>Получилось черт знает что. Увы Лучше бы добавили шаблоны, удалили interface/implementation, и forward — и язык бы преобразился.

Ага без interface/implementation вышла такая же лажа, как с хидерами, тормозящими процесс и портящими инкапсуляцию.
Кто тебе мишает также включать сишные хидеры в дельфях/паскале?

{$i 'MyHeader.h'}
{$include 'MyHeader2.h'}

Напиши эти две строчки и будет те счастье.

Здравствуйте, Кодёнок, Вы писали:


СГ>>Современной версией языка Pascal (1970 год) является язык Component Pascal (1997 год)

Кё>Получилось черт знает что. Увы

К чему конкретно у Вас есть претензии?

Кё> Лучше бы добавили шаблоны, удалили interface/implementation, и forward — и язык бы преобразился.

В языке Pascal (1970) ключевых слов interface/implementation НЕ БЫЛО.
Они были в языках Turbo Pascal, Object Pascal, Free Pascal, Delphi,...- которые к Никлаусу Вирту никакого отношения не имеют.

Кё> ...и forward — и язык бы преобразился.

Вы, видимо, не внимательно читали, forward в языке Component Pascal отсутсвует.

Здравствуйте, iGorash, Вы писали:

>> Современной версией языка Pascal (1970 год) является язык Component Pascal (1997 год)
>>
>> Отличия Компонентного Паскаля от Паскаля
>> [skipped]

G>ИМХО, какую-то лажу сделали.
G>Все более или менее полезные и хорошие мелочи, котрых не хватает в С/С++ убрали.

Какие конкретно у Вас есть претензии?

Здравствуйте, Кодёнок, Вы писали:


СГ>>Современной версией языка Pascal (1970 год) является язык Component Pascal (1997 год)

Кё> Лучше бы добавили шаблоны


Pascal ->- Modula ->- Modula 2 ->- Oberon ->- Oberon 2 ->- Component Pascal

Начиная с Modula эти языки являются модульными. Шаблоны в модульных языках практического смысла не имеют. Вот, например, в не модульном языке С++ шаблоны имеют практический смысл потому что можно один раз написать шаблон в одном текстовом файле, а потом инклюдить этот текстовый файл в другие текстовые файлы исходного кода программы и многократно использовать этот шаблон. В модульных языках программирования отсутсвует само понятие инклюда, там используется импорт (уже скомпилированных — бинарных) модулей, стало быть шаблоны, если бы они были, пришлось бы писать в каждом модуле заново — отсюда и исчезновение практического смысла. Модули и Шаблоны взаимосключают практический смысл существования друг друга, поэтому язык либо модульный, либо "шаблонный", но ни то и другое одновременно. Однако, вместо шаблонов в модульных языках можно применять так называемые generics — они, конечно, не идентичны templates, но все же могут быть полезны.

СГ>>>Современной версией языка Pascal (1970 год) является язык Component Pascal (1997 год)

Кё>>Получилось черт знает что. Увы Лучше бы добавили шаблоны, удалили interface/implementation, и forward — и язык бы преобразился.

DK>Ага без interface/implementation вышла такая же лажа, как с хидерами, тормозящими процесс и портящими инкапсуляцию.
DK>Кто тебе мишает также включать сишные хидеры в дельфях/паскале?
DK>

DK>{$i 'MyHeader.h'}
DK>{$include 'MyHeader2.h'}
DK>

DK>Напиши эти две строчки и будет те счастье.

interface в Borland Pascal 100% инкапсуляцию тоже не обеспечивает. И зачем оно? Напусти на исходник простой процессор, и он выдаст вам .int — файл, где есть действительно только интерфейсная часть. В компиляции такой файл все равно не участвует. А вот дублирование заголовков функций в interface и implementation сильно портит жизнь. Поменял определение — ищи в большом файле реализацию. Приходилось мне поддерживать и дорабатывать код на Delphi, так что я очень злой на эту фигню

Модуль все равно целиком в ОДНОМ файле. И если файл модифицируется, он целиком перекомпилируется. Что тут меняется? Зато удобство — очень большое. А скрытие ненужного из интерфейса модуля можно сделать директивами вроде private или hidden.

Сергей Губанов пишет:

> СГ>>Современной версией языка *Pascal (1970 год)* является язык
> *Component Pascal (1997 год)*
> Кё> Лучше бы добавили шаблоны
> Pascal ->- Modula ->- Modula 2 ->- Oberon ->- Oberon 2 ->- Component
> Pascal
> Начиная с Modula эти языки являются модульными. Шаблоны в модульных
> языках практического смысла не имеют. Вот, например, в не модульном
> языке С++

Да???? Это С++ с его механизмом раздельной компиляции — не модульный
язык????

И почему в "модульных" языках бессмысленны шаблоны?

--
С уважением,
Alex Besogonov (alexy@izh.com)

СГ>>>Современной версией языка Pascal (1970 год) является язык Component Pascal (1997 год)

СГ>К чему конкретно у Вас есть претензии?

Хочу удобный синтаксис и обобщенное программирование

Кё>> Лучше бы добавили шаблоны, удалили interface/implementation, и forward — и язык бы преобразился.



СГ>Вы, видимо, не внимательно читали, forward в языке Component Pascal отсутсвует.

Упреждающие (Forward) объявления необходимы, если процедура используется до ее определения.

Здравствуйте, Кодёнок, Вы писали:


Кё> Хочу удобный синтаксис и обобщенное программирование

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

Кё>

Упреждающие (Forward) объявления необходимы, если процедура используется до ее определения.

Я имел в виду, что вместо слова "forward" используется символ "^"

PROCEDURE^ f(x: REAL): REAL;

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




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

TYPE
  A = POINTER TO RECORD
    b: B;
    c: C;
    d: D;
  END;

  B = POINTER TO RECORD
    a: A;
    c: C;
    d: D;
  END;

  C = POINTER TO RECORD
    a: A;
    b: B;
    d: D;
  END;

  D = POINTER TO RECORD
    a: A;
    b: B;
    c: C;
  END;

предварительное объявление типов не требуется.

Кё>> Хочу удобный синтаксис и обобщенное программирование

СГ>Синтаксис там удобный. А шаблоны в модульных языках сильно ограничены в своей силе, так что практического смысла в них не много.

Я клоню известный мне паскаль (Delphi) к С++, а вы развиваете Oberon. Дальше тут не имеет смысла спорить

Кё>>

Упреждающие (Forward) объявления необходимы, если процедура используется до ее определения.

СГ>Я имел в виду, что вместо слова "forward" используется символ "^"

СГ>PROCEDURE^ f(x: REAL): REAL;

СГ>упреждающие объявления процедур встречаются так редко, что выгоднее в случае необходимости разок написать упреждающее объявление процедуры, чем вместо этого замедлить скорость компиляции всех программ во всем мире написанных на этом языке.

СГ>Кстати, упреждающее объявление требуется только для процедур, но не для типов. Для типов в Component Pascal можно спокойно писать "зацикленные" объявления безовсякого предварительного объявления:

Это уже хорошо, т.к. из-за упреждающих объявлений классов меня эта "фича" (просто наследие старых и ленивых компиляторов) раздражала. И в чем тогда потаённый смысл? Если компиляция все равно двупроходная?

Здравствуйте, Cyberax, Вы писали:

C>Да???? Это С++ с его механизмом раздельной компиляции — не модульный
C>язык????

Да, именно так.

C>И почему в "модульных" языках бессмысленны шаблоны?

Не то что бессмысленны, а "сильно ограничены в своей силе", то есть практического смысла в них мало. Именно на этот вопрос я и дал ответ в своем сообщении. Повторяю: В модульных языках есть только импорт БИНАРНЫХ модулей.

MODULE MyModule;
 IMPORT StdLog, Math; (* Импорт БИНАРНЫХ модулей StdLog и Math, но не их исходных текстовых файлов *)

(* .... *)

BEGIN
  StdLog.String("'MyModule' loaded into memory"); StdLog.Ln()
CLOSE
  StdLog.String("'MyModule' unloaded from memory"); StdLog.Ln()
END MyModule.

Это означает, что НЕЛЬЗЯ использовать шаблон описанный в другом модуле (НЕТ ИНКЛЮДА исходников, а есть ИМПОРТ БИНАРНИКОВ). А раз так, то область действия шаблона ограничивается одним единственным модулем — тем самым в котором он определен.

Представте себе что бы было если бы в С++ каждый template можно было бы использовать только в том текстовом файле где он определен, а в другом текстовом файле этот temlate использовать было бы нельзя? Много практического смысла было бы от таких templates-ов? Нет конечно их можно ввести (внутримодульные шаблоны), но зачем они такие нужны?

Здравствуйте, Кодёнок, Вы писали:

Кё> И в чем тогда потаённый смысл? Если компиляция все равно двупроходная?

Я не знаю.

Кстати исходные коды компилятора языка Component Pascal от Oberon Microsystems являются открытыми. Скачать можно отсюда http://www.oberon.ch/blackbox.html качать BlackBox 1.5 BETA for Windows — чуть меньше 8 мегабайтов. Я сейчас в них потихоньку копаюсь, как раз это и пытаюсь понять...

Сергей Губанов пишет:

> C>Да???? Это С++ с его механизмом раздельной компиляции — не модульный
> C>язык????
> Да, именно так.

Я так не считаю. С/C++ — вполне модульные языки, модули состоят из
интерфейса (определяемого h-файлом) и реализации, которая находится в
lib- или obj-файлах.

Шаблоны — это просто средство ГЕНЕРАЦИИ кода. Сгенерированный код (то
бишь инстанцированные шаблоны) можно паковать в модули. Экспортировать
же сами _генераторы_ (то есть шаблоны) — бессмысленно, хотя и возможно
при большом желании.

> C>И почему в "модульных" языках бессмысленны шаблоны?
> Не то что бессмысленны, а "сильно ограничены в своей силе", то есть
> практического смысла в них мало. Именно на этот вопрос я и дал ответ в
> своем сообщении. Повторяю: В модульных языках есть только импорт
> БИНАРНЫХ модулей.

Ну так и в С++ есть только импорт модулей, правда у них интерфейс не
бинарный. Но считать бинарный интерфейс модулей главным отличительным
признаком — это уже просто глупость.

> Это означает, что НЕЛЬЗЯ использовать шаблон описанный в другом модуле
> (НЕТ ИНКЛЮДА исходников, а есть ИМПОРТ БИНАРНИКОВ). А раз так, то
> область действия шаблона ограничивается одним единственным модулем —
> тем самым в котором он определен.

Кстати, в стандарте С++ есть такая фича: export templates. То есть
экспортированные в БИНАРНОМ виде шаблоны. Ее, правда, поддерживает всего
пара компиляторов (просто оказалось, что такая фича не особо и нужна).

> Представте себе что бы было если бы в С++ каждый template можно было
> бы использовать только в том текстовом файле где он определен, а в
> другом текстовом файле этот temlate использовать было бы нельзя? Много
> практического смысла было бы от таких templates-ов? Нет конечно их
> можно ввести (внутримодульные шаблоны), но зачем они такие нужны?

А мысль о том, что "модуль" может состоять не из одного файла, вам в
голову никогда не приходила?

--
С уважением,
Alex Besogonov (alexy@izh.com)

Здравствуйте, DEMON HOOD, Вы писали:

DH>Чегото вспомнилось сегодня, решил запостить...

DH>Начинал программировать на паскале, причина тривиальная — в наличии был только компилятор паскаля. IDE Borland Pascal
DH>потом появилась у меня IDE Borland C. И там и там были жёлтые буквы на синем фоне ;) да и паскаль от си не сильно отличается,
DH>но единственная фича которая перевесила в пользу си — это возможность обьявлять переменные в произвольном месте :super: , а не где-то там, в блоке var.

Интересно, почему никто не упомянул пре/пост-инкременты/декременты?
Я в свое время был просто очарован ими :)

особенно записями вида

while (*dest++ = *src++);

и еще отсутствие разделения на процедуры и функции

You will always get what you always got
  If you always do  what you always did

J>Интересно, почему никто не упомянул пре/пост-инкременты/декременты?
J>Я в свое время был просто очарован ими

J>особенно записями вида
J>

J>while (*dest++ = *src++);
J>

изучи тогда какой-нибудь функциональный язык, Haskel например — может еще в С++ разочаруешься

Здравствуйте, Cyberax, Вы писали:

C>А мысль о том, что "модуль" может состоять не из одного файла, вам в
C>голову никогда не приходила?


BlackBox ->- Help ->- Contents ->- Design Practices


3.2 Modules and subsystems
.....

Before a module can be used, it must be loaded from disk into memory. But before it can be loaded, it must be compiled (command Dev->Compile). When compiling a module, the compiler produces a code file and a symbol file. The code file contains the executable code, which can be loaded into memory. The code file is a kind of super-lightweight DLL. The compiler also produces a symbol file, which contains a binary representation of the module's interface. If a module imports other modules, the compiler reads the symbol files of all these modules, in order to check that their interfaces are used correctly. The compilation process can be visualized in the following way:

Source File -->-----+                         +--->--- Code File
                    |                         |
                    +---->--- Compiller --->--+
                    |                         |
Symbol Files --->---+                         +--->--- Symbol File

When you compile a module for the first time, a new symbol file is generated. In the log window, the compiler writes a message similar to the following one:

compiling "ObxPhoneDB"
new symbol file 964 640

The first of the two numbers indicates that the machine code in the new code file is 964 bytes long. The second number indicates that the module contains 320 bytes global variables (five entries in the db variable; each entry consisting of two strings with 32 elements each; each element is a 2-byte Unicode character). If a symbol file for exactly the same interface already exists, the compiler writes a shorter message:

compiling "ObxPhoneDB" 964 640

If the interface has changed, the compiler writes a new symbol file and indicates the changes compared to the old version in the log. For example, if you just have introduced procedure LookupByNumber in the most recent version, the compiler writes:

compiling "ObxPhoneDB"
LookupByNumber is new in symbol file 964 640

Symbol files are only used at compile-time, they have no meaning at run-time. In order to load a module, only its code file is needed. Modules are loaded dynamically, i.e., there is no separate linking step as required by more static languages. To see a list of currently loaded modules, call command Info->Loaded Modules. As result, a window will be opened with a contents similar to the following one:

module name bytes clients compiled             loaded

StdLinks    20639    1    2.7.1996  18:42:15   29.8.1996  14:31:14
StdFolds    20425    1    2.7.1996  18:41:33   29.8.1996  14:31:12
StdCmds     25066    7    2.7.1996  18:39:12   29.8.1996  14:31:00

Config        125    0    2.7.1996  18:38:21   29.8.1996  14:31:20
Init          682    0    2.7.1996  18:40:21   29.8.1996  14:31:05
Controls    78876    5    7.7.1996  14:14:58   29.8.1996  14:31:00
Services     1472    5    2.7.1996  18:37:14   29.8.1996  14:30:54
Containers  37348   40    2.7.1996  18:37:51   29.8.1996  14:30:52
Properties   8337   42    2.7.1996  18:37:40   29.8.1996  14:30:49
Controllers  6037   42    2.7.1996  18:37:36   29.8.1996  14:30:49
Views       31589   49    2.7.1996  18:37:33   29.8.1996  14:30:49
Models       4267   50    2.7.1996  18:37:27   29.8.1996  14:30:48
Converters   2189   51   14.7.1996  22:45:12   29.8.1996  14:30:48
Dialog       8979   54    2.7.1996  18:37:13   29.8.1996  14:30:48
Dates        3848   45    2.7.1996  18:37:07   29.8.1996  14:30:48
Meta        19275   11    2.7.1996  18:37:10   29.8.1996  14:30:48
Stores      22302   53    2.7.1996  18:37:22   29.8.1996  14:30:47
Strings     17547   15    2.7.1996  18:37:05   29.8.1996  14:30:47
Math        15408    2    3.7.1996   1:45:05   29.8.1996  14:30:47
Ports       10631   56    2.7.1996  18:37:17   29.8.1996  14:30:46
Fonts        1589   58    2.7.1996  18:37:15   29.8.1996  14:30:46
Files        3814   62    2.7.1996  18:36:28         linked
...

Table 3-5. List of loaded modules
The list shows all loaded modules. For each module, it shows its code size in bytes, how many other modules import it, when it has been compiled, and when it has been loaded.

......

Здравствуйте, jazzer, Вы писали:

J>и еще отсутствие разделения на процедуры и функции

В Component Pascal тоже "нет разделения на процедуры и функции".

PROCEDURE g(x: REAL);       (* Процедура         *)
PROCEDURE f(x: REAL): REAL; (* Процедура-функция *)

> Какие конкретно у Вас есть претензии?

• Типы-диапазоны
• Перечислительные типы
• Произвольные диапазоны для массивов
• Нет общих множеств

Не спорю, то что добавили — хорошо.
Впрочем все это уже написано ниже.
Я бы хотел удобный и красивый Паскалеский синтаксис расширить мощью С++.

Здравствуйте, iGorash, Вы писали:


>> Какие конкретно у Вас есть претензии?

G>• Типы-диапазоны
G>• Перечислительные типы
G>• Произвольные диапазоны для массивов
G>• Нет общих множеств


Ну это не претензии, а так — пожелания. Конечно хорошо бы иметь такие фичи чем не иметь, но и без них тоже не плохо.

Здравствуйте, DangerDen, Вы писали:

DD>Здравствуйте, Аноним, Вы писали:

DD>ПОлностью согласен!

DD>Когда я знал более менее паскаль, мне умные люди рассказывали как круто знать С и С++. Что его могут знать лишь избранные (я жил в маленьком городе и там таких не было ). И тогда я понял надо бросать Паскаль и Дельфи и рулить к Visual Studio (тогда я думал что это тоже что и С++) — то что там нельзя написать прогу мышкой доказывало мне силу С++ .
DD>В итоге я перешел на С++, узнал что много где заблуждался, а С++ реально крут!

продолжение из моего опыта:

... но как выяснилось, большинство пишущих на с++ пишут на нем в стиле плохого дельфи-кодераочень многие не могут даже на паскале нормально написать (как выразился один мой коллега-дельфин: "тут ведь если компилируется, то работает!" — это про паскаль конечно). Люди, пишущие на C++ не знают stl, не используют шаблоны и нэймспэйсы, создают кучу глобальных переменных, называя их MyVar и ... вообще, даже страуструпа похоже не читали.
зато все мегабаксовые вакансии с работных сайтов с гордыми заголовками "С++" для них. и рекрутеры пытаются выудить из потока г...
мнда...

добавлю в заклюении, то все встретившиекся в моей жизни дебилы от программирования (кроме одного ) писали на С++

Здравствуйте, Кодёнок, Вы писали:


J>>Интересно, почему никто не упомянул пре/пост-инкременты/декременты?
J>>Я в свое время был просто очарован ими

J>>особенно записями вида
J>>

J>>while (*dest++ = *src++);
J>>

Кё>изучи тогда какой-нибудь функциональный язык, Haskel например — может еще в С++ разочаруешься

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

С функциональным языком я имею дело, работаю в системе Mathematica.
Не знаю, как он в сравнении с Хаскелом, наверняка, хуже

You will always get what you always got
  If you always do  what you always did