При большом объеме программного кода возникает проблема эффективного управления им. Особенно это заметно, когда прошло достаточно много времени и прежде, чем что-либо изменить в собственном коде, не говоря уже о чужом, приходится тратить много времени на повторное освоение давно написанного и уже подзабытого. Также затруднительно вносить какие-либо существенные изменения. Часто проще, переписать весь проект заново, чем серьезно изменять существующий код. Не зря говорится в среде программистов: «Работает – не трожь!»

Конечно, в разных системах программирования есть разные возможности по структурированию кода. Самые важные из них это модульность и следование «правильным» принципам оформления исходного текста. Естественно, что процедурное программирование будет отличаться, от объектно-ориентированного или там клиент-серверного. Тем не менее, уверен, что вполне можно говорить об общих принципах.

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

Далее, код должен быть максимально линеаризованным. Вот возьмем для простоты 1С77. Программируем конфигурацию с нуля самостоятельно. Выносим максимум кода во внешние обработки. Во внешнюю обработку с общим кодом передаем контекст вызывающей ее формы (внешней либо внутренней) и также возвращаем из нее другой, нужный нам, контекст.

В начальной процедуре пишем нечто вроде:

Процедура ПриОткрытии()
    Если ИницСправочников() = 0 Тогда
        Перейти ~Финиш;
    КонецЕсли;                          

    Если ИницПарамФормы() = 0 Тогда
        Перейти ~Финиш;
    КонецЕсли;

    // . . .

~Финиш:
    СтатусВозврата(0); // Данная команда не даст открыться форме обработки
    Возврат;  
КонецПроцедуры

Во второй функции пишем нечто вроде:

Функция ИницПарамФормы()
    Если ПроверкаИсходнДанных() = 0 Тогда
        Возврат 0;
    КонецЕсли;                          
    
    Если ПолучитьКонтВызывФормы() = 0 Тогда
        Возврат 0;
    КонецЕсли;                          
    
    Если ОбработатьИсточнДанных() = 0 Тогда
        Возврат 0;
    КонецЕсли;                          
    
    // . . .

    Возврат 1;
КонецФункции // ИницПарамФормы()

И т.д. и т.п. Только в конечных функциях код может быть нелинеен, но должен быть достаточно простым для восприятия и хорошо задокументирован.

Полагаю, идея линеаризация кода понятна. Правда она достигается ценой большого количества общих переменных модуля. А «семерка» это, «восьмерка» или «девятка», не суть важно. В С++ можно программировать аналогично, разве что модули там определяются программистом.

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

Мое мнение, НУЖНО ПРОГРАММИРОВАТЬ КОД КАК ГИПЕРТЕКСТ. Одних сверток тел функций явно недостаточно. К сожалению, я не знаю систем программирования, предоставляющих подобный функционал. В принципе можно оформлять подобный гипертекст в MS Word либо аналогичных текстовых процессорах. Однако сказать, что это будет удобно, совершенно невозможно.

Какие ваши идеи?

GOTO бывает незаменим внутри "Выполнить", поскольку там нельзя вызывать "Возврат". В остальных случаях - на усмотрение разработчика.

Вложенность циклов или условий более 2-3 - плохой признак. Значит, скоро там кто-то запутается.

Глобальные переменные - зло, особенно для УФ. Во многих случаях они легко заменяются на одноименные функции, которые уже можно кэшировать в каком-нибудь Соответствии. Потерь скорости практически нет.

Свертка кода - приятная фича, но можно спокойно жить и без нее. Точка входа, F12, F12, ....

(77) Нет ни одной задачи автоматизации, которую нельзя решить при помощи асма.

(81) А посложнее
СхемаКомпоновкиДанныхДляВыводаВТабличныйДокументИмениБорисаНуралиева (с)

(85)+ и второе - код не надо писать. Его надо генерировать. Но данная нам объективной реальности 1С - не умеет этого делать. Ибо те кто планируют разработку платформы и введение новых возможностей - *удаки.

(87) есть:
создай каталог телефонных номеров за 10 минут, с поиском и сортировкой по имени, фамилии, отчеству и городу

(87) используя bones можно решать легко на scheme

(88) скдЖе

(86) Вот про Выполнить() не подумал. Наверно потому что не пользуюсь. Проще так не издеваться и свой "выполнитель скриптов" наваять спец. Даже несколько разных с нужным функционалом.

(90) Где там код?

