Средство визуального проектирования для создания графического интерфейса

Введение в разработку графического интерфейса пользователя – учебный курс по IDE NetBeans

Предоставлено Салимом Гулом (Saleem Gul) и Томасом Павеком (Tomas Pavek)

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

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

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

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

Более детальное руководство по функциям разработки конструктора графического интерфейса пользователя, включая видеодемонстрации различных функций разработки см. в разделе Разработка графического пользовательского интерфейса Swing в IDE NetBeans.

Предполагаемая продолжительность: 20 минут

Упражнение 1: Создание проекта

Первым действием является создание проекта среды IDE для разрабатываемого приложения. Дадим проекту имя NumberAddition.

1. Выберите “Файл” > “Создать проект”. Также можно щелкнуть значок “New Project” на панели инструментов среды IDE.
2. В области “Categories” выберите узел “Java”. В области “Projects” выберите “Java Application”. Нажмите кнопку “Далее”.
3. Введите NumberAddition в поле Project Name (“Имя проекта”) и укажите путь, например, в вашем основном каталоге, как местоположение проекта.
4. Установите флажок “Использовать отдельную папку для хранения библиотек” и укажите местоположение папки библиотек (необязательно). Дополнительная информация приведена в статье Предоставление доступа к библиотеке другим пользователям в документе Разработка приложений с помощью NetBeans IDE.
5. Удалите флажок “Create Main Class”, если он установлен.
6. Нажмите кнопку 'Готово'.

Упражнение 2: Создание внешнего интерфейса

Для продолжения процесса создания интерфейса необходимо создать контейнер Java, в который будут помещены другие требуемые элементы графического интерфейса. В этом действии контейнер будет создан с помощью элемента JFrame. Контейнер будет помещен в новый пакет, который будет отображаться в узле “Source Packages”.

1. В окне 'Проекты' щелкните правой кнопкой мыши узел NumberAddition и выберите Создать > Другие.
2. В диалоговом окне создания файла выберите категорию Swing GUI Forms и тип файла JFrame Form. Нажмите кнопку “Далее”.
3. Введите NumberAdditionUI в качестве имени класса.
4. Выберите пакет my.numberaddition.
5. Нажмите кнопку 'Готово'.

Среда IDE создает форму NumberAdditionUI и класс NumberAdditionUI в приложении NumberAddition и открывает форму NumberAdditionUI в GUI Builder. Пакет my.NumberAddition заменяет собой пакет по умолчанию.

Добавление элементов: создание внешнего интерфейса

Далее с помощью окна “Palette” внешний интерфейс приложения заполняется панелью JPanel.

После этого добавляются три элемента JLabel (текстовые подписи), три элемента JTextField (текстовые поля) и три элемента JButton (кнопки).

Если до этого работа с конструктором графического интерфейса пользователя не выполнялась сведения о размещения компонентов см. в разделе Разработка графического пользовательского интерфейса Swing в IDE NetBeans.

После перетаскивания и размещения указанных выше элементов элемент JFrame должен выглядеть так, как показано на рисунке ниже.

Если в правом верхнем углу среды IDE отсутствует окно Palette (“Палитра”), выберите Window (“Окно”) > Palette (“Палитра”).

1. Для начала выберите панель из категории Swing Containers (“Контейнеры Swing”) в палитре и перетащите ее на JFrame.
2. Панель JPanel будет выделена. Перейдите к окну “Properties” и нажмите кнопку с многоточием (…) рядом с полем “Border” для выбора стиля границы.
3. В диалоговом окне “Border” выберите “TitledBorder” из списка и введите Number Addition в поле “Title”. Для сохранения изменений и закрытия диалогового окна нажмите кнопку “OK”.
4. Теперь на экране должен отображаться пустой элемент “JFrame” с заголовком “Number Addition”, как показано на рисунке. Согласно рисунку добавьте к нему три метки JLabel, три текстовых поля JTextField и три кнопки JButton.

Переименование элементов

На этом этапе будет выполнено переименование элементов, которые были добавлены к элементу JFrame.

1. Дважды щелкните jLabel1 и измените ntrcn (свойство “text”) на First Number.
2. Дважды щелкните jLabel2 и измените текст на Second Number.
3. Дважды щелкните jLabel3 и измените текст на Result.
4. Удалите стандартный текст из jTextField1. Отображаемый текст можно преобразовать в редактируемый. Для этого щелкните правой кнопкой мыши текстовое поле и выберите 'Редактировать текст' во всплывающем меню. При этом может потребоваться восстановить первоначальный размер поля jTextField1. Повторите это действие для полей jTextField2 и jTextField3.
5. Измените отображаемый текст jButton1 на Clear. (Для изменения текста кнопки щелкните кнопку правой кнопкой мыши и выберите “Edit Text”. В качестве альтернативы можно щелкнуть кнопку, выдержать паузу и щелкнуть еще раз.)
6. Измените отображаемый текст jButton2 на Add.
7. Измените отображаемый текст jButton3 на Exit.

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

