Features of the development of software agents. Instrumental development and software support environments
Instrumental tools for the development of software agents form a medium that is optimized for the release of a certain type of application, with a specific architecture.
The main distinguishing tool environments from other means of building software agents is that the environment provides a full cycle of software agent development, including the stages of the subject area analysis, design stages, development, verification, as well as the deployment and accompaniment steps.
You can select the most famous and popular agent development environments:
Ave (Agent Building Environment);
Consider in more detail the listed instrumental environmental agent development environments.
1. The AgentBuilder tool environment provides developers to develop a development tools and an account of an agent application. The technology of creating an intelligent agent in the AgentBuilder environment is presented in Figure 2.1.
Fig. 2.1
Development and implementation media are written in the Java programming language, which allows them to work on all platforms where the Java Wednesday is installed. The agent created using the AgentBuilder toolkit can be performed on any platform with a Java virtual machine (version 1.1 and above).
Development tools are a convenient graphical interface for analyzing the subject area of \u200b\u200bthe developed MAC and the specification of the desired behavior of agents developed by graphic editors. In this instrumental environment, the following steps of building a multi-agent application are provided:
definition of the agency;
creating agents, which provides for the construction of ontology used to perform delegated authority agent, and mental model (belief, ability, obligations, rules of conduct);
creation of protocols for the specification of the interaction of agents of this agency;
generating a special Agent description file in the RADL language, which, ultimately, represents the mental model and the desired behavior of the agent.
The runtime of the agent application consists of an agent and processor for performing an agent. The processor uses effective logical output procedures by comparing the rules of the behavior of the agent's behavior with the beliefs of the agent defined by the current mental model, and incoming messages. Based on the arguments, the processor performs certain actions associated with the authority of the agent. The agent program is the definition of an agent in the form of a RADL file along with the project's installed library. A stranded program together with the processor form a performed agent. When running the runtime environment, an agent processor is initialized that uses the RADL model and an ontology of the agent presented as a project class library (Project Accessories Library). This requires the definition of the agent (the RADL file that provides an agent with the ability to reasoning and the initial mental model) and the project classes library (the support classes of the PACS project from the project classes library) - these objects are used to display the subject area of \u200b\u200bthe task.
2. In the Bee-Gent environment, the development of agency-oriented applications is performed by the methodology for specifying the behavior of the distributed system agents using the MAC - library implemented in the Java language. Based on the BEE-GENT system offered by the BEE-Gent system, it is possible to clearly structuring the behavior of each agent as a graph of states and determining the interaction protocols of agents. Count states of agents are built on the basis of the viability of roles defined in the form of regular expressions at the stage of an agency-oriented analysis (for example, according to the GAIA methodology). An example of a fragment of the agent behavior graph The student of the training system is shown in Figure 2.2.
Fig. 2.2.
The state graph registers all the names of states in which the agent may be. In the next step of development, classes are defined for each state. Each state in the column is an instance of the AWRipState class from the TOSHIBA stranded library implemented in the Java language. In the class designer, pre and post conditions are determined, i.e. The conditions that must be executed in the current state in order to perform actions defined by the status class and determine the transition to the following state. Then the actions that should be performed in each state (including their own agent and interaction processes with other agents) are then specified. For the initial and end states, the "init" and "end" classes are also created. If the agent interacts with other agents, then with the specific states specification, the BEE-GENT system provides for the definition of the interaction protocol. The protocol must reflect all the agent behavior lines in this state. In each state, the Agent's activities are aimed at performing the interaction protocols in order to implement the planned behavior line. The activities of each agent in the MAC are determined, for example, a model of services developed at the stage of an agent-oriented analysis on the GAIA methodology.
Each behavior line is documented by the chart of the interaction of agents with the contents of the messages and their sequence. Figure 2.3 shows an example of the interaction diagram for the state of studying the discipline of the student's agent. The message format is determined by the XML / ACL language, which is the development of the KQML communications language.
Fig. 2.3. Chart of interaction of agent student in the state of "study of discipline"
Thus, based on the developed logical models, the BEE-Gent system automatically generates the Skeleton of a multi-agent software program code in the Java language, which is complemented by the necessary program code that provides a given "life cycle" of agents. In the BEE-Gent system, in contrast to AgentBuilder, when describing the behavior of agents, rules are not used to determine the agent's reaction to external events and its internal state.
3. Jack TM Intelligent Agents (Jack) is an agency-oriented development environment that is based on the Java programming language. Jack is a java add-in in the form of expansion of Java syntax designs for software implementation of properties associated with the concept of an intelligent agent. Jack Agent Programming Language offers the following features:
defines new basic classes, interfaces and methods;
expands Java syntax to support new angent-oriented classes, definitions and operators;
provides expansion of semantics (features when executing) to support the execution model required by an actent-oriented software system.
All language extensions are implemented as Plug-in, which makes the language as expandable as possible and flexible in an agency-oriented programming.
At the classes level, 5 main structures were introduced:
agent that simulates intellectual entities in Jack;
the ability that collects in one whole functional components (events, plans, many beliefs and other abilities), for use by the agents;
an event for modeling situations and messages to which the agent must be able to answer;
a plan that is intended to simulate a procedural description of how the agent manages this event (all the actions undertaken by the Agent are provided in advance and are described in its plans);
many convictions, for modeling the knowledge of the agent in the form of beliefs that adhere to the semantics of a closed or open world. This design represents the belief of the agent in the form of relational tuples of the first order and ensures their logical consistency.
It should be noted that the desired agent behavior is encapsulated in modular units defined by these classes, and classes contain all the structure required for independent execution and methods that programmers in the Jack language can use. To establish the relationship between the above-mentioned classes, there is a set of declarations.
To establish relationships between the above-mentioned classes, a set of declarations is provided. Below is a fragment of the code to implement the design of the plan written on the Jack (syntax elements that belong to Jack are highlighted in bold):
plan MovementResponse Extends Plan (
#Handles Event RobotmoveEvent Moversponse;
#USES Agent Implementing RobotInterface Robot;
static Boolean Relevant (RobotmoveEvent EV)
context () (...)
#reasoning Method
In this example, the defined program action plan of the program agent inherits its basic functions from the Jackplan class. In addition, using multiple declarations for Jack's plans, it is indicated how the plan will be used. Each declaration is preceded by the "#" symbol in order to distinguish them from the Java syntax elements. #Handles Event Declaration defines a target or event that this plan answers. Declaration #USES Agent Implementing enshrines agent (s) that can use this plan. The plan in the example can only be performed by those agents that implement the specified interface (ROBOTINTERFACE). Figured brackets contain the usual Java code.
In addition to the declaration, the Jack language for describing the arguments and behavior undertaken by the agent when implementing the plan provides its operators of reasoning methods that are allocated by the preceding symbol "@".
To support the execution of an agency-oriented software system, the Jack provides the following additional language extensions providing the following semantics:
Multipleness is built into the kernel and removed from under the control of the programmer.
The work of agents is carried out in such a way that the agents handle many plans and have access to belief descriptions. Agents fulfill plans in event management tasks when they arise, comparing their beliefs when necessary. These plans may initiate subtasks that, in turn, can initiate their subtasks if the agent requires a time-consuming and difficult answer.
A new data structure has been introduced, the named logic element (Logical Member), the value of which depends on the result of the query to the set of agent beliefs.
The ability to perform requests to a multitude of agent convictions using logical elements for this, through their association to obtain the desired result. If the request has success, the logical element contains the desired value.
The Jack Development Environment Component (Jack Development Environment) makes it possible to draw overview diagrams by which the environment generates the skeleton of the program code and ensures that the changes made in the code are displayed in the diagrams.
The agents created in Jack have an architecture inherent in intellectual agents. Thus, it is possible to model reasonable behavior, in accordance with the theoretical model of the Agent BDI-architecture, based on beliefs, desires and intentions.
According to the BDI architecture, Jack's intelligent agents are autonomous software components that can show sensible behavior based on proactivity (focus) and reactivity (event sent) to input signals. Each such agent has:
convictions (this is his set of data about the world);
desires (a set of events on which it will react and a set of purposes, the achievements of which it can desire);
intent (a set of plans that describe how it can manage emerging goals and plans).
If the agent is considered as an analog of personality, then the set of plans describes the steps that the agent must execute when a certain event occurs or the desire to achieve a certain result. At first glance, the behavior of the agent may seem similar to the actions of expert systems, with all the limitations inherent in them. However, the fundamental difference between the agent-oriented systems is that agents can be programmed to fulfill the plans in the same way as a reasonable personality would operate. In particular, with the help of agents, you can implement the following properties associated with reasonable behavior:
sustainable focus - Agents are focused on purposes, and not on the selected methods to achieve them;
contextual dependence in real time - agents will follow the options that are applicable at each time and make decisions regarding follow-up actions based on existing conditions;
the approval of the correctness of the approach in real time - the agent will ensure that it follows the selected course of actions until certain conditions continue to be true;
simultaneousness - an agent system is multi-threaded. If new goals and events arise, the agent is able to determine priorities at the request of multitasking.
Jack app is a source code that implements the characteristic for an anent-oriented approach: agents, abilities, events, plans, beliefs, View (queries), as well as a Java class with the Main () function, which is the entry point for the Java virtual machine, And any other Java required files. Files that are created for these concepts must have the same name as the object defined in the file. They have an extension defining the type of Jack concept. The jack agent compiler converts the source files in the Jack agent language into the code in the Java language, which is then compiled into the Java virtual machine code to perform the target system.
4. Jade Software (Java Agent Development Framework) has been widely used to develop multi-agent systems. It is fully implemented in Java and supports FIPA - standards for creating intelligent agents. The goal of creating a Jade environment is to simplify the development process by standardizing the methods of interaction of agents in the system of system services.
To achieve this goal, Jade offers a programmer to developing agent systems the following features:
fIPA-Compliant Agent Platform, based on FIPA and including mandatory types of system agents for managing, first, by an agent platform (AMS), second, communication channel (ACC) and directory services (DF) (these types of agents automatically activated when the platform is started);
distributed Agent Distributed Agent Platform, which can use multiple hosts, and only one Java Virtual Machine starts on each node. Agents are performed as java streams. Depending on the location of the agent, sending a message, and the one who receives it, the corresponding transport mechanism is used to deliver messages.
Multiple Domains Support - a number of FIPA DF-agents based on the federation, thus implementing a multidage agent.
Multithreaded Execution Environment With Twolevel Scheduling. Each Jade agent has its own flow flow, but it is also capable of working in multi-threaded mode. Java Virtual Machine is planning tasks executed by agents or one of them.
Object-Oried Programming Environment. Most concepts characteristic of FIPA-specifications are represented by Java classes forming the user interface.
Library of Interaction Protocols. Standard Interactive FIPA Request and FIPA-Contract-Net Interactive Protocols are used. In order to create an agent that could operate according to such protocols, application developers, you only need to implement specific domain actions, while all the protocol logic independent of the application will be implemented by the Jade system.
Administration GUI. Simple platform management operations can be executed via a graphical interface that displays active agents and agent containers. Using the GUI, platform administrators can create, destroy, interrupt and resume agents, create domain hierarchies and multi-agent DF federations (facilitators).
Jade is based on Java RMI technologies, Java Corba IDL, Java Serialization and Java Reflection API. The development of MAC in this environment is simplified thanks to the use of FIPA-specifications and a number of tools for supporting the debugging and system deployment. This agent platform can be installed on computers with different operating systems, and it can be configured through a remote GUI interface. The process of configuring this platform is quite flexible: it can be changed even during the execution of programs by moving agents from one machine to another. The only requirement for system operation is the installation on the Java Run Time 1.2 machine.
Each running instance of the Jade environment is a container, because May contain several agents. A group of active containers form a platform. The main container should always be active, and all other containers must be registered with them when creating them. Therefore, the first container running on the platform is the main container, and all the other are regular containers and should receive instructions on where their main container is on which they must be registered. If another main container is launched on the network, it represents another platform on which new regular containers have the ability to register. Figure 2.4 shows the above platform and container concepts and shows a script with two Jade platforms consisting of three and one container, respectively.
Fig. 2.4. Wednesday "Existence" Jade agents
Jade agents must have unique names, know each other's names and, thanks to this, they can communicate directly, regardless of their actual location, i.e. Inside a single container (for example, A2 and A3 agents), in various containers within one platform (for example, A1 and A2) or in various platforms (for example, A4 and A5). The main container differs from the usual in that it contains an agent management system and a router that is automatically started when the main container is started. AMS Agent Management System (Agent Management System) is "power" in the platform (creating / deleting agents in remote containers requested via AMS) and provides agent naming service. DF Directory Router (Directory Facilitator), which provides the "yellow pages" service, helps to find an agent of other agents, to obtain the necessary services you need to achieve your goals.
To communicate, the Environment architecture provides a flexible and efficient messaging process in which Jade creates a queue and controls the ACL-message stream, which are private for each agent. Agents are capable of contacting the queue using a combination of several modes of their work: blocking, voting, breaking in operation and comparison with the standard (if it concerns the search methods). Multi-agent platform toolkit
In the latest versions of the system, Java RMI, Event-Notification and IIOP are used. However, you can easily add other protocols. Also provides the ability to integrate SMTP, HTTP and WAP. Most communication protocols that are already identified by the international community of developers of agent environments are available and can be illustrated on specific examples after determining the behavior of the system and its basic states. Together with the support of user-defined content languages, the ontology of agent management, as well as ontologies, which can be implemented and registered with agents and are used by the system. In order to significantly expand the performance of Jade, it is possible to integrate with Jess and Java-shell Clips.
A comparative analysis of the capabilities of the considered tool media to develop software agents is provided in Table 4. And in Figure 2.5 shows the results of this analysis.
Table 4.
Comparative analysis of the possibilities of tool media for the development of software agents
|
Opportunities of instrumental environments |
||||
|
Means of building agencies |
||||
|
Project management tools |
||||
|
Graphic environment to determine the specifications of agents |
||||
|
Integrity control mechanism |
||||
|
Tools of construction ontology |
||||
|
Library for mass development |
||||
|
The mechanism of arguments of the agent about its abilities and abilities of other agents |
||||
|
Formal language communication |
||||
|
Agent interaction tools |
||||
|
Specifying agents with specified abilities |
||||
Fig. 2.5
Based on the comparison of the characteristics of the considered instrumental environments, it can be concluded that the most powerful and flexible technologies for the implementation of the concept of "agent" are the approaches proposed by the AgentBuilder tool and the Jack environment.
It is necessary to pay attention to the fact that for the Jade platform there is an additional BDI extension - JADEX environment. This environment provides a hybrid reactive-deliberative architecture, in which the agent is considered as a "black box" accepting and sending messages. Based on the results of processing messages, internal and external events, the Deliberative mechanism makes decisions on the transition to a new action plan or the continuation of the old one. The current plan can send messages to other agents, change the database of beliefs, form new goals and cause internal events. The system uses the plans library that are processed as Java classes.
One of the main advantages of developing intelligent agents on the Jadex platform is that it is not required to study new programming languages. Instead, the agents are encoded on the basis of object-oriented programming in an integrated development environment (IDES), such as Eclipse and Intellij IDEA.
Another important aspect is the independence of the binder software, since JADEX independently with its modules can be used in completely other scenarios at the top level of the platform. Agent-oriented programs add the explicit properties of autonomous acting elements that take part in the decision-making process to passive objects. In this regard, the agents provide active ingredients with individual interaction capabilities with components.
Jadex is designed as an independent decision mechanism, adapted to work with any binding systems that perform interaction with the agent relative to its own management and receipt of messages.
The agent can freely migrate between hosts, performing operations both on the server side and on the user side, while maintaining independence from the place of execution of the tasks.
The analysis of the most well-known tool systems allowed to choose an effective and affordable Jadex environment.
Integrated Development Environment (IPR) is a software tool system used by programmers to develop software. In English, such an environment is called Integrated Development Environment or abbreviated IDE.
The IPR typically includes a text editor, compiler, an interpreter, software development and assembly and debugger. Sometimes also contains tools for integration with version control systems and a variety of tools to simplify the design of the graphical user interface. Many modern development environments also include the programmatic classes window, the object inspector and the classes hierarchy chart - for use in object-oriented software development. Most modern ISRs are designed to develop programs in multiple programming languages \u200b\u200bat the same time.
One of the special cases of the IPR - visual development environment, which include the possibility of visual editing the program interface.
The main window is the text editor that is used to enter the source code in the IPR and focuses on working with the symbol sequence in text files. Such editors provide advanced functionality - the syntax highlighting, sorting strings, patterns, encoding conversion, symbol codes, etc. Sometimes they are called code editors, since their main purpose is to write source code of computer programs.
Syntax highlighting is highlighting text syntactic designs using various colors, fonts and designs. Usually applied in text editors to facilitate the reading of the source text, improving visual perception. It is often used when publishing source code in the Internet.
The concept of broadcasting, compiler and interpreter was given in previous lectures.
One of the most important parts of the IPR is a debugger, which is a development environment module or a separate application designed to search for errors in the program. The debugger allows you to perform step-by-step trace, track, install or change the values \u200b\u200bof variables during the program execution, install and delete control points or stop conditions, etc.
The most common debuggers are:
- GNU DEBUGGER - debugger programs from the GNU project;
- IDA - disassembler and low-level debugger for Windows and GNU / Linux family operating systems;
- Microsoft Visual Studio - software development environment, including debugging from Microsoft Corporation;
- Ollydbg is a free low-level debugger for Windows operating systems;
- SoftICE - low-level debugger for Windows operating systems;
- Dr. Watson - the standard Windows debugger allows you to create memory dumps;
- WinDBG is a free debugger from Microsoft.
The main debugging process is trace. Tracing is a process of step by step program execution. In trace mode, the programmer sees the sequence of execution of commands and the values \u200b\u200bof the variables at this program step, which makes it easier to detect errors. Tracing can be started and ended anywhere in the program, the execution of the program can stop on each command or on the stop points, tracing can be performed at the procedure / function and without visiting.
The most important IPR module with the joint development of medium and high complexity projects is the version management system. Version control system (English abbreviation CVS) - software to facilitate working with changing information. It allows you to store a few versions of the same document, if necessary, return to earlier versions, determine who and when did one or another change and much more.
Such systems are most widely used when developing software, to store the source code of the program being developed. However, they can be successfully applied in other areas in which work is underway with a large number of continuously changing electronic documents, in particular, they are increasingly used in CAD, usually as part of product management systems. Version management is used in configuration management tools of various devices and systems.
In our country, it is possible due to the small number of large-scale projects, the versions control systems did not receive distribution, despite the fact that their use is the key to the successful implementation of large projects. In this regard, we will focus more on this feature of the IPR.
Most versions control systems use a centralized model when there is a single document repository managed by a special server, which performs most of the versions management features. The user working with documents must first get the version of the document from the repository you need; A local copy of the document is usually created, the so-called "workflow". The latest version or any of the previously selected version or date of creation can be obtained, sometimes for other features. After the necessary changes are made to the document, the new version is placed in the repository. Unlike simple saving file, the previous version is not erased, and also remains in the storage and can be obtained from there at any time. The server can use delta compression - a method for storing documents in which only changes between serial versions are saved, which reduces the volume of stored data.
Sometimes creating a new version is performed unnoticed by the user (transparent) - either using an application program that has built-in support for such a function, or by using a special file system. In the latter case, the user just works with a file as usual, and when saving the file, a new version is automatically created.
It often happens that several people work on one project at the same time. If two people change the same file, then one of them may accidentally cancel the changes made by others. Version control systems track such conflicts and offer tools to solve them. Most systems can automatically combine (merge) changes made by different developers. However, such an automatic association of changes is usually only for text files and then, only if it changed different (inhabited) parts of this file. Such a restriction is due to the fact that most versions management systems are focused on supporting the software development process, and source program codes are stored in text files. If the automatic association failed, the system can suggest solving the problem manually.
Often, merge cannot be configured in automatic, nor in manual mode, for example, if the file format is too complicated or unknown at all. Some versions control systems make it possible to block the file in the repository. Locking does not allow other users to get a working copy or prevents the change in a working copy of the file (for example, the file system tools) and thus ensures exceptionally access to the user who works with the document.
Other features of the version management system consist:
In creating different variants of one document-branch, with a general history of changes to the branch point and with different things after it.
Journal management where users can record explanations about what and why they changed in this version;
Controls user access rights, resolving or prohibit reading or data change depending on who requests this action.
A separate class is distributed versions control systems. Such systems use a distributed model instead of a traditional client-server. In general, they do not need a centralized storage: the entire history of changes to the documents is stored on each computer, in the local storage, and, if necessary, individual fragments of the history of local storage are synchronized with the similar storage on another computer. In some such systems, the local storage is located directly in the working copy directories.
When the user of such a system performs ordinary actions, such as retrieving a specific version of the document, creating a new version and the like, it works with its local repository copy. As the storage changes belonging to different developers are made, they begin to differ, and there is a need for synchronization. Such synchronization can be carried out by sharing patches or so-called change sets (eng. Change Sets) between users.
The main advantage of distributed systems is their flexibility. Each developer can work independently, as it is convenient for it, keeping intermediate documents and transmitting results to other participants when it considers it necessary. In this case, the exchange of change sets can be carried out in various schemes. In small groups, work participants can exchange changes on the "each with each" principle, due to which there is no need to create a dedicated server. A large community, on the contrary, can use a centralized server with which copies of all its participants are synchronized. More complex options are also possible, for example, with the creation of groups for work in certain areas inside a larger project.
To use version control systems, it is necessary to own the terminology of these systems. There is no generally accepted terminology, various names can be used in different systems for the same actions.
Below are some of the most frequently used options. Due to the fact that the systems were developed by the English-language community, and Russian-speaking terminology was still developed, English terms are used.
branch (branch) - the direction of development, independent of others. The branch is a copy of the part (as a rule, of one directory) of the repository, which can be made of changes that do not affect other branches. Documents in different branches have the same story to the branch point and different - after it.
check-in, Commit, Submit - Creating a new version, Publish changes. Distribute changes made in a working copy to the document repository. At the same time, the repository creates a new version of the changed documents.
C. heck-out, Clone - extracting a document from the repository and creating a working copy.
C. onflict - a conflict situation when several users made changes to the same area of \u200b\u200bthe document. The conflict is detected in the case when one user has already published its changes, and the second only tries to publish them and the system itself cannot correctly drain the conflicting changes. Since the program may not be reasonable enough to determine which change is "correct", the second user needs to resolve the conflict (RESOLVE).
M. erge, Integration (merger) - Combining independent changes to a single version of the document. It is carried out when two people changed the same file or when transferring changes from one branch to another.
R. epository - a place where the version management system stores all documents along with the history of their change and other service information.
R. evision. Version control systems distinguish version versions that are automatically assigned.
T. aG, Label (label) - which can be assigned a specific version of the document. The label is a symbolic name for a document group, and it describes not only the set of file names, but also the revision of each file. The revisions included in the label of documents can belong to different points of time.
T. rUNK, Mainline (trunk) is the main branch of the project development. The work policy with the trunk may differ from the project to the project, but in general it is as follows: most changes are made in the barrel; If a serious change is required, able to lead to instability, a branch is created, which merges with the barrel when innovation is sufficiently tested; Before the release of the next version, a "release" branch is created in which only corrections are made.
U. pDATE, SYNC (Update, Synchronization) - Synchronization of the working copy to some specified state of the repository. Most often, this action means updating a working copy to the very fresh storage state. However, if necessary, you can synchronize a working copy and to an older state than the current one.
W. oRKING COPY (Working Copy) - Working (Local) Copy of Documents.
Consider the possibilities of the IPR on the example of the most affordable and popular versions.
Eclipse (from English. Eclipse) is a free integrated development environment for modular cross-platform applications (Figure 69). Developed and supported by the non-profit organization Eclipse Foundation (http://www.eclipse.org/).
Original Eclipse was developed by IBM as a corporate IPR standard for developing in different languages \u200b\u200bunder the platform from this company. According to IBM, design and development cost $ 40 million. The source code was fully open and made available after Eclipse has been transferred to the further development of the IBM independent community.
The OSGI and SWT / JFACE framework is based on Eclipse, based on the following layer - RCP (Rich Client Platform, platform for developing full-fledged client applications). RCP serves as the basis not only for Eclipse, but also for other RCP applications, such as Azureus and File Arranger. The next layer is the Eclipse itself, which is a set of RCP extensions: editors, panels, prospects, CVS module and Java Development Tools module (JDT).
Eclipse - first of all, a full Java ICR, aimed at group development: CVS support is included in the supply of eclipse, several SVN modules are actively developing, there is support for VSS and others. By virtue of free and high quality, Eclipse in many organizations is a corporate standard for developing applications.
The second purpose of Eclipse is to serve as a platform for developing new extensions than he has gained popularity: any developer can expand eclipse with its modules. There are already C / C ++ Development Tools (CDT) developed by QNX engineers with "IBM", and means for COBOL, Fortran, PHP languages \u200b\u200band others from various developers. Many extensions complement the Eclipse Wednesday by managers to work with databases, application servers, etc.
Figure 69. . Main Window Interface Eclipse
Eclipse is written in Java, therefore is a platform-independent product, with the exception of the SWT library, which is developed for all common platforms. The SWT library is used instead of a standard Swing library for Java. It completely relies on the underlying platform (operating system), which provides the speed and natural appearance of the user interface, but sometimes causes the problems of compatibility and sustainability of applications on different platforms.
The basis of Eclipse is the Extended Client platform (RCP from English. Rich Client Platform). Its components:
OSGI (standard set of supplies of sets (eng. Bundles));
SWT (portable widget toolkit);
JFACE (File Buffers, Working with Text, Text Editors);
Working environment Eclipse (panels, editors, projections, masters).
Another popular free ISR is KDevelop (http://www.kdevelop.org, Fig. 70). KDevelop (eng. KDEVELOP) - Free software development environment for UNIX-like operating systems. The project started in 1998. KDevelop applies according to the GNU license (General Public License).
Figure 70. Interface KDEvelop
KDEVELOP does not include compiler, instead, it uses any compiler to create an executable code.
The current stable version supports a large number of programming languages, such as hell, Bash, C, C ++, Fortran, Java, Pascal, Perl, PHP, Python, Ruby and SQL.
CDEVELOP uses the built-in component - a text editor - through KPARTS technology. The main editor is Kate.
Functions Kdewelop:
Illumination of the source code, taking into account the syntax of the programming language used, which is automatically determined;
Project manager for projects of different types, such as Automake, Qmake for projects based on Qt and Ant technologies for projects based on Java;
Class navigator (Class Browser);
Front-End for GNU Compiler Collection;
Front-End for GNU Debugger;
Helpers for generating and updating classes and platform (framework);
Automatic code completion system (SI / C ++);
Built-in support for the source code documentation system (DOXYGEN);
One of the versions control systems: SCM, CVS, Subversion, Perforce and Clearcase;
The Quick Open function allows you to quickly navigate through files.
Kdevelop It is a "plug-in" architecture. When the developer makes changes, it should only compile the plugin. It is possible to save profiles indicating which plugins must be loaded.Kdevelop Not supplied with a built-in text editor, it is connected as a plugin.Kdevelop It does not depend on the programming language and from the platform on which it starts, supporting KDE, GNOME and many other technologies (for example, Qt, GTK + and WXWidgets).
Built-in debuggerKdevelop Allows you to work graphically with all debugging tools, such as breakpoints and trace. It can also work with dynamically loadable plugins, in contrast to the console GDB.
At the moment there is about 50 to 100 plug-ins for this IDE. Among the most useful - PersisTent Project-Wide Code Bookmarks, Code Abbreviations, allowing you to quickly deploy text, Source Formatter, which reformat text for Style Guide to save, search for regular expressions and project-wide search / replacement.
The latest ICR isMicrosoft Visual Studio. (Microsoft Visual Studio, Fig. 71). In fact,Microsoft Visual Studio. it is the line of products of Microsoft, which includes an integrated software development environment and a number of other tools.
Figure 71. MICROSOFT VISUAL STUDIO interface
Microsoft Visual Studio. Includes one or more components from the following: Visual Basic.Net, Visual C ++, Visual C #, Visual F #, Microsoft SQL Server, Visual Interdev, Visual J ++, Visual J #, Visual Foxpro, Visual Source Safe.
One of the main advantages of Microsoft Visual Studio is the high quality documentation of the process of developing and describing possible problems in MSDN Library. However, the most interesting for professional part dedicated to the intricacies of development exists only in English.
Microsoft also offers a free analogue of the Visual Studio Express product.
Alexey Fedorov, Natalia Elfova
The previous article of the current cycle was devoted to the consideration of logical and physical design of data and tool used in this process. We were convinced that data design plays a key role in the development of information systems - after all, the costs of the creation of applications for end users depend on the quality of this work, as well as with the subsequent support and modernization of the created product. The result of this stage is the "empty" database (that is, the database, the table of which is mostly not containing records, except, possibly reference tables such as a list of constituent entities of the Russian Federation or phone codes).
The next stage of the life cycle of the information system is the development of client applications. The result of this stage is a finished product consisting of a number of applications that allow users to enter data into the tables or to edit existing data, analyze the data entered and represent them in a more convenient form of graphs, summary tables or reports (including " paper "documents).
The process of designing data for relational DBMS is to a certain extent a logical process and obeys a single standard methodology. This causes a low degree of dependence of the sequence performed when designing these actions, as from the exact data design tool, it is applied and on whether it is applied at all. Actually, that is why data design tools are more or less similar to its interface reflecting essentially the process of drawing data models on paper.
The process of creating client applications running with databases is rather difficult to describe in the form of a similar universal sequence of actions, since the logic of a particular application almost completely depends on the logic of the simulated business process. Application development tools as a category of software products exist much longer than data design tools, and they are more diverse - from the compiler running from the command line to tools where the finished application is collected by the "mouse" from the finished components, and the code is generated automatically. With such a variety of development tools, they should somehow classify that we will try to do in this article, while told which of them it is convenient to apply in one way or another.
Classification of application development tools
You can classify development tools from various positions, for example, based on the programming language supported by them, or the performance of the applications created on a particular platform, or the presence of certain libraries and visual funds in them. We will try to classify application development tools based on the convenience of applying them to create products that are a user interface to the database.
Virtually any development tool, little appropriate to universality, can be forced to work with any database - sufficiently supporting the application in this means of developing third-party libraries and the presence of a set of client interfaces (API) for the platform on which the applications have been created . However, not any pair of products "Development Tool Plus DBMS" is attractive from the point of view of labor costs associated with creating such applications. You can write a full-fledged application that causing the functions of the client API and implementing a convenient user interface using the language compiler with and the simplest graphic library (for example, which allows you to change the color of pixels on the screen) for the operating system in which this application will work. But the costs associated with the implementation of such a project may be completely unjustified - in this case, the developers will have to implement functions that are already contained in the classroom libraries and components of development tools, more deeply-oriented applications with database applications or including support for creating such applications.
Development tools focused on specific DBMS
Ten to twenty years ago in many applications using databases, the client API functions were called from the code written in one of the programming languages, most often on C. It is enough to look at the description of the client part of the client part of almost any server DBMS - and you will find a lot of examples most typical code fragments, for example, to register the user, executing queries, etc. However, it became clear enough to develop the DBMS to develop that the labor costs associated with writing a similar code can be significantly reduced by collecting the most typical code fragments and the most common elements of the user interface (even if they even for alphanumeric terminals) by issuing these libraries in The form of a separate product and adding the development environment to it and the user form design utility to view and edit data, as well as reports. This is exactly how the first developments focused on specific DBMSs appeared, such as Oracle * Forms (the predecessor of the current Oracle Forms Developer.).
Products of this class on the market of development tools are available today. Almost all server DBMS manufacturers also produce application development tools. In the overwhelming majority of cases, modern versions of these development tools support access to the DBMS of other manufacturers at a minimum using one of the universal data access mechanisms (ODBC, OLE DB, BDE). However, access to "its" DBMS is usually carried out by the most efficient way, that is, using client APIs, objects contained in the libraries of the client part of server DBMS, special classes for accessing these DBMS data or by implementing drivers for universal data access mechanisms, Capable to take into account the specific features of this DBMS.
In a separate category, you can allocate desktop database development environments. In the article of this cycle dedicated to the desktop DBMS, we have already noted that the vast majority of desktop DBMS, which lived to today, such as Microsoft Visual Foxpro, Microsoft Access, Corel Paradox, Visual DBase, support access to the server DBMS, at a minimum, using Universal data access mechanisms, which makes it possible to conditionally attribute them to the category of means of development. We note, however, that currently the creation of applications in the client-server architecture with their help is an infrequent phenomenon. Exception, perhaps, make up Microsoft Access - MSDE pairs, Microsoft Access - Microsoft SQL Server and Microsoft Visual Foxpro - Microsoft SQL Server. Here is the result of the competent Microsoft policy, striving for maximum compatibility of its products and providing the most painless to users to replace its desktop databases on their own database servers (ACCESS-\u003e MSDE-\u003e Microsoft SQL Server, FoxPro-\u003e Visual FoxPro-\u003e Microsoft SQL Server) .
Development tools, universal in relation to DBMS
Development tools, universal in relation to DBMS (or applying to such versatility), as a rule, are followers of conventional means of developing applications that are not directly related to databases. Typical examples of development tools are Borland Pascal, Borland C ++, Microsoft Quickc. Capable to use third-party libraries, these tools allowed access to the functions of the client APIs, and with the development of universal data access mechanisms (such as ODBC) - and to the Library API functions that implement such mechanisms. Note that it is often possible with the help of these developments, desktop database environments (such as dBase, FoxBase) or pseudo-compilers for the languages \u200b\u200bof the XBASE family are created (for example, Clipper).
Later versions of the designated means of development acquired libraries of functions and classes designed to access data with certain universal mechanisms. Further development of development tools led to the emergence of two categories of products for this purpose.
The first category includes development tools with extensive class libraries, a large number of "masters" and code generates, but "manual" oriented code creation and quite rarely used to create "standard" applications for working with databases (here under the phrase "standard application "We mean the application that has direct access to the database with which the user interacts, that is, the" classic "client of the server DBMS). Typical (and the only really popular software in the software market) The representative of this product class is Microsoft Visual C ++. Using Microsoft Visual C ++ and MFC libraries (Microsoft Foundation Classes), you can create any applications if you have skill, knowledge, skill and time. Nevertheless, applications with a complex user interface (for example, using databases), it is not so often developed with it (although examples of this use can be found even in domestic literature). Mostly, this product is used to create client applications in the event of a special requirement for them, such as high performance, the ability to carry out any non-standard operations, etc.
The second category includes the development tools with developed visual tools that literally "draw" the user interface, partially erase the differences between the work of the programmer and the user and the harassing final product by attracting the development interface of developers who are not the highest qualification (if you carefully learn coursework programs Training centers specializing in training for Microsoft, Borland and Sybase development tools, it can be found that the duration of the training course, listening to which the usual Windows user must learn how to create client applications for server DBMSs, ranges from 5 to 10 working days).
It is this category of development tools that is most commonly used when creating client applications. The most popular products of this class include Microsoft Visual Basic., Borland Delphi, Sybase PowerBuilder. and Borland C ++ Builder. The development environment for such products is very similar to externally (with an accuracy of the location of the windows on the screen installed "by default"): as a rule, the development environment of such a product contains a "blank" of the projected form (analog of the window), a separate panel with user interface elements and other pictograms The objects used in the application that can be selected and placed on the form, window, which displays and edit the properties of one of the elements selected on the form (and sometimes the list of events to which this item responds), the code editor window where the code fragments can be entered associated with the processing of certain events, as well as the code that implements the logic of the operation of this application. As a rule, modern means of developing such a class make it possible to create simple applications for data editing practically without writing code.
Recently, the creation of applications that use access to databases, but located within ordinary documents, has been very popular. The basis for developing such applications is the macro languages \u200b\u200bof the relevant editors. The most typical and practically the only popular representative of the development of this category is Visual Basic for Applications, similar to the visual development tools listed above and differ from them that the application created with it is contained within Microsoft Office documents and are not alienated from them.
We note, however, that the given division of development tools for these two classes is very conditional. As we have spoken above, almost all means of developing applications with databases, including those oriented on specific DBMS, maintain at least one of the universal data access mechanisms. And almost all the "universal" application development tools, if they belong to the manufacturer of any server DBMS, support "their" DBMS better than the DBMS of third-party manufacturers (this can be expressed, for example, in special libraries of classes or components to access this server, and also in the presence of general repository of objects and data models, and sometimes common with the client part of the server DBMS of access parameter settings or data schemes)
Classification of applications using databases
Applications in the client-server architecture
In previous articles of this cycle, we have already talked about what is a "client-server" architecture in a traditional understanding. Therefore, we only briefly remind that the information systems created in such an architecture are a database server that manipulates data and the client application that appeals to it and uses the client APIs (or encapsulating their calls classes and components), or one From universal data access mechanisms. Usually, when using such an architecture of applications to the database server, monitoring of compliance with business rules implemented in the form of stored procedures, triggers, server restrictions and other database objects.
To create client applications, in this case, the development facilities with developed visual instruments are most commonly used, such as Microsoft Visual Basic, Borland Delphi, Sybase PowerBuilder, Borland C ++ Builder.
Note, however, that the choice of architectures of modern applications is currently quite wide and is not exhausted by the "classic" client-server architecture, implied that the application consists of a database server and client applications that interact with this server. Therefore, we will discuss below, which developments are conveniently used when creating distributed applications.
Distributed applications
Distributed (or multi-part) applications usually consist of presentation services (or "thin" clients with which end users usually interact), business logic services implemented in the form of business objects (or intermediate layer services - Middle Tier; often to describe a set These services use the term Middleware) and data services (usually consisting of databases and data access mechanisms). Business logic services are designed to receive user-entered data from presentation services, interacting with data services to perform business operations (for example, processing orders or calculating accounting) and return the results of these operations with presentation services.
Unlike regular applications in the client-server architecture, in multi-part systems "thin" clients, as a rule, do not have direct access to the data. Instead, customers send requests to special business objects specifically designed for this purpose. Those, in turn, can perform business operations requested by the client (such as order processing, banking transaction, etc.).
Some of the business objects can access data services using certain data access mechanisms. Since the end user does not interact directly with business objects, the latter usually do not have a user interface in the usual understanding. Physically, business objects can be implemented in the form of operating system services, console applications or Windows applications, as well as libraries downloaded to the address space specifically designed for this purpose of the server application (Web server, application server, transaction monitor, etc. ). Often one business object serves a lot of customers.
To create business objects, both developing tests with developed visual instruments and development tools focused on "manual" Creating an application code (such as Visual C ++). It should be noted that the latest versions of almost all the most popular Windows-application development tools (Microsoft Visual Basic, Borland Delphi and Visual C ++, Borland Delphi and C ++ Builder, Sybase PowerBuilder) support the creation of various types of business objects (Web applications, ASP- Objects, COM servers, etc.), except, perhaps, Microsoft Access - this product is designed rather on qualified users than on developers of distributed systems. Often, this purpose also uses the creation of Java applications (such as Borland Jbuilder).
Note that, in addition to the "universal" means of creating both applications in the Client-Server architecture and business objects for distributed systems, there are also specialized funds in the market for creating business objects (usually , Web applications). From the development of this class for the Windows platform, Microsoft Visual Interdev is most popular, the first version of which appeared in 1998. You can also mention another interesting product related to the same category of development tools - Borland Intrabuilder, which appeared in two years earlier, but for some reason, despite the growing need for products of this class, which did not receive further development. Tools for the development of a similar class, as a rule, allow you to create applications that dynamically generating HTML code or code on one of the scripted languages \u200b\u200b(VBScript or JavaScript), which is transmitted by the Web server to the user browser as part of the web page, and perceive the data entered by the user In HTML-form and transferred to the browser the Web server.
Conclusion
In this article, we discussed the process of creating applications using databases, as well as various categories of funds used in their development. We were convinced that the development tools can be divided into the tools focused on the use of specific DBMS, universal tools with respect to DBMS, and desktop database environments used to develop applications. On the other hand, they can be divided into funds focused on the visual design of the user interface (this category includes Microsoft Visual Basic, Borland Delphi, Sybase PowerBuilder, Borland C ++ Builder), and on behalf of writing code code (Visual C ++ ).
Having considered the several most popular tools for developing applications, we were convinced that most similar products usually support:
- at a minimum one of the universal data access mechanisms, which allows the use of various DBMS data in the applications created;
- creation of several types of distributed applications;
- automatic generation of application code based on models created using the most popular data design tools and modeling business processes.
We also discussed what applications in the client-server architecture differ from distributed systems and which development tools can be used when creating both types of applications.
The life cycle of the information system is not completed by the development of applications. After creating them, it is supposed to test, implement, teach users of their use, and finally, to exploit them for a number of years. As a result of such operation, data is accumulated, which, as a rule, are much more valuable than the actual applications. These data are often necessary for making important management solutions material, therefore it is important to be able to convert them to the form suitable for a similar purpose. For this, there are means related to the Business Intelligence category - report generators, analytical data processing tools and the search for patterns. We will talk about them in the next article of this cycle.
To optimally develop a software environment, it is necessary to combine various programming languages, as each of them is aimed at performing certain goals and tasks. As, for example, several PHP commands allow you to create a whole web page, but in practice almost always the script is used in conjunction with HTML, and usually the source code of the script contains a large number of rows. But, despite this, it should be noted that the code on PHP can be in any place of the HTML document, but it does not have to use HTML. It is only necessary to ensure that the PHP code creates the correct HTML code, which will then be properly displayed by the Web browser.
HTML - hypertext markup language, which is used to create documents on the Internet. Using it, a necessary structure and a page grid is created, the appearance of which is further being improved by CSS and JavaScript. At the moment, the last version is HTML5, which was preceded by HTML4.01. Most Web resources are built on the basis of this language.
Unlike HTML 4, in which 3 validators, HTML 5 Validator is one:. HTML 5 supports Mathml and SVG.
New Tags: Section, Article, Aside, Hgroup, Header, Footer, Nav, Dialog, Figure, Video, Audio, Source, Embed to insert Content with plugin (only), Mark, Progress, Meter, Time, Ruby, RT, RP , Canvas, Command, Detales, DataList, Keygen, Output.
New Types input: Tel, Search, URL, Email, DateTime, Date, Month, Week, Time, DateTime-Local, Number, Range, Color.
New attributes for tags: Ping Media attributes for A and Area, etc.
The disappearance of some tags, due to the fact that they can be replaced by CSS: Basefont, Big, Center, Font, S, Strike, TT, U.
The disappearance of frames due to the negative impact on the entire page
The disappearance of some tags replaced in the updated specification to more relevant: acronym (used by ABBR), Applet (Used Object), Isindex, DIR.
Some attributes for tags are not supported due to lack of need: Rev and Charset in Link and A, Shape and Coords U a, etc.
Some attributes for tags are not supported due to the fact that when using CSS, the best effect is achieved: Align has all tags, Alink, Link, Text, Vlink at Body and so on.
New API: Drawing 2D pictures in real time; control over the playback of media files; storage of data in the browser; editing; DRAG-AND-DROP; work with the network; MIME; New elements in DOM.
CSS is a formal description language of the appearance of a document written using the markup language. CSS is an acronym for Cascading Style Sheets / Cascading Style Tables. CSS is a style language that defines the display of HTML documents. For example, CSS works with fonts, color, fields, lines, height, width, background images, positioning of elements and many other things. HTML can be used to design Web sites, but CSS provides great opportunities and more accurate and worked. CSS, to date, supported by all browsers.
HTML is used to structuring the contents of the page. CSS is used to format this structured content. As Web develops, designers began to look for the possibility of formatting online documents. To meet the increased requirements of consumers, browser manufacturers (then - Netscape and Microsoft) invented new HTML-tags, such as which differed from original HTML tags in that they determined the appearance, and not the structure. It also led to the fact that the original structuring tags, such as , more and more apply to the design of pages instead of structuring text. Many new design tags, such as