вот это по сути про ООП  http://v8.1c.ru/o7/201603module/index.htm
единственное сделано через ж...

(86) а еще в eval()  можно обратно в цикл зайти, и много прикольных плюшек поиметь. Ну нахер такой изврат.

(94) Уже сейчас в типовых никакой поллитры не хватит чтобы разобраться. После использования этого в типовых они станут черными ящиками.
И будет проще свои ящики объекты (справочники и документы) ваять чем править существующие.

(31)
А, понял. То есть вы просто не знаете хоткей "F12" и "Ctrl + Shift + -" в Конфигураторе? Бывает.

(97) а еще там отладчик есть и СП "от Дениса"

(97) Обратный переход вроде просто ctrl+"-"

(93) вот и я том же
(94) не надо свои педали прикручивать к нашей лодке
это не для ооп, это для других задач

(99)
Возможно. Навскидку не помню, я его всегда на Alt-Left переназначаю, привычка.

(97) (99) не то и не другое, забыл не могу вспомнить (
вы оба написали сворачивание группировки

(94) Это скорее не ООП, АОП (аспектно-ориентированное)

(102) Нет, мы все правильно пишем. Сворачивание - это контрол-шифт-NUM-, а тут ctrl+"ОбычныйМинусНеНумпадовский"

(104) блин, точно, есть же другой минус

контрол-шифт-NUM- это свернуть все
контрол-NUM- свернуть текущую группировку

(100) >вот и я том же
Одинэса там тоже нет.

(107) на 1С это делается за 10 минут без сточки кода

Все разжевывать нужно чтоли? Нет задач в 1С где нужен ООП.
Для любых возникающих задач хватает того что есть, но даже для самых извращенных можно подключить внешнюю компоненту.

(91) Используя питон можно легко и непринуждённо генерить код фокспро.

(108) На экселе создаётся новый документ.

(108) В опу 1С - речь шла о задачах автоматизации вообще.

(110) на экселе тоже можно решать задачи. но только небольшого определенного круга.
(111) с фига ли? читай (57)

(112) Читай своё же (77)

(109) но фокпрос не умеет копилироватся на асм. а схема через кости - может

(113) Не тупи, вопрос был про задачу автоматизации на 1С, т.к. (77) ответ на (57) который об 1С

и с такой логикой тебе давать ООП? нет уж, извольте.

(115) Не выкручивайся.

(114) И это хорошо.

(59) ты ИНОГДА плохой и негодный программист, но очень редко

В одной C#-кальке с 1С было приятно кодить. Прямо крылья расправлялись.

(119) и где эти решения то? речь про NG Framework?

(97)  > А, понял. То есть вы просто не знаете хоткей "F12" и "Ctrl + Shift + -" в Конфигураторе? Бывает.

Переход на определения функций и сворачивание / их тел это не полноценный гипертекст. Смотрите, лучше всего дела обстоят в VC++. Допустим там мы определили два класса в файлах SomeClass.h и SomeClass.cpp. Пусть в классе под сотню функций, не считая определений констант и переменных. Естественно, ничто нам не мешает нам на имени некоторой функции нажать F12 или Ctrl+F12 (перейти к определению или к объявлению) либо просто показать определения, никуда не переходя (Alt+F12). Можно даже там найти все ссылки (Shift+F12), показать иерархию вызовов (Crrl+KT) и много чего еще. Все это просто великолепно. Но хочется большего. Например, я хочу каждую функцию видеть на отдельной странице / закладке нашей IDE. Не суть важно, чтобы это было сто файлов для одного класса, которые еще замучаешься компоновать всякими #include и т.п. Но, отображения разных функций я хочу в видеть в разных окнах, чтобы не отвлекаться на «лишний» код. Вот, что я имею в виду под гипертекстом – отображение / визуализацию кода на разных страницах IDE, но не обязательно в разных файлах. С файлами я и так могу делать, что хочу.

гипертекст... "..Конгресс, немцы какие-то... голова пухнет! ..." (c)


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

(122) в спагетти-коде с кучей goto проблема понять в многоэкранных портянках это все еще та же функция или уже другая

вот ТС и хочет чтобы каждая функция на отдельной закладке, и случайно спагетину с другой функции не засосать

http://its.1c.ru/db/v8std#browse:13:-1:72:73

(120) Ага. Вроде оно.

(122) До сих пор программный код ЯВУ представлен в виде обычного текста. Я хочу, чтобы это был гипертекст. И так, наверное, будет, рано или поздно. А навигацию по коду удобно делать мышкой, как, например, в справочной системе Qt. А на верхней панели чтобы были стрелочки вперед / назад по дереву навигации. Нужно еще, чтобы любая страница кода сразу же могла редактироваться в стиле MS Word. Идеологически это похоже на высокоразвитые средства разработки сайтов. Пока  наиболее близкий по реализации продукт – последняя версия MS VS C++. Думаю, мелкософт здесь движется в правильном направлении.

<Идеологически это похоже на высокоразвитые средства разработки сайтов>

Это какие например?

(126) <последняя версия MS VS C++>

Это называется MS Visual Studio

(126) Понятно. Можно сделать через IDE. Это просто интерфейс.
Использование функции в коде помечается гиперссылкой. При нажатии нее автоматом переход в  код этой функции.

Но не сможете пользоваться таким. Неудобно будет. Например переименование функции как?

(129) > Использование функции в коде помечается гиперссылкой. При нажатии нее автоматом переход в  код этой функции.

А на странице будет отображаться только одна эта функция или все имеющиеся функции? Понятно, что речь идет о примочках IDE, там уже много чего есть, но есть и куда еще совершенствоваться.

> Но не сможете пользоваться таким. Неудобно будет. Например переименование функции как?

Рефакторинг отлично реализован в IntelliJ IDEA последних версий, пусть MS возьмет оттуда лучшее.

(124) +1
(0) Зачем внешние обработки? Для 77 есть замечательная ВК TurboMD. А все остальное - просто структурируйте код (по ссылке в (124) рассказано как). Пишите понятно, и никаких проблем.

(131) > Зачем внешние обработки? Для 77 есть замечательная ВК TurboMD.

Я вот сейчас еще раз почитал информацию в Интернете об этой компоненте и не нашел там ничего интересного. Почему внешние обработки? А потому, что они подгружаются по мере необходимости, что очень удобно для разделения кода. Вызываю я их через общее меню «семерки», посредством вызова простейшей внутренней прокси-обработки, которая уже вызывает внешнюю форму. А та может делать дальнейшие вызовы по необходимости. Не вижу причин отказываться от внешних обработок, они меня вполне устраивают.

> А все остальное - просто структурируйте код (по ссылке в (124) рассказано как).

К сожалению, там требуется регистрация, поэтому содержимое посмотреть не могу. Теоретически, наша фирма имеет право на подобный сервис, мы покупали годовую подписку ИТС, но из-за войны в ЛНР, поставщик из Луганска кинул нас и сам пропал. В итоге у нас не было ни дисков, ни прав на регистрацию в подобном сервисе.

> Пишите понятно, и никаких проблем.

Я уже писал, что главное это максимальная линеаризация кода, комментирование и логическая модульность. Другие возможности связаны с интерфейсом используемой IDE и внешними компонентами. Возможности гипертекстового кода оставим на будущее.

(132) >максимальная линеаризация кода, комментирование и логическая модульность

Какая еще линеаризация? Отвыкаем от квикбейсика. Переходите на прогрессивный визуал бейсик и турбо паскаль.

(132) "...логическая модульность"
- я здесь понимаю это словосочетание как "смысловая модульноть". потому как по логике все может быть правильно но настолько "запутано" по смыслу шо каец...
- я прав?

(121)
Вам бы вместо маниловщины и невнятных мечтаний матчасть как следует освоить. Поизучать состав меню Окна в конфигураторе. Он между прочим позволяет разделять/слеплять/дублировать окна в любых мыслимых и немыслимых сочетаниях, не говоря уж о пристыковывании их к любой стороне экрана. Чтобы писать код, надо просто писать код. Через неделю привыкаешь, и всякие невнятные хотелки отпадают, так как всё нормально получается и без них.

(133) > Какая еще линеаризация?

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

(135) Т.е., если я Вас правильно понял, Вы утверждаете, что программный код ЯВУ всегда был, есть и будет текстовым и никогда гипертекстовым? А в конфигураторе «восьмерки» есть все что нужно?

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

(137) В нормальной IDE он и так гипертекстовый.

(136) кстати, я так последнее время и стараюсь писать...

(137) за всех не скажу, скажу за себя - в 7.7 есть прекрасная вещь на основе OpenConf - называется SiColorer, и в ней сделана возможность гипертекстовости процедур и функций, то есть Ctrl + LMB делают переход на нее. Вот только этой фичей я не пользуюсь - потому что быстрее нажать Ctrl+Enter (точно такой же результат), чем снимать правую руку с клавы на мышь, кликать, а потом назад.

(134)
- Доктор, почему меня все игнорируют?
- Следующий!

(138) > В нормальной IDE он и так гипертекстовый.

Можете привести образец такого гипертекстового кода, для конкретной IDE? Типа html-верстки.

(136) Нет смысла в линейном коде.
Для простоты чтения. Достаточно выносить в функции/процедуры. Весь код внутри циклов. По максимуму. И внутри прочих сложных конструкций тоже.

(142) https://ru.wikipedia.org/wiki/IntelliSense

(134) > - я здесь понимаю это словосочетание как "смысловая модульноть". потому как по логике все может быть правильно но настолько "запутано" по смыслу шо каец...
- я прав?

Русский язык, от такой :) . В С++ под логическим модулем естественно понимать один класс и то в двух файлах *.h и *.cpp. В 1С это понятие более размыто. Я воспринимаю его как набор функций для решения определенной задачи, например для создания полууниверсальной обработки (в «семерке», в «восьмерке» целесообразней использовать другие возможности) для создания определенной группы отчетов и загрузок промежуточных данных для последующих специальных отчетов. Или это могут общие функции для первичных и вторичных журналов расчетов (реализованных на справочниках) и т.д. и т.п.