Упражнение 3: Добавление функциональности

В этом упражнении будет добавлена необходимая функциональность к кнопкам “Add”, “Clear” и “Exit”. Поля jTextField1 и jTextField2 будут использоваться для ввода значений пользователем, а jTextField3 – для вывода результата работы программы. Создаваемая программа представляет собой простейший калькулятор. Итак, приступим!

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

1. Щелкните правой кнопкой мыши кнопку “Exit”. Во всплывающем меню выберите Events (“События”) > Action (“Действие”) > actionPerformed. Учтите, что меню содержит множество других событий, на которые может реагировать программа! При выборе события actionPerformed среда IDE автоматически добавит прослушиватель ActionListener к кнопке Exit (“Выход”) и создаст метод обработчика для обработки метода прослушивателя actionPerformed.
2. В среде IDE автоматически открывается окно “Source Code”, где отображается место вставки действия, которое должно выполняться кнопкой при ее нажатии (с помощью мыши или клавиатуры). Окно “Source Code” должно содержать следующие строки:private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) { //TODO add your handling code here: }
3. Теперь добавим код действия, которое должна выполнять кнопка “Exit”. Замените строку TODO на System.exit(0);. Готовый код кнопки “Exit” должен выглядеть следующим образом:private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) { System.exit(0); }

Добавление функциональности к кнопке “Clear”

1. Щелкните вкладку “Design” в верхней части рабочей области для возврата к экрану “Form Design”.
2. Щелкните правой кнопкой мыши кнопку “Clear” (jButton1). В появившемся меню выберите “Events > Action > actionPerformed”.
3. Нажатие кнопки “Clear” должно приводить к удалению всего текста из всех текстовых полей “jTextField”.

   Для этого следует добавить код, аналогичный приведенному выше. Готовый исходный код должен выглядеть следующим образом:private void jButton1ActionPerformed(java.awt.event.ActionEvent evt){ jTextField1.setText(“”); jTextField2.setText(“”); jTextField3.

   setText(“”); }

Этот код удаляет текст из всех трех полей JTextField, оставляя их пустыми.

Добавление функциональности к кнопке “Add”

Кнопка “Add” должна выполнять три действия.

1. Сначала она принимает данные, введенные пользователем в полях jTextField1 и jTextField2, и преобразовывает их из типа “String” в тип “Float”.
2. Затем она выполнит сложение двух чисел.
3. И, наконец, она преобразует сумму в тип String и поместит ее в jTextField3.

Начнем!

