Введение в визуальное программирование (конспект лекций)

ОГЛАВЛЕНИЕ
Введение .........................................................................................................................................2
1. Методологии программирования.........................................................................................3
1.1. Определения ...................................................................................................................3
1.2. Классификация методологий программирования ......................................................4
1.2.1.
Императи́вное программи́рование .......................................................................4
1.2.2.
Структу́рное программи́рование ..........................................................................5
1.2.3.
Функциона́льное программи́рование ..................................................................6
1.2.4.
Логи́ческое программи́рование ............................................................................7
1.2.5.
Объе́ктно-ориенти́рованное программи́рование ................................................8
1.2.6.
Событи́йно-ориенти́рованное программи́рование .............................................9
2. Основы объектно-ориентированного программирования...............................................11
2.1. Основные понятия .......................................................................................................11
2.2. Определение ООП и его основные концепции.........................................................11
2.2.1.
Сложности определения .....................................................................................12
2.2.2.
Концепции ............................................................................................................13
2.3. Особенности реализации ............................................................................................14
2.4. Подходы к проектированию программ в целом .......................................................15
2.5. Родственные методологии ..........................................................................................16
2.5.1.
Компонентное программирование.....................................................................16
2.5.2.
Прототипное программирование .......................................................................17
2.5.3.
Класс-ориентированное программирование .....................................................17
2.6. Производительность объектных программ ...............................................................17
2.7. Критика ООП ...............................................................................................................18
2.8. Объектно-ориентированные языки ............................................................................20
3. Визуальное программирование ..........................................................................................22
3.1. Графические, или визуальные, языки программирования ......................................22
3.2. Визуальные средства разработки ...............................................................................23
4. MS Visual Basic ....................................................................................................................24
4.1. Эволюция Visual Basic ................................................................................................24
4.2. Основные разновидности Visual Basic ......................................................................25
4.2.1.
Классический Visual Basic (версии 5-6) ............................................................25
4.2.2.
Visual Basic for Applications (VBA) ....................................................................26
4.2.3.
Visual Basic Scripting Edition (VBScript) ............................................................26
4.3. Достоинства и недостатки ..........................................................................................26
4.3.1.
Достоинства .........................................................................................................26
4.3.2.
Недостатки ...........................................................................................................27
4.3.3.
Критика .................................................................................................................27
ВВЕДЕНИЕ
Появление специальных языков программирования, позволило преобразовывать
отдельные вычислительные операции в соответствующий программный код. Основой
данной методологии разработки программ являлась процедурная или алгоритмическая
организация структуры программного кода. Исходным понятием этой методологии
являлось понятие алгоритма.
Алгоритм это полное и точное предписание выполнить определенную последовательность
действий, направленных на достижение заданной цели или решение поставленной задачи.
Исполнитель алгоритма это биологическая, техническая или биотехническая система,
способная выполнить действия, предписанные алгоритмом. Исполнитель выполняет все
инструкции не задавая вопросов «Зачем?» и «Почему?»
1. МЕТОДОЛОГИИ ПРОГРАММИРОВАНИЯ
1.1. Определения
Методология (Паради́гма) программирования — это система принципов, а также
совокупность идей, понятий, методов, способов и средств, определяющих стиль
написания, отладки и сопровождения программ, организации теоретической,
практической и производственной деятельности, а также учение о системах знаний,
понятий и предметной и производственной деятельности.
–
Императивная парадигма
Императивный язык должен описывать не столько саму задачу (описание, «ЧТО» нужно
получить), сколько её решение («КАК» получить).
–
Функциональная парадигма
Позволяет записывать программу как композицию функций. В чистом функциональном
языке нет переменных. Так как функции не имеют побочных эффектов, они могут
выполняться в любом порядке.
–
Логическая парадигма
Программа представляет собой описание фактов и правил вывода в некотором логическом
исчислении. Желаемый результат, который часто записывается как вопрос, получается
системой в результате попытки применения описанных правил — путем логического
вывода. Интересными особенностями являются отсутствие детерминированности в общем
случае, внутренняя склонность к распараллеливанию.
–
Доказательная парадигма
Направлен на разработку алгоритмов и программ с доказательствами их правильности с
использованием спецификаций программ.
–
Объектно-ориентированная парадигма
Основана на представлении всего в виде объектов, являющихся экземплярами того или
иного класса и воплощает применение концепции абстрагирования. Объект при этом
соединяет внутри себя как данные, так и методы, их обрабатывающие. Как правило,
поддерживаются
характерные
возможности:
наследование,
инкапсуляцию
и
полиморфизм.
–
Рефлексивная парадигма
Наличие в языке мощных механизмов интроспекции, функции eval. Возможность
программы на данном языке оперировать собственным кодом как данными.
–
Обобщенное программирование
Обобщенное программирование позволяет записывать алгоритмы, принимающие данные
любого типа.
–
Декларативная парадигма
Противоположность императивному. Декларативный язык описывает не столько решение
задачи, сколько саму задачу («ЧТО» нужно получить), а каким образом получить
решение, уже должен определять компьютер.
–
Распределенная парадигма
Язык, содержащий специальные конструкции для поддержки распараллеливания
программы на несколько компьютеров.
Важно отметить, что парадигма программирования не определяется однозначно языком
программирования; практически все современные языки программирования в той или
иной мере допускают использование различных парадигм (мультипарадигмальное
программирование). Так на языке Си, который не является объектно-ориентированным,
можно работать в соответствии с принципами объектно-ориентированного
программирования, хотя это и сопряжено с определёнными сложностями;
функциональное программирование можно применять при работе на любом
императивном языке, в котором имеются функции (для этого достаточно не применять
присваивание), и т. д.
Приверженность определённого человека какой-то одной парадигме иногда носит
настолько сильный характер, что споры о преимуществах и недостатках различных
парадигм относятся в околокомпьютерных кругах к разряду так называемых
«религиозных» войн — холиваров.
1.2. Классификация методологий программирования
Основные модели программирования:





Императивное программирование
Структурное программирование
Функциональное программирование
Логическое программирование
Объектно-ориентированное программирование
o Программирование, основанное на классах
o Программирование, основанное на прототипах
o Субъектно-ориентированное программирование
1.2.1. Императи́вное программи́рование
Императи́вное программи́рование — это парадигма программирования, которая
описывает процесс вычисления в виде инструкций, изменяющих состояние программы.
Императивная программа очень похожа на приказы, выражаемые повелительным
наклонением в естественных языках.
Процедурное (императивное) программирование является отражением архитектуры
традиционных ЭВМ, которая была предложена фон Нейманом в 1940-х годах.
Теоретической моделью процедурного программирования служит алгоритмическая
система под названием Машина Тьюринга.
Выполнение программы сводится к последовательному выполнению операторов с целью
преобразования исходного состояния памяти, то есть значений исходных данных, в
заключительное, то есть в результаты. Таким образом, с точки зрения программиста
имеются программа и память, причем первая последовательно обновляет содержимое
последней.
Процедурный язык программирования предоставляет возможность программисту
определять каждый шаг в процессе решения задачи. Особенность таких языков
программирования состоит в том, что задачи разбиваются на шаги и решаются шаг за
шагом. Используя процедурный язык, программист определяет языковые конструкции для
выполнения последовательности алгоритмических шагов.
Императивные языки программирования противопоставляются функциональным и
логическим языкам программирования. Функциональные языки, например, Haskell, не
представляют собой последовательность инструкций и не имеют глобального состояния.
Логические языки программирования, такие как Prolog, обычно определяют что надо
вычислить, а не как это надо делать.
Процедурные языки программирования