А так, Ваше замечание правильно. Но простое нередко является гениальным :) .

(139) кстати, я так последнее время и стараюсь писать...

Ну вот, уже появились единомышленники, что на форумах редко бывает :) .

(146) а с +рекурсией это у меня получается при последовательном чтении иксемелек...

(140) > за всех не скажу, скажу за себя - в 7.7 есть прекрасная вещь на основе OpenConf

Согласен, недавно вот поставил себе, понравилось. Спасибо Александру Орефкову! Уже даже пришлось редактировать скрипты, которые вызвали ошибки в работе. Благо, это нетрудно сделать. Со временем, надеюсь освоить глубже.

(145) " Но простое нередко является гениальным :) ." - прям как
Флажок = 1-Флажок;

(149)

Функция НЕ(ЧислоБулево01)
  Возврат 1-ЧислоБулево01;
КонецФункции

И тогда Флажок = НЕ(Флажок);

(143) > Для простоты чтения. Достаточно выносить в функции/процедуры

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

Всё придумано до нас.

(151) Функции вызываются не последовательно. А согласно структурам программы. Могут и не вызываться. Так как пропустили. Или вызываться много раз. Могут заново начать вызываться с начала (рекурсия основной программы на себя).

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

(153) "Могут и не вызываться.".. фигня.. это тот же самый выхов, но 0 раз... ;-)