1. Щелкните вкладку “Design” в верхней части рабочей области для возврата к экрану “Form Design”.
2. Щелкните правой кнопкой мыши кнопку “Add” (jButton2). Во всплывающем меню выберите Events (“События”) > Action (“Действие”) > actionPerformed.
3. Добавьте код действий, которые должна выполнять кнопка “Add”. Готовый исходный код должен выглядеть следующим образом:private void jButton2ActionPerformed(java.awt.event.ActionEvent evt){ // First we define float variables. float num1, num2, result; // We have to parse the text to a type float. num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Now we can perform the addition. result = num1+num2; // We will now pass the value of result to jTextField3. // At the same time, we are going to // change the value of result from a float to a string. jTextField3.setText(String.valueOf(result)); }

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

Упражнение 4: Выполнение программы

Для выполнения программы в среде IDE выполните следующие действия:

1. Выберите Run (“Запуск”) > Run Main Project (“Запуск главного проекта”) (как вариант, нажмите F6).

   Примечание. При открытии окна с указанием того, что для Project NumberAddition не задан основной класс, следует выбрать my.NumberAddition.NumberAdditionUI в качестве основного класса в том же окне и нажать кнопку ОК.

Для запуска программы вне среды IDE выполните следующие действия:

1. Для сборки архива JAR приложения выберите “Run > Clean and Build Main Project” (Shift-F11).
2. При помощи проводника по файловой системе или диспетчера файлов перейдите в каталог NumberAddition/dist.

   Примечание. Местоположение каталога проекта NumberAddition зависит от пути, указанного при создании проекта в шаге 3 в разделе Упражнение 1. Создание проекта.

3. Дважды щелкните файл NumberAddition.jar.

Через несколько секунд приложение запустится.

Примечание. Если при двойном щелчке файла JAR не выполняется запуск приложения, дополнительные сведения о настройке связей файлов JAR в используемой операционной системе см эту статью.

Можно также запустить приложение из командной строки.

Для запуска приложения из командной строки выполните следующие действия:

1. Вызовите командную строку или окно терминала.
2. В командной строке измените текущий каталог на каталог NumberAddition/dist.
3. В командной строке введите следующий оператор:java -jar NumberAddition.jar

   Примечание. Убедитесь, что my.NumberAddition.NumberAdditionUI задан как основной класс до запуска приложения.

   Для провери этого, щелкните правой кнопкой узел мыши узел проекта NumberAddition на панели 'Проекты', выберите 'Свойства' во всплывающем меню и выберите категорию 'Выполнить' в диалоговом окне 'Свойства проекта'. В поле 'Основной класс' должно отображаться my.numberaddition.NumberAdditionUI.

Механизм обработки событий

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

1. Вернитесь к файлу NumberAdditionUI.java в редакторе. Щелкните вкладку “Design” для просмотра структуры графического интерфейса в GUI Builder.
2. Щелкните правой кнопкой мыши любой элемент графического интерфейса и выберите “Events” в появившемся меню. Теперь можно просто изучить содержимое меню, не выбирая каких-либо пунктов.
3. В качестве альтернативы можно выбрать “Properties” в меню “Window”. В окне “Properties” щелкните вкладку “Events”. Вкладка “Events” позволяет просмотреть и изменить обработчики событий, связанные с текущим активным элементом графического интерфейса.
4. Приложение также может реагировать на нажатие клавиш, одинарный, двойной или тройной щелчок мышью, перемещение указателя мыши, изменение размера окна и перемещение фокуса ввода. Меню “Events” позволяет автоматически создать обработчики событий для всех этих событий. Наиболее распространенным из них является событие “Action”. (Для получения дополнительных сведений см. практические рекомендации по обработке событий в руководстве Sun Java Events Tutorial.)

Как выполняется обработка событий? При каждом выборе события из меню событий среда IDE автоматически создает так называемый прослушиватель событий и связывает его с компонентом разработчика. Для более подробного ознакомления с процессом обработки событий выполните следующие действия.

1. Вернитесь к файлу NumberAdditionUI.java в редакторе. Щелкните вкладку “Source” для просмотра исходного кода графического интерфейса.
2. Выполните прокрутку вниз и просмотрите реализованные методы jButton1ActionPerformed(), jButton2ActionPerformed() и jButton3ActionPerformed(). Эти методы называются обработчиками событий.
3. Теперь перейдите к методу initComponents(). Если этот метод отсутствует, найдите строку Generated Code и щелкните знак + рядом с этой строкой для отображения скрытого метода initComponents().
4. Обратите внимание на синий блок, окружающий метод initComponents(). Этот код был автоматически создан средой IDE и не может быть изменен пользователем.
5. Теперь посмотрите на сам метод initComponents(). Помимо прочего, он содержит код, инициализирующий элементы графического интерфейса и помещающий их в форму. Этот код создается и обновляется автоматически при размещении и изменении элементов в режиме проектирования.
6. В методе initComponents() найдите следующий фрагмент:jButton3.setText(“Exit”);
   jButton3.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { jButton3ActionPerformed(evt); } });

   В этом месте к элементу графического интерфейса, в данном случае к jButton3, добавляется объект прослушивания событий “ActionListener”.

   Интерфейс “ActionListener” имеет метод “actionPerformed” объекта “ActionEvent”, который реализуется путем простого вызова обработчика событий jButton3ActionPerformed. Теперь эта кнопка реагирует на события действий.

   Каждый раз при нажатии кнопки создается событие “ActionEvent”, которое передается в метод “actionPerformed” интерфейса прослушивания событий, исполняющий код, предусмотренный разработчиком для этого события в обработчике событий.

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

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

Отправить отзыв по этому учебному курсу

Дополнительные сведения

Источник: https://netbeans.org/kb/docs/java/gui-functionality_ru.html

Методы и средства разработки пользовательского интерфейса: современное состояние

Клещев А.С., Грибова В.В. 25.03.2001

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

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

По оценкам специалистов в среднем она составляет более половины времени реализации проекта [1]. Актуальным является снижение затрат на разработку и сопровождение программных систем или разработка эффективного программного инструментария, где под эффективностью понимается простота разработки, легкость сопровождения и удобство работы с программой [2].

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

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

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

В литературе не существует единой общепринятой классификации средств для разработки пользовательского интерфейса.

Так, в [3] программное обеспечение для разработки пользовательского интерфейса разделяется на две основные группы – инструментарий для разработки пользовательского интерфейса (toolkits) и высокоуровневые средства разработки интерфейса (higher-level development tools).

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

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

