Justification of the choice of means and software development environment. CPU Automated Management Systems and Industrial Safety

Integrated Development Environment (IPR) is a software tool system used by programmers for development. software. IN english language This 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 source code In IPR and focused on working with a sequence of characters 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 ISR - 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 funds from Microsoft;

- 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 used in configuration management tools 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 the creation of a new version is performed imperceptibly for 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 control 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 management 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 by 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/).

Originally, Eclipse was developed by IBM as a corporate IPR standard for developing on different languages under platforms 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 speed and natural appearance user interface, but sometimes causes 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 \u200b\u200bsuch 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 the 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 high quality Documenting the process of development and description 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.

Currently, with each programming system, not separate tools (for example, compiler) are associated with some logically associated set of software and hardware tools supporting the development and support of the PS in this programming language or oriented to any specific subject area. Such a totality will call instrumental environment for the development and maintenance of PS. For such instrumental environments, it is characteristic, firstly, the use of both software and hardware tools, and, secondly, a certain orientation or to a specific programming language, or to a specific subject area.

The tool medium does not have to function on the computer on which the developed PS will be applied. Often, such combination is quite convenient (if only the power of the computer used allows this): It is not necessary to deal with computers of different types, the components of the tool medium can be included in the PS developed. However, if the computer on which the PS should be applied is not available for developers of this PS (for example, it is constantly engaged in other work, which cannot be interrupted, or it is still under development), or uncomfortable for the development of PS, or the power of this computer is insufficient for ensuring the functioning of the required tool medium, then the so-called is used tool-object approach. The essence of it is that the PS is developed on one computer, called instrumentaland it will be applied on another computer called target(or object).

There are three main class of instrumental media and maintenance of PS (Fig. 16.1): ·

programming environment, ·

computer technology workplaces, ·

programming technology instrumental systems.

Programming environmentit is intended mainly to support programming processes (encoding), testing and debugging PS. Computer technology workplacefocused on the support of early stages of the development of PS (specifications) and automatic generation of programs on specifications. Programming Technology Tool Systemit is intended to support all the processes of development and maintenance throughout the entire life cycle of the PS and are focused on the collective development of large software systems with a long life cycle. For such systems, the cost of escort usually exceeds the cost of development.

Fig. 16.1. The main classes of instrumental environments for the development and maintenance of PS.

Instrumental programming environments.

Programming tool environment contains primarily a text editor that allows you to design programs in a specified programming language, tools that allow compile or interpret programs in this language, as well as test and debug the obtained programs. In addition, there may be other tools, for example, for static or dynamic program analysis. These tools interact with each other through regular files using standard file system features.

The following classes of programming tool media distinguish (see Fig. 14.2): ·

general Areas, ·

language oriented environment.

Programming tool environment general purposecontain a set of software tools that support program development in different programming languages \u200b\u200b(for example, a text editor, a link editor, or a target computer language interpreter) and usually represent some expansion of the capabilities used operating system. For programming in such an environment, any programming language will require additional tools oriented to this language (for example, the compiler).

Fig.16.2. Classification of programming tool media.

Language orientedthe programming tool environment is designed to support the development of the PS on any one programming language and knowledge of this language were significantly used in constructing such an environment. As a result, there may be sufficiently powerful possibilities that take into account the specifics in such a medium. of this language. Such environments are divided into two subclasses: ·

interpretive media, ·

syntactically controlled environments.

