Программные инструкции на естественном языке, или интенциональное программирование

    Данная тема способна вызвать скорее негативную реакцию благодаря тому, что большинство разработчиков являются ее противниками. Все потому, что интенциональное программирование, по сравнению с классическим, имеет существенные недостатки:
    • слабая детерминированность инструкций на естественном языке
    • значительная длина каждой инструкции, что заставляет вводить довольно объемный код
    • код выглядит единообразным, что может затруднять его восприятие и процесс поиска
    • сниженная скорость работы программы за счет анализа большего количества символов

    Но у него есть и существенные достоинства:
    • человеку интуитивно понятны все инструкции, нет необходимости в предварительном изучения нового языка
    • каждая инструкция однозначно отражает намерение разработчика, ее написавшего
    • природная способность естественного языка к обобщению и созданию новых уровней абстракции (как для объектов, так и для методов манипуляции с ними) на основе существующих
    • процесс программирования на естественном языке возможен не только в чисто императивном виде, но и в виде общения

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

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

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


    Для решения проблемы слабой детерминированности естественного языка предлагается ввести правило постройки программной инструкции на основе так называемых валентностей и триад на их основе. Идея заключается в постоении всех инструкций из триад — строительных блоков, которые состоят из трех компонент:


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

    Разные глаголы имеют разное количество открытых валентностей, обычно от 1 до 7. Например, у глагола «переместить» по сравнению с глаголом «положить» появляется дополнительная валентность «откуда». Также, валентности могут быть не только у глагола, но и у других понятий. Например в предложении «Он положил большую книгу туда.» у понятия «книга» заполнилась валентность «какая» благодаря понятию «большая».

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

    Это предложение является фреймом — содержит один глагол, поэтому именно глагол является началом отсчета, от него распростаняются валентности в обе стороны.

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

    Это можно объяснить подробнее на другом, более техническом примере. Допустим, имеется переменная Переменная1, которой нужно присвоить значение «1». На естественном языке такая инструкция выглядела бы так:
    присвоить переменной Переменная1 значение 1.


    На языке с явно указанными валентностями эта инструкция будет выглядеть так:
    присвоить (?чему Переменная1, ?что 1).


    В этом примере у понятия действия «присвоить» явно заданы две валентности: присвоить что и присвоить чему. Скобки тут необходимы, чтобы иметь возможность задать в линейном предложении древовидную структуру:
    присвоить
             ?чему
                  Переменная1
             ?что
                  1
    

    Передача информации при помощи таких конструкций с явным указанием семантических связей также возможна. Например, предложение:
    Земля это планета солнечной системы.

    можно разложить следующим образом:
    Земля ?что есть ?что планета ?чего системы ?какой солнечной.


    Получаем древовидную структуру:
    есть
        ?что
            Земля
        ?что
            планета
                   ?чего
                        системы
                               ?какой
                                     солнечной
    

    Еще один пример:
    Атом водорода имеет один электрон.

    можно преобразовать так:
    водорода ?чего атом ?что имеет (?что электрон, ?сколько 1).


    Получаем древовидную структуру:
    имеет
         ?что
             атом
                 ?чего
                      водорода
         ?что
             электрон
         ?сколько
                 1
    

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

    Средняя зарплата в IT

    120 000 ₽/мес.
    Средняя зарплата по всем IT-специализациям на основании 3 502 анкет, за 1-ое пол. 2021 года Узнать свою зарплату
    Реклама
    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее

    Комментарии 209

      0
      А где можно увидеть определение того, что такое «интенциональное программирование»?

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

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

      Ну и в-третьих, в вашей последней конструкции как определить, атом имеет электрон, или электрон имеет атом?
        0
        Это, как раз, не очень сложно. Можно доопределить, что при одинаковых вопросах первым идёт субъект, а вторым — объект.

        А по теме — для того чтоб такую штуку завести, нужно долго и много кодить на обычных ЯП, что лень, ибо выигрыш не очевиден. Какие-нибудь примеры рабочих систем, чтоб пощупать, уже есть?
          0
          Каждое такое «доопределение» отдаляет систему от естественного языка.

          (Нет, я знаю, что во многих языках порядок слов определен, но почти во всх из них при этом можно сделать инверсию, и все еще сохранить понимаемость)
            0
            Насколько я понимаю, это доопределение будет чисто «внутренним», для интерпретатора или компилятора, который будет разбирать предложение с естественного языка во внутреннее древовидное представление. Так что внешне язык все еще будет оставаться естественным. Ну это в будущем, так как по словам автора:
            … речь пойдет все таки о плановом языке… коротый, в процессе развития, имеет возможность трансформироваться практически в естественный.
              0
              Насколько я понимаю, это доопределение будет чисто «внутренним», для интерпретатора или компилятора, который будет разбирать предложение с естественного языка во внутреннее древовидное представление.

              Ага, а компилятор/интерпретатор такой где взять, да еще и с гарантированной семантической однозначностью?
                0
                Ну в Inform7 же сделали что-то подобное
                  0
                  Угу, вопрос, насколько оно действительно разбирает произвольное предложение.
            0
            Какие-нибудь примеры рабочих систем, чтоб пощупать, уже есть?
            Смотреть пока не на что, но код рабочий, отображает бегающую по кругу змейку в бесконечном цикле.
              0
              Можно доопределить, что при одинаковых вопросах первым идёт субъект, а вторым — объект.

              А можно заставить парсер интерпретатора строить оба варианта дерева и выбирать тот, который имеет смысл в данном контексте.
                0
                выбирать тот, который имеет смысл в данном контексте.

                Для этого нужно научить парсер понимать смысл сказанного, ага.
                  0
                  Я не зря сказал «парсер интерпретатора». Имеется в виду осмысленность в контексте среды выполнения, конечно.
                    0
                    Так все равно надо смысл понимать. То, что мы сузили зону допустимых вариантов, нам еще не сильно помогло. А если мы будем ее сужать до однозначности, мы получим DSL со всеми вытекающими.
                    0
                    Не обязательно. Достаточно определить является это субъектом, и может ли он выполнять действия. Файлы .qsl загружаются в БД. В ней же можно хранить такую онтологию.
                      0
                      Эээ, но в приведенном примере и атом, и электрон — субъекты, и они оба могут выполнять действия.
                        0
                        Электрон часть атома, потому это скорее атом имеет, чем электрон. Я к тому, что это все формализуемо (пока).
                          0
                          Так вам для этого нужно научить систему знанию, что электрон — часть атома.
                            0
                            Да
                            электрон ?что есть ?что часть ?чего атом.
                              0
                              … и сразу вы влетаете в две замечательных ситуации. Во-первых, ваша инструкция говорит, что «электрон — это часть атома», или «часть атома — это электрон»? Но это ладно, это мелочи. Что веселее — это то, что теперь вам надо создать в системе правило, что сущности, связанные отношением «а — это часть б», могут вступать в отношения «б имеет а» только в таких ролях.
                                0
                                Что веселее — это то, что теперь вам надо создать в системе правило, что сущности, связанные отношением «а — это часть б», могут вступать в отношения «б имеет а» только в таких ролях.
                                Ну а как же иначе.
                                Вообще-то это сильно забегая вперед. Сейчас вы уже касаетесь базы знаний, для которой (в частности) этот интерпретатор создается. И на данных которой сможет работать.
                                  0
                                  Ну а как же иначе.

                                  Угу, осталось выяснить, как вы будете это задавать, сколько ресурсов на это уйдет, и чем это будет отличаться от NLP.

                                  Сейчас вы уже касаетесь базы знаний, для которой (в частности) этот интерпретатор создается.

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

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

                Ну и в-третьих, в вашей последней конструкции как определить, атом имеет электрон, или электрон имеет атом?
                Слева от глагола актор (валентности «кто» и «что»), справа актант (валентности «кто» и «что»). При построении дерева делаются соответствующие пометки.
                  0
                  Информации по нему не много.

                  И та, которая приведена по ссылке, вообще никак не сочетается с тем, что вы описываете в статье.

                  Поэтому я переформулирую вопрос: что вы называете «интенциональным программированием», когда приводите список недостатков и достоинств в начале статьи? У мне, если честно, создается ощущение, что вы приравниваете его к «программированию на естественном языке».

                  С исполнимыми инструкциями кода проблем нет.

                  И как же вы планируете это реализовать?

                  Слева от глагола актор (валентности «кто» и «что»), справа актант (валентности «кто» и «что»).

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

                    И как же вы планируете это реализовать?
                    Код на видео уже работает.

                    Еще одно ограничение, которое уводит вашу систему еще дальше от естественного языка.
                    Нет, это свойство любого естественного языка. Все множество языков разбиваются на жесткий порядок субъект-глагол-объект (как в английском) и более-менее произвольный (как в русском).
                      0
                      Ну, скажем, программирование на естественном языке можно рассматривать, как подмножество вариантов интенционального.

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

                      Код на видео уже работает.

                      Так как же?

                      Нет, это свойство любого естественного языка.

                      Свойство любого естественного языка — избыточность (и, как следствие, многозначность).

                      Все множество языков разбиваются на жесткий порядок субъект-глагол-объект (как в английском)

                      Очень. Смешно. «Down the stairs came the dog».
                        +1
                        Нет, не смешно. Это не каноническая форма английского языка. И там, откуда вы этот пример выдрали говорится, то такая инверсия возможна только некоторых случаях, когда по смыслу понятно кто объект а кто субъект. Или вы хотите, чтобы я бросил все, что нужно реализовывать и сосредоточился на ненужной (в данном случае) проблеме перестановки слагаемых. Это не художественная литература, здесь такой проблемы нет и не нужно притягивать кота за яйца.
                          0
                          Это не каноническая форма английского языка.

                          Here comes the bride — это тоже не каноническая форма?

                          некоторых случаях, когда по смыслу понятно кто объект а кто субъект

                          Ключевое слово — «понятно по смыслу».

                          Или вы хотите, чтобы я бросил все, что нужно реализовывать и сосредоточился на ненужной (в данном случае) проблеме перестановки слагаемых. Это не художественная литература, здесь такой проблемы нет и не нужно притягивать кота за яйца.

                          Если вы накладываете на язык ограничения, то он становится все менее и менее естественным. Это само по себе не проблема (собственно, наоборот, ubiquitous language и DLS как раз идут по этому пути, и именно для повышения точности), просто это обратное тому, что вы заявляете.
                            0
                            Ключевое слово — «понятно по смыслу».
                            Ну какой смысл в простеньком интерпретаторе. При введении онтологий, эта проблема возможно решаема.

                            Я ничего не заявляю, просто предлагаю способ сделать конструкции более детерминированными, а парсинг более простым. Чтобы одновременно и оперировать словами естественного языка и не заморачиваться с разбором всех его многообразий. Пока не заморачиваться.
                              0
                              Я ничего не заявляю, просто предлагаю способ сделать конструкции более детерминированными, а парсинг более простым.

                              Тем самым вы делаете из естественного языка язык программирования.

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

                              Так вы хотите оперировать словами естественного языка (что, в общем-то, делает большая часть языков программирования), или естественным языком?
                                0
                                Тем самым вы делаете из естественного языка язык программирования.
                                Скорее что-то среднее.
                                Так вы хотите оперировать словами естественного языка (что, в общем-то, делает большая часть языков программирования), или естественным языком?
                                Они не предназначены одновременно и для выполнения кода и для передачи информации. Мне нужна дополнительная коммуникативная функция, свойственная для ЕЯ. Чем ближе к естественному, тем лучше, но можно выбрать и что-то промежуточное.
                                  0
                                  Скорее что-то среднее.

                                  То есть ни то, ни другое.

                                  Они не предназначены одновременно и для выполнения кода и для передачи информации.

                                  Это почему еще? AST — это информация в чистом виде.
                                    0
                                    То есть ни то, ни другое.
                                    Или и то и другое. Это как вам угодно.

                                    Это почему еще? AST — это информация в чистом виде.
                                    Ну так дерево приходится и мне строить, для каждой инструкции. Но уже после передачи ее через канал коммуникации, а не до. Домохозяйка не будет этим заниматься (оборачивать координаты посудного шкафа в XML или JSON), пытаясь объяснить роботу куда складывать помытую посуду.
                                      +1
                                      Ну так дерево приходится и мне строить, для каждой инструкции. Но уже после передачи ее через канал коммуникации, а не до.

                                      А почему вы думаете, что у языков программирования это иначе?

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

                                      Ни XML, ни JSON не являются языками программирования. При чем тут это?
                                        0
                                        А почему вы думаете, что у языков программирования это иначе?
                                        Я так не думаю, всем приходится строить дерево. Я просто не понял к чему вы упомянули про AST

                                        Ни XML, ни JSON не являются языками программирования. При чем тут это?
                                        Тогда опять, при чем был AST. Хотя, не важно.

                                        Давайте так. Есть механизм, есть канал коммуникации, есть человек (среднестатистический, не програмист). Механизм обладает минимальным набором поведенческих алгоритмов и способен понимать некоторый язык через канал коммуникации (скажем пока текстовый). Задача человека, на основе уже заложенного набора алгоритмов (используя некий язык) расширить (обучить) функциональные возможности механизма в процессе коммуникации. Желательно чтобы человек при этом не оперировал непосредственно объектами кода (именами переменных, структур, процедур..), а оперировал более абстрактными объектами. Мне интересна только такая модель, ее и пытаюсь изучать. Все что за рамками — оффтоп.
                                          0
                                          Я так не думаю, всем приходится строить дерево. Я просто не понял к чему вы упомянули про AST

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

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

                                          Угу. Если это невозможно — это проблема человека или механизма?
                                            0
                                            Проблема человека сделать так, чтобы это было возможно.
                                              0
                                              Вы говорите о том человеке, который коммуницирует с механизмом, или каком-то другом?
                                                0
                                                О другом, конечно.
                                                  0
                                                  И как он это будет делать? Исправляя человека-коммуникатора или механизм?
                                                    0
                                                    Возможно сначала ответ будет, как это обычно бывает, посередине. Но в идеале, решение должно максимизировать функциональность механизма при минимальных усилиях человека.
                                                      0
                                                      Но в идеале, решение должно максимизировать функциональность механизма при минимальных усилиях человека.

                                                      Для этого вам понадобится искусственный интеллект. Потому что сначала вам придется научиться распознавать естественные языки (причем без этих ваших ограничений), а потом — формализовывать задачу и строить алгоритм ее решения без участия человека.
                                                        0
                                                        Тогда буду ждать, пока его кто-то создаст, а сам в это время буду пить пиво и смотреть телевизор, или в игрушки играть.
                                            0
                                            Есть механизм, есть канал коммуникации, есть человек (среднестатистический, не програмист). Механизм обладает минимальным набором поведенческих алгоритмов и способен понимать некоторый язык через канал коммуникации (скажем пока текстовый). Задача человека, на основе уже заложенного набора алгоритмов (используя некий язык) расширить (обучить) функциональные возможности механизма в процессе коммуникации.

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

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

                                                    Так уже получилось же.
                                                      0
                                                      Так уже получилось же.
                                                      Где?
                                                        0
                                                        В моем марсоходе. Или в DSL.
                                                          0
                                                          Ну так это тоже претендент в DSL.
                                                            0
                                                            Вот только DSL — не естественный язык, и для работы с ним нужен специалист (в области домена). А разрабатывает его программист.
                                                  0
                                                  Да, кстати (извините за повторный комментарий), а вы считаете, что чтобы взаимодействовать с вашей системой в ее нынешнем состоянии не надо обучаться и оперировать специальными инструкциями? Ваш код говорит об обратном.
                                                    0
                                                    Сейчас из того, что хотелось бы еще практически ничего нет. Предполагается, что содержимое инициаллизирующей процедуры (самая первая и самая большая) будет формироваться автоматически. Также, те инструкции, которые есть сейчас, сильно низкоуровневые. На их основе можно создать набор более высокоуровневых инструкций (используя мощь естественного языка). Сейчас это только фундамент.
                                                      0
                                                      На их основе можно создать набор более высокоуровневых инструкций (используя мощь естественного языка).

                                                      Чтобы использовать мощь естественного языка, его нужно разбирать. Далее возвращаемся к вопросу, как вы это собираетесь делать.

                                                      Собственно, это все напоминает известную картинку про сову. Два круга вы нарисовали, но чтобы получилась сова, вам нужно совершить скачок сложности (причем гигантский, на самом деле) от элементарных операций к нетривиальным.
                                                        0
                                                        Далее возвращаемся к вопросу, как вы это собираетесь делать.
                                                        Набор инструкций все таки конечен. Если что-то системе не ясно, она всегда может спросить. Можно хранить базу синонимов. По частным случаям нужно будет разбираться отдельно.
                                                          0
                                                          Набор инструкций все таки конечен.

                                                          Дело не в инструкциях как таковых, а в структуре языке.

                                                          Если что-то системе не ясно, она всегда может спросить.

                                                          Хуже, когда системе ясно, но ясно неправильно.
                                                            0
                                                            Дело не в инструкциях как таковых, а в структуре языке.
                                                            Потому и использовал упрощение в виде эксплицитных валентностей.

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

                                                              Угу, и тем самым превратили естественный язык в язык программирования с именованными аргументами методов. Нет, серьезно. Любая инструкция вашего языка — это операция, которой передан список пар «имя-значение».

                                                              От этого никакой ЯП не застрахован, иначе отладчиков бы не существовало.

                                                              А для этого уже нужна квалификация оператора.
                                                                0
                                                                Угу, и тем самым превратили естественный язык в язык программирования с именованными аргументами методов.
                                                                Программирования и обмена информацией, что важно. ЯП — для программирования, ЕЯ — для обмена информацией. Тут получилось пересечение свойств, что и требуется.
                                                                  0
                                                                  Мы уже выяснили, что язык программирования вполне может быть языком обмена информацией, поэтому ничего нового не произошло.
                                                        0
                                                        И процесс написания кода действительно похож на классический, но из-за того, что нет конструкций условных переходов и циклов он все таки отличается, и процесс этот довольно увлекательный. Пока приходится заниматься стандартными вещами. В планах на ближайшее будущее создание отладчика.
                                                          0
                                                          И процесс написания кода действительно похож на классический, но из-за того, что нет конструкций условных переходов и циклов он все таки отличается, и процесс этот довольно увлекательный.

                                                          Увлекательность — хорошее качество для игры, а не для системы программирования.
                                                            0
                                                            Звучит, как аксиома. Не согласен.
                                                              0
                                                              Это мое личное мнение. Я предпочитаю, чтобы увлекательной была задача, а не инструменты, которые ее решают.
                      0
                      Пример кода в видео выглядит гораздо сложнее кода на обычных ЯП…

                      каждая инструкция однозначно отражает намерение разработчика, ее написавшего

                      Слово «есть» можно интерпретировать как прием пищи. Не факт, что стоит разбивать термин «солнечная система». Стоит ли разбивать термин «атом водорода» тоже наверное зависит от ситуации… Т.е. язык получается не очень однозначный.

                      Чтобы такой язык был возможен, нужна онтология. Вообще, интересная идея использовать онтологии при программировании…
                        0
                        Пример кода в видео выглядит гораздо сложнее кода на обычных ЯП…
                        Там все глаголы только в инфинитиве, валентности только в м. роде и ед. числе. Это потому, что еще не все реализовано в парсере. Обработка падежных форм тоже не реализована, все в им. падеже. Время — только настоящее. Эти проблемы буду решаться. Хотя, возможно вы «в общем» имели в виду. Это скорее связано с тем, что смысл некоторых инструкций нужно объяснять, так как они связаны еще с одной идеей: если присмотреться, в коде нет инструкций циклов и условных переходов.
                          0
                          если присмотреться, в коде нет инструкций циклов и условных переходов.

                          Зато есть условия, которые дают тот же эффект.
                            0
                            Зато есть условия, которые дают тот же эффект.

                            Так и есть. Создание блока с инстукциями описывающими условия предполагается автоматизировать. Есть интересные мысли, но пока не готовые к изложению.
                              0
                              Создание блока с инстукциями описывающими условия предполагается автоматизировать.

                              На основании каких входных данных?
                                0
                                На основании каких входных данных?
                                Это тема для отдельной статьи, пожалуй. Но если кратко, то у триггеров, из которых состоят условия будут символические имена, даже не имена, а конструкции, выражаемые предложением. Поиск процедуры, код которой нужно править будет выполнятся ассоциативно, на основе набора символических имен.
                                Например, мы хотим запросить (и изменить ее код) у системы процедуру, которая вызывается в ситуции (из примера на видео), когда (в этой ситуации нужно будет изменить направление движения змейки):
                                1. Текущая секция змейки является головой
                                2. Направление движения змейки — вниз
                                3. Голова змейки находится в самой нижней клетке поля
                                Можно описать эти символические имена на языке с валентностями и передать системе, на что она должна ассоциативно найти процедуру и вернуть ее текст для правки. Если процедура для такой ситуации не предусмотрена, она будет создана, попутно будут созданы необходимые условия. Это может позволить автоматически давать имена (технические) переменным в коде, триггерам, условиям, процедурам. Т.е. человек возможно не будет оперировать объектами кода в привычном понимании. Отвечать на вопросы я пока не готов. Реализация этого всего дело не близкого будущего, да и к текущей теме не относится.
                                  0
                                  1. Текущая секция змейки является головой
                                  2. Направление движения змейки — вниз
                                  3. Голова змейки находится в самой нижней клетке поля

                                  Вот же они, ваши входные данные. И они же и есть условия.

                                  PS

                                  match state with
                                  | (currentSection, direction, headPosition)
                                      when (currentSection |> isHead)
                                      and (direction |> isDown)
                                      and (headPosition |> isAtLowestBound)
                                      -> ...
                                  
                                    0
                                    Ну да. Вот теперь наглядно сравните два этих куска кода. Интенциональность какого из них выше.
                                      0
                                      Одинакова.
                                        0
                                        И не сомневался.
                                        И плюс к тому, первый кусок теоретически способен программировать действия машины без доступа к коду. Второй даже теоретически на это не способен.
                                          +2
                                          Я не понимаю, что вы имеете в виду под «первый кусок способен программировать». Программирует не кусок, программирует человек.
                        +1
                        В моём представлении «интенциональность» программирования не имеет прямой связи с естественным языком. Это способ формулировки программ, в котором приоритет уделяется смыслу описываемых действий, а выбор конкретного способа осуществления по мере возможности отдаётся на откуп машине. Скажем, вызов функции sort вместо вписывания пары циклов «пузырька» повышает интенциональность. Такие программы легче для понимания, а формализованный анализ и поиск ошибок забирается на более высокий уровень абстракции, что повышает надёжность.
                        Нетрудно заметить, что факт использования естественного языка сам по себе не гарантирует какой-то высшей степени интенциональности: на естественном языке легко можно наформулировать такой ереси, что волосы дыбом встанут, или же просто растекаться мыслью по древу, болтаясь вокруг основной сути. Для семантически однозначных программ нужен семантически однозначный язык, будь то ассемблер, питон или ыфкуиль.
                          +1
                          Скажем, вызов функции sort вместо вписывания пары циклов «пузырька» повышает интенциональность.

                          Кстати, да.

                          SELECT FROM Authors WHERE Name CONTAINS 'Gaiman'
                          


                          Прекрасно выражает интент разработчика, разве нет?

                          (а то, что там происходит под капотом — уже другой вопрос совершенно)
                            0
                            Выражает. SQL очень даже интенциональный и в его нише другого не надо.
                              +3
                              Есть у меня пара старых добрых запросов, где уже даже я, как автор, не до конца улавливаю свои первоначальные «интенции» :) Хорошо, что СУБД не переспрашивает, что конкретно я имел в виду.
                              0
                              Совершенно верно: выражает, понятно, формализованно. SQL ведь делался как раз с этим прицелом. Тем не менее, какой-нибудь трёхэтажный составной запрос с маловразумительными именами таблиц и полей, коих немало можно накопать на The Daily WTF, намекает нам, что даже на таком превосходном и продуманном языке степень интенциональности может очень сильно варьироваться и в первую очередь зависит от прикладываемых разработчиком усилий.
                            0
                            Где-нибудь можно посмотреть весь листинг программы из видео?
                              0
                              Файл программы лежит на гитхабе. Но подсветки синтаксиса там нет.
                                +1
                                Вы знаете, простой заменой регулярками из этой программы можно получить валидный код на PHP. Это значит, что ваша программа вполне себе императивна, и замена "=" на «устанавливать» не дает никаких преимуществ. К тому же абстракция протекает, что выражается в виде технической конструкции для языка Python «преобразовывать (? что элемент? как-что число,? во-что Temp? как-что буква).». У вас получился просто еще один язык программирования, никаким дальнейшим развитием языка императивность не исправить.

                                Если кому интересно
                                Заменяем, правим начало и конец, добавляем переводы строк, добавляем обвязку для запуска. При реализации рантайма по-быстрому «в лоб» происходит зацикливание в процедуре СP001 (триггер на изменение ListIterator) на строчке «set_value($ListIterator, 'значение', $ListIterator['значение'] + 1);». После добавления флага для запрещения срабатывания триггеров внутри триггеров программа выдает строку «CLR[13] SET[14] INIT[10:10] SET[A1] SET[A2] SET[A3] REFR[] ».

                                регулярные выражения
                                заменять в notepad++ или через javascript
                                ^(\t*)создавать \?что \(=(.+) \?что иметь \?что имя \?какой (.+)\)\.\s*$
                                $1$GLOBALS['$3'] = ['имя' => '$3', 'значение' => [null]]; $$$3 = &$GLOBALS['$3']; $$$2 = &$$$3;
                                
                                
                                ^(\t*)добавлять \?что (.+) \?чего (.+)\.\s*$
                                $1$$$3['значение'][] = null; $$$2 = &$$$3['значение'][count\($$$3['значение']\) - 1];
                                
                                
                                ^(\t*)использовать \?что ([^\s\(\)]+) \(\?чего (.+), \?какой (\d+)\)\.\s*$
                                $1$$$2 = &$$$3['значение'][$4];
                                
                                
                                ^(\t*)использовать \?что ([^\s\(\)]+) \(\?чего (.+), \?какой ([^\s\(\)]+)\)\.\s*$
                                $1$$$2 = &$$$3['значение'][$$$4['значение']];
                                
                                
                                элемент \(\?чего ([^\s\(\)]+), \?какой ([\d]+)\)
                                $$$1['значение'][$2]
                                
                                
                                элемент \(\?чего ([^\s\(\)]+), \?какой ([\w]+)\)
                                $$$1['значение'][$$$2['значение']]
                                
                                
                                ^(\t*)устанавливать \?что (.+) \(\?чего (.+), \?какой (\d+)\)\.\s*$
                                $1set_value\($$$3, '$2', $4\);
                                
                                
                                ^(\t*)устанавливать \?что (.+) \(\?чего (.+), \?какой (.+)\)\.\s*$
                                $1set_value\($$$3, '$2', $$$4['значение']\);
                                
                                
                                "\['значение'\]
                                "
                                
                                
                                выполнять \?что \(=процедура \?что иметь \?что имя \?какой Snake.(.+)\)\.
                                $1\(\);
                                
                                
                                \\"
                                "
                                
                                
                                ^(\t*)регистрировать \?что ([^\s\(\)]+) \(\?на-что ([^\s\(\)]+), \?для-чего ([^\s\(\)]+)\)\.\s*$
                                $1unset\($$$2\); register\($$$2, '$3', $$$4\);
                                
                                
                                ^(\t*)регистрировать \?что ([^\s\(\)]+) \(\?какой (.+), \?на-что ([^\s\(\)]+) \?какой (.+), \?для-чего (.+)\)\.\s*$
                                $1unset\($$$2\); register_ex\($$$2, $3, '$4', $5, $$$6\);
                                
                                
                                ^(\t*)присоединять \(\?что ([^\s\(\)]+), \?к-чему ([^\s\(\)]+)\)\.\s*$
                                $1attach\($$$2, '$3'\);
                                
                                
                                ^(\t*)печатать \?что значение \?какой (.+)\.\s*$
                                $1echo $2;
                                
                                
                                ^(\t*)печатать \?что ([^\s\(\)]+) \?чего (.+)\.\s*$
                                $1echo $$$3['$2'];
                                
                                
                                \$\$
                                $
                                
                                
                                ^(\t*)преобразовывать \(\?что (.+) \?как-что (.+), \?во-что (.+) \?как-что буква\)\.\s*$
                                $1$$$4 = $$$2;
                                
                                
                                ^(\t*)увеличивать \(\?что (.+) \?чего (.+), \?на-сколько (\d+)\)\.\s*$
                                $1set_value\($$$3, '$2', $$$3['$2'] + $4\);
                                
                                
                                ^(\t*)уменьшать \(\?что (.+) \?чего (.+), \?на-сколько (\d+)\)\.\s*$
                                $1set_value\($$$3, '$2', $$$3['$2'] - $4\);
                                
                                
                                
                                \$\$
                                $
                                
                                
                                ^(\t*)процедура (.+)\s*$
                                $1}\n\n$1function $2\(\)\n$1{\n\t\tforeach \($GLOBALS as $key => $value\) { $$$$key = &$GLOBALS[$key]; }\n
                                
                                
                                \$"
                                "
                                
                                
                                \#
                                //
                                


                                код
                                <?php
                                    global $triggers, $allow_triggers;
                                    $triggers = [];
                                    $allow_triggers = true;
                                
                                
                                    function register(&$trigger, $type, &$variable)
                                    {
                                        global $triggers;
                                
                                        $trigger = [
                                            'type' => $type,
                                            'reference' => &$variable,
                                            'property' => 'значение',
                                            'const_value' => null,
                                            'conditions' => [],
                                        ];
                                
                                        $triggers[] = &$trigger;
                                    }
                                
                                    function register_ex(&$trigger, $type, $property, $const_value, &$variable)
                                    {
                                        global $triggers;
                                
                                        $trigger = [
                                            'type' => $type,
                                            'reference' => &$variable,
                                            'property' => $property,
                                            'const_value' => $const_value,
                                            'conditions' => [],
                                        ];
                                
                                        $triggers[] = &$trigger;
                                    }
                                
                                    function attach(&$trigger, $condition_name)
                                    {
                                        $trigger['conditions'][] = $condition_name;
                                    }
                                
                                    function ref_equals(&$a, &$b)
                                    {
                                        $t = $a;
                                
                                        $a = 1;
                                        $eq1 = ($b === $a);
                                        $a = 2;
                                        $eq2 = ($b === $a);
                                
                                        $a = $t;
                                        return ($eq1 && $eq2);
                                    }
                                
                                    function process_triggers(&$variable, $old_value, $new_value)
                                    {
                                        global $triggers, $allow_triggers;
                                
                                        if (!isset($variable['имя'])) return;
                                
                                        if (!$allow_triggers) return;
                                        $allow_triggers = false;
                                
                                        $handlers = [];
                                        foreach ($triggers as $trigger) {
                                            if (!ref_equals($trigger['reference'], $variable)) continue;
                                
                                            if (
                                                   $trigger['type'] == 'изменение' && $old_value != $new_value
                                                || $trigger['type'] == '==' && $new_value == $trigger['const_value']
                                                || $trigger['type'] == '!=' && $new_value != $trigger['const_value']
                                            )
                                            {
                                                foreach ($trigger['conditions'] as $condition_name) {
                                                    if (!isset($GLOBALS[$condition_name])) continue;
                                
                                                    $condition = $GLOBALS[$condition_name];
                                                    $handlers[] = [
                                                        'обработчик' => $condition['обработчик'],
                                                        'приоритет' => isset($condition['приоритет']) ? $condition['приоритет'] : 0,
                                                    ];
                                                }
                                
                                                if (isset($trigger['обработчик']) && isset($trigger['приоритет'])) {
                                                    $handlers[] = [
                                                        'обработчик' => $trigger['обработчик'],
                                                        'приоритет' => isset($trigger['приоритет']) ? $trigger['приоритет'] : 0,
                                                    ];
                                                }
                                            }
                                        }
                                
                                        usort($handlers, function($a, $b) {
                                            if ($a['приоритет'] == $b['приоритет']) return 0;
                                            return ($a['приоритет'] > $b['приоритет'] ? -1 : 1);
                                        });
                                
                                        foreach ($handlers as $handler) {
                                            eval($handler['обработчик']);
                                        }
                                
                                        $allow_triggers = true;
                                    }
                                
                                    function set_value(&$variable, $property, $new_value)
                                    {
                                        $old_value = isset($variable[$property]) ? $variable[$property] : null;
                                        $variable[$property] = $new_value;
                                
                                        process_triggers($variable, $old_value, $new_value);
                                    }
                                
                                
                                
                                
                                    function Init()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Инициализация при загрузке модуля
                                        $GLOBALS['XList'] = ['имя' => 'XList', 'значение' => [null]]; $XList = &$GLOBALS['XList']; $список = &$XList;
                                        $список['значение'][] = null; $элемент = &$список['значение'][count($список['значение']) - 1];
                                        set_value($элемент, 'значение', 1);
                                        $список['значение'][] = null; $элемент = &$список['значение'][count($список['значение']) - 1];
                                        set_value($элемент, 'значение', 1);
                                        $список['значение'][] = null; $элемент = &$список['значение'][count($список['значение']) - 1];
                                        set_value($элемент, 'значение', 1);
                                
                                        $GLOBALS['YList'] = ['имя' => 'YList', 'значение' => [null]]; $YList = &$GLOBALS['YList']; $список = &$YList;
                                        $список['значение'][] = null; $элемент = &$список['значение'][count($список['значение']) - 1];
                                        set_value($элемент, 'значение', 1);
                                        $список['значение'][] = null; $элемент = &$список['значение'][count($список['значение']) - 1];
                                        set_value($элемент, 'значение', 2);
                                        $список['значение'][] = null; $элемент = &$список['значение'][count($список['значение']) - 1];
                                        set_value($элемент, 'значение', 3);
                                
                                        $GLOBALS['SnakeLength'] = ['имя' => 'SnakeLength', 'значение' => [null]]; $SnakeLength = &$GLOBALS['SnakeLength']; $поле = &$SnakeLength;
                                        set_value($поле, 'значение', 3);
                                
                                        $GLOBALS['Temp'] = ['имя' => 'Temp', 'значение' => [null]]; $Temp = &$GLOBALS['Temp']; $поле = &$Temp;
                                        $GLOBALS['ListIterator'] = ['имя' => 'ListIterator', 'значение' => [null]]; $ListIterator = &$GLOBALS['ListIterator']; $поле = &$ListIterator;
                                
                                        $GLOBALS['C1'] = ['имя' => 'C1', 'значение' => [null]]; $C1 = &$GLOBALS['C1']; $условие = &$C1;
                                        set_value($условие, 'обработчик', "СP001();");
                                        set_value($условие, 'приоритет', 3);
                                
                                        $GLOBALS['C2'] = ['имя' => 'C2', 'значение' => [null]]; $C2 = &$GLOBALS['C2']; $условие = &$C2;
                                        set_value($условие, 'обработчик', "СP002();");
                                        set_value($условие, 'приоритет', 2);
                                
                                        $GLOBALS['C3'] = ['имя' => 'C3', 'значение' => [null]]; $C3 = &$GLOBALS['C3']; $условие = &$C3;
                                        set_value($условие, 'обработчик', "СP003();");
                                        set_value($условие, 'приоритет', 2);
                                
                                        $GLOBALS['C4'] = ['имя' => 'C4', 'значение' => [null]]; $C4 = &$GLOBALS['C4']; $условие = &$C4;
                                        set_value($условие, 'обработчик', "СP004();");
                                        set_value($условие, 'приоритет', 2);
                                
                                        $GLOBALS['C5'] = ['имя' => 'C5', 'значение' => [null]]; $C5 = &$GLOBALS['C5']; $условие = &$C5;
                                        set_value($условие, 'обработчик', "СP005();");
                                        set_value($условие, 'приоритет', 2);
                                
                                        $GLOBALS['C6'] = ['имя' => 'C6', 'значение' => [null]]; $C6 = &$GLOBALS['C6']; $условие = &$C6;
                                        set_value($условие, 'обработчик', "СP006();");
                                
                                        $GLOBALS['C7'] = ['имя' => 'C7', 'значение' => [null]]; $C7 = &$GLOBALS['C7']; $условие = &$C7;
                                        set_value($условие, 'обработчик', "СP007();");
                                
                                        $GLOBALS['C8'] = ['имя' => 'C8', 'значение' => [null]]; $C8 = &$GLOBALS['C8']; $условие = &$C8;
                                        set_value($условие, 'обработчик', "СP008();");
                                
                                        $GLOBALS['C9'] = ['имя' => 'C9', 'значение' => [null]]; $C9 = &$GLOBALS['C9']; $условие = &$C9;
                                        set_value($условие, 'обработчик', "СP009();");
                                
                                        unset($триггер); register($триггер, 'изменение', $поле);
                                        attach($триггер, 'C1');
                                
                                        unset($триггер); register_ex($триггер, "!=", 'значение', 3, $поле);
                                        attach($триггер, 'C1');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 1, $поле);
                                        set_value($триггер, 'обработчик', "TP001();");
                                        set_value($триггер, 'приоритет', 1);
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 3, $поле);
                                        set_value($триггер, 'обработчик', "TP002();");
                                        set_value($триггер, 'приоритет', 3);
                                
                                        attach($триггер, 'C2');
                                        attach($триггер, 'C3');
                                        attach($триггер, 'C4');
                                        attach($триггер, 'C5');
                                        attach($триггер, 'C6');
                                        attach($триггер, 'C7');
                                        attach($триггер, 'C8');
                                        attach($триггер, 'C9');
                                
                                        $GLOBALS['Direction'] = ['имя' => 'Direction', 'значение' => [null]]; $Direction = &$GLOBALS['Direction']; $поле = &$Direction;
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 1, $поле);
                                        attach($триггер, 'C2');
                                        attach($триггер, 'C6');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 2, $поле);
                                        attach($триггер, 'C3');
                                        attach($триггер, 'C8');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 3, $поле);
                                        attach($триггер, 'C4');
                                        attach($триггер, 'C9');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 4, $поле);
                                        attach($триггер, 'C5');
                                        attach($триггер, 'C7');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 1, $YList['значение'][3]);
                                        attach($триггер, 'C8');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 10, $YList['значение'][3]);
                                        attach($триггер, 'C6');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 1, $XList['значение'][3]);
                                        attach($триггер, 'C9');
                                
                                        unset($триггер); register_ex($триггер, "==", 'значение', 10, $XList['значение'][3]);
                                        attach($триггер, 'C7');
                                
                                        set_value($ListIterator, 'значение', 1);
                                        set_value($Direction, 'значение', 1);
                                
                                        echo "INIT[10:10]\n";
                                        echo "SET[A1]\n";
                                        echo "SET[A2]\n";
                                        echo "SET[A3]\n";
                                        echo "REFR[]\n";
                                    }
                                
                                    function TP001()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Триггер ListIterator==1
                                        echo "CLR[";
                                        $элемент = &$XList['значение'][1];
                                        $Temp = $элемент;
                                        echo $Temp['значение'];
                                        $элемент = &$YList['значение'][$ListIterator['значение']];
                                        echo $элемент['значение'];
                                        echo "]\n";
                                    }
                                
                                    function TP002()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Триггер ListIterator==3
                                        set_value($ListIterator, 'значение', 1);
                                        echo "REFR[]\n";
                                    }
                                
                                    function СP001()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator, ListIterator!=3)
                                        set_value($Temp, 'значение', $ListIterator['значение']);
                                        set_value($Temp, 'значение', $Temp['значение'] + 1);
                                        $элемент = &$XList['значение'][$Temp['значение']];
                                        set_value($XList['значение'][$ListIterator['значение']], 'значение', $элемент['значение']);
                                        $элемент = &$YList['значение'][$Temp['значение']];
                                        set_value($YList['значение'][$ListIterator['значение']], 'значение', $элемент['значение']);
                                        set_value($ListIterator, 'значение', $ListIterator['значение'] + 1);
                                    }
                                
                                    function СP002()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==1)
                                        $элемент = &$XList['значение'][$ListIterator['значение']];
                                        $Temp = $элемент;
                                        set_value($YList['значение'][$ListIterator['значение']], 'значение', $YList['значение'][$ListIterator['значение']]['значение'] + 1);
                                        echo "SET[";
                                        echo $Temp['значение'];
                                        echo $YList['значение'][$ListIterator['значение']]['значение'];
                                        echo "]\n";
                                    }
                                
                                    function СP003()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==1)
                                        $элемент = &$XList['значение'][$ListIterator['значение']];
                                        $Temp = $элемент;
                                        set_value($YList['значение'][$ListIterator['значение']], 'значение', $YList['значение'][$ListIterator['значение']]['значение'] - 1);
                                        echo "SET[";
                                        echo $Temp['значение'];
                                        echo $YList['значение'][$ListIterator['значение']]['значение'];
                                        echo "]\n";
                                    }
                                
                                    function СP004()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==4)
                                        set_value($XList['значение'][$ListIterator['значение']], 'значение', $XList['значение'][$ListIterator['значение']]['значение'] - 1);
                                        $элемент = &$XList['значение'][$ListIterator['значение']];
                                        $Temp = $элемент;
                                        echo "SET[";
                                        echo $Temp['значение'];
                                        echo $YList['значение'][$ListIterator['значение']]['значение'];
                                        echo "]\n";
                                    }
                                
                                    function СP005()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==4)
                                        set_value($XList['значение'][$ListIterator['значение']], 'значение', $XList['значение'][$ListIterator['значение']]['значение'] + 1);
                                        $элемент = &$XList['значение'][$ListIterator['значение']];
                                        $Temp = $элемент;
                                        echo "SET[";
                                        echo $Temp['значение'];
                                        echo $YList['значение'][$ListIterator['значение']]['значение'];
                                        echo "]\n";
                                    }
                                
                                    function СP006()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==1, Y[3]==10)
                                        set_value($Direction, 'значение', 4);
                                    }
                                
                                    function СP007()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==4, X[3]==10)
                                        set_value($Direction, 'значение', 2);
                                    }
                                
                                    function СP008()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==2, Y[3]==1)
                                        set_value($Direction, 'значение', 3);
                                    }
                                
                                    function СP009()
                                    {
                                        foreach ($GLOBALS as $key => $value) { $$key = &$GLOBALS[$key]; }
                                
                                        // Условие (ListIterator==3, Direction==3, X[3]==1)
                                        set_value($Direction, 'значение', 1);
                                    }
                                
                                
                                    Init();
                                



                                  0
                                  Я не против "=", как и не против PHP. Но он не обладает свойством коммуникативности. Задача была не избавиться от императивности, а скорее наоборот, сохранить ее и добавить к ней коммуникативности. Чтобы язык и выполняться мог и информацию переносить.
                                  После добавления флага для запрещения срабатывания триггеров внутри триггеров
                                  Это вы правильно сделали.
                                  программа выдает строку «CLR[13] SET[14] INIT[10:10] SET[A1] SET[A2] SET[A3] REFR[] ».
                                  Должно быть так:
                                  INIT[10:10] — определяем игровое поле для змейки 10х10 клеток
                                  SET[A1] SET[A2] SET[A3] — Устанавливаем «звездочку» в ячейки A1, A2, A3
                                  REFR[] — обновление содержимого экрана
                                  CLR[A1] — удаляем «звездочку» из ячейки A1
                                  SET[A4] — устанавливаем звездочку в ячейку А4
                                  REFR[] — обновление содержимого экрана
                                  CLR[A2] — удаляем «звездочку» из ячейки A2
                                  SET[A5] — устанавливаем звездочку в ячейку А5
                                  REFR[] — обновление содержимого экрана
                                  CLR[A3] — удаляем «звездочку» из ячейки A3
                                  SET[A6] — устанавливаем звездочку в ячейку А6
                                  REFR[] — обновление содержимого экрана
                                  и т.д. пока змейка не дойдет до грани поля
                                  Эти комманды записываются в пайп, из которого читает другая программа-терминал, отображающая эти команды как бегающую змейку.

                                  У вас порядок инструкций попутался т.к. некоторые триггеры и условия могут активироваться одновременно, но их обработчики не всегда могут вызываться в произвольном порядке, тут есть правила, которые я уже выявил. Таким образом, обработчикам, присваиваются приоритеты, чтобы в спорном случае интерпретатор знал, какой обработчик нужно вызывать первым. В коде из примера приоритеты заданы явно инструкцией «устанавливать? что приоритет (? чего X,? какой Y).» Хотя в реальной работе они будут рассчитываться интерпертатором (сейчас я по установленному алгоритму определяю приоритеты расчетами в экселе)
                                    +1
                                    Задача была не избавиться от императивности, а скорее наоборот, сохранить ее

                                    Тогда вы не сможете «программировать через описание». Да с интенциональностью это плохо сочетается.

                                    Чтобы язык и выполняться мог и информацию переносить.

                                    Для переноса информации ничто из того, что вы используете, не обязательно (и не нужно).

                                      0
                                      Тогда вы не сможете «программировать через описание». Да с интенциональностью это плохо сочетается.
                                      Почему не смогу?

                                      Для переноса информации ничто из того, что вы используете, не обязательно (и не нужно).
                                      Что по вашему мнению я должен использовать вместо всего этого?
                                        0
                                        Почему не смогу?

                                        Потому что описание (в обычном его понимании) — это декларативное, а не императивное программирование.

                                        Что по вашему мнению я должен использовать вместо всего этого?

                                        Структур данных придумано достаточно. В частности, все, что вы используете, заменяется обычным списком.
                                          0
                                          Потому что описание (в обычном его понимании) — это декларативное, а не императивное программирование.
                                          В случае с обучением с учителем нужно как декларативное, так и императивное.

                                          Структур данных придумано достаточно. В частности, все, что вы используете, заменяется обычным списком.
                                          Списком из чего?
                                            0
                                            В случае с обучением с учителем нужно как декларативное, так и императивное.

                                            Тогда оно перестает быть описанием.

                                            Списком из чего?

                                            Список как структура данных. Причем она может быть и просто «транспортом», и при этом быть выполнимой.
                                              0
                                              Список как структура данных.
                                              А кто должен будет заполнять этот список-структуру? Непрограммист сможет это делать?
                                                0
                                                А кто должен будет заполнять этот список-структуру?

                                                Тот же, кто заполняет ваше «дерево».

                                                Непрограммист сможет это делать?

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

                                                Собственно, мы опять уперлись в задачу. Для каждого сценария есть свой наиболее удобный способ организации и ввода данных.
                                                  0
                                                  Вы же не ожидаете, что непрограммист будет формулировать ваши инструкции с указанием валентностей?
                                                  Сначала будет. Я же говорю, для человека это вообще не проблема, а для машины большое упрощение. Потом система сама будет их заполнять. Предвидя следующий вопрос «А как?» скажу, что не знаю. Вернее, большинство валентностей заполнимы по предлогам и союзам:
                                                  "Переместить (?откуда Х, ?куда Y)."
                                                  = «Переместить из X в
                                                  С проблемами разбираться по мере их возникновения.
                                                    0
                                                    Я же говорю, для человека это вообще не проблема

                                                    Я тут верну вам ваш аргумент: это для вас не проблема. А для «обычного человека» может быть.

                                                    Ну и да, если это для человека не проблема, то и заполнение списка для человека не проблема.
                                      +1
                                      Приоритеты учитываются, ошибка в другом, но суть не в этом. Я просто хотел показать, что вы не ушли от использования объектов кода. То, что вы условие (ListIterator == 3 && Direction == 1) обозначили одной переменной C2, не означает, что вы от нее избавились. И программа все равно требует знаний в области программирования, несмотря на то, что часть переменных названа русскими буквами.

                                      Вы неоднократно говорите в комментах что-то в стиле «это еще не реализовано» и «это будет потом». Я же вам предлагал в прошлой статье сделать сначала законченный пример приложения типа игры в дурака и посмотреть на объем и наглядность получившегося кода. При реализации этой змейки на обычном языке программирования объем кода в 3 раза меньше (у меня получилось 60 строк с отступами и комментариями). Зачем показывать промежуточные примеры, да еще и требующие отдельного интерпретатора команд?

                                      Кстати, а зачем вы сделали отдельный интерпретатор? Не потому ли, что с такой системой триггеров очистить участок экрана AxB это не самая простая задача?)
                                        0
                                        Зачем показывать промежуточные примеры, да еще и требующие отдельного интерпретатора команд?
                                        Чтобы периодически получать фидбэк. Обсуждение обычно помогает лучше понять.
                                0
                                Спасибо за статью.
                                Я вижу две основных проблемы с естественными языками:
                                1. Они неоднозначны, т.е., допускают возможность различного трактования в зависимости от массы факторов, как внутренних, так и внешних. «ДАО, которое может быть выражено словами, не есть постоянное дао.»
                                2. Они многословны и громоздки, по сравнению с отточенными формальными языками программирования (или с языком математических формул, например).
                                Именно поэтому я предпочту строго формализованный язык программирования естественному.

                                Но при этом я считаю, что рано или поздно нужно научить эту тупую железяку общаться по-человечески, а уж для программирования или для каких-то других целей — там разберемся ;)
                                  +1
                                  Хорошей проверкой способностей языка было бы попробовать написать компилятор подобного языка на нём самом.
                                    +1
                                    Пара пунктов в копилку минусов:
                                    — можно определять парадоксальные объекты типа множества всех множеств
                                    — интерпретатор насколько статичен? Если подобно человеку он постоянно накапливает знания, то результат работы программы может измениться от прогона к прогону. Если нет, непонятно как он наберёт и будет поддерживать способность к интерпретации естественного языка.
                                      0
                                      интерпретатор насколько статичен? Если подобно человеку он постоянно накапливает знания, то результат работы программы может измениться от прогона к прогону.
                                      Это можно считать плюсом, если с каждым прогоном изменение поведения программы приближает его к цели/целям.
                                        +1
                                        Вот скачиваете вы программу, и пытаетесь запустить. А оно говорит: я вот такой оборот речи впервые встречаю и не понимаю, обратитесь к разработчику.
                                      0
                                      >глагол «положил» имеет три заполненных валентности
                                      похоже на пролог

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

                                      >Можно доопределить, что при одинаковых вопросах первым идёт субъект, а вторым — объект
                                      если уж фиксировать порядок, стоит задуматься, то почему бы не хранить фреймы в таблицах, с колонками-валентностями, например, в CSV-формате с разделителем «пробел», получим просто в несколько пробелов там, где не все валентности заданы.
                                      Когда-то даже пытался писать базу данных на этой идее, только вместо одного ключевого слова можно использовать любое сочетание.

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

                                      А почему бы не пойти еще дальше: зачем нам ключевое слово? зачем валентности? Предлагаю язык bundle, предложения-твиты(не совсем естественный язык :)).
                                        0
                                        Может кто не видел статью.
                                        Также язык сценариев warcraft 3 тоже довольно человекочитаем.
                                        Не совсем понял, как ваша идея соотносится с литературным программированием. С другой стороны, в интенциональном программировании нет такого упора на естественный язык: как вы относитесь к тому, чтобы словами описывать цвет и размер кнопок, чуть правее поля ввода имени пользователя словами?
                                          +1
                                          Также язык сценариев warcraft 3 тоже довольно человекочитаем.

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

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

                                            Меня скорее интересует такая модель (повторю из комментария выше): «Есть механизм, есть канал коммуникации, есть человек (среднестатистический, не програмист). Механизм обладает минимальным набором поведенческих алгоритмов и способен понимать некоторый язык через канал коммуникации (скажем пока текстовый). Задача человека, на основе уже заложенного набора алгоритмов (используя некий язык) расширить (обучить) функциональные возможности механизма в процессе коммуникации. Желательно чтобы человек при этом не оперировал непосредственно объектами кода (именами переменных, структур, процедур..), а оперировал более абстрактными объектами.»
                                            Как пример (и план работ в конкретном направлении на ближайшее время) это обучение компьютера играть в игры. Т.е. берется любая игра (шашки, нарды, карточная, тетрис, и пр.). Задача человека обучить правилам игры не прибегая (совсем, или практически) к непосредственному программированию. Т.е. речь о коммуникативном программировании объяснением, как это происходит, когда один человек учит другого правилам игры.
                                              0
                                              Задача человека обучить правилам игры не прибегая (совсем, или практически) к непосредственному программированию.

                                              Обучить правилам или научить играть в игру?
                                                0
                                                Можете считать, что это одно и то же, т.к. теория без практики не особо полезна
                                                  0
                                                  Вообще-то, это совершенно разные вещи. Прочитав правила, человек может играть в игру (если они полны и непротиворечивы). Но что интереснее, он после этого может начать строить выигрышные стратегии (то есть учиться играть), причем как с внешним обучением, так и без него.
                                                    0
                                                    Тема призрачного СИИ далека от моих интересов.
                                                      +1
                                                      Без СИИ то, что вы описываете (в полной форме), невозможно.
                                                        0
                                                        Возможно. Посмотрим
                                                0
                                                обучение компьютера играть в игры

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

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

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

                                                Машина может либо узнавать по вопросам игры, которые она знает. Либо может узнавать у человека новые игры.

                                                Есть готовый софт для создания разных типовых игр www.gambit-project.org
                                                Есть теория, та же теория игр.

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

                                                  В каждой игре должна быть какая-то целевая функция, возможные окончания (выигрыш, проигрыш, ничья) или промежуточные этапы.
                                                  Да, все так.
                                                  0
                                                  Задача человека обучить правилам игры не прибегая (совсем, или практически) к непосредственному программированию. Т.е. речь о коммуникативном программировании объяснением, как это происходит, когда один человек учит другого правилам игры.
                                                  Ну тут тоже можно ничего не объясняя показать много сыгранных партий(в удобной компьютеру форме). Причем можно даже не объяснять кто выиграл, тогда просто будет обучение одновременно паре игр(шашки/поддавки).

                                                  А вообще задача интересная: на стыке обработки естественного языка и теории игр!
                                                    0
                                                    Ну тут тоже можно ничего не объясняя показать много сыгранных партий(в удобной компьютеру форме). Причем можно даже не объяснять кто выиграл, тогда просто будет обучение одновременно паре игр(шашки/поддавки).
                                                    Это проблема обучения без учителя, обучения наблюдением. И эта задача из области СИИ (сильного ИИ), а не ИИ, она затрагивает умение естественного интеллекта к ассоциативной классиикации. Причем к классификации всего и вся. Для этого нужно выявить принципы работы такого умения, а они насколько я знаю пока неизвестны (именно универсальный классификатор всего и вся).
                                                0
                                                чтобы немного увязать с вашей предыдущей статьей, стоит вспомнить о наличии видов у глагола: совершенный и несовершенный, отлично подходящих для описания состояния(ситуации) и действия(или события) соответсвенно
                                                  0
                                                  Не во всяком языке есть виды глаголов. А состояние вообще не описывается глаголом.
                                                    0
                                                    как это не описывается:
                                                    «человек вступил в клуб»
                                                    «процесс запущен»
                                                    «значение переменной х равно
                                                    «двигатель включен»
                                                    а чем же оно тогда описывается?

                                                    вот, кстати, пример проблемного описания — запретительное:
                                                    «пока кран закрыт(состояние), запретить включение(событие) насоса»
                                                    языком нейрофизиологии тут требуется ингибиторный синапс и ингибиторный постсинаптический потенциал
                                                      0
                                                      человек вступил в клуб

                                                      Это действие, а не состояние. Остальные примеры — это причастия, у них… сложные отношения с глаголами (я знаю, что это глагольная форма).

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

                                                      При этом, впрочем, вид глагола к этому не имеет никакого отношения. «Двигатель запущен» — это одновременно событие («двигатель был запущен в 15:00») и состояние («двигатель запущен и не был остановлен»), при этом это же состояние можно выразить глаголом другого вида («двигатель работает»).

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

                                                        0
                                                        >«Двигатель запущен» — это одновременно событие и состояние
                                                        если правильно понял, то именно это и понимает автор под событиями

                                                        с причастиями вы меня подловили :)
                                                          0
                                                          если правильно понял, то именно это и понимает автор под событиями

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

                                                            «Двигатель запущен» — это одновременно событие и состояние
                                                            если правильно понял, то именно это и понимает автор под событиями
                                                            Это событие. А «двигатель работает» это состояние. Все зависит от того, что важно для системы, то что двигатель был запущен, или то, что он работает именно сейчас.

                                                            Во время обсуждения прошлой статьи с ув. lair стало понятно, что кроме событий есть еще и состояния. Оба эти термина объедены в понятие триггер. Он имеет 2 устойчивых состояния: активирован и деактивирован. Триггер состояния может быть активным долгое время, триггер события деактивируется после вызова его обработчика. Несколько триггеров могут быть объединены в условие, которое активируется тогда, когда все его триггеры активированы.
                                                              0
                                                              В таком случае, может оказаться удобно рассматривать триггеры не как физические состояния, а как знание системы об этих состояниях.
                                                              Не «двигатель работает», а «известно, что двигатель работает».
                                                              Поскольку знания устаревают, то их триггеры можно сбрасывать по таймауту.
                                                              Но тогда может оказаться, что триггер не установлен(например при инициализации системы), а двигатель работает.
                                                              Значит, когда триггер сброшен, а он входит в «ситуацию», нужно проверить какие-то условия. Если ситуация желаемая, то кроме проверки можно предпринять действия, направленные на выполнение условий триггера(как в makefile).
                                                              Тогда весь поток управления — не более чем рекоммендуемая последовательность проверок, которую можно заменить на систему приоритетов.

                                                              После некоторого обобщения получаем граф последовательности и к граф вытеснения(этого в makefile нет).
                                                                0
                                                                Тогда весь поток управления — не более чем рекоммендуемая последовательность проверок, которую можно заменить на систему приоритетов.
                                                                Можно и так сказать.
                                                                Если из двух обработчиков первый изменяет значение переменной, а второй только читает ее значение, то второй обработчик должен выполняться первым, а первый вторым. Главное, что условия и циклы берет на себя интерпретатор, и человеку не нужно задумываться о связях между разными обработчиками. Но для этого интерпретатор должен просмотреть все строки кода и построить зависимости.
                                                                  0
                                                                  Главное, что условия и циклы берет на себя интерпретатор, и человеку не нужно задумываться о связях между разными обработчиками. Но для этого интерпретатор должен просмотреть все строки кода и построить зависимости.

                                                                  Вы-таки собираетесь решать проблему останова?
                                                      0
                                                      >Не во всяком языке есть виды глаголов.
                                                      Приведите пожалуйста пример, мне просто интересно.
                                                      Даже в китайском есть:
                                                      Прошедшее завершенное время глагола обозначает действие, которое было совершено в прошлом. Для того, чтобы показать завершенность действия к глаголу присоединяется суффикс 了 le
                                                        0
                                                        Приведите пожалуйста пример, мне просто интересно.

                                                        Английский, испанский (чуть ли не все романские, на самом деле). В них есть завершенные (совершенные) времена, но нет деления глаголов на совершенные и несовершенные.
                                                          0
                                                          это уже детали: есть doing-done, stopping-stoped…
                                                            0
                                                            Эти детали и отличают понимание языка. В русском вы можете определить вид глагола по его неопределенной форме, а в английском — нет. Более того, глагол read принесет вам столько счастья…
                                                    +1
                                                    Допустим, у автора получится. И что это изменит? Сложность предметной области от этого никуда не пропадёт.
                                                    Будут описывать её не в миллионах строк программного кода, а миллионах строк книжных томов.

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

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

                                                    При этом легко посадить противоречие, приводящее к неопределённому поведению (которая машина, в соответствии с теоремой Гёделя, сама найти не может, всё вылезет на тестах и эксплуатации)
                                                      0
                                                      В ваших словах есть доля правды, если вы читали прошлую статью и осознали плюсы ее подхода. Для этого и разрабатывается интерпретатор, чтобы подтвердить, или опровергнуть.
                                                      В принципе, ситуационное программирование интересно само по себе, чего не скажешь про программирование на естественном языке. Но в паре они могут позволить выполнять программирование (изменение поведения) объяснением, без оперирования объектами кода. Подчеркиваю, не позволят, а могут позволить. Это предмет исследования.
                                                        0
                                                        Но в паре...
                                                        предлагаю термин широкое программирование(wide programming), а вместе с ним еще парочку: идентификатор ситуации, событийный адрес, ассоциативный адрес
                                                          0
                                                          Уточню, что событие и ситуация это не одно и то же. Событие и состояние это триггер. Ситуация это условие — группа триггеров.
                                                            0
                                                            тогда:
                                                            событийный адрес — это дерево триггеров, приводящее к ситуации
                                                            идентификатор ситуации — множество условий, однозначно эту ситуацию идентифицирующее
                                                              0
                                                              Понятие «событийный адрес» не нужно.
                                                              Человек описывает системе ситуацию через набор триггеров:
                                                              1. Текущая секция змейки является головой
                                                              2. Направление движения змейки — вниз
                                                              3. Голова змейки находится в самой нижней клетке поля
                                                              Система сама ищет обработчик этой ситуации. Если его нет — создает.
                                                              Событие это один триггер, как и состояние это один триггер.
                                                              Ситуация (условие) это совокупность триггеров (и вложенных ситуаций). Т.е. ситуации (условия) иерархичны. Вложение одних условий в другие пока не реализовано, но оно необходимо.
                                                              Ситуация в понимании человека = условие в интерпретаторе.
                                                                0
                                                                Понятие «событийный адрес» не нужно.
                                                                это пока вы не добавите к валентостям «зачем?» :)

                                                                пример событийного адреса: «победа в шахматы»
                                                            0
                                                            предлагаю термин широкое программирование(wide programming)
                                                            я бы сказал (и в шутку и в серьез) что это естественное программирование, поскольку естественный язык (ну хорошо, близкий к нему, пока что) это естественно для человека. А объяснение поведения через описание ситуции, в которой это поведение применимо, естественно для человека не менее, чем естественный язык, на котором оно объясняется.
                                                              0
                                                              Не столь отдаленное будущее: искусственное программирование — программа объясняет поведение через ситуации :)
                                                          0
                                                          Внос изменений будет таким же сложным, как обычное программирование. Сначала человек месяцы это читает и отмечает, где что расписано.
                                                          Как раз делается попытка ухода от этого. В коде не нужно будет разбираться. Человек работает с одной, конкретной ситуацией, поведение, при возникновении которой, он хотел бы изменить.
                                                            0
                                                            Человек работает с одной, конкретной ситуацией, поведение, при возникновении которой, он хотел бы изменить.

                                                            Угу. А как определить, какая ситуация ему нужна? Что важнее — как определить, что изменится, когда он внесет свои изменения?
                                                              0
                                                              Угу. А как определить, какая ситуация ему нужна?
                                                              Процитирую то, что уже писал выше, может быть на этот раз вы прочтете все.
                                                              «Это тема для отдельной статьи, пожалуй. Но если кратко, то у триггеров, из которых состоят условия будут символические имена, даже не имена, а конструкции, выражаемые предложением. Поиск процедуры, код которой нужно править будет выполнятся ассоциативно, на основе набора символических имен.
                                                              Например, мы хотим запросить (и изменить ее код) у системы процедуру, которая вызывается в ситуции (из примера на видео), когда (в этой ситуации нужно будет изменить направление движения змейки):
                                                              1. Текущая секция змейки является головой
                                                              2. Направление движения змейки — вниз
                                                              3. Голова змейки находится в самой нижней клетке поля
                                                              Можно описать эти символические имена на языке с валентностями и передать системе, на что она должна ассоциативно найти процедуру и вернуть ее текст для правки. Если процедура для такой ситуации не предусмотрена, она будет создана, попутно будут созданы необходимые условия. Это может позволить автоматически давать имена (технические) переменным в коде, триггерам, условиям, процедурам. Т.е. человек возможно не будет оперировать объектами кода в привычном понимании. Отвечать на вопросы я пока не готов. Реализация этого всего дело не близкого будущего, да и к текущей теме не относится.»

                                                              Что важнее — как определить, что изменится, когда он внесет свои изменения?
                                                              Всякое изменение само стремится себя проявить, вам ли, как разработчику, этого и не знать.
                                                                +1
                                                                Например, мы хотим запросить (и изменить ее код) у системы процедуру, которая вызывается в ситуции

                                                                Но откуда мы возьмем набор входных условий?

                                                                Есть и более занятный вопрос: предположим, в системе уже определена реакция на состояние «направление движения — вниз». Теперь мы хотим определить реакцию на состояние «направление движения — вниз, и позиция в нижнем ряду». Как эти две реакции будут друг с другом соотноситься?

                                                                Всякое изменение само стремится себя проявить, вам ли, как разработчику, этого и не знать.

                                                                Вот как раз как разработчик я очень хорошо знаю, что в любой сколь-либо сложной системе изменение может проявиться не сразу, и неочевидным образом. Иными словами, чем сложнее система, тем, при прочих равных, вероятнее в ней эффект бабочки.
                                                                  0
                                                                  Но откуда мы возьмем набор входных условий?
                                                                  Для этого и нужен естественный язык. Набор входных условий описывает на нем человек:
                                                                  1. Текущая секция змейки является головой
                                                                  2. Направление движения змейки — вниз
                                                                  3. Голова змейки находится в самой нижней клетке поля
                                                                  После чего он указывает набор инструкций для выполнения в этой ситуации.

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

                                                                  Вы сейчас говорите о программировании в классическом понимании, когда тестировщик понятия не имеет, что вы исправили в коде, а если и имеет, то поверхностное.
                                                                  А давайте отойдем от модели обучения с учителем и предположим, что все программы будут создаваться на основе ситуационного подхода. Вы, как программист, изменивший набор ситуаций (условий) можете предоставить список этих условий тестировщику. Если он все их протестирует, то откуда возникнет эффект бабочки?
                                                                  Хотя, в некоторой степени вы конечно правы, и ошибка может возникнуть всегда, но ситуационный подход сильно уменьшает ее возникновение, это же очевидно.
                                                                    0
                                                                    Для этого и нужен естественный язык. Набор входных условий описывает на нем человек:
                                                                    1. Текущая секция змейки является головой
                                                                    2. Направление движения змейки — вниз
                                                                    3. Голова змейки находится в самой нижней клетке поля

                                                                    А откуда он их возьмет?

                                                                    Если он все их протестирует, то откуда возникнет эффект бабочки?

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

                                                                    Более того, внесенное вами поведение может провоцировать новые ситуации и новые реакции, и как это протестировать?

                                                                    Вы совершенно зря проигнорировали мой пример с пересекающимися условиями.
                                                                      0
                                                                      А откуда он их возьмет?
                                                                      Из головы.

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

                                                                      Более того, внесенное вами поведение может провоцировать новые ситуации и новые реакции, и как это протестировать?
                                                                      Это только в классическом программировании. В ситуационном, если разработчик добавил новую ситуацию, она должна попадать в документацию и полноценно тестироваться.
                                                                      Вы совершенно зря проигнорировали мой пример с пересекающимися условиями.
                                                                      Возможно случайно, как ситуации могут пересекаться?
                                                                        0
                                                                        Из головы.

                                                                        Угу. В этом и будет основная сложность.

                                                                        Конечно для всех. А что неполное тестирование когда-то красило тестировщика?

                                                                        Проблема в том, что вы усложняете его работу.

                                                                        За одну итерацию исправления он врядли будет большим.

                                                                        Вы не можете это предсказать.

                                                                        В ситуационном, если разработчик добавил новую ситуацию, она должна попадать в документацию и полноценно тестироваться.

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

                                                                        Возможно случайно, как ситуации могут пересекаться?

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

                                                                          «предположим, в системе уже определена реакция на состояние «направление движения — вниз». Теперь мы хотим определить реакцию на состояние «направление движения — вниз, и позиция в нижнем ряду». Как эти две реакции будут друг с другом соотноситься
                                                                          Вопрос хороший. В данном случае нужно будет править одновременно 2 обработчика. Вернее перенести часть из первого во второй. Надо будет думать, как это автоматизировать. Пока еще рано. Возможно, что автоматизировать не получиться.
                                                                          Но
                                                                          «направление движения — вниз» — это один триггер
                                                                          «направление движения — вниз, и позиция в нижнем ряду» — это условие (ситуация), состоящее из двух триггеров
                                                                          Обработчики у них разные.
                                                                            +1
                                                                            Могу, аналитик передает вполне конкретный и ограниченный перечень доработок программисту. Он в свою очередь тестировщику.

                                                                            Вот тут ваша фундаментальная ошибка.

                                                                            Аналитик сказал «надо добавить обработчик вот такой ситуации». Программист сказал «ок» и добавил. Тестировщик пошел и проверил добавленный обработчик. Откуда все они узнают про то, что на одном из условий в этой ситуации висел другой обработчик, который при специфическом сочетании условий даст побочный эффект?

                                                                            Регламентом.

                                                                            Извините, но в «традиционном» программировании это тоже все можно сделать регламентом. Только не работает регламент. Никогда.

                                                                            А про побочные эффеты мне не известно.

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

                                                                            В данном случае нужно будет править одновременно 2 обработчика. Вернее перенести часть из первого во второй.

                                                                            Откуда вы это знаете?

                                                                            Надо будет думать, как это автоматизировать. Пока еще рано. Возможно, что автоматизировать не получиться.

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

                                                                            Обработчики у них разные.

                                                                            Да понятно, что разные, но вызывается ли первый, когда вызывается второй?
                                                                              0
                                                                              который при специфическом сочетании условий даст побочный эффект?
                                                                              Такого быть не должно. Обработчики не пересекаются.

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

                                                                              Откуда вы это знаете?
                                                                              Потому что сталкивался уже с этим.

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

                                                                              Да понятно, что разные, но вызывается ли первый, когда вызывается второй?
                                                                              Если понятно, то это странный вопрос.

                                                                                0
                                                                                Такого быть не должно. Обработчики не пересекаются.

                                                                                Во-первых, пересекаются, мы это выяснили. Во-вторых, как в таком случае обработать вот такой банальный набор требований:

                                                                                (1) при каждом списании 100 рублей со счета, на связанный счет должен начисляться 1 рубль (бонусная система)
                                                                                (2) раз в месяц со счета должны списываться 1000 рублей (регулярный платеж)

                                                                                Такие комментарии отбивают охоту отвечать. Вы же понимаете, что то, чего нет, может появится.

                                                                                Я не просто понимаю, что оно может появиться, я говорю, что оно обязательно появится. И сразу возникает вопрос, как вы будете бороться с возрастанием сложности в таком случае.

                                                                                Потому что сталкивался уже с этим.

                                                                                И уже успели обобщить свой опыт на все возможные ситуации?

                                                                                Возможно. Но это все равно гораздо легче, чем править линейную простыню.

                                                                                О какой «линейной простыне» вы говорите?

                                                                                Если понятно, то это странный вопрос.

                                                                                Обработчики — разные, но их условия совпадают. По логике, должны вызываться оба. Это так, или нет?

                                                                                  0
                                                                                  Во-первых, пересекаются, мы это выяснили.
                                                                                  Когда выяснили? Они могут пересекаться только если создается новое условие.

                                                                                  (1) при каждом списании 100 рублей со счета, на связанный счет должен начисляться 1 рубль (бонусная система)
                                                                                  (2) раз в месяц со счета должны списываться 1000 рублей (регулярный платеж)
                                                                                  Это отдельная подпрограмма, соизмеримая со змейкой. Но она реализуема.

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

                                                                                  И уже успели обобщить свой опыт на все возможные ситуации
                                                                                  Да, пока не появились ситуации не вписывающиеся в опыт.

                                                                                  О какой «линейной простыне» вы говорите?
                                                                                  Об классическом программирование: if, for, while…

                                                                                  Обработчики — разные, но их условия совпадают. По логике, должны вызываться оба. Это так, или нет?
                                                                                  Не может быть так. У каждого условия (ситуации) свой обработчик.
                                                                                    0
                                                                                    Когда выяснили? Они могут пересекаться только если создается новое условие.

                                                                                    Могут же, этого достаточно.

                                                                                    Это отдельная подпрограмма, соизмеримая со змейкой. Но она реализуема.

                                                                                    Это же два разных условия, правильно? И два разных обработчика, так?

                                                                                    Об классическом программирование: if, for, while…

                                                                                    Знаете, структурное программирование — которое избавляет от линейных простыней — давно придумали.

                                                                                    Не может быть так. У каждого условия (ситуации) свой обработчик.

                                                                                    Во-первых, тезис «у каждой ситуации свой обработчик» не запрещает иметь два обработчика на одну ситуацию. Во-вторых, если вы введете ограничение «на одну ситуацию один обработчик», вы резко уменьшите поддерживаемость системы (потому что бывают независимые обработчики).

                                                                                    Наконец, в-третьих, я говорил об обработчиках, условия которых совпадают, но не идентичны. Пример был выше: условиями одной ситуации является «движение вниз», условиями другой — «движение вниз и позиция в нижнем краю». Это же два разных обработчика?
                                                                                      0
                                                                                      Могут же, этого достаточно.
                                                                                      Не могут. Под пересечением я имел в виду не одновременный вызов, а то, что часть кода из одного может мигрировать в другой (новый). Это же разные вещи.

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

                                                                                      Знаете, структурное программирование — которое избавляет от линейных простыней — давно придумали.
                                                                                      Структурное программирование призвано уменьшить код блока (процедуры/функции).
                                                                                      Ситуационное программирование призвано свести код блока к 1-2 строкам.

                                                                                      Во-первых, тезис «у каждой ситуации свой обработчик» не запрещает иметь два обработчика на одну ситуацию.
                                                                                      Да как же у одной ситуации может быть больше одного обработчика??

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

                                                                                      Наконец, в-третьих, я говорил об обработчиках, условия которых совпадают, но не идентичны. Пример был выше: условиями одной ситуации является «движение вниз», условиями другой — «движение вниз и позиция в нижнем краю». Это же два разных обработчика?
                                                                                      Ну конечно. Первое это триггер, у него свой обработчик. Второе это условие из двух триггеров, у этого условия свой обработчик.
                                                                                        0
                                                                                        Боюсь там будет побольше двух условий (и обработчиков). Было бы
                                                                                        так просто я бы сразу код написал. Но то, что они разные это точно.

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

                                                                                        Ситуационное программирование призвано свести код блока к 1-2 строкам.

                                                                                        Что такого предлагает ситуационное программирование, что позволяет радикально уменьшить размер (семантически эквивалентного) блока кода?

                                                                                        Да как же у одной ситуации может быть больше одного обработчика?

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

                                                                                        Это два независимых правила, реализующих различные бизнес-задачи. Как следствие, SRP говорит нам, что они должны быть в разных обработчиках.

                                                                                        Ничего не понял.

                                                                                        Пример выше.

                                                                                        Ну конечно. Первое это триггер, у него свой обработчик. Второе это условие из двух триггеров, у этого условия свой обработчик.

                                                                                        Так вот, когда состояние системы удовлетворяет условиям «движение вниз и позиция в нижнем краю» — вызываются оба обработчика, или только один?

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

                                                                                          Что такого предлагает ситуационное программирование, что позволяет радикально уменьшить размер (семантически эквивалентного) блока кода?
                                                                                          Я не про семантически эквивалентный блок, а про процедуру (функцию), как блок. Правда в СП количество процедур действительно будет больше.

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

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

                                                                                          Так вот, когда состояние системы удовлетворяет условиям «движение вниз и позиция в нижнем краю» — вызываются оба обработчика, или только один?
                                                                                          Могут и два, если у них нет общих переменных, то могу вызваться параллельно, если есть, то друг за другом. Но код в каждом из них будет разный, каждый для своего случая. Это видно на реальном примере. У меня сложностей с пониманием что куда нужно распихивать не возникало ни разу. Но не стану утверждать, что и не возникнет.
                                                                                            0
                                                                                            Похоже, что так.

                                                                                            Вот вы и получили побочный эффект в обработчике.

                                                                                            Я не про семантически эквивалентный блок, а про процедуру (функцию), как блок.

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

                                                                                            Это два алгоритма, которые будут реализованы в разных подпрограммах, но вызваны в рамках одного обработчика, который вызывается для ситуации «Транзакция по счету завершилась».

                                                                                            Во-первых, что за понятие «подпрограмма», откуда оно внезапно взялось, вы же вроде говорили, что оператор не использует объекты из кода?
                                                                                            Во-вторых, если это будет один обработчик, то вы нарушаете SRP.

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

                                                                                            Собственно, и чем это отличается от «традиционного» программирования?

                                                                                            Могут и два, если у них нет общих переменных, то могу вызваться параллельно, если есть, то друг за другом.

                                                                                            Если два обработчика, то вы снова можете получить непредвиденные побочные эффекты.

                                                                                            У меня сложностей с пониманием что куда нужно распихивать не возникало ни разу.

                                                                                            На задачах какой сложности? На змейке? Попробуйте сделать все то же самое, только с дюжиной змеек с разным поведением и общими вещами типа «пока едет вниз, раскрашена в синий».
                                                              +1
                                                              Человек работает с одной, конкретной ситуацией

                                                              При программировании человек описывает реакции на входные данные, а не на ситуацию (поскольку все ситуации уникальные и все их просто невозможно перечислить). Конкретная ситуация складывается из множества входных посылок и суть программирования — на основании входов идентифицировать ситуацию и выбрать поведение. Если логические правила для этого предоставляет программист, то мы не уходим от сложности, а с ней и непредвиденных программистом ситуаций, ошибок, глюков. Когда правила формулирует система в результате диалога с человеком, это какая-то далёкая фантастика, в стиле «ты тут сам подумай, разберись и сделай, чтобы все мои пожелания были учтены».
                                                                0
                                                                При программировании человек описывает реакции на входные данные, а не на ситуацию
                                                                Это при классическом программировании, не при ситуационном (естественном для человека).
                                                                поскольку все ситуации уникальные и все их просто невозможно перечислить
                                                                В программе программист пытается описать все ситуации, иначе кому нужна программа, которая не обрабатывает часть из возможных ситуаций. Обычно в таких неописанных ситуациях программа ведет себя непредсказуемо или вообще падает в дапм (корку). Разве это хорошо?
                                                                Число ситуаций всегда конечно. Особенно, если вести модульность ситуаций. Разбивать их на уровни абстракции.
                                                                Когда правила формулирует система в результате диалога с человеком, это какая-то далёкая фантастика, в стиле «ты тут сам подумай, разберись и сделай, чтобы все мои пожелания были учтены».
                                                                Ничто не заставляет задуматься об этом уже сейчас, хотя описанные подходы строго говоря совсем о другом.
                                                                  0
                                                                  В программе программист пытается описать все ситуации

                                                                  Не в программе, а у себя в голове. В программу попадает алгоритм реакции на события, а не описание ситуаций.
                                                                    0
                                                                    Совершенно верно, программист транслирует естественное (для человека) описание ситуаций в неестественное — многоуровневое вложение условий. Это и отличает программиста от человека. Хотя отличие не только в этом. Отличие еще в том, что программист способен удерживать внимание на большем количестве объектов, чем непрограммист. Я решил задачу Эйнштейна за 40 минут, без ручки и бумаги, только в уме, не читая алгоритм нахождения ответа, и про сам ответ. Считаю, что на это способен любой программист с опытом. Чего не скажешь про непрограммистов.
                                                                      0
                                                                      Я же хочу решить проблему программирования без необходимости одновременно оперировать десятком уровней вложенности условий и десятками переменных.
                                                                        +1
                                                                        Да, вы превращаете два уровня вложенности условий в соответствующее количество плоских условий, тем самым увеличивая их число. При этом вы забываете тот занимательный факт, что количество объектов одного уровня, воспринимаемых человеком, ограниченно, а иерархия как раз позволяет снять эту проблему.
                                                                          0
                                                                          Да, вы превращаете два уровня вложенности условий в соответствующее количество плоских условий,
                                                                          тем самым увеличивая их число
                                                                          Эм…
                                                                            0
                                                                            А что «эм»?

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

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

                                                                              Это неправда. Человеческий мозг прекрасно структурирует информацию — именно для того, чтобы бороться со сложностью, — и иерархия один из способов такого структурирования.

                                                                              Банальный пример (из тех же правил): "(в некоторый момент игры) вы взяли карту. Если это карта типа а, то. Если эта карта типа б, то." Мы сначала ограничили область видимости («в некоторый момент игры вы взяли карту»), а только потом разбираем ее тип. Вот и иерархия.

                                                                              Объектами кода человек вообще не будет оперировать.

                                                                              А объекты кода тут ни при чем, мы обсуждаем условия и реакции.
                                                                                0
                                                                                Это неправда. Человеческий мозг прекрасно структурирует информацию — именно для того, чтобы бороться со сложностью, — и иерархия один из способов такого структурирования.
                                                                                Согласен

                                                                                Банальный пример (из тех же правил): "(в некоторый момент игры) вы взяли карту. Если это карта типа а, то. Если эта карта типа б, то." Мы сначала ограничили область видимости («в некоторый момент игры вы взяли карту»), а только потом разбираем ее тип. Вот и иерархия.
                                                                                Но это можно представить и как линейный список:
                                                                                Идет игра X
                                                                                Игрок Y взял карту Z
                                                                                Выбранная карта это А
                                                                                (Перечень инструкций)

                                                                                Идет игра X
                                                                                Игрок Y взял карту Z
                                                                                Выбранная карта это В
                                                                                (Перечень инструкций)

                                                                                Но замечание дельное, надо будет об этом думать, но точно не сейчас.
                                                                                  0
                                                                                  Но это можно представить и как линейный список:

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

                                                                                          А теперь посмотрим: вот мы представили первую взятую карту хода как контекст, и расписываем возможные условия: карта А, карта Б, карта Ц… чем это отличается от традиционной процедуры с переключателем по типам карт?
                                                                      0
                                                                      Это при классическом программировании, не при ситуационном (естественном для человека).

                                                                      А почему вы считаете, что ситуационное программирование естественно для человека? В прошлой дискуссии вы так и не смогли это утверждение как-то подтвердить.
                                                                        0
                                                                        Конечно не смог, это либо понимаешь, либо нет. Для меня это очевидно. Но для прожженного программиста это может быть и неочевидно. Он же уже не может перестроиться в нормального человека с природным мышлением.
                                                                          0
                                                                          Если вы не можете объяснить то, что вам очевидно, может, оно не так и очевидно?

                                                                          А чтобы избавиться от аргументов ad hominem — которые вас не красят — просто возьмите десяток правил настольных игр, написанных далеко не программистами, и обратите внимание, что они вполне укладываются во flowchart. Более того, именно flowchart — это одна из первых записей, к которым приходят люди, когда пытаются объяснить друг другу какой-то сложный процесс.