К таким средствам авторы относят построители диалога (interface builders) и СУПИ – системы управления пользовательским интерфейсом (User Interface Management Systems – UIMS). Помимо СУПИ, некоторые авторы используют такие термины, как User Interface Development Systems (UIDS) – системы разработки пользовательского интерфейса, User Interface Design Environment (UIDE) – среда разработки пользовательского интерфейса и др.

В [4] инструментарий для разработки интерфейса разделен на три группы, которые определяются следующим образом.

В первую группу входит инструментарий для поддержки создания интерфейса написанием кода – UIMS и Toolkits; во вторую – интерактивные инструментальные средства, позволяющие сконструировать интерфейс из “заготовок” (кнопок, меню, полос прокрутки и т.д.

), – Interface Builders; третий тип основан на создании интерфейса путем связывания отдельно созданных его компонент – Component Architectures.

Как замечено в [2], терминология данного направления окончательно не сформировалась и в настоящее время также является предметом исследования. Однако в большинстве работ для ссылки на специализированные средства для разработки интерфейса приводится термин СУПИ, который и будет использоваться в данной работе.

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

Можно выделить несколько основных способов спецификации интерфейса [2].

1. Языковой, когда применяются специальные языки для задания синтаксиса интерфейса (декларативные, объектно-ориентированные, языки событий и др.).

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

3. Спецификация интерфейса, основанная на объектно-ориентированном подходе, связана с принципом, называемым непосредственное манипулирование.

Основное его свойство – взаимодействие пользователя с индивидуальными объектами, а не со всей системой как единым целым.

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

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

Основной концепцией СУПИ является отделение разработки пользовательского интерфейса от остального приложения. В настоящее время идея раздельного проектирования интерфейса и приложения либо закреплена в определении СУПИ, либо является основным его свойством [5].

В [6] состав СУПИ определен как набор инструментов этапа разработки и периода исполнения. Инструменты этапа разработки оперируют с моделями интерфейса для построения их проектов.

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

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

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

Поведение интерфейса и прикладной программы определяется характером взаимодействия с пользователем. Можно выделить три различных типа взаимодействия [2]: инициатива диалога принадлежит пользователю, прикладной программе либо является смешанной.

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

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

Смешанная инициатива управления. Данный тип взаимодействия объединяет два предыдущих подхода, при котором пользователь определяет входные данные, но если прикладной программе для решения необходимы дополнительные данные, то она запрашивает их у пользователя.

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

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

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

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

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

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

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

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

По определению, например, в [8], пользовательский интерфейс предназначен для обеспечения взаимодействия между пользователем и процессом, выполняющим некоторое задание – прикладной программой.

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

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

Ориентация на конечного пользователя означает, что интерфейс должен иметь возможности для представления исходных данных и результатов в виде, общепринятом в данной предметной области, либо в зависимости от категорий пользователей и их пожеланий: графическом, табличном, вербальном, причем каждое из них также может иметь несколько видов представлений. Иными словами, как отмечено в [10], для одной и той же информации могут существовать различные передающие сообщения, образующие класс эквивалентных сообщений. При этом всегда существует базисная система сообщений, в которой можно выразить любую информацию о предметной области, однозначно понимаемую и интерпретируемую всеми ее представителями, и к которой сводятся все сообщения пользователя. Такой системой сообщений является система понятий предметной области. В терминах системы понятий именуются объекты предметной области, формулируются утверждения о том, что они обладают некими свойствами и характеристиками, которые позволяют устанавливать сходство и различие объекта по отношению к другим объектам, а также указывают на взаимоотношения, в которых объекты находятся между собой. Таким образом, составляющей пользовательского интерфейса является описание информации через систему понятий предметной области, задающей функцию интерпретации сообщений.

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

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

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

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

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

Таким образом, составной частью пользовательского интерфейса, неразрывно связанной с передачей сообщений, является определение формы сообщений.

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

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

Эти правила должны задавать последовательность переходов от одного состояния к другому.

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

Таким образом, в состав пользовательского интерфейса входят:

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

средства управления взаимодействием пользователя и интерфейса.

Источник: http://guimachine.ru/?p=937

Основные принципы разработки графического пользовательского интерфейса

Введение

Правила проектирования пользовательского интерфейса

Правило 1: дать контроль пользователю

Правило 2: уменьшить нагрузку на пользователя

Правило 3: сделать интерфейс совместимым

Руководящие принципы

Программа “Tidy Start Menu”

Заключение

Литература

“Золотое правило проектировщика гласит: “Никогда не делай другим того, что они сделали тебе”. Вспомните, что вам не нравится в программном обеспечении, которым вы пользуетесь. И не делайте того же самого в программе, над которой работаете.”

Трэйси Леонард

Почему надо следовать принципам построения пользовательского интерфейса?

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

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

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

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

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

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

Три принципа разработки пользовательского интерфейса формулируются так:

1)контроль пользователем интерфейса;

2)уменьшение загрузки памяти пользователя;

3)последовательность пользовательского интерфейса.

Хансен представил первый список принципов проектирования[2]. Принципы таковы:

1)знать пользователя;

2)сократить запоминание;

3)оптимизировать операции;

4)устранить ошибки.

Многие крупные производители операционных систем, выпусти на рынок свои новые продукты, публикуют соответствующие руководства и инструкции. В этих изданиях раскрываются принципы подхода к проектированию интерфейса. Руководства выпускали Apple Computer, Inc. (1992), IBM Corporation (1992), Microsoft Corporation (1995) и UNIX OSF/Motif (1993).

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

“Несовместимость интерфейса может стоить большой компании миллионов долларов убытка из-за потери продуктивности и увеличения стоимости технической поддержки.” – Джесси Брист.

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

Данные принципы выдержали проверку временем и появлением новых компьютерных технологий.

Якоб Нильсен заметил: “Принципы останутся основополагающими даже если программа будет иметь футуристичный трехмерный дизайн с печаткой “DataGlove”, служащей для ввода, будут распознаваться движения и “живые” видеоизображения. Они будут актуальны, поскольку выражают основную идею диалога с машиной при помощи команд”[8].

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

Пользовательские модели и модели проектировщика также различны и влияют на то, как будут применяться принципы. На некоторых важных этапах разработки проекта может встать вопрос: “Что произойдет далее?”.

Ответ должен быть таким: “Что захочет пользователь!”.

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

“Делай это проще, но не примитивнее.”

Альберт Эйнштейн

Правило 1: дать контроль пользователю

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

Поэтому дорожки никогда не прокладывают одновременно с возведением зданий. На площадках между домами помещаются таблички с надписью: “Пожалуйста ходите по траве”.

Через некоторое время строители возвращаются и только теперь, согласно “волеизъявлению” населения, заливают протоптанные дорожки асфальтом.

Принципы, которые дают пользователю контроль над системой:

1)использовать режимы благоразумно;

2)предоставить пользователю возможность выбирать: работать либо мышью, либо клавиатурой, либо их комбинацией;

3)позволить пользователю сфокусировать внимание;

4)демонстрировать сообщения, которые помогут ему в работе;

5)создать условия для немедленных и обратимых действий, а также обратной связи;

6)обеспечить соответствующие пути и выходы;

7)приспосабливайте систему к пользователям с различным уровнем подготовки;

8)сделать пользовательский интерфейс более понятным;

9)дать пользователю возможность настраивать интерфейс по своему вкусу;

10)разрешить пользователю напрямую манипулировать объектами интерфейса;

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

Возможность работы с клавиатурой использование клавиатуры вместо мыши. Это значит, что пользователю будет легче работать, просто он либо не может ею пользоваться, либо ее у него нет. Панели инструментов созданы, чтобы ускорить работу при использовании мыши. Однако при работе с клавиатурой до них нельзя добраться — для подобных случаев предусмотрены “выпадающие” меню.

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

Во всем интерфейсе использовать понятные для пользователя термины. Они не обязаны знать о битах и байтах!

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

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

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

Вторжение Internet показало, что навигация — основная интерактивная техника в Internet. Если пользователь понимает, как зайти на нужную страницу в WWW, то существует 80-процентная вероятность, что он разберется в интерфейсе.

Люди осваивают методы работы с браузером очень быстро.

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

Пользовательский интерфейс — “мифическая” часть программного продукта. При хорошем проекте пользователи даже не ощущают его “присутствия”.

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

Задача интерфейса — помочь людям почувствовать себя находящимся как бы “внутри” компьютера, свободно манипулировать и работать с объектами. Это и называется “прозрачным” интерфейсом!

Источник: http://MirZnanii.com/a/113833/osnovnye-printsipy-razrabotki-graficheskogo-polzovatelskogo-interfeysa

Программирование на Visual Basic.NET, Создание графического интерфейса | Programmirovanie-dla-sсhool

Урок из серии  “Программирование на Visual Basic.NET для школьников”

Продолжим изучать систему программирования Visual Basic.NET 2003.

На предыдущем уроке мы настроили среду разработки Visual Studio.NET на язык программирвания Visual Basic.

В этом уроке мы познакомимся с основными инструментами среды разработки  Visual Studio.NET и с  основными этапами создания проектов.

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

Создание проекта

1. Для запуска среды программирования  Visual Studio.Net выполните команду:
   Пуск – Все программы – Microsoft Visual Basic.NET – Microsoft Visual Studio.NET 2003.

   Загрузится Начальная страница Visual Studio.

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