А ещё, могут вызываться строго по порядку, а могут произвольно...

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

(137)
Упс. Только сейчас понял, что про семёрку речь идет. В ней да, чуть похуже. Но там надо ставить openconf+telepat+scicolorer - немного исправляет ситуацию.

(10) +1000

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

(132) Самый популярный отмаз для отказа чтения ИТС. Там тест-драйв есть :)

(161) > Там тест-драйв есть :)

На него я не обратил внимание. Получил временную регистрацию, посмотрел указанные примеры. В принципе, как я и предполагал там речь идет о правильном стиле программирования в 1С, как таковом. При этом ничего не говорится о выносе кода конфигурации во внешние модули (обработки). Почему стоит вопрос об этом? Просто текущие конфигурации вроде 1С:ЕРП УП слишком уж монстрообразные. Поэтому хотелось разделить их код на внешние модули, загружаемые по мере необходимости. Речь не идет конкретно о данной ЕРП, а вообще, хочется иметь дело не с монолитным блоком 1С, а с чем-то более структурированным. Это и отладку облегчает и исправление отдельных модулей, и понимание структуры и т.д.

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

Кстати, похожая проблема есть и опенсорсных С++ проектах. Так, я решил чуток переделать под себя код Audacity, использующий wxWidgets,. Все, в общем-то, прекрасно получается, однако процесс перекомпиляции проекта при изменениях занимает слишком большое время. Понятно, что без предварительной компиляции отдельных модулей никуда не деться. Как раз с этим сейчас и разбираюсь, в свободное время.

(0)  Из всего текста важное: "При программировании код нужно структурировать".  Все остальное можно не читать.

посмотри СКАТ-ПРОФЕССИОНАЛ.
они почти весь прикладной уровень решения вынесли за конфигуратор.