Ada (язык общего назначения)
Basic (версии начиная с Quick Basic до появления Visual Basic)
Си
КОБОЛ
Фортран
Модула-2
HAL/S
Pascal
ПЛ/1
Рапира
REXX
1.2.2. Структу́рное программи́рование
Структу́рное
программи́рование —
методология
разработки
программного
обеспечения, в основе которой лежит представление программы в виде иерархической
структуры блоков. Предложена в 70-х годах XX века Э. Дейкстрой, разработана и
дополнена Н. Виртом.
В соответствии с данной методологией
1. Любая программа представляет собой структуру, построенную из трёх типов
базовых конструкций:
o последовательное исполнение — однократное выполнение операций в том
порядке, в котором они записаны в тексте программы;
o ветвление — однократное выполнение одной из двух или более операций, в
зависимости от выполнения некоторого заданного условия;
o цикл — многократное исполнение одной и той же операции до тех пор,
пока выполняется некоторое заданное условие (условие продолжения
цикла).
В программе базовые конструкции могут быть вложены друг в друга произвольным
образом, но никаких других средств управления последовательностью выполнения
операций не предусматривается.
2. Повторяющиеся фрагменты программы (либо не повторяющиеся, но
представляющие собой логически целостные вычислительные блоки) могут
оформляться в виде т. н. подпрограмм (процедур или функций). В этом случае в
тексте основной программы, вместо помещённого в подпрограмму фрагмента,
вставляется инструкция вызова подпрограммы. При выполнении такой
инструкции выполняется вызванная подпрограмма, после чего исполнение
программы продолжается с инструкции, следующей за командой вызова
подпрограммы.
3. Разработка программы ведётся пошагово, методом «сверху вниз».
Сначала пишется текст основной программы, в котором, вместо каждого связного
логического фрагмента текста, вставляется вызов подпрограммы, которая будет
выполнять этот фрагмент. Вместо настоящих, работающих подпрограмм, в программу
вставляются «заглушки», которые ничего не делают. Полученная программа проверяется
и отлаживается. После того, как программист убедится, что подпрограммы вызываются в
правильной последовательности (то есть общая структура программы верна),
подпрограммы-заглушки последовательно заменяются на реально работающие, причём
разработка каждой подпрограммы ведётся тем же методом, что и основной программы.
Разработка заканчивается тогда, когда не останется ни одной «затычки», которая не была
бы удалена. Такая последовательность гарантирует, что на каждом этапе разработки
программист одновременно имеет дело с обозримым и понятным ему множеством
фрагментов, и может быть уверен, что общая структура всех более высоких уровней
программы верна. При сопровождении и внесении изменений в программу выясняется, в
какие именно процедуры нужно внести изменения, и они вносятся, не затрагивая части
программы, непосредственно не связанные с ними. Это позволяет гарантировать, что при
внесении изменений и исправлении ошибок не выйдет из строя какая-то часть программы,
находящаяся в данный момент вне зоны внимания программиста.
Теорема о структурном программировании (Теорема Бома-Якопини):
Любую схему алгоритма можно представить в виде композиции вложенных блоков begin
и end, условных операторов if, then, else, циклов с предусловием (while) и может быть
дополнительных логических переменных (флагов).
Эта теорема была сформулирована итальянскими математиками К. Бомом и Дж. Якопини
в 1966 году и говорит нам о том, как можно избежать использования оператора перехода
goto.
1.2.3. Функциона́льное программи́рование
Функциона́льное программи́рование — парадигма программирования, в которой
процесс вычисления трактуется как вычисление значений функций в математическом
понимании последних (в отличие от функций как подпрограмм в процедурном
программировании).
Противопоставляется парадигме императивного программирования, которая описывает
процесс вычислений как последовательное изменение состояний (в значении, подобном
таковому в теории автоматов). При необходимости, в функциональном программировании
вся совокупность последовательных состояний вычислительного процесса представляется
явным образом, например как список.
Функциональное программирование предполагает обходиться вычислением результатов
функций от исходных данных и результатов других функций, и не предполагает явного
хранения состояния программы. Соответственно, не предполагает оно и изменяемость
этого состояния (в отличие от императивного, где одной из базовых концепций является
переменная, хранящая своё значение и позволяющая менять его по мере выполнения
алгоритма).
На практике отличие математической функции от понятия «функции» в императивном
программировании заключается в том, что императивные функции могут опираться не
только на аргументы, но и на состояние внешних по отношению к функции переменных, а
также иметь побочные эффекты и менять состояние внешних переменных. Таким
образом, в императивном программировании при вызове одной и той же функции с
одинаковыми параметрами, но на разных этапах выполнения алгоритма, можно получить
разные данные на выходе из-за влияния на функцию состояния переменных. А в
функциональном языке при вызове функции с одними и теми же аргументами мы всегда
получим одинаковый результат: выходные данные зависят только от входных. Это
позволяет средам выполнения программ на функциональных языках кешировать
результаты функций и вызывать их в порядке, не определяемом алгоритмом и
распараллеливать их без каких-либо дополнительных действий со стороны программиста.
Языки функционального программирования
Наиболее известными языками функционального программирования являются[2]:










LISP — (Джон МакКарти, 1958) и множество его диалектов, наиболее современные
из которых:
o Scheme
o Clojure
o Common Lisp
Erlang — (Joe Armstrong, 1986) функциональный язык с поддержкой процессов.
APL — предшественник современных научных вычислительных сред, таких как
MATLAB.
ML (Робин Милнер, 1979, из ныне используемых диалектов известны Standard ML
и Objective CAML).
F# — функциональный язык семейства ML для платформы .NET
Scala
Miranda (Дэвид Тёрнер, 1985, который впоследствии дал развитие языку Haskell).
Nemerle — гибридный функционально/императивный язык.
XSLT и XQuery
Haskell — чистый функциональный.
1.2.4. Логи́ческое программи́рование
Логи́ческое программи́рование — парадигма программирования, основанная на
автоматическом доказательстве теорем, а также раздел дискретной математики,
изучающий принципы логического вывода информации на основе заданных фактов и
правил вывода. Логическое программирование основано на теории и аппарате
математической логики с использованием математических принципов резолюций.
Самым известным языком логического программирования является Prolog.
Первым языком логического программирования был язык Planner (см. обзор Шапиро
(Ehud Shapiro) [1989]), в котором была заложена возможность автоматического вывода
результата из данных и заданных правил перебора вариантов (совокупность которых
называлась планом). Planner использовался для того, чтобы понизить требования к
вычислительным ресурсам (с помощью метода backtracking) и обеспечить возможность
вывода фактов, без активного использования стека. Затем был разработан язык Prolog,
который не требовал плана перебора вариантов и был, в этом смысле, упрощением языка
Planner.
От языка Planner также произошли логические языки программирования QA-4, Popler,
Conniver и QLISP. Языки программирования Mercury, Visual Prolog, Oz и Fril произошли
уже от языка Prolog. На базе языка Planner было разработано также несколько
альтернативных языков логического программирования, не основанных на методе поиска
с возвратами (backtracking), например, Ether (см. обзор Шапиро [1989]).
1.2.5. Объе́ктно-ориенти́рованное программи́рование
Объе́ктно-ориенти́рованное, или объектное, программи́рование (в дальнейшем ООП) —
парадигма программирования, в которой основными концепциями являются понятия
объектов и классов. В случае языков с прототипированием вместо классов используются
объекты-прототипы.
ООП возникло в результате развития идеологии процедурного программирования, где
данные и подпрограммы (процедуры, функции) их обработки формально не связаны. Для
дальнейшего развития объектно-ориентированного программирования часто большое
значение имеют понятия события (так называемое событийно-ориентированное
программирование) и компонента (компонентное программирование, КОП).
Формирование КОП от ООП произошло, как случилось формирование модульного от
процедурного программирования: процедуры сформировались в модули — независимые
части кода до уровня сборки программы, так объекты сформировались в компоненты —
независимые части кода до уровня выполнения программы. Взаимодействие объектов
происходит посредством сообщений. Результатом дальнейшего развития ООП, повидимому, будет агентно-ориентированое программирование, где агенты — независимые
части кода на уровне выполнения. Взаимодействие агентов происходит посредством
изменения среды, в которой они находятся.
Языковые конструкции, конструктивно не относящиеся непосредственно к объектам, но
сопутствующие им для их безопасной (исключительные ситуации, проверки) и
эффективной работы, инкапсулируются от них в аспекты (в аспектно-ориентированном
программировании). Субъектно-ориентированное программирование расширяет понятие
объект посредством обеспечения более унифицированного и независимого
взаимодействия объектов. Может являться переходной стадией между ООП и агентным
программирование в части самостоятельного их взаимодействия.
Первым языком программирования, в котором были предложены принципы объектной
ориентированности, была Симула. В момент своего появления (в 1967 году), этот язык
программирования предложил поистине революционные идеи: объекты, классы,
виртуальные методы и др., однако это всё не было воспринято современниками как нечто
грандиозное. Тем не менее, большинство концепций были развиты Аланом Кэйем и
Дэном Ингаллсом в языке Smalltalk. Именно он стал первым широко распространённым
объектно-ориентированным языком программирования.
В настоящее время количество прикладных языков программирования (список языков),
реализующих объектно-ориентированную парадигму, является наибольшим по
отношению к другим парадигмам. В области системного программирования до сих пор
применяется парадигма процедурного программирования, и общепринятым языком
программирования является язык C. Хотя при взаимодействии системного и прикладного
уровней операционных систем заметное влияние стали оказывать языки объектноориентированного программирования. Например, одной из наиболее распространенных
библиотек
мультиплатформенного
программирования
является
объектноориентированная библиотека Qt, написанная на языке C++.
1.2.6. Событи́йно-ориенти́рованное программи́рование
Событи́йно-ориенти́рованное программи́рование (англ. event-driven programming; в
дальнейшем СОП) — парадигма программирования, в которой выполнение программы
определяется событиями — действиями пользователя (клавиатура, мышь), сообщениями
других программ и потоков, событиями операционной системы (например, поступлением
сетевого пакета).
СОП можно также определить как способ построения компьютерной программы, при
котором в коде (как правило, в головной функции программы) явным образом выделяется
главный цикл приложения, тело которого состоит из двух частей: выборки события и
обработки события.
Как правило, в реальных задачах оказывается недопустимым длительное выполнение
обработчика события, поскольку при этом программа не может реагировать на другие
события. В связи с этим при написании событийно-ориентированных программ часто
применяют автоматное программирование.
Событийно-ориентированное программирование, как правило, применяется в трех
случаях:
1. при построении пользовательских интерфейсов (в том числе графических);
2. при создании серверных приложений в случае, если по тем или иным причинам
нежелательно порождение обслуживающих процессов;
3. при программировании игр, в которых осуществляется управление множеством
объектов.
В современных языках программирования события и обработчики событий являются
центральным звеном реализации графического интерфейса пользователя.
Рассмотрим, к примеру, взаимодействие программы с событиями от мыши. Нажатие
правой клавиши мыши вызывает системное прерывание, запускающее определенную
процедуру внутри операционной системы. В этой процедуре происходит поиск окна,
находящегося под курсором мыши. Если окно найдено, то данное событие посылается в
очередь обработки сообщений этого окна. Далее, в зависимости от типа окна, могут
генерироваться дополнительные события. Например, если окно является кнопкой (в
Windows все графические элементы являются окнами), то дополнительно генерируется
событие нажатия на кнопку. Отличие последнего события в том, что оно более
абстрактно, а именно, не содержит координат курсора, а говорит просто о том, что было
произведено нажатие на данную кнопку.
Обработчик события может выглядеть следующим образом (на примере C#):
private void button1_Click(object sender, EventArgs e)
{
MessageBox.Show("Была нажата кнопка");
}
Здесь обработчик события представляет собой процедуру, в которую передается параметр
sender, как правило содержащий указатель на источник события. Это позволяет
использовать одну и ту же процедуру для обработки событий от нескольких кнопок,
различая их по этому параметру.
Разные языки программирования поддерживают СОП в разной степени. Наиболее полной
поддержкой событий обладают следующие языки (неполный список):





Perl (события и демоны DAEMON, и их приоритеты PRIO),[2]
Java,
Delphi,
ActionScript 3.0,
C# (события event)[3].
Остальные языки, в большей их части, поддерживают события как обработку
исключительных ситуаций.
2. ОСНОВЫ ОБЪЕКТНО-ОРИЕНТИРОВАННОГО
ПРОГРАММИРОВАНИЯ
2.1.Основные понятия
Абстракция
Абстрагирование — это способ выделить набор значимых характеристик объекта,
исключая из рассмотрения незначимые. Соответственно, абстракция — это набор
всех таких характеристик.[1]
Инкапсуляция
Инкапсуляция — это свойство системы, позволяющее объединить данные и
методы, работающие с ними, в классе и скрыть детали реализации от
пользователя.[1]
Наследование
Наследование — это свойство системы, позволяющее описать новый класс на
основе уже существующего с частично или полностью заимствующейся
функциональностью. Класс, от которого производится наследование, называется
базовым, родительским или суперклассом. Новый класс — потомком, наследником
или производным классом.[1]
Полиморфизм
Полиморфизм — это свойство системы использовать объекты с одинаковым
интерфейсом без информации о типе и внутренней структуре объекта.[1]
Класс
Класс является описываемой на языке терминологии (пространства имён)
исходного кода моделью ещё не существующей сущности (объекта). Фактически
он описывает устройство объекта, являясь своего рода чертежом. Говорят, что
объект — это экземпляр класса. При этом в некоторых исполняющих системах
класс также может представляться некоторым объектом при выполнении
программы посредством динамической идентификации типа данных. Обычно
классы разрабатывают таким образом, чтобы их объекты соответствовали объектам
предметной области.
Объект
Сущность в адресном пространстве вычислительной системы, появляющаяся при
создании экземпляра класса или копирования прототипа (например, после запуска
результатов компиляции и связывания исходного кода на выполнение).
Прототип
Прототип — это объект-образец, по образу и подобию которого создаются другие
объекты. Объекты-копии могут сохранять связь с родительским объектом,
автоматически наследуя изменения в прототипе; эта особенность определяется в
рамках конкретного языка.
2.2.Определение ООП и его основные концепции
В центре ООП находится понятие объекта. Объект — это сущность, которой можно
посылать сообщения, и которая может на них реагировать, используя свои данные.
Данные объекта скрыты от остальной программы. Сокрытие данных называется
инкапсуляцией.
Наличие инкапсуляции достаточно для объектности языка программирования, но ещё не
означает его объектной ориентированности — для этого требуется наличие наследования.
Но даже наличие инкапсуляции и наследования не делает язык программирования в
полной мере объектным с точки зрения ООП. Основные преимущества ООП проявляются
только в том случае, когда в языке программирования реализован полиморфизм; то есть
возможность объектов с одинаковой спецификацией иметь различную реализацию.
Язык Self, соблюдая многие исходные положения объектно-ориентированного
программирования, ввёл альтернативное классам понятие прототипа, положив начало
прототипному программированию, считающемуся подвидом объектного.
2.2.1. Сложности определения
ООП имеет уже более чем сорокалетнюю историю, но, несмотря на это, до сих пор не
существует чёткого общепринятого определения данной технологии[2]. Основные
принципы, заложенные в первые объектные языки и системы, подверглись
существенному изменению (или искажению) и дополнению при многочисленных
реализациях последующего времени. Кроме того, примерно с середины 1980-х годов
термин «объектно-ориентированный» стал модным, в результате с ним произошло то же
самое, что несколько раньше с термином «структурный» (ставшим модным после
распространения технологии структурного программирования) — его стали искусственно
«прикреплять» к любым новым разработкам, чтобы обеспечить им привлекательность.
Бьёрн Страуструп в 1988 году писал, что обоснование «объектной ориентированности»
чего-либо, в большинстве случаев, сводится к ложному силлогизму: «X — это хорошо.
Объектная ориентированность — это хорошо. Следовательно, X является объектноориентированным».
Тимоти Бадд пишет[3][4]:
Роджер Кинг аргументированно настаивал, что его кот является объектноориентированным. Кроме прочих своих достоинств, кот демонстрирует характерное
поведение, реагирует на сообщения, наделён унаследованными реакциями и управляет
своим, вполне независимым, внутренним состоянием.
По мнению Алана Кея, создателя языка Smalltalk, которого считают одним из «отцовоснователей» ООП, объектно-ориентированный подход заключается в следующем наборе
основных принципов (цитируется по вышеупомянутой книге Т. Бадда).
1. Всё является объектом.
2. Вычисления осуществляются путём взаимодействия (обмена данными) между
объектами, при котором один объект требует, чтобы другой объект выполнил
некоторое действие. Объекты взаимодействуют, посылая и получая сообщения.
Сообщение — это запрос на выполнение действия, дополненный набором
аргументов, которые могут понадобиться при выполнении действия.
3. Каждый объект имеет независимую память, которая состоит из других объектов.
4. Каждый объект является представителем класса, который выражает общие
свойства объектов (таких, как целые числа или списки).
5. В классе задаётся поведение (функциональность) объекта. Тем самым все объекты,
которые являются экземплярами одного класса, могут выполнять одни и те же
действия.
6. Классы организованы в единую древовидную структуру с общим корнем,
называемую иерархией наследования. Память и поведение, связанное с
экземплярами определённого класса, автоматически доступны любому классу,
расположенному ниже в иерархическом дереве.
Таким образом, программа представляет собой набор объектов, имеющих состояние и
поведение. Объекты взаимодействуют посредством сообщений. Естественным образом
выстраивается иерархия объектов: программа в целом — это объект, для выполнения
своих функций она обращается к входящим в неё объектам, которые, в свою очередь,
выполняют запрошенное путём обращения к другим объектам программы. Естественно,
чтобы избежать бесконечной рекурсии в обращениях, на каком-то этапе объект
трансформирует обращённое к нему сообщение в сообщения к стандартным системным
объектам, предоставляемым языком и средой программирования.
Устойчивость и управляемость системы обеспечивается за счёт чёткого разделения
ответственности объектов (за каждое действие отвечает определённый объект),
однозначного определения интерфейсов межобъектного взаимодействия и полной
изолированности внутренней структуры объекта от внешней среды (инкапсуляции).
Определить ООП можно и многими другими способами[5].
2.2.2. Концепции
Появление в ООП отдельного понятия класса закономерно вытекает из желания иметь
множество объектов со сходным поведением. Класс в ООП — это в чистом виде
абстрактный тип данных, создаваемый программистом. С этой точки зрения объекты
являются значениями данного абстрактного типа, а определение класса задаёт
внутреннюю структуру значений и набор операций, которые над этими значениями могут
быть выполнены. Желательность иерархии классов (а значит, наследования) вытекает из
требований к повторному использованию кода — если несколько классов имеют сходное
поведение, нет смысла дублировать их описание, лучше выделить общую часть в общий
родительский класс, а в описании самих этих классов оставить только различающиеся
элементы.
Необходимость совместного использования объектов разных классов, способных
обрабатывать однотипные сообщения, требует поддержки полиморфизма —
возможности записывать разные объекты в переменные одного и того же типа. В таких
условиях объект, отправляя сообщение, может не знать в точности, к какому классу
относится адресат, и одни и те же сообщения, отправленные переменным одного типа,
содержащим объекты разных классов, вызовут различную реакцию.
Отдельного пояснения требует понятие обмена сообщениями. Первоначально (например,
в том же Smalltalk) взаимодействие объектов представлялось как «настоящий» обмен
сообщениями, то есть пересылка от одного объекта другому специального объектасообщения. Такая модель является чрезвычайно общей. Она прекрасно подходит,
например, для описания параллельных вычислений с помощью активных объектов,
каждый из которых имеет собственный поток исполнения и работает одновременно с
прочими. Такие объекты могут вести себя как отдельные, абсолютно автономные
вычислительные единицы. Посылка сообщений естественным образом решает вопрос
обработки сообщений объектами, присвоенными полиморфным переменным —
независимо от того, как объявляется переменная, сообщение обрабатывает код класса, к
которому относится присвоенный переменной объект.
Однако общность механизма обмена сообщениями имеет и другую сторону —
«полноценная» передача сообщений требует дополнительных накладных расходов, что не
всегда приемлемо. Поэтому в большинстве ныне существующих объектноориентированных языков программирования используется концепция «отправка
сообщения как вызов метода» — объекты имеют доступные извне методы, вызовами
которых и обеспечивается взаимодействие объектов. Данный подход реализован в
огромном количестве языков программирования, в том числе C++, Object Pascal, Java,
Oberon-2. В настоящий момент именно он является наиболее распространённым в
объектно-ориентированных языках.
Концепция виртуальных методов, поддерживаемая этими и другими современными
языками, появилась как средство обеспечить выполнение нужных методов при
использовании полиморфных переменных, то есть, по сути, как попытка расширить
возможности вызова методов для реализации части функциональности, обеспечиваемой
механизмом обработки сообщений.
2.3.Особенности реализации
Как уже говорилось выше, в современных объектно-ориентированных языках
программирования каждый объект является значением, относящимся к определённому
классу. Класс представляет собой объявленный программистом составной тип данных,
имеющий в составе:
Поля данных
Параметры объекта (конечно, не все, а только необходимые в программе),
задающие его состояние (свойства объекта предметной области). Иногда поля
данных объекта называют свойствами объекта, из-за чего возможна путаница.
Физически поля представляют собой значения (переменные, константы),
объявленные как принадлежащие классу.
Методы
Процедуры и функции, связанные с классом. Они определяют действия, которые
можно выполнять над объектом такого типа, и которые сам объект может
выполнять.
Классы могут наследоваться друг от друга. Класс-потомок получает все поля и методы
класса-родителя, но может дополнять их собственными либо переопределять уже
имеющиеся. Большинство языков программирования поддерживает только единичное
наследование (класс может иметь только один класс-родитель), лишь в некоторых
допускается множественное наследование — порождение класса от двух или более
классов-родителей. Множественное наследование создаёт целый ряд проблем, как
логических, так и чисто реализационных, поэтому в полном объёме его поддержка не
распространена. Вместо этого в 1990-е годы появилось и стало активно вводиться в
объектно-ориентированные языки понятие интерфейса. Интерфейс — это класс без полей
и без реализации, включающий только заголовки методов. Если некий класс наследует
(или, как говорят, реализует) интерфейс, он должен реализовать все входящие в него
методы. Использование интерфейсов предоставляет относительно дешёвую альтернативу
множественному наследованию.
Взаимодействие объектов в абсолютном большинстве случаев обеспечивается вызовом
ими методов друг друга.
Инкапсуляция обеспечивается следующими средствами
Контроль доступа
Поскольку методы класса могут быть как чисто внутренними, обеспечивающими
логику функционирования объекта, так и внешними, с помощью которых
взаимодействуют объекты, необходимо обеспечить скрытость первых при
доступности извне вторых. Для этого в языки вводятся специальные
синтаксические конструкции, явно задающие область видимости каждого члена
класса. Традиционно это модификаторы public, protected и private, обозначающие,
соответственно, открытые члены класса, члены класса, доступные только из
классов-потомков и скрытые, доступные только внутри класса. Конкретная
номенклатура модификаторов и их точный смысл различаются в разных языках.
Методы доступа
Поля класса, в общем случае, не должны быть доступны извне, поскольку такой
доступ позволил бы произвольным образом менять внутреннее состояние объектов.
Поэтому поля обычно объявляются скрытыми (либо язык в принципе не позволяет
обращаться к полям класса извне), а для доступа к находящимся в полях данным
используются специальные методы, называемые методами доступа. Такие методы
либо возвращают значение того или иного поля, либо производят запись в это поле
нового значения. При записи метод доступа может проконтролировать
допустимость записываемого значения и, при необходимости, произвести другие
манипуляции с данными объекта, чтобы они остались корректными (внутренне
согласованными). Методы доступа называют ещё аксессорами (от англ. access —
доступ), а по отдельности — геттерами (англ. get — чтение) и сеттерами
(англ. set — запись)[6].
Свойства объекта
Псевдополя, доступные для чтения и/или записи. Свойства внешне выглядят как
поля и используются аналогично доступным полям (с некоторыми исключениями),
однако фактически при обращении к ним происходит вызов методов доступа.
Таким образом, свойства можно рассматривать как «умные» поля данных,
сопровождающие доступ к внутренним данным объекта какими-либо
дополнительными действиями (например, когда изменение координаты объекта
сопровождается его перерисовкой на новом месте). Свойства, по сути — не более
чем синтаксический сахар, поскольку никаких новых возможностей они не
добавляют, а лишь скрывают вызов методов доступа. Конкретная языковая
реализация свойств может быть разной. Например, в C# объявление свойства
непосредственно содержит код методов доступа, который вызывается только при
работе со свойствами, то есть не требует отдельных методов доступа, доступных
для непосредственного вызова. В Delphi объявление свойства содержит лишь
имена методов доступа, которые должны вызываться при обращении к полю. Сами
методы доступа представляют собой обычные методы с некоторыми
дополнительными требованиями к сигнатуре.
Полиморфизм реализуется путём введения в язык правил, согласно которым переменной
типа «класс» может быть присвоен объект любого класса-потомка её класса.
2.4.Подходы к проектированию программ в целом
ООП ориентировано на разработку крупных программных комплексов, разрабатываемых
командой программистов (возможно, достаточно большой). Проектирование системы в
целом, создание отдельных компонентов и их объединение в конечный продукт при этом
часто выполняется разными людьми, и нет ни одного специалиста, который знал бы о
проекте всё.
Объектно-ориентированное проектирование состоит в описании структуры и поведения
проектируемой системы, то есть, фактически, в ответе на два основных вопроса:


Из каких частей состоит система.
В чём состоит ответственность каждой из частей.
Выделение частей производится таким образом, чтобы каждая имела минимальный по
объёму и точно определённый набор выполняемых функций (обязанностей), и при этом
взаимодействовала с другими частями как можно меньше.
Дальнейшее уточнение приводит к выделению более мелких фрагментов описания. По
мере детализации описания и определения ответственности выявляются данные, которые
необходимо хранить, наличие близких по поведению агентов, которые становятся
кандидатами на реализацию в виде классов с общими предками. После выделения
компонентов и определения интерфейсов между ними реализация каждого компонента
может проводиться практически независимо от остальных (разумеется, при соблюдении
соответствующей технологической дисциплины).
Большое значение имеет правильное построение иерархии классов. Одна из известных
проблем больших систем, построенных по ООП-технологии — так называемая проблема
хрупкости базового класса. Она состоит в том, что на поздних этапах разработки, когда
иерархия классов построена и на её основе разработано большое количество кода,
оказывается трудно или даже невозможно внести какие-либо изменения в код базовых
классов иерархии (от которых порождены все или многие работающие в системе классы).
Даже если вносимые изменения не затронут интерфейс базового класса, изменение его
поведения может непредсказуемым образом отразиться на классах-потомках. В случае
крупной системы разработчик базового класса просто не в состоянии предугадать
последствия изменений, он даже не знает о том, как именно базовый класс используется и
от каких особенностей его поведения зависит корректность работы классов-потомков.
2.5.Родственные методологии
Компонентное программирование — следующий этап развития ООП; прототип- и классориентированное программирование — разные подходы к созданию программы, которые
могут комбинироваться, имеющие свои преимущества и недостатки.
2.5.1. Компонентное программирование
Компонентно-ориентированное программирование — это своеобразная «надстройка» над
ООП, набор правил и ограничений, направленных на построение крупных развивающихся
программных систем с большим временем жизни. Программная система в этой
методологии представляет собой набор компонентов с хорошо определёнными
интерфейсами. Изменения в существующую систему вносятся путём создания новых
компонентов в дополнение или в качестве замены ранее существующих. При создании
новых компонентов на основе ранее созданных запрещено использование наследования
реализации — новый компонент может наследовать лишь интерфейсы базового. Таким
образом компонентное программирование обходит проблему хрупкости базового класса.
2.5.2. Прототипное программирование
Прототипное программирование, сохранив часть черт ООП, отказалось от базовых
понятий — класса и наследования.



Вместо механизма описания классов и порождения экземпляров язык
предоставляет механизм создания объекта (путём задания набора полей и методов,
которые объект должен иметь) и механизм клонирования объектов.
Каждый вновь созданный объект является «экземпляром без класса». Каждый
объект может стать прототипом — быть использован для создания нового объекта
с помощью операции клонирования. После клонирования новый объект может быть
изменён, в частности, дополнен новыми полями и методами.
Клонированный объект либо становится полной копией прототипа, хранящей все
значения его полей и дублирующей его методы, либо сохраняет ссылку на
прототип, не включая в себя клонированных полей и методов до тех пор, пока они
не будут изменены. В последнем случае среда исполнения обеспечивает механизм
делегирования — если при обращении к объекту он сам не содержит нужного
метода или поля данных, вызов передаётся прототипу, от него, при
необходимости — дальше по цепочке.
2.5.3. Класс-ориентированное программирование
2.6.Производительность объектных программ
Гради Буч указывает[7] на следующие причины, приводящие к снижению
производительности программ из-за использования объектно-ориентированных средств:
Динамическое связывание методов.
Обеспечение полиморфного поведения объектов приводит к необходимости
связывать методы, вызываемые программой (то есть определять, какой конкретно
метод будет вызываться) не на этапе компиляции, а в процессе исполнения
программы, на что тратится дополнительное время. При этом реально
динамическое связывание требуется не более чем для 20 % вызовов, но некоторые
ООП-языки используют его постоянно.
Значительная глубина абстракции.
ООП-разработка часто приводит к созданию «многослойных» приложений, где
выполнение объектом требуемого действия сводится к множеству обращений к
объектам более низкого уровня. В таком приложении происходит очень много
вызовов методов и возвратов из методов, что, естественно, сказывается на
производительности.
Наследование «размывает» код.
Код, относящийся к «оконечным» классам иерархии наследования (которые
обычно и используются программой непосредственно) — находится не только в
самих этих классах, но и в их классах-предках. Относящиеся к одному классу
методы фактически описываются в разных классах. Это приводит к двум
неприятным моментам:


Снижается скорость трансляции, так как компоновщику приходится
подгружать описания всех классов иерархии.
Снижается производительность программы в системе со страничной
памятью — поскольку методы одного класса физически находятся в разных
местах кода, далеко друг от друга, при работе фрагментов программы,
активно обращающихся к унаследованным методам, система вынуждена
производить частые переключения страниц.
Инкапсуляция снижает скорость доступа к данным.
Запрет на прямой доступ к полям класса извне приводит к необходимости создания
и использования методов доступа. И написание, и компиляция, и исполнение
методов доступа сопряжено с дополнительными расходами.
Динамическое создание и уничтожение объектов.
Динамически создаваемые объекты, как правило, размещаются в куче, что менее
эффективно, чем размещение их на стеке и, тем более, статическое выделение
памяти под них на этапе компиляции.
Несмотря на отмеченные недостатки, Буч утверждает, что выгоды от использования ООП
более весомы. Кроме того, повышение производительности за счёт лучшей организации
ООП-кода, по его словам, в некоторых случаях компенсирует дополнительные накладные
расходы на организацию функционирования программы. Можно также заметить, что
многие эффекты снижения производительности могут сглаживаться или даже полностью
устраняться за счёт качественной оптимизации кода компилятором. Например,
упомянутое выше снижение скорости доступа к полям класса из-за использования
методов доступа устраняется, если компилятор вместо вызова метода доступа использует
инлайн-подстановку (современные компиляторы делают это вполне уверенно).
2.7. Критика ООП
Несмотря на отдельные критические замечания в адрес ООП, в настоящее время именно
эта парадигма используется в подавляющем большинстве промышленных проектов.
Однако, нельзя считать, что ООП является наилучшей из методик программирования во
всех случаях.
Критические высказывания в адрес ООП:




Исследование Thomas E. Potok, Mladen Vouk и Andy Rindos [1] показало отсутствие
значимой разницы в продуктивности разработки программного обеспечения между
ООП и процедурным подходом.
Кристофер Дэйт указывает на невозможность сравнения ООП и других технологий
во многом из-за отсутствия строгого и общепризнанного определения ООП (C. J.
Date, Introduction to Database Systems, 6th-ed., Page 650)
Александр Степанов, в одном из своих интервью, указывал на то, что ООП
«методологически неправильно» и что «… ООП практически такая же
мистификация как и искусственный интеллект…» ([2]).
Фредерик Брукс (Frederick P. Brooks, Jr.) в своей статье «No Silver Bullet. Essence
and Accidents of Software Engineering» (Computer Magazine; April 1987) указывает
на то, что наиболее сложной частью создания программного обеспечения является
« … спецификация, дизайн и тестирование концептуальных конструкций, а отнюдь
не работа по выражению этих концептуальных конструкций…». ООП (наряду с
такими технологиями как искусственный интеллект, верификация программ,
автоматическое программирование, графическое программирование, экспертные
системы и др.), по его мнению, не является «серебряной пулей», которая могла бы
на порядок величины (то есть примерно в 10 раз, как говорится в статье) снизить
сложность разработки программных систем. Согласно Бруксу, «…ООП позволяет




сократить только привнесённую сложность в выражение дизайна. Дизайн остаётся
сложным по своей природе…». ([3])
Эдсгер Дейкстра указывал: «… то о чём общество в большинстве случаев
просит — это змеиное масло. Естественно, „змеиное масло“ имеет очень
впечатляющие имена, иначе будет очень трудно что-то продать: „Структурный
анализ и Дизайн“, „Программная инженерия“, „Модели зрелости“, „Управляющие
информационные системы“ (Management Information Systems), „Интегрированные
среды поддержки проектов“, „Объектная ориентированность“, „Реинжиниринг
бизнес-процессов“…» — EWD 1175: The strengths of the academic enterprise
Никлаус Вирт считает, что ООП — не более чем тривиальная надстройка над
структурным программированием, и преувеличение её значимости, выражающееся,
в том числе, во включении в языки программирования всё новых модных
«объектно-ориентированных» средств, вредит качеству разрабатываемого
программного обеспечения.
Патрик Киллелиа в своей книге «Тюнинг веб-сервера» писал: «… ООП
предоставляет вам множество способов замедлить работу ваших программ …»
Известная обзорная статья проблем современного ООП-программирования
перечисляет некоторые типичные проблемы ООП — Почему объектноориентированное программирование провалилось
Если попытаться классифицировать критические высказывания в адрес ООП, можно
выделить несколько аспектов критики данного подхода к программированию.
Критика рекламы ООП.
Критикуется явно высказываемое или подразумеваемое в работах некоторых
пропагандистов ООП, а также в рекламных материалах «объектноориентированных»
средств
разработки
представление
об
объектном
программировании как о некоем всемогущем подходе, который магическим
образом устраняет сложность программирования. Как замечали многие, в том
числе упомянутые выше Брукс и Дейкстра, «серебряной пули не существует» —
независимо от того, какой парадигмы программирования придерживается
разработчик, создание нетривиальной сложной программной системы всегда
сопряжено со значительными затратами интеллектуальных ресурсов и времени. Из
наиболее квалифицированных специалистов в области ООП никто, как правило, не
отрицает справедливость критики этого типа.
Оспаривание эффективности разработки методами ООП.
Критики оспаривают тезис о том, что разработка объектно-ориентированных
программ требует меньше ресурсов или приводит к созданию более качественного
ПО. Проводится сравнение затрат на разработку разными методами, на основании
которого делается вывод об отсутствии у ООП преимуществ в данном
направлении. Учитывая крайнюю сложность объективного сравнения различных
разработок, подобные сопоставления, как минимум, спорны. С другой стороны
получается что ровно так же спорны и утверждения об эффективности ООП.
Производительность объектно-ориентированных программ.
Указывается на то, что целый ряд «врождённых особенностей» ООП-технологии
делает построенные на её основе программы технически менее эффективными, по
сравнению с аналогичными необъектными программами. Не отрицая
действительно имеющихся дополнительных накладных расходов на организацию
работы ООП-программ (см. раздел «Производительность» выше), нужно, однако,
отметить, что значение снижения производительности часто преувеличивается
критиками. В современных условиях, когда технические возможности
компьютеров чрезвычайно велики и постоянно растут, для большинства
прикладных программ техническая эффективность оказывается менее
существенна, чем функциональность, скорость разработки и сопровождаемость.
Лишь для некоторого, очень ограниченного класса программ (ПО встроенных
систем, драйверы устройств, низкоуровневая часть системного ПО, научное ПО)
производительность остаётся критическим фактором.
Критика отдельных технологических решений в ООП-языках и библиотеках.
Эта критика многочисленна, но затрагивает она не ООП как таковое, а
приемлемость и применимость в конкретных случаях тех или иных реализаций её
механизмов. Одним из излюбленных объектов критики является язык C++,
входящий в число наиболее распространённых промышленных ООП-языков.
2.8. Объектно-ориентированные языки
Многие современные языки специально созданы для облегчения объектноориентированного программирования. Однако следует отметить, что можно применять
техники ООП и для не-объектно-ориентированного языка и наоборот, применение
объектно-ориентированного языка вовсе не означает, что код автоматически становится
объектно-ориентированным.
Современный объектно-ориентированный язык предлагает, как правило, следующий
обязательный набор синтаксических средств:




Объявление классов с полями (данными — членами класса) и методами
(функциями — членами класса).
Механизм расширения класса (наследования) — порождение нового класса от
существующего с автоматическим включением всех особенностей реализации
класса-предка в состав класса-потомка. Большинство ООП-языков поддерживают
только единичное наследование.
Полиморфные переменные и параметры функций (методов), позволяющие
присваивать одной и той же переменной экземпляры различных классов.
Полиморфное поведение экземпляров классов за счёт использования виртуальных
методов. В некоторых ООП-языках все методы классов являются виртуальными.
Видимо, минимальным традиционным объектно-ориентированным языком можно считать
язык Оберон, который не содержит никаких других объектных средств, кроме
вышеперечисленных (в исходном Обероне даже нет отдельного ключевого слова для
объявления класса, а также отсутствуют явно описываемые методы, их заменяют поля
процедурного типа). Но большинство языков добавляют к указанному минимальному
набору те или иные дополнительные средства. В их числе:






Конструкторы, деструкторы, финализаторы.
Свойства (аксессоры).
Индексаторы.
Интерфейсы (например, в Java используются также как альтернатива
множественному наследованию — любой класс может реализовать сколько угодно
интерфейсов).
Переопределение операторов для классов.
Средства защиты внутренней структуры классов от несанкционированного
использования извне. Обычно это модификаторы доступа к полям и методам, типа
public, private, обычно также protected, иногда некоторые другие.
Часть языков (иногда называемых «чисто объектными») целиком построена вокруг
объектных средств — в них любые данные (возможно, за небольшим числом исключений
в виде встроенных скалярных типов данных) являются объектами, любой код — методом
какого-либо класса, и невозможно написать программу, в которой не использовались бы
объекты. Примеры подобных языков — Smalltalk, Python, Java, C#, Ruby, AS3. Другие
языки (иногда используется термин «гибридные») включают ООП-подсистему в исходно
процедурный язык. В них существует возможность программировать, не обращаясь к
объектным средствам. Классические примеры — C++, Delphi и Perl.
3. ВИЗУАЛЬНОЕ ПРОГРАММИРОВАНИЕ
Визуальное программирование — способ создания программы для ЭВМ путём
манипулирования графическими объектами вместо написания её текста.
Необходимо различать:


графический язык программирования — который прежде всего язык
программирования (со своим синтаксисом)
визуальные средства разработки — как правило, под ними подразумевают средства
проектирования интерфейсов или какую либо CASE-систему для быстрой
разработки
приложений
или
SCADA-систему для
программирования
микроконтроллеров.
Языки визуального программирования могут быть дополнительно классифицированы в
зависимости от типа и степени визуального выражения, на следующие типы:



языки на основе объектов, когда визуальная среда программирования
предоставляет графические или символьные элементы, которыми можно
манипулировать интерактивным образом в соответствии с некоторыми правилами;
языки, в интегрированной среде разработки которых на этапе проектирования
интерфейса применяются формы, с возможностью настройкой их свойств.
Примеры: Delphi и C++ Builder фирмы Borland, С#
языки схем, основанные на идее «фигур и линий», где фигуры (прямоугольники,
овалы и т. п.) рассматриваются как субъекты и соединяются линиями (стрелками,
дугами и др.), которые представляют собой отношения.
Визуально-преобразованные языки являются невизуальными языками с наложенным
визуальным представлением (например, среда Visual C++ для языка C++). Естественновизуальные языки имеют неотъемлемое визуальное выражение, для которого нет
очевидного текстового эквивалента (например, графический язык G в среде LabVIEW).
3.1.Графические, или визуальные, языки программирования
Графический язык программирования — язык, предназначенный для написания
программы для компьютера или вычислительного устройства, в котором вместо
текстового описания алгоритма работы используется графическое. К графическим языкам
программирования, с некоторой натяжкой, можно отнести генераторы кода по блоксхемам или Дракон-схемам..




Дракон-схемы — графический язык программирования, используется для
программирования в ракетно-космической технике («Буран», «Морской старт»,
«Тополь»). Существует бесплатный Дракон-редактор. Этот язык имеет наиболее
строгое теоретическое обоснование.
Язык последовательных функциональных схем SFC (Sequential Function Chart) —
графический язык программирования широко используется для программирования
промышленных логических контроллеров PLC. В SFC программа описывается в
виде схематической последовательности шагов, объединённых переходами.
LD — язык релейно-контактных схем
FBD — язык Функциональных блоковых диаграмм.



Язык CFC (Continuous Flow Chart) — ещё один высокоуровневый язык
графического программирования. CFC — это дальнейшее развития языка FBD.
CFC был специально создан для проектирования систем управления
непрерывными технологическими процессами.
G, язык, используемый в среде разработки LabVIEW
VisSim это визуальный язык программирования предназначенный для
моделирования динамическая систем, а также проектирования, базирующегося на
моделях,
3.2.Визуальные средства разработки
AgentSheets, легкая в использовании авторская система для игр и научных расчётов
Alice
Analytica
AppWare, also known as MicroBrew, программирование, на основе иконок для Mac
OS и Microsoft Windows
5. AudioMulch, основанная на потоке звукового сигнала, также для среда для
создания музыки
6. Macromedia Authorware
7. Automator
8. vvvv
9. Aviary Peacock, визуальная лаборатория на основе просмотра файлов
10. Baltie
11. Befunge, эзотерический текстовый язык программирования, в котором команды
размещаются графически в текстовом файле
12. CODE
13. eXpecco, основанный на графическом потоке язык программирования и среда
разработки для автоматизации тестирования
14. JMCAD среда графической разработки систем для промышленности, инженеров и
учёных
15. Flow
16. Kwikpoint, пиктограммный визуальный транслятор, созданный Аланом Стилманом
17. LabVIEW, среда графического программирования, разработанный для инженеров и
учёных
18. HiAsm, конструктор программ
19. MQL-Studio for HiAsm, пакет для разработки экспертов, скриптов, индикаторов на
языке MQL5 в визуальном редакторе программ HiAsm.
20. ДРАКОН, язык, созданный для разработки Советского Бурана (космического
корабля)
21. Miracle C Compiler, среда графического программирования, позволяющая
формировать матрицу отношений компонентов платформы (сайт: http://www.ccompiler.com)
22. LogicProgram, язык, среда графического программирования, позволяющая
формировать матрицу отношений компонентов платформы
23. Thyrd, свободная, открытая графическая среда программирования (иерархия
графических примитивов) на базе Forth (Форт) языка
1.
2.
3.
4.
4. MS VISUAL BASIC
Microsoft Visual Basic — средство разработки программного обеспечения,
разрабатываемое корпорацией Microsoft и включающее язык программирования и среду
разработки. Язык Visual Basic унаследовал дух, стиль и отчасти синтаксис своего
предка — языка Бейсик, у которого есть немало диалектов. В то же время Visual Basic
сочетает в себе процедуры и элементы объектно-ориентированных и компонентноориентированных языков программирования. Среда разработки VB включает
инструменты для визуального конструирования пользовательского интерфейса.
Visual Basic считается хорошим средством быстрой разработки прототипов программы,
для разработки приложений баз данных и вообще для компонентного способа создания
программ, работающих под управлением операционных систем семейства Microsoft
Windows.
Первое признание серьёзными разработчиками Visual Basic получил после выхода версии
3 — VB3. Окончательное признание как полноценного средства программирования для
Windows — при выходе версии 5 — VB5. Версия VB6, входящая в состав Microsoft Visual
Studio 6.0, стала по-настоящему зрелым и функционально богатым продуктом. После
этого разработчики из Microsoft существенно изменили направление развития данной
технологии.
Visual Basic .NET не позволяет программировать по-старому, ибо по сути является
совершенно другим языком, таким же, как и любой другой язык программирования для
платформы .NET. Индивидуальность языка, так же как и его преимущества (простота,
скорость создания программ, лёгкость использования готовых компонентов) при
использовании в среде .NET не имеют такого значения, как раньше — всё сосредоточено
на возможностях самой системы .NET, на её библиотеке классов. Поэтому сегодня (май
2012 года) нужно говорить о классическом Visual Basic, его диалектах Visual Basic for
Applications (VBA) и Visual Basic Scripting Edition (VBScript) и о языке для платформы
.NET — Visual Basic .NET.
4.1. Эволюция Visual Basic


май 1991 — выпущен Visual Basic 1.0 для Microsoft Windows. За основу языка был
взят синтаксис QBasic, а новшеством, принесшим затем языку огромную
популярность, явился принцип связи языка и графического интерфейса. Этот
принцип был разработан Аланом Купером (Alan Cooper) и реализован в прототипе
Tripod (также известном как Ruby). Первый Visual Basic был интерпретатором.
сентябрь 1992 — выпущен Visual Basic 1.0 под DOS. Он не был полностью
совместим с Windows-версией VB, поскольку по сути являлся следующей версией
QuickBASIC и работал в текстовом режиме экрана.
Интересно отметить, что в составе была специальная утилита, которая
конвертировала проекты данной версии в проекты Visual Basic 1.0. Она делала код
максимально совместимым с Windows-версией, конвертировала формы (хотя
результат получался неудовлетворительным из-за различий текстового и
графического режима), а также давала в коде комментарии с подсказками по
дальнейшему улучшению.







ноябрь 1992 — выпущен Visual Basic 2.0. Среда разработки стала проще в
использовании и работала быстрее.
летом 1993 — вышел в свет Visual Basic 3.0 в версиях Standard и Professional. Ко
всему прочему, в состав поставки добавился движок для работы с базами данных
Access.
август 1995 — Visual Basic 4.0 — версия, которая могла создавать как 32-х так и
16-разрядные Windows-программы. Кроме того, появилась возможность писать на
VB классы, а также Visual Basic наконец-то стал полноценным компилятором, что
значительно увеличило скорость выполнения программ.
февраль 1997 — Visual Basic 5.0 — начиная с этой версии, стало возможно, наряду
с обычными приложениями, разрабатывать COM-компоненты. Скомпилировав
такой компонент в OCX-файл и поставляя его, можно было предоставить свой
объект управления не только конечному пользователю, но и другим разработчикам,
после чего они могли интегрировать этот объект в свои приложения.
В середине 1998 — вышла Visual Basic 6.0. После этого Microsoft резко изменила
политику в отношении языков семейства Basic. Вместо развития Visual Basic, был
создан абсолютно новый язык Visual Basic .NET, первая версия которого появилась
в 2001. Это принципиально новый язык, имеющий, помимо синтаксиса, очень мало
схожего с VB 6.0; и отличаясь от него так же сильно, как в своё время VB
отличался от QBASIC. VB.NET сразу же занял место VB в Visual Studio, и на этом
развитие классического Visual Basic остановилось.
В 2005 году вышла новая версия Visual Basic, в комплекте Visual Studio.
Порадовала она новым интерфейсом и возможностями. Язык основан на Visual
Basic.NET. Она не была классической версией VB.
В конце 2007 Microsoft выпустила новую версию Visual Basic — Visual Basic 2008,
которая также была основана на Visual Basic.NET.
4.2. Основные разновидности Visual Basic
4.2.1. Классический Visual Basic (версии 5-6)
Этот язык очень сильно привязан к своей среде разработки и к операционной системе
Windows, являясь исключительно инструментом написания Windows-приложений.
Привязка к среде заключается в том, что существует большое количество средств,
предназначенных для помощи и удобства программирования: встроенный отладчик,
просмотр переменных и структур данных на лету, окно отладки, всплывающая подсказка
при наборе текста программы (IntelliSense). Все эти преимущества делают бесполезным и
даже невозможным использование Visual Basic вне среды разработки, например в
обычном текстовом редакторе.
4.2.2. Visual Basic for Applications (VBA)
Основная статья: VBA
Это средство программирования, практически ничем не отличающееся от классического
Visual Basic, которое предназначено для написания макросов и других прикладных
программ для конкретных приложений. Наибольшую популярность получил благодаря
своему использованию в пакете Microsoft Office. Широкое распространение Visual Basic
for Applications в сочетании с изначально недостаточным вниманием к вопросам
безопасности привело к широкому распространению макровирусов.
Особенности:


Оператор \ — деление нацело, любая дробная часть отсекается.
Перед выполнением операции a\b a и b округляются до целого.
4.2.3. Visual Basic Scripting Edition (VBScript)
Основная статья: Visual Basic Scripting Edition
Скриптовый язык, являющийся несколько усечённой версией обычного Visual Basic.
Используется в основном для автоматизации администрирования систем Windows, а
также для создания страниц ASP и сценариев для Internet Explorer.
4.3. Достоинства и недостатки
4.3.1. Достоинства





Высокая скорость создания приложений с графическим интерфейсом для MS
Windows.
Простой синтаксис, позволяющий очень быстро освоить язык.
Возможность компиляции как в машинный код, так и в P-код (по выбору
программиста). В режиме отладки программа всегда (вне зависимости от выбора)
компилируется в P-код, что позволяет приостанавливать выполнение программы,
вносить значительные изменения в исходный код, а затем продолжать выполнение:
полная перекомпиляция и перезапуск программы при этом не требуется.
Защита от ошибок, связанных с применением указателей и доступом к памяти.
Этот аспект делает Visual Basic приложения более стабильными, но также является
объектом критики.
Возможность использования большинства WinAPI функций[1] для расширения
функциональных возможностей приложения. Данный вопрос наиболее полно
исследован Дэном Эпплманом, написавшим книгу «Visual Basic Programmer’s
Guide to the Win32 API».
4.3.2. Недостатки




Поддержка операционных систем только семейства Windows и Mac OS X
(Исключение — VB1 for DOS).
Отсутствие механизма наследования реализации объектов[2]. Существующее в
языке наследование позволяет наследовать только интерфейсы, но не их
реализацию.
Требует установленную msvbvmXX.dll[3] для работы программы.
Низкая скорость работы, обусловленная тем, что практически все встроенные
функции языка реализованы через библиотеку времени исполнения (runtime
library), которая, в свою очередь, производит много «лишней» работы по проверке
и/или преобразованию типов.
4.3.3. Критика


Часто критике подвергаются такие аспекты Visual Basic, как возможность
отключить средства слежения за объявленными переменными, возможность
неявного преобразования переменных, наличие типа данных «Variant». По мнению
критиков, это даёт возможность писать крайне плохой код. С другой стороны, это
можно рассматривать как плюс, так как VB не навязывает «хороший стиль», а даёт
больше свободы программисту.
Отсутствие указателей, низкоуровневого доступа к памяти, ASM-вставок.
Несмотря на то, что парадигма Visual Basic позволяет среднему VB-программисту
обходиться без всего этого, перечисленные вещи также нередко становятся
объектами критики. И хотя, используя недокументированные возможности и
определённые ухищрения, всё это можно реализовать и на VB (например с
помощью функций для получения указателей VarPtr(), StrPtr() и ObjPtr());
пользоваться этими трюками гораздо сложнее, чем, например, на Си++.
Однако стоит отметить, что все недостатки языка вытекают из его основного
достоинства — простоты разработки графического интерфейса. Поэтому многие
программисты используют Visual Basic для разработки интерфейса пользователя, а
функциональность программы реализуют в виде динамически подключаемых библиотек
(DLL), написанных на другом языке (чаще всего C++).