72945-1 (Разум-ориентированное программирование)

Разум-ориентированное программирование

Дмитрий Сахань

Не кажется ли вам, что нынче программирование интеллекта уперлось в непреодолимую стену? Тогда давайте для начала порассуждаем об эволюции самого программирования. На заре развития (история гораздо глубже, но мы начнем от первых Бейсиков) программирование ограничивалось простым командным программированием. Не было понятия процедур и функций, были только переменные и операторы, то бишь команды. Код программы выглядел в виде пронумерованного списка инструкций. Единственной на тот момент командой перехода между строками исходного кода был оператор GOTO. Безусловно, очень скоро возможности командного программирования исчерпались, нужно было расширить его рамки.

Первой ласточкой процедурного программирования явился оператор GOSUB – вызов подпрограммы. Но это еще не было процедурное программирование в чистом виде. Был лишь факт, что шаг сделан в правильном направлении. Через короткое время идея вызова подпрограмм оформилась в вызовы функций и процедур, а программирование стало называться процедурным. Основная фишка такого подхода заключалась в том, что процедуры и функции могли принимать большое количество входных параметров, то есть код процедур уже не обязательно должен был привязываться к именам глобальных переменных. Вместе с этим родилось понятие глобальных и локальных (доступных только внутри процедуры) переменных. Кроме того функции могли возвращать результат выполнения в вызвавшую их точку исходного кода. В свою очередь это привело к возможности рекурсивного программирования (когда функция вызывает саму себя N раз, анализируя свой же возвращаемый результат), которое по сути дела является стилем процедурного программирования, а не отдельным программированием. Еще с появлением процедурного программирования отпала необходимость нумерации строк программы, так как функции и процедуры имели свои имена и могли свободно располагаться в любом месте кода (нумерация же строк привязывает фрагмент кода к определенному местоположению в исходном коде).

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

AgeData = record // объявление структуры (AgeData)

Birth: String //

Dead: String //

end

Worker = record // объявление следующей структуры (Worker)

Name: String //

Age: AgeData // в ней находится вложенная структура типа AgeData

Address: String //

Remark: String //

end

var

A: Worker // объявление переменной со структурой типа Worker

begin

A.Name = "Петя Иванов" // доступ к нужному полю через символ точки

A.Age.Birth = "01 января 2000" // доступ к нужному полю через символ точки

print(A.Name) // доступ к нужному полю через символ точки

end

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

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

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

Worker = class // объявление класса (Worker)

Name: String // поле (переменная) внутри класса

Birth: String // поле (переменная) внутри класса

Age: String // поле (переменная) внутри класса

//

procedure Create // процедура (метод) внутри класса

procedure ComputeAge // процедура (метод) внутри класса

procedure Destroy // процедура (метод) внутри класса

end

var

A: Worker // объявление объекта класса Worker

begin

A.Create // выполнить Create – это метод объекта

A.Name = "Петя Иванов"

A.Birth = "01 января 2000"

A.ComputeAge // вызывается еще один метод объекта

print(A.Name)

end

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

Методы как классы методов

В настоящее время программирование остановилось на ООП, но все явнее чувствуется следующий барьер. По истории программирования можно было заметить, как переменные превратились в структуры, а те в свою очередь в объекты. Долгое время объекты удовлетворяли программистов, пока дело не дошло до разумных (с точки зрения разума вообще) действий. Вроде бы в объектах больше ничего не придумаешь, и все же что-то должно измениться. Сейчас тяжело представить, какой вид примут "разумные" объекты. Большую проблему представляет самостоятельная перестройка работы объекта. Здесь обычными свойствами и методами проблему не решить. Дело в том, что разумный организм умеет адаптироваться к окружающим условиям, то есть менять алгоритмы своего функционирования. Еще сложнее, что методы "разумного" объекта вообще могут не задаваться явно в момент создания объекта, они могут быть "сконструированы" объектом потом в результате его опыта. Естественно, должны быть какие-то базовые методы, из которых в дальнейшем собирается удовлетворяющая конструкция-метод.

Большое значение имеет соотнесение метода с самостоятельным классом. То есть класс методов, а не класс объектов. Тут немного другое понятие, и пока слишком призрачно представляется, как должен выглядеть класс методов. В качестве примера можно привести класс методов поиска разумного организма. Когда, например, человеку говорят: "Найди что-то там-то", фактически, называют класс методов, который просят привлечь для выполнения требуемого действия, но не указывают, как конкретно выполнять метод. Даже можно сказать, что под методом "Найди" подразумевают набор схожих алгоритмов, и разумный организм уже сам решит, какой же из алгоритмов выбрать в данном случае. Такой себе метод-массив, где под одним и тем же именем скрывается сразу несколько алгоритмов. Словосочетание "метод-массив" условно и всего лишь служит для образного представления многомерности одного метода. Также класс методов может включать в себя другие классы методов.

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

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

Попробую объяснить взаимодействие классов методов на наглядном примере. Допустим, у нас есть некоторый объект "А". Пусть объект находится в двумерной плоскости, разделенной на клетки. Одна из клеток помечена красным цветом. Объект видит клетки (вдоль линии взгляда) только перед собой. Объект может поворачиваться на 90, 180 и 270 градусов вправо или влево. Объект может шагать на одну клетку вперед. Задача объекта "А": найти красную клетку, чтобы она оказалась в любой клетке прямо перед ним.