(162) "рекурсивной линеаризации" - это что? На пальцах может рассказать?

(164) > посмотри СКАТ-ПРОФЕССИОНАЛ.
> они почти весь прикладной уровень решения вынесли за конфигуратор.

Посмотрел. И «семерку» и «восьмерку». Только не понял, что имеется в виду в последнем предложении? Как по мне, то все на месте. Часть кода защищена от просмотра и редактирования, только и всего. Все остальное как обычно. Хотя в «семерке» много всяких ВК используется, это можно поизучать.

А вот конфигурация "РБ-Софт:Рабочее место кассира" для «семерки» действительно почти не работает ни с собственной базой данных ни с собственными формами. Весьма экзотический вариант, хотя и глюковатый. Доступ к внешним dbf осуществляется через компоненту v7mysql.dll. А вместо формы списков используются обычные ТЗ. Кое-что здесь действительно интересно, но в целом выглядит странновато.

(166)  8-ка у них весьма интересная
Я с их программером пообщался, он меня в экспресс-режиме протащил по решению, обновление у них делается просто - просто загрузкой нового дт, все остальное вынесено в метаконфигуратор, то есть можно под себя написать в прикладном режиме почти все и то большинство всякими собственными настройками, вплоть до произвольных правил видимости любых реквизитов на формах
Короче интересно

(165) "рекурсивной линеаризации" - это что? На пальцах может рассказать?

В теме приведен схематический пример кода для 1С77. В «главной» функции делаем «линейные» вызовы вида:

Функция ИницПарамВызывающФормы()
    Если ПроверкаИсходнДанных() = 0 Тогда
        Возврат 0;
    КонецЕсли;                          
    
    Если ПолучитьКонтВызывающФормы() = 0 Тогда
        Возврат 0;
    КонецЕсли;                          
    
    Если ОбработатьИсточнДанных() = 0 Тогда
        Возврат 0;
    КонецЕсли;                          
    
    // . . .

    Возврат 1;
КонецФункции // ИницПарамВызывающФормы ()

Каждая вызываемая функция имеет аналогичную «линейную» структуру, если она не последняя в «дереве» кода. Последняя функция может быть нелинейной, но желательно не слишком сложной, иначе логично разбить ее на последовательные субфункции. Это не жесткое правило, а просто общая тенденция. Например, первая используемая функция будет:

Функция ПроверкаИсходнДанных()
    Если ПроверкаЭлемСпрПараметры() = 0 Тогда
        Возврат 0;
    КонецЕсли;

    Если ПроверкаПриемнДанных() = 0 Тогда
        Возврат 0;
    КонецЕсли;
    
    Возврат 1;
КонецФункции  // ПроверкаИсходнДанных()

И так «рекурсивно» углубляемся до каждой «конечной» функции. «Последние» функции будут уже иметь более содержательный вид. Не исключен нелинейный код (переключатели, циклы, попытки – исключения, транзакции и т.п.) в «промежуточных» функциях. Но он должен быть максимально простой структуры, как правило, в виде вызовов функций следующего уровня. Где-то так.

Когда я сделаю рефакторинг своей конфигурации в этом стиле, я опубликую ее код для примера. Подобные идеи (с различными вариациями) можно применять в других ЯВУ. В том же С++ функции часто возвращают целочисленное значение, характеризующую меру своего успеха / неудачи выполнения (вроде типа HRESULT).

(167) А мануал по этому метаконфигуратору есть у них?

(167) > Короче интересно

А свои модули в «восьмерке» «УправлениеПроведением», «УправлениеРегистрацией» и «БюджетныйУчет» они защитили с помощью WiseAdvise?

(169) А мануал по этому метаконфигуратору есть у них?

У них на сайте есть файл scat_help8.zip (запакованный chm-файл в виде CKAT8.exe ). Там есть раздел Метаконфигуратор. Также этот раздел есть в кратком варианте документации СКАТ-Профессионал.pdf.

(168) :pre и :post из кложуры - ты об этом хотел сказать?

Вообще, идея местами - то ли на контрактное программирование похожа, то ли на функциональное, то ли на автоматы писаные руками, то ли еще на какую эзотерику. Минусов реализации такого на 1С - чуть больше чем дофига.

Уже говорил, но повторюсь - нельзя писать код. Его надо генерить.

Но если генерить не получается - то простой DSL для твоего случая -

