| Статья опубликована в "Системы и средства информатики. -М.: Наука, вып. 3., 1993 г." |
| HTML вариант за декабрь 2000. |
Сложность разработки программного обеспечения (ПО) выдвигает задачу экономии человеческих ресурсов, затрачиваемых на этот процесс. Интеллектуализация всех видов деятельности человека, связанных с вычислительной техникой - универсальный ключ к решению этой задачи. В данной статье излагается подход к интеллектуализации трех аспектов взаимодействия человека с ЭВМ: языка, интерфейса и технологии разработки программ. Подход основан на привлечении объектно-ориентированной модели реального мира в процесс программирования.
В традиционном промышленном подходе к разработке ПО отправной точкой служат требования заказчика (пользователя). Процесс разработки разбивается на последовательные этапы: анализ, проектирование, программирование, документирование, тестирование, сопровождение. Этапы выполняются отдельными людьми или коллективами в соответствии с четко определенными интерфейсам между этапами. Такой подход позволяет упростить работу на каждом этапе, ввести некоторую параллельность их выполнения, и за счет этого повысить эффективность разработки и качество готового программного продукта.
Существенным недостатком традиционного подхода является отсутствие гибкости: решения, принятые на ранних этапах, не могут быть изменены без значительных затрат временных и человеческих ресурсов и понижения качества окончательного продукта. Тот же недостаток проявляется и при попытке внести изменения в отдельную часть сложной программы - как правило, приходится вносить изменения и в другие части.
Рассмотрим этап проектирования сложной программной системы. Применяемые здесь методы декомпозиции системы на модули навязываются характером используемых на следующем этапе средств и методов программирования на базе традиционных языков типа Фортран, Паскаль, Си. А те, в свою очередь, носят отпечаток фон-Неймановской архитектуры ЭВМ.
Типичная статическая структура системы включает главный модуль с общими глобальными данными и ряд подчиненных ему, но относительно независимых друг от друга, модулей с локальными данными. Динамическая структура состоит из последовательности вызовов главным модулем подчиненных модулей. Некоторые дополнительные средства структуризации, такие, как рекурсия, итерация, блочная структура, принципиально не меняют представленную здесь схему декомпозиции.
Очевидно, что изменение структуры системы, например, в результате обнаружения ошибки в логике взаимосвязей между модулями, влечет за собой перепрограммирование затронутых модулей, повторное тестирование и отладку. Это может внести ошибки в реализацию других модулей, связанных с первыми через глобальные данные, и привести к необходимости нового пересмотра общей структуры системы. Причем каждая итерация в цикле жизни программной системы обходится дорого, особенно в тех случаях, когда разные этапы выполнются разными людьми.
Конечный пользователь разрабатываемого ПО, его заказчик, напрямую заинтересован в более гибком подходе. Требования к системе могут измениться по многим причинам: накопленному опыту работы с ней, изменением конфигурации аппаратных средств, переносом на другую ЭВМ. Таким образом, нужен подход, позволяющий осуществить быструю перенастройку системы производства ПО, иными словами, создание нечто вроде гибкого автоматизированного производства (ГАП) ПО.
Объектно-ориентированный подход к программированию состоит в повышении степени интеллектуальности методов и средств общения пользователя с ЭВМ за счет наделения их свойствами, присущими человеческому общению, поведению человека в реальном мире.
Объектно-ориентированнную модель реального мира можно представить в следующим образом. Реальный мир "заселен" объектами. Объект обладает свойствами, поведением, текущим состоянием. Между объектами существуют отношения, например, объекты с одинаковыми свойствами и поведением относятся к одному классу. Объекты одного класса могут иметь частично одинаковые свойства с объектами другого класса, наследуя эти свойства от него. Это соответствует статической структуре модели, причем она существенно богаче структуры типа "главный-подчиненные" и имеет древовидный или в общем случае сетевой тип.
Объекты взаимодействуют друг с другом путем передачи информации от одного объекта другому. Информация передается путем посылки сообщения. Объект, принимающий сообщение, реагирует на него особым, только ему известным образом. При этом он может послать сообщения другим объектам, получить от них ответы, изменить свое состояние и, наконец, вернуть ответ тому объекту, который послал ему сообщение. Объекты могут "порождаться" и "умирать". Важно здесь то, что действуют объекты, как правило, параллельно (одновременно). Это соответствует динамической структуре модели и она также значительно богаче традиционной последовательной структуры.
Впервые идеи об объектно-ориентированном подходе были воплощены в языке программирования Симула еще в середине 60-х годов [1], где были введены понятия:
В аппаратуре понятие объекта, как защищенной области памяти, содержащей взаимосвязанные команды и данные, было реализовано в известном 32-разрядном микропроцессоре iAPX-432 фирмы Интел [2].
Однако первой системой, полностью основанной на объектно-ориентированном подходе, считается система программирования Смолток [3].
Система Смолток, состоящая из интерпретатора объектно-ориентированного языка программирования высокого уровня и интерактивного графического пользовательского интерфейса (среды программирования), разрабатывается начиная с 1970 г. фирмой Ксерокс в исследовательском центре г. Пало-Альто (США). В настоящее время неофициальным стандартом является вариант языка и системы Смолток-80 [4,5].
Развитие объектно-ориентированных языков и систем идет по трем направлениям:
Это типичный процесс конкуренции эволюционного (1,2) и революционного (3) развития.
Хотя до сих пор нет точного критерия, по которому язык программирования мог быть отнесен к объектно-ориентированным, большинство исследователей выделяют следующие четыре необходимых свойства такого языка:
Скрытие реализации, по существу, означает тотальную, доведенную до высшей степени модульность, причем модулем может быть любой объект системы, от крупного компонента системы, например, компилятора, до обыкновенной числовой константы. Каждый такой модуль-объект имеет внешний интерфейс, известный за его пределами, и внутренюю реализацию, скрытую от других объектов.
Вид внешнего интерфейса и степень контроля за правильностью его использования зависит от языка. Впервые скрытие реализации было предложено в языке Модула и далее развито в языках Модула-2 и Ада. Здесь в качества внешнего интерфейса могут быть наборы взаимосвязанных данных и процедур, причем обеспечивается контроль за правильностью их совместного использования.
Скрытие реализации позволяет изменять отдельные модули, не затрагивая остальную часть системы, что облегчает внесение изменений и повышает надежность системы.
Абстрактные типы данных - средство, позволяющее с помощью встроенных в язык типов данных определять другие типы данных произвольной сложности, определять для них допустимые операции (процедуры, функции, декларации) и затем использовать новые типы по тем же правилам, что и обычные встроенные типы. В большинстве случаев абстрактные типы данных существенно опираются на скрытие реализации.
Впервые абстрактные типы данных были реализованы в языке Clu [6] в виде модулей, названных кластерами (отсюда и название языка). Дальнейшее развитие они получили в языках Ада и С++ [7].
Абстрактные типы данных дают возможность существенно повысить уровень языка, приблизив его к проблемной области, не выходя при этом за пределы синтаксиса и семантики языка.
Динамическое связывание означает, что значение любого имени в программе становится известно только в момент обращения к этому имени во время выполнения программы. Для данных это означает, что их адрес вычисляется во время обращения к ним по имени. Для процедур - вычисляется адрес машинной последовательности команд, которая будет выполнять данную процедуру.
В большинстве языков реализовано статическое связывание имени со значением - во время компиляции программы. Динамическое связывание чаще всего предполагает реализацию языкового процессора методом интерпретации. Впервые динамическое связывание в полной мере было реализовано в языке Лисп. Дальнейшее развитие этот метод получил в языках Форт, Лого, Пролог.
Преимущество динамического связывания состоит в наиболее полной реализации принципов скрытия реализации и гибкости, при котором изменение одного модуля не требует перекомпиляции взаимодействующих с ним модулей. Кроме того, уменьшается размер программы, поскольку нет необходимости в программировании условных операторов, контролирующих правильность соответствия типов во время выполнения программы. Очевидный недостаток - замедление скорости выполнения программы.
Наследование свойств позволяет строить новые объекты на базе существующих, указывая лишь, чем новые объекты отличаются от старых, т.е. либо добавляя новые свойства, либо переопределяя некоторые из старых свойств.
Впервые механизм наследования свойств был включен в язык Симула, дальнейшее развитие он получил в языках Ада, Objective C [8].
Наследование свойств позволяет сокращать размер программ за счет многократного использования частей различными объектами. Повышается также надежность и удобство внесения изменений в программы.
Рассмотрим характерные свойства объектно-ориентированных языков и систем программирования на примере системы Смолток-80.
Ключевым понятием языка и системы Смолток является объект. Объект - это унифицированное представление абстрактного понятия реального мира. Он характеризуется свойствами, поведением и состоянием. Для этого объект имеет собственную память, где хранится информация о свойствах и состоянии, и набор операций над элементами памяти, реализующий поведение объекта. На доступ к указанной информации и на выполнение операций имеет право только сам этот объект. Таким образом, здесь в полной мере воплощен принцип скрытия реализации.
Объекты взаимодействуют друг с другом путем посылки сообщений. Если один объект желает послать другому сообщение, он указывает имя объекта - приемника сообщения, затем имя сообщения и, наконец, аргументы сообщения. С каждым объектом связан набор (протокол) сообщений, которые он понимает. Это и есть внешний интерфейс объекта, через который он взаимодействует с другими объектами.
Всякому имени из протокола сообщений внутри объекта соответствует реализующая его процедура, называемая методом. Метод определяет реакцию объекта на данное сообщение, т.е. поведение объекта. Метод состоит из операций над элементами собственной памяти и, возможно, из посылок сообщений другим объектам. В конечном счете, объект возвращает ответ на посланное ему сообщение.
Объекты с одинаковыми свойствами и поведением группируются в классы. Класс тоже является объектом. Такое решение ведет к изящному общему принципу, согласно которому в системе нет ничего, кроме взаимодествующих объектов. Это удобно и с точки зрения реализации. Поскольку объекты одного класса имеют, во-первых, одинаковые свойства, а, следовательно, и одинаковую внутренную структуру и, во-вторых, один протокол сообщений, то объект-класс может содержать как шаблон со структурой свойств, так и весь набор методов.
Объект, принадлежащий некоторому классу, называется экземпляром этого класса. Чтобы создать новый экземпляр, классу посылается об этом сообщение. Класс создает экземпляр с присущей всем объектам этого класса структурой. Если нужно, инициализирует элементы этой структуры, и выдает созданный экземпляр в качестве ответа на сообщение. Элементы внутренней структуры экземпляра называются переменными экземпляра. Они-то и служат хранилищем информации о свойствах и состоянии объекта.
Очевидно, что понятие класса полностью включает в себя принцип абстрактных типов данных.
Классы в системе Смолток организованы иерархически в виде дерева. Каждый класс имеет одного предка, называемого его суперклассом. Класс может иметь несколько потомков, называемых его подклассами. Эта схема целиком реализует принцип наследования свойств и поведения. Всякий класс наследует переменные экземпляра и методы своего суперкласса. Кроме того, он может содержать новые переменные экземпляра и методы, может переопределять унаследованные.
При получении сообщения объект ищет в своем классе метод с именем, совпадающим с именем сообщения. Если такого метода нет, он ищется в списке методов суперкласса и так далее. Когда метод обнаружен, он выполняется. Если нигде, вплоть до корня дерева, метод не будет обнаружен, выдается ответ с сообщением об ошибке.
Из сказанного следует, что поиск метода с заданным именем и соответствующих переменных экземпляра происходит во время выполнения программы, следовательно в системе принято динамическое связываение имени со значением.
Таким образом, в языке Смолток воплощены все четыре основных принципа объектно-ориентированного программирования: скрытие реализации, абстрактные типы данных, динамическое связывание и наследование.
Синтаксис языка чрезвычайно прост. В его основе лежит правило записи посылки сообщения, которое выражается следующим образом:
_объектПриемникСообщения имяСообщения аргументы
Отправителем сообщения является тот объект, который в своем методе вычисляет вышеуказанное выражение. Метод составляется из таких выражений, разделенных точкой. Выражения могут включать несколько посылок сообщений благодаря рекурсивному правилу, согласно которому приемником и аргументом может быть любое выражение. Перед выражением, возвращающим ответ на сообщение, ставится символ стрелка вверх.
Указанный простой синтаксис распространяется на любые выражения, например:
a - 3.
"объекту a послать сообщение
с именем - и аргументом 3"
таблица вПозиции: 5 поместить: 2.7
"в пятый элемент массива таблица
записать число 2.7"
Второй пример здесь показывает применение составного имени сообщения вПозиции:поместить: с аргументами 5 и 2.7.
Поскольку объекты языка не имеют фиксированных типов, то описание классов сводится к простому перечислению используемых переменных и определению методов.
Помимо четырех основных принципов объектно-ориентированного программирования, необходимо указать еще на некоторые, с нашей точки зрения важные принципы Смолтока, имеющие перспективу для развития подобных языков и систем.
Прежде всего, это полиморфизм. Когда одно и то же сообщение посылается разным объектам или одному объекту в разное время, то реагировать на него они будут, вообще говоря, по-разному, поскольку поиск метода реализации сообщения, во-первых, выполняется самим объектом, и, во-вторых, идет во время выполнения программы. Полиморфизм, следовательно, обеспечивается сочетанием принципов скрытия реализации и динамического связывания.
Пусть нужно, например, напечатать содержимое массива, элементами которого могут быть данные различных типов. Очевидно, что процедуры печати для них будут разные. В системе, не поддерживающей полиморфизм, имена процедур должны быть разные и выбор правильной процедуры для каждого элемента массива должен сопровождаться условным оператором (или оператором выбора), проверяющим тип элемента. В системе с полиморфизмом достаточно в цикле послать очередному элементу массива одно и то же сообщение о печати, а нужную процедуру печати (метод) он найдет в своем классе.
Использование полиморфизма делает программы более краткими и емкими.
Другой важный дополнительный принцип объектно-ориентированного программирования - единая трактовка данных и процедур. И те и другие считаются объектами, которым отправляются сообщения и которые сами могут быть переданы в качестве аргументов сообщения. Чтобы прибавить к целочисленному объекту А двойку, ему посылается сообщение с именем + и аргументом 2. Чтобы выполнить блок, заключающий в себе заданную последовательность действий, ему посылается об этом фиксированное в языке сообщение. С другой стороны, сам блок можно послать в качестве аргумента сообщения булевскому выражению, и мы получим модель условного оператора.
Единая трактовка данных и процедур, как объектов, упрощает синтаксис языка и делает программы более наглядными.
Наконец, еще один важный принцип, применяемый в объектно-ориентированных системах, - автоматическая сборка мусора. Согласно этому принципу, программист явно только "порождает" объекты, но никогда не заботится об их уничтожении. Это существенно повышает надежность программ и эффективность использования памяти, поскольку исключает слишком раннее и слишком позднее "убивание" объектов.
Объектно-ориентированная среда Смолток является интегрированной средой программирования, то есть взаимосвязанной совокупностью средств разработки программ с единым пользовательским интерфейсом, общей базой данных и отсутствием понятия "режима". Последнее означает, что вызов любого средства не регламентируется предысторией вызовов других средств, а зависит только от текущего состояния среды, точно отражаемого на экране дисплея.
Среда Смолток состоит из стандартного, встроенного в систему набора классов, представляющих пользователю общепринятые средства программирования: основные структуры данных и структуры управления, обработку текстов, численные методы, графику, многооконные средства, меню, управление файлами, управление процессами, средства компиляции и отладки. Из приведенного списка видно, что в среде нет разделения компонентов на прикладные и системные - все предоставляется в распоряжение пользователя.
Стандартная среда может расширяться пользователем в сторону любой выбранной им предметной области. Расширение выполняется точно так же, как и разработка самой среды, а именно: путем последовательного создания новых классов - подклассов существующего набора встроенных классов. Для этой цели имеются так называемые "окна просмотра иерархии классов", позволяющие изучать дерево классов системы, менять классы и отдельные методы, заводить новые классы. Такой способ изменения среды, по-существу, является необычным по сравнению с традиционными стилем программирования в системе Смолток.
В основу интерфейса с пользователем положены средства, впервые предложенные именно авторами системы Смолток, и теперь ставшие обязательной принадлежностью большинства развитых интегрированных сред программирования. Здесь имеется в виду система перекрывающихся окон на экране дисплея, иерархическое выставление меню и указатель курсора типа мышь. Рассмотрим кратко эти три средства.
Экран дисплея разбивается на прямоугольники, называемые окнами. Окна имеют произвольные размеры и местоположение на экране, что напоминает разложенные и частично перекрывающиеся листы бумаги на столе. С каждым окном связан некоторый процесс, представляющий отдельную работу пользователя. Одно, самое верхнее окно является активным и в текущий момент времени пользователь работает именно в нем. Пользователь может менять размеры окна, и если информация не помещается в нем, ее можно сдвигать вверх и вниз, вправо и влево, просматривая, таким образом, все интересующие части. Окна могут быть различных типов: текстовые, списковые, для просмотра классов и др. Сложные типы окон могут разбиваться на рамки.
Переключение окон выполняется мгновенно, одним нажатием клавиши или кнопки мыши.
Иерархическая система меню позволяет избавить пользователя от утомительного набора команд на клавиатуре. Исследования показали, что львиная доля работы на ЭВМ выполняется по установленным сценариям, поэтому вместо того, чтобы набирать однообразные последовательности команд типа "отредактировать - оттранслировать - скомпоновать - выполнить", лучше просто выбирать очередную команду из предложенного в меню набора команд.
С каждым типом окна или рамки связано свое меню. Нажатием одной клавиши это меню вызывается в удобное место окна на передний план, но так, чтобы не закрывать полностью основную информацию. Подогнав курсор на нужную функцию, пользователь нажимает клавишу выбора и функция выполняется, после чего меню исчезает. Некоторые функции меню требуют дополнительной информации и тогда появляется меню следующего уровня.
Устройство управления курсором типа мышь позволяет быстро перемещать курсор к нужному месту экрана, не отвлекая при этом внимания пользователя на клавиатуру. Наличие кнопок дает возможность выполнять управляющие действия.
Как и вся системная часть среды, интерфейс с пользователем реализован в виде встроенных классов и, в принципе, может быть изменен по желанию пользователя.
Язык реализации системы и входной язык программирования для пользователя один и тот же - Смолток. На нем написана вся машинно-независимая часть, составляющая около 85% всей системы. Машинно-зависимая часть ради эффективности должна быть реализована на более низком уровне, в том числе и микропрограммно. При переносе системы на другую машину эта часть переписывается полностью.
Указанные две части системы получили название виртуального образа и виртуальной машины.
Виртуальный образ представляет собой откомпилированный образ написанной на Смолтоке части системы. Это встроенный набор классов и методов, за исключением так называемых примитивных методов, реализующих самый нижний уровень системы. Собственно говоря, выполнение любого метода в конечном счете сводится к последовательности вызовов примитивных методов.
В системе есть компилятор, переводящий программу с языка Смолток в промежуточный код стековой виртуальной машины (байт-код). Для того, чтобы была возможность вести отладку на уровне исходного языка, в байт-коде есть ссылки на соответствующее исходное представление программы, расположенное в файловой системе на диске.
Скомпилированные методы в виде байт-кодов интерпретируются виртуальной машиной. Виртуальная машина состоит из трех частей: интерпретатора, набора примитивных методов и системы управления памятью объектов.
Интерпретатор рассматривает скомпилированный метод как последовательность однобайтовых команд. Команда может иметь продолжение еще в нескольких байтах. Обычно байтовая команда работает со стеком, занося и читая из него операнды, представляющие собой указатели на объекты. Некоторые байтовые команды являются вызовами примитивных методов.
Поскольку в системе используется динамическое связывание, большая роль отводится распределению памяти под объекты. В больших программах могут порождаться тысячи и десятки тысяч объектов, поэтому необходимо своевременно освобождать память от ненужных объектов.
Сборка мусора в системе реализована методом счетчика ссылок. Если значение счетчика, связанного с некоторым объектом, становится равным нулю, объект переводится в список "мусора". В определенные моменты работы программы, и, в частности, всегда, когда свободная память исчерпывается полностью, выполняется процедура сборки мусора. Недостаток метода счетчика ссылок состоит в больших накладных расходах на ведение счетчиков. Сейчас предложены другие, более совершенные методы сборки мусора [9].
При разработке программного обеспечения используются объектно-ориентированная модель реального мира "объект - класс - сообщение", основные принципы объектно-ориентированного программирования, язык, интерфейс и встроенный набор классов в качестве инструмента реали- зации.
Процесс разработки можно условно разбить на несколько этапов:
В составе системы есть встроенные средства, поддерживающие объектно-ориентированный метод разработки программ. Эти средства позволяют просматривать всю иерархию классов решаемой задачи. Для каждого класса можно узнать список его подклассов, структуру его объектов, перечень и тексты методов. Для каждого метода можно получить список объектов - отправителей сообщений с именем данного метода и список объектов, которые он вызывает.
Вся работа по изучению и изменению системы ведется в специальных окнах, называемых окнами просмотра иерархии классов.
При разработке ПО массовых ЭВМ нужно иметь в виду, что язык общения конечного пользователя с ЭВМ должен быть максимально приближен к предметной области. Это означает, что пользователь не должен знать структуру инструментальной среды программирования, изучать стандартный набор классов объектно-ориентированной системы.
При решении задач в объктно-ориентированной среде пользователь должен только усвоить предлагаемую абстрактную модель "объект - класс - сообщение" и изучить интерфейс при работе с ЭВМ, т.е. методы работы с окнами, меню, клавиатурой или мышью.
Модель "объект - класс - сообщение" носит фундаментальный характер и легко может применяться в любой предметной области.
Можно рассмотреть два крайних способа работы в объектно-ориентированной среде. Первый - чистая разработка ПО, второй - чистое использование ПО. Первый способ уже был описан ранее, собственно ему и посвящена основная часть статьи. Второй способ предполагает, что пользователь никак не изменяет среду, в которой он работает. Он посылает сообщения, а результаты получает в виде выводимой различными способами из ЭВМ информации. Такой способ может использоваться, например, в учрежденческих системах.
Если же конечный пользователь желает сделать прикладную систему более гибкой, а так обычно бывает в случае работы с персональной ЭВМ, он должен использовать промежуточный способ: работая, в основном, в режиме запрос-ответ, иметь возможность модифицировать систему путем создания новых классов и объектов.
Объектно-ориенированные языки и системы программирования получили распространение в первую очередь в системах искусственного интеллекта. Их промышленное использование сдерживается недостаточной эффективностью реализаций на машинах традиционной архитектуры. Поэтому одним из путей развития таких систем является создание архитектуры ЭВМ, полностью ориентированной на объекты [10-12].
Можно указать на несколько направлений развития собственно объектно-ориентированных языков. Первое - это отражение в языке параллельности, присущей объектам реального мира. Смолток-80 и большинство подобных систем чисто последовательные, в которых объект, послав сообщение, ждет ответа. Разрешив объекту продолжать свои действия после посылки сообщения и после отправки ответа, мы вводим в язык параллельность со всеми сопутствующими проблемами диспетчеризации и синхронизации процессов. Уже существует несколько реализациий таких систем [13-15].
Второе направление - создание распределенных объектно-ориентированных систем, в частности, баз данных, предпосылкой которому является поддержка изолированности объектов и обмена сообщениями между ними [16,17].
Третье направление - введение множественного наследования и, соответственно, сетевой структуры классов. Это усложняет реализацию системы, но делает ее более универсальной [18]. Древовидная структура классов Смолтока-80 не позволяет ввести множественное наследование свойств, когда объект или класс имеет несколько суперклассов.