Interpretingthe programming tool environment ensures the interpretation of programs in this programming language, i.e. First of all, the programming language interpreter on which this environment is oriented. This environment is necessary for the programming languages \u200b\u200bof an interpretive type (such as Lisp), but can also be used for other languages \u200b\u200b(for example, on a tool computer). Syntax-managedthe programming tool environment is based on the programming language syntax to which it is oriented. In such an environment, instead of a text, a syntax-managed editor is used, allowing the user to use different patterns of syntactic structures (as a result of this, the program being developed will always be syntactically correct). Simultaneously with the program, such an editor shapes (in the computer's memory) its syntax tree that can be used by other tools.

The appearance of Makefile can be considered the first step to create programming systems. Makefile language has become standard meansUnified for compilers of all developers. It was comfortable, but quite complicated technical remedyrequiring a high degree of preparation and professional knowledge from the developer, since the command language Makefile itself was comparable to simple language Programming.

Such a structure of the development tools existed enough for a long timeIn some cases, it is used to this day (especially when creating system programs). Its widespread was due to the fact that the whole structure of the development tools was very convenient for the batch execution of programs on the computer, which contributed to its widespread use in the MainFrame era with UNIX type operating systems.

4.5. Integrated development environments

Visual Studio 97 is the first released version of Visual Studio. For the first time, various means of developing software were collected together. The system was released in two versions: Professional and Enterprise. It included Visual Basic 5.0, Visual C ++ 5.0, Visual J ++ 1.1, Visual FoxPro 5.0, first appeared ASP development environment - Visual Interdev. Visual Studio 97 was the first Microsoft attempt to create a single environment for developing in different programming languages: Visual C ++, Visual J ++, Visual Interdev and MSDN used one environment called Developer Studio. Visual Basic and Visual FoxPro applied individual development environments.
Visual Studio 6.0 came out in June 1998. This is the latest version of Visual Studio, operating on the Win9x platform. Still are still popular among programmers using Visual Basic. This version was the main environment for developing applications under Windows from Microsoft, before the 5.net platform appears.
Visual Studio .Net (Rainier code name; Internal version 7.0) issued in February 2002 (includes .NET Framework 1.0). Service Pack 1 for Visual Studio .NET (2002) released in March 2005
Visual Studio .NET 2003 (Code name Everett; Internal version 7.1) appeared in April 2003 (includes .NET Framework 1.1). Service Pack 1 for Visual Studio .NET 2003 released on September 13, 2006
Visual Studio 2005 (Code name WHIDBEY; Internal version 8.0) was released at the end of October 2005, the last officially operating on Windows 2000 (includes .NET Framework 2.0). In early November 2005, a series of products was also published in the Edition of Express: Visual C ++ 2005 Express, Visual Basic 2005 Express, Visual C # 2005 Express, and others. On April 19, 2006, the EXPRESS editorial was free. Service Pack 1 for VS2005 and all express-editions released on December 14, 2006. Additional patch for SP1, decisive problem Compatibility S. Windows Vista. released on March 6, 2007
Visual Studio 2008 (ORCAS code name) was released on November 19, 2007, at the same time X.NET Framework 3.5. Aims to create applications for Windows Vista (but supports both XP), Office 2007 and web applications. Includes LINQ, new versions of C # and Visual Basic languages. The studio did not enter Visual J #. From October 28, 2008, the version is available for the first time in Russian.
Visual Studio 2010 (Hawaii code name, for Ultimate - Rosario) released on April 12, 2010 together with S.Net Framework 4.0. Visual Studio includes support for Languages \u200b\u200bC # 4.0 and Visual Basic .NET 10.0, as well as the F # language that was absent in previous versions.

Wednesday Visual Studio 2010 allows you to effectively create complex applications for a short period of time. The model of this environment is significantly richer early or uses such concepts as a solution (solution), project, namespace (Namespace) and assembly (Assembly). The concept of the project is present in many media, for example, in wednesday Delphi. The project file contains the enumeration of the source files and other resources from which the system will build an application. The Visual Studio environmental solution includes several projects that may be dependent or independent of each other. Stand out starting project. The concept of assembly comes from the general-language executive environment CLR (COMMON LANGUAGE RUNTIME). The CLR environment is the most revolutionary invention, with which the process of writing and executing applications becomes fundamentally different.

The compiler converts files with source code to the codes in the intermediate MSIL language ( Microsoft Intermediate Language.). Together with the metadata, these codes are recorded by PE files (Portal Executable), having an extension EXE or DLL depending on the type of project. A module can also be obtained with the NetModule extension that does not contain metadata.

Total there are 12 types of projects. When loading PE files "on the fly" is broadcast to the commands of the actual processor. Framework frame. NET, providing program execution, is not included in Visual Studio, but is a setup over the operating system. This is an analogue of virtual Java-Mashina.

The assembly is a minimum unit for deploying applications. Each type of assembly is characterized by a unique identifier, identified by the author's digital signature and unique number versions. There is the following ratio between assemblies and spaces of names. The assembly may contain several namespaces. At the same time, the namespace may take several assemblies. The assembly may have in its composition both one and several files that are combined in the so-called manifest or assembly description.

At the level of C #, the namespace, similar to Packages in Java, serve to structuring the project. Namespace includes one or more classes. In one source file, several namespaces can be determined and at the same time one namespace can be determined in several files. And even the class can be located in several files (PARTIAL CLASSES).

For novice programmers, such an abundance of opportunities can cause considerable difficulties. The size and complexity of the medium can be judged by the following comparative table of three environments.

Interesting and promising seems operating environment Eclipse developed in IBM. The initial goal of the project was to create a corporate IDE standard for developing programs in different languages \u200b\u200bfor various platforms. Then the project was renamed Eclipse and highlighted in open access. The license allows for free use of code and development environment and at the same time creating closed commercial products. Thanks to this, the system has become widespread and for many organizations has become a corporate standard for developing applications.

Ecosystem Eclipse refers to consolidated technologies, the year of the widespread distribution of which is 2007. The system is implemented by java language and initially represented a full-fledged integrated Wednesday for the Java language. In the future, other languages \u200b\u200bbegan to be supported. The first versions were inconvenient, since the target product was forced to include excessive functionality. Starting from the third version, the architecture of the entire system was reworked in order to maximize the separation of modules and the relationship between them. At the same time, Eclipse modules formed from agreed class sets gave the functionality of the whole subsystems, such as assistance subsystems, product updates, learning, presentations, multilingual support And many others. By developing the application, you can now gradually increase the functionality, connecting ready-made free components. In the terminology of Eclipse, these components are called "plug-in modules", or "plugins" (plugins). Such technology becomes typical of developed operating environments. The platform based on this technology was named

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;

generation special File Descriptions of the agent 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 agent-oriented software system 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 on 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 operations Platform management can be executed through 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 recent versions Systems use Java RMI, Event-Notification and IIOP. 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.

This article is devoted to the technology development technologies and their development trends in the context of the majority of domestic and foreign companies from the natural automation of individual areas of their activities to single integrated solutions.

Development of applications in modern IT projects

The current period of development of automation and informatization of domestic enterprises can be characterized as the time of mass transition from the natural automation of individual areas of the company's activities to single integrated solutions covering all aspects of their existence. It could not not affect the composition and volume of the most frequently running IT projects and on the methods of their implementation.

Features of modern IT projects

If another five or seven years ago, projects related to custom-made of unique applications were widespread (and somewhat less - solutions based on ready-made components intended for a particular subject area) and performed by the erudite programmers of a wide profile owning and related specialties (for example, Able to administer local networks And the DBMS), today, first of all, the projects for the implementation of ready-made business applications and ERP systems are ordered, within which projects are often implemented on the basis of solutions based on all the same business applications. The reason for this is, on the one hand, the awareness of the leaders of most companies of the fact that, as it were, their company claims to unique in their marketing strategy, essentially its production, and the individual aspects of its activities are quite typical, and on the other hand - The awareness of business applications of business applications of the unusual business processes of most companies and the creation of a wide range of typical solutions with simultaneous provision of services for their implementation, accompaniment and update on their own or by the forces of partners.

Transition to the division of labor in projects for the development of

Such a situation could not not affect the personnel composition of IT companies, among which system integrators have recently prevail (sometimes having their development department, but specializing mainly on integrated projects, including not only application development), and companies specializing exclusively on development Applications, little. In the latter, the process of specialization, dividing a group of developers on business analysts, system analysts, programmers, technical writers and project managers, is underway. At the same time, the system analyst does not know how to program, the business analyst does not lead projects, and the project manager is engaged only by organizational work and is not interested in the architecture of the application, or the more subject area. This reflects the fact of the transition from the minor production of exclusive software to the mass industrial production of typical solutions in demand by modern users.

Change applications

Speaking about application development projects and related to the development of applications parts of complex IT projects, it should be noted that today the creation of corporate solutions based on not only DBMS, but also other products - office applications, GIS and CAD systems, becomes the most relevant. Funds of business analysis, specialized server products, enterprise management systems and other business applications. The requirements for the protection of the created solutions are also noticeably different from those that existed three years ago. Finally, one of the important trends is the growth of interest in applications for mobile devices and applications capable of working autonomously and, if necessary, synchronize with the enterprise information system.

From other trends that have recently been in the field of developing corporate decisions, it should be noted the growing need of companies in the means of business analysis that are part of the existing solutions or existing in the form of individual tools. Despite the fact that the creation of applications with the application of business analytics is difficult due to the fact that today the standardization of access to data from multidimensional storage and the language of requests to them remains relevant, in the hands of developers there are already enough means of solving such tasks for the most popular analytical platforms as from suppliers of analytical platforms (for example, Oracle, Microsoft and Hyperion) and from companies specializing in data analysis tools (Cognos, Proclarity and Business Objects). In addition, Business Intelligence and Report Tools, Birt (Business Intelligence and Report Tools, Birt) are available for the Eclipse platform, which is now half the market for the development of Java applications.

Involvement of the Customer in the Development Process

Evaluation of the contribution of application developers into the success of the customer's business business, as well as an assessment of the quality of the process itself and its result has always been a controversial issue and a reason for misunderstanding and conflicts. However, recently there have been methods for evaluating the maturity of development processes and recommendations based on the Capability Maturity Model Integration (CMMI) models, as well as a number of application development methodologies, providing the application to the application the ability to control the development process. The CMMI model allows you to evaluate and improve application development processes and take advantage of the successful examples of such processes, and the availability of an assessment of one or level of maturity according to this model, the developer's company knows the quality assurance of the final result of the product development process in this company.

The family development methodologies under the general name of Agile Methodologies (including, in particular, the extreme programming methodology, which we wrote several months ago) provides "recipes" for daily management of the project team, including, along with other, the principle of development controlled by testing (Test -Driven Development, TDD), which has proven itself as a means of obtaining high-quality code. A feature of this family methodology is the involvement of the Customer in the process of development so that it can control it at all stages.

Most Popular Architectures and Platforms

Services-oriented architecture

One of the current trends in the development of the IT infrastructure of modern enterprises and architectures of corporate applications is the transition to the services-oriented architecture (Service Oriented Architecture, SOA). This architecture assumes the creation and implementation of distributed applications and services based on the use of various technologies, such as web services (as similar technologies, are widely supported by the Eclipse platform and Borland and Microsoft development tools).

Most popular platforms

One of the most notable trends of recently is manifested in the unification of the platforms for which most applications are created, and the allocation of two leaders among them is Windows / Microsoft .NET and Java / J2ee. This is largely due to the ability of these platforms to ensure the ability to create applications, the degree of data protection in which, as well as the ability to create user interfaces and provide access to services and data, meet modern requirements. However, the specified trend has long been not new for anyone.

We also note that due to the rapid growth of the interest of corporate customers to developments for mobile devices, the development of this category of applications and mobile platforms themselves are becoming increasingly popular among developers.

Rising popularity of mobile platforms

Today, mobile applications are developed approximately for one and a half dozens of platforms. According to the research company Evans Data Corp conducted at the end of last year. Survey of several hundred developers mobile applicationsThe main leaders in this area are.Net Compact Framework and Java 2 Mobile Edition (J2ME), as well as other Microsoft platforms for mobile devices and Embedded Linux (Fig. 1).

Fig. 1. Popularity mobile platforms Among developers (source - developers' Choice Wireless Platforms. Definitive Rankings of Wireless Platform by Developers Worldwide - Evans Data Corp., September 2005)

Nevertheless, according to the same survey, in terms of meeting developers to the quality of tools and the level of development community support, the Nokia Series 60 platform is now occupied. According to the predictions of the same Evans Data Corp., the share of Embedded Linux is expected on the mobile platform market.

As for the development of applications, for windows platforms Mobile tools from Microsoft exist for several years. Borland's tools are available for Platforms .Net Compact Framework, Symbian and J2ME. In addition, there are some tools for developing mobile applications from Sybase, as well as a number of other manufacturers.

Developer tools today

Narrow specialization of developers led to active development over the past five years of so-called support life cycle Applications intended for large developers teams. Similar tools include the means of management of requirements, modeling business processes, applications and data, testing and application optimization, collective work management, versions control, change management. Many leading Suppliers by: IBM, Computer Associates, Borland, Microsoft, Oracle and a number of others produce such tools.

Recently, many companies previously specialized in the creation of development environments (in particular, IBM, COMPUTER Associates, Borland, Microsoft, Oracle and Sybase) have close attention to the instruments of such a purpose. The need to mutually integrate all these "heavy" tools led to the creation of entire platforms for role-based software development and application life cycle management - such platforms are now manufactured by Borland, IBM, Microsoft companies and near others.

As a rule, the use of such tools requires consideration of the software development process as a production process and, accordingly, creating and implementing methodologies for managing this process similar to the methods of management of material production processes. The introduction of such techniques is often carried out by implementing individual (and not cheap!) IT projects for implementation in companies - developers of integrated application development platforms in order to automate and optimize processes accompanying development, including task management, requirements management, achievement of quality standards.

Free versions of commercial tools

If you remember what happened with the tools for developing in the last two years, it can be noted that the trend has recently been very actively manifested by the leading manufacturers of the development of their free versions (and with good functionality) In order to attract the attention of developers to the potential and opportunities of full-featured products and platforms for which they are intended. In particular, Borland produces about three years free versions Some of their developments. Microsoft has recently been released a family of Express products, which includes several tools for developing Windows Forms and ASP .NET applications. Oracle, in turn, also provided free developer access to the Oracle Jdeveloper 10G tool.

Open source tools

There is another trend characteristic of the modern market for development tools, is an active growth in the popularity of open source platforms and tools, which is currently invested by a lot of funds by commercial companies, including such well-known manufacturers of platforms as IBM, Novell and Oracle. Among the most striking examples should be the active development of the Eclipse environment - a universal open development platform compatible with many languages, deployment and technologies platforms, as well as the Mono project of the part of the platform .NET platform for the Linux operating system (compilers and other tools are currently being actively produced) .

The Eclipse project was found in 1998 by IBM, which set itself the goal of creating an integrated Java development environment of a new generation expanded by the integrated tools built into it, forces of several Java tool providers. To this end, IBM Corporation at the end of 2001 provided the Open Source community part of the source code of its Java Application Development Tools WebSphere Studio Workbench and formed the Eclipse Consortium (included representatives of Borland, IBM, Merant, QNX Software Systems, Rational Software, Red Hat, SuSe , Togethersoft and WebGain) to manage the further development of this development environment, transformed later into an independent non-commercial organization Eclipse Foundation, which has 115 members today.

Today, after five years from the moment of its creation, the Eclipse platform has become so popular that it began to outstrett it from the market widely used commercial tools (for example, some Java-development tools). Today, the share of the Java application development tools, occupied by Eclipse, is approximately 50%. At the same time, during the previous year, the tendency to transform Eclipse from the Java development environment to the tool integration platform for the entire application development life cycle - Recently, such projects have been launched as creating a graphic modeling environment, tools for services oriented in the Eclipse consort And also released updated versions of testing tools, business analysis, Web application tools.

As for the actual means of developing applications, the Eclipse platform is currently created by the development environment for PHP, Fortran, Macromedia Flex; It is planned to issue a number of tools for developing applications for embedded and mobile platforms. For the Eclipse platform, there are commercial means of developing IBM, Borland and SAP companies.

Most Popular Development Environments

According to a survey of 1200 developers conducted in June of this year by the Evans Data Corp research company, the most widely used development medium turned out to be Microsoft Visual Studio .NET (Fig. 2).

Fig. 2. Development media use frequency (Source - Developers' Choice IDE Scorecard - Evans Data Corp., June 2006)

According to the same survey, the most popular in terms of the functionality of the application development environment turned out to be IBM Rational Application Developer, recognized as parties to a survey as a tool for modeling and assembling applications and with the best set of examples (Fig. 3).

The results of this survey reflect already mentioned trends in the prevalence of the two most popular platforms (Windows / Microsoft .NET and Java / J2ee - almost all popular development environments are intended for these platforms) and the increase in the popularity of funds and development platforms with open source (as evidenced by the presence of Eclipse in the five most popular development environments).

So, current tendencies of developing application development technologies include a decrease in the share of application development in IT projects, a gradual transition from the low-level solutions to the mass production of standard solutions, an increasingly active application of approve development life cycle tools (including projects for implementing integrated platforms for Application development). Recently, interest in creating applications for mobile platforms has also strengthened. The characteristic trend of recent years is also the appearance of high-quality open source tools. It is possible that these trends will continue for even several years.