2. Нажмите кнопку Создать проект. Появиться диалоговое окно Создать проект.

   На левой стороне представлены Типы проектов, на правой показаны так называемые Шаблоны, которые относятся к выбранному типу проекта.

   Для того, чтобы создать приложение  Windows:

   • В списке Типы проектов выберите тип Проекты Visual Basic.
   • В окне Шаблоны выберите шаблон Приложение для Windows.
   • В текстовом поле Имя введите имя проекта
   • В поле Расположение укажите путь для хранения файлов проекта.  Чтобы выбрать папку на диске, можно нажать кнопку Обзор.
   • Нажмите ОК.
3. Откроется новый созданный проект и на экране отобразится пустая графическая форма Windows (обычно имеющая название Form1), на основе которой вы будите создавать интерфейс для пользователя вашего приложения.

   Вы видите все основные инструменты среды разработки Visual Studio:

   • Окно формы. Окно будущего приложения.
   • Область элементов. Содержит элементы управления, которые можно использовать для создания интерфейса пользователя.
   • Обозреватель решений. Содержит файлы проекта.
   • Окно Свойства. Отображает свойства текущего объекта

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

Визуальное проектирование интерфейса пользователя

После создания проекта открылась наша первая форма.

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

Вы можете изменить размеры представленной формы и другие её свойства.

Свойства формы отображаются в окне Свойства в правой части среды разработки. Эти свойства разделены на группы и их довольно много. Некоторые свойства имеют свои подсвойства. Например, свойство Font (Шрифт) имеет подсвойства: Name,  Size и др.

Изменением этих свойств мы можем полностью видоизменить данную форму. Например, изменением свойства BackColor мы можем изменить цвет фона этой формы.

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

Как мы то будем делать?

В названии содержится  слово Visual, которое подсказывает способ, при помощи которого создается графический интерфейс.

Это делается визуально, то есть на глаз..

Программист выбирает элементы управления  из Области элементов Visual Studio и рисует их в нужном месте окна приложения.  Это похоже на то, как создаются простейшие фигуры  в графическом редакторе.

Если Область элементов не видна, то её можно вывести на экран,  выполнив команду Вид – Область элементов.

Давайте установим на Форме,  например, Кнопку (Button).

Для размещения кнопки на форме,  щелкните соответствующую элемент в Области элементов, а затем установите указатель мыши в нужном месте на форме, протяните мышь вниз и вправо.

Появиться серая рамка – это контуры будущей кнопки. Доведите курсор мыши до нужного размера объекта и опустите кнопку мыши. На форме появиться выбранный вами элемент управления с маркерами изменения размера.

Как только элемент управления из панели Область элементов поместили на форму, он превращается в объект, так как уже имеет  набор свойств по умолчанию: цвет, шрифт, местоположение.

Например, элемент управления Button станет объектом Button1 (кнопкой) и будет иметь свойства, которые ему предписаны по умолчанию.

Значения свойств элементов управления можно настраивать (изменить) после их размещения на форме.

Для установки свойств какого-либо объекта необходимо его выделить, щелкнув по нему мышью.  Тогда в окне Свойства отображаются свойства этого объекта, в этом окне их можно будет настраивать.

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

Для удаления элемента управления достаточно его выделить и нажать клавишу Delete.

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

Программный код проекта

Давайте посмотрим, какой код Visual Basic автоматически создал для нашей Формы.

Для этого в окне Обозреватель решений нажмите кнопку Посмотреть код. В центральном окне отобразится код, появиться новая вкладка Form1.vb.

Теперь с помощью вкладок Form1.vb[Design] и Form1.vb можно будет перемещаться с Формы в соответствующий код, и обратно.

За пиктограммой со знаком «+» скрывается свертываемый блок кода, который называется «Код, автоматически созданный конструктором форм Windows».

Этот блок кода находится между командами #Region и #End Region.

Во время визуального проектирования Формы, ввода в неё элементов с панели Область элементов, файл Form.vb будет автоматически дополняться.

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

Таким образом, в создание проекта можно выделить несколько последовательных этапов.

Этапы создания проекта на Visual Basic.NET

Для создания проекта с самого начала, необходимо выполнить четыре  основных шага:

1. Создать новый проект.
2. Создать графический интерфейс пользователя c помощью элементов управления из Области элементов Visual Studio.
3. Настроить свойства этих элементов управления.
4. Написать программный код, который определит, что будет делать ваша  программа.

В этом уроке мы познакомились с основными инструментами разработки в среде Visual Studio и с  основными этапами создания проектов.

В следующем уроке мы создадим наш первый проект.

Следующий урок: Создание первого проекта в Visual Basic.NET

Источник: http://gospodaretsva.com/urok-2-graficheskij-interfejs-proekta.html

Программная среда для визуального проектирования баз знаний