Функция ИницПарамВызывающФормы()
@Когда (ПроверкаИсходнДанных() = 1
            ПолучитьКонтВызывающФормы() = 1
            ОбработатьИсточнДанных() = 1 )
    
    // . . .

    Возврат 1;
КонецФункции // ИницПарамВызывающФормы ()
ну а @Когда раскрываешь уже сам в меру сил и потребностей отдельным компилятором, который берет все твои макросы и раскрывает их на 1С.

(172) Нам трудно понять друг друга по обрывкам информации. Любой используемый принцип не абсолют,  применяется постольку, поскольку в нем имеется смысл. Излагаемые здесь идеи подсмотрены  в открытом С++ коде. Но там легко применялись исключения из правил, когда это является целесообразным. Возможно в будущем, когда код будет представлен в двух видах (внутреннем, как html / xml и т.п. и внешнем как гипертекст) то средства структурирования программ станут на порядок лучше.

(173) Все равно не понял. Зачем тебе гипертекст??? что он даст? Вот тебе функция -
Функция ф(х,у)
если х = 0 тогда
   вызватьисключение "Делимое 0 - так нельзя";
конецесли
если у = 0 тогда
   вызватьисключение "Делитель 0 - так нельзя";
конецесли
если у = 1 тогда
   вызватьисключение "Делитель 1 - так  тоже нельзя";
конецесли

если у = 2 тогда
   вызватьисключение "Делитель 2 - и так  тоже нельзя";
конецесли
возврат х / у;
конецфункции

Перепиши в своей нотации с гипертекстом. Как это будет выглядеть?

(174) > Все равно не понял. Зачем тебе гипертекст??? что он даст?

Для удобства навигации по коду (как, скажем, в справочной системе Qt). При этом желательно, чтобы на одной странице отображалась только одна функция (или несколько, по выбору, т.е., чтобы «лишний» код не загромождал обзор), причем во внутреннем представлении это должен быть один модуль (в соответствии с нашим проектом). Также должно быть доступно редактирование гипертекста в своем внешнем представлении (а не только через html-коды, их, вообще, должна делать система автоматически). Теоретически из такого кода можно будет сделать целый сайт со всякими прибамбасами, но внутренняя его структура должна определяться выбранной структурой проекта. Возможно, это покажется чересчур избыточным, но, почему-то уверен, что так будет. M$ уже не знает, что придумать в программировании, поэтому ему можно продать эту идею :) .

> Вот тебе функция

Переходы можно делать по именам (переменных, констант, структур, классов, функций и т.п.), примерно то, что сейчас достигается в Visual Studio C++ через клавиши (Ctrl+F12; Shift+F12; Alt+F12; Ctrl+KT и т.п. Только там нет отображения одного объекта на одну страницу / вкладку / закладку / экран / окно и т.д.). В твоей функции представлены только параметры, ключевые слова и текст. Есть смысл, здесь демонстрировать только каким либо образом (на уровне системы), что x и y являются параметрами данной функции.

может на doxygen посмотришь? я так понимаю это то что тебе надо, только без редактирования текста.

(176) > это то что тебе надо, только без редактирования текста

Вот! В принципе, близко. Только обязательно должно быть редактирование и просмотр выбранного объекта в отдельном окне, без нарушения структуры проекта.

(177) пиши на яве. Там каждый объект в отдельном окне (файле)

(178) Под объектом я понимаю не только класс, но и любую структурную единицу, например, функцию, обычную структуру, перечисление и т.п.

А Ява предлагает только размешать один класс в одном файле, да еще и структуру каталогов поддерживать самому. Лучше уж писать на С++ с фрейморками в Visual Studio или в Qt Creator. Это, на мой взгляд, более удобные системы программирования.

(177) Ну напиши. Ничего сложного нет - парсинг текста + анализ + хранение информации + отображение.

(180) > Ну напиши. Ничего сложного нет - парсинг текста + анализ + хранение информации + отображение.

Смеешься? Хотя, если оформить как плагин для Qt Creator, то можно подумать.

"НУЖНО ПРОГРАММИРОВАТЬ КОД КАК ГИПЕРТЕКСТ"
чот напомнило: "современные ракетные двигатели - они скорее как цилиндр"©

(181) да не привязывайся ты к инструменту. Делай методологию. Тогда и инструмент станет  понятен

(183) Согласен, что теория нужна, но примеры реализации не повредят. Будем стремиться.

http://fixin.livejournal.com/1995918.html