Т.Е.Гелеверя, В.А.Горовой

Институт Высокопроизводительных Вычислений и Баз Данных при
СПбГПУ (Политех), 191187, СПб, наб. р. Фонтанки д. 6,

Тел.: (812) 275-45-65, факс: (812) ???, e-mail:
vgorovoy@mail.ru

Введение

В последние годы в связи со стремительным развитием информационных технологий возникла потребность в так называемом CAKE-инструментарии (Computer Aided Knowledge Engineering – средства, ориентированные на поддержку инженерии знаний). К CAKE-инструментарию относятся оболочки и инструментальные пакеты для

создания экспертных систем.

Среди инструментальных пакетов [Гаврилова, Хорошевский, 2000] специалисты
выделяют ART [ART, 1984], KEE [Florentin, 1987] и Knowledge
Craft [CARNEGIE, 1987].

Краткое описание этих систем можно найти в работах [Wall et al., 1986; Richer, 1986; Gillmore et al., 1985]. В середине 90-х годов в класс самых мощных и развитых систем вошла среда G2 [Попов, 1996].

Все вышеперечисленные пакеты являются многофункциональными, мощными и достаточно

дорогими системами.

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

распространяемых оболочек можно выделить:

CLIPS ( http://www.jsc.nasa.gov/~clips/CLIPS.htm ) и связанные
системы –

DYNACLIPS ( http://ai.iit.nrc.ca/fuzzy/fuzzy.html ),

wxCLIPS ( http://www.aiai.ed.ac.uk/~jacs/wxclips/wxclips.html ).

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

SOAR ( ftp.cs.cmu.edu:/user/ai/areas/expert/systems/ops5/ops5.tar.gz ),

RT – EXPERT ( ftp.hcrl.open.ac.uk:/pub/software/pc/MIKEV25.ZIP ),

BABYLON ( http://www.gmd.de/ ),

WindExS ( etoupin@aol.com ),

ES ( http://vvv.com/ai/ ),
Easy Reasoner ( http://www.haley.com ), ECLIPSE ( http://www.haley.com ),
EXSYS Professional ( http://www.exsysinfo.com ). К сожалению,
большинство коммерческих оболочек достаточно дороги.

Среди российских разработок последних лет в этой области следует упомянуть о
SIMER+MIR [Осипов, 1997], а также об инструментальном комплексе
АТ-ТЕХНОЛОГИЯ [Рыбина, 1998].

Визуальный инструментарий CAKE v2.0

Таким образом, на рынке инструментальных средств имеется потребность в недорогих и простых в изучении и использовании оболочек для создания экспертных систем. Некоторый пробел в этой сфере призвана восполнить система CAKE v2.0, ориентированная на быструю разработку и последующее использование продукционных экспертных систем (ЭС). Система CAKE v2.0 развивает идеи, заложенные в CAKE v1.0

[Воинов, 1996].

Любая ЭС состоит из следующих компонент:

• база знаний
• машина вывода
• подсистема объяснений
• пользовательский интерфейс

CAKE v2.0 обеспечивает работу со всеми из вышеперечисленных компонент.

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

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

В силу простого и интуитивно понятного интерфейса системы пользователю не надо иметь большого опыта работы с компьютером –

достаточно иметь общее представление.

В качестве примера ЭС, разработанной с помощью CAKE v2.0, можно привести ЭС “Alpine” – экспертную систему, позволяющую подобрать оптимальную модель горных лыж на основе данных о покупателе. При разработке этой ЭС использовался личный опыт эксперта и информация с сайта компании производителя горнолыжной продукции

и аксессуаров “Elan” – http://www.elanskis.com .

Концептуальная модель системы

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

Перечисленные зависимости представлены на рисунке «Модель концепта» (рис. 1)

Система CAKE v2.0 позволяет инженеру по знаниям достаточно удобный интерфейс для создания и последующей работы с концептуальной областью системы. Визуальное представление концептуальной модели ЭС “Alpine” представлено на

рис. 2

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

Концепты в системе принадлежат к одному из трех типов:

• Концепты первого уровня. Могут определять только начальные факты при выводе. В ЭС “Alpine” это концепты “Человек”, “Горнолыжник”, “Финансовые возможности”, значения атрибутов которых известны до применения правил из базы

  знаний.

• Концепты промежуточного уровня. Являются результатом промежуточного вывода. Данные концепты могут служить как условием, так и заключением при осуществлении вывода. В ЭС “Alpine” это концепты “Ski Series” и “Ski Model”, определяющие соответственно серию (например, “спортивная линейка”, “лыжи для фрирайда”) и модель лыж. Значения атрибутов этих концептов вычисляются

  посредством применения правил из базы знаний.

• Концепты результата . Являются результатом работы вывода. В ЭС “Alpine” это концепт “Result”. Значения атрибутов концептов этого типа вычисляются с помощью машины вывода на основе базы знаний, но, в отличие от концептов

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

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

EXSYS).

Система CAKE v2.0 позволяет инженеру по знаниям работать с достаточно большими концептуальными моделями, не испытывая при этом неудобств. Для каждого концепта можно выбрать один из трех вариантов его визуального представления: только название концепта; концепт со своим атрибутивным составом; концепт со

всеми допустимыми значениями всех своих атрибутов (рис.2).

Инструментарий также предоставляет удобный интерфейс для добавления, удаления
и редактирования связей между концептами (рис. 3).

Работа с базой знаний

В системе CAKE v2.0 реализована продукционная база знаний. Продукция
представляет собой правило вида:

если (условие), то (заключение)

Правила формируются на основании определенного концептуального состава, и определяют базу знаний по данной предметной области. Элементом условия или

заключения является элемент правила , состоящий из триады:

[not] ::::

где:

– концепт предметной области

– атрибут концепта

– значение концепта

[not] – признак отрицания

При формировании продукций элементы правила, входящие в условие связываются логическим операндом “И” (“AND”). Заключение представляет собой вектор элементов

правила.

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

правила использовать несколько простых).

Интерфейс ЭС “Alpine” при работе с базой знаний представлен на
рис. 4

Система CAKE v2.0 предоставляет удобный интерфейс для формирования новых, а
также для редактирования, просмотра и удаления существующих правил.

Машина вывода

Машина вывода осуществляет логический вывод на основе имеющихся начальных фактов и продукционной базы знаний. Тип вывода – “в ширину”. Машина вывода осуществляет как “прямой” вывод (от условия к заключению), так и “обратный” (от заключения к условию). Результатом работы является набор элементов правила,

разделенных по уровням вывода.

Интерфейс ЭС “Alpine” при работе с машиной вывода представлен на
рис. 5

Система CAKE v2.0 предоставляет простой и удобный интерфейс для формирования исходных фактов. В результате их обработки получаются выходные данные. Все промежуточные результаты, а также правила, использованные при их получении, доступны для просмотра пользователем. Предоставляется также интуитивно понятное

графическое представление результатов вывода (рис. 6)

Заключение

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

разработки ЭС.

Литература

[Boинов, 1996] Воинов А., Гаврилова Т. А., Данцин Е. Я. Язык
визуального представления знаний и его место в САКЕ-технологии // Журнал
Известия РАН, Теория и системы управления , 1996, N2. – c.146-151.

[Гаврилова, Хорошевский, 2000] Гаврилова Т.А., Хорошевский В.Ф. Базы
знаний интеллектуальных систем. СПб: Питер 2000.

[Гаврилова, 1997] Гаврилова Т. А. Воинов А. Визуальный концептуальный
анализ знаний и данных для интеллектуальных и обучающих систем // VI
Междунар. конф. «Знание -Диалог-Решение» KDS-97. – Ялта, 1997. – с.1-8.

[Осипов, 1997] Осипов Г.С. Приобретение знаний интеллектуальными
системами. М.: Наука, 1997.

[Попов, 1996] Попов Э.В., Фоминых И.Б., Кисель Е.Б., Шамот М.Д. Статические и динамические экспертные системы // Москва, Финансы и статистика,

1996.

[Рыбина, 1998] Рыбина Г.В. Автоматизированное построение интегрированных экспертных систем для статических проблемных областей (проект АТ-технология): некоторые итоги и результаты // КИИ’98 Шестая национальная конференция по

искусственному интеллекту с международным участием, 1998.

[ART, 1984] ART User’s Manual // Inference Systems Inc., Ca, 1984.

[CARNEGIE, 1987] CARNEGIE GROUP INC. // Expert Systems, 1987, Vol. 4, No.
2.

[Florentin, 1987] Florentin J.J. Software Review: KEE // Expert Systems,
1987, Vol.4, No. 2. p. 118-120

[Gillmore et al., 1985] Gillmore J.F., Pulaski K. A survey of expert system tools // Proc. of the Second IEEE Conf. on AI Applications, 1985, p.

498-502

[Richer et al., 1986] Richer M. An evaluating of expert system
development tools // Expert Systems, 1986, p. 166-183

[Wall et al., 1988] Wall R., Apon A., Beal J. et al. An evaluation of
commercial expert system building tools // Data Knowledge Eng., 1988, p. 279-304

Источник:www.bigspb.ru

• Обучение, Развитие, Управление талантами

• Обучение персонала
• Управление знаниями

Источник: http://hr-portal.ru/article/programmnaya-sreda-dlya-vizualnogo-proektirovaniya-baz-znaniy