Software development tools. Software Development Support Tools

The essence and concept of instrumental software

Tool software (IPO) - software intended for use in the design, development and maintenance of programs.

Applied tooling in the development phase. Tool software is a set of programs used to assist programmers in their work, to assist software development managers in their quest to control the development process and the resulting output. The most well-known representatives of this piece of software are programs of translators from programming languages, which help programmers write machine instructions. The tool programs are translators from Fortran, Cobol, Jovial, BASIC, APL and Pascal. They facilitate the process of creating new work programs. However, translators from languages are only the most well-known part of the tool programs; there are a great many of them.

The use of computers to help create new programs is far from obvious to people who are not professional programmers. It often happens that professionals talk about tool (development phase) and system (use phase) software in one breath, assuming that the uninitiated in the secrets of their skill is aware of this role of tool software. As well as in the use phase (for application programs), the system software also works in the development phase, but only in conjunction with the tool software. Tool software or programming systems are systems for automating the development of new programs in a programming language.

In the most general case, to create a program in the selected programming language (system programming language), you need to have the following components:

1. Text editor for creating a file with the source code of the program.

2. Compiler or interpreter. The source text is translated into an intermediate object code using a compiler program. The source text of a large program consists of several modules (files with source texts). Each module is compiled into a separate file with object code, which then must be combined into a single unit.

3. A linker or assembler that links object modules and generates a workable application - executable code.

An executable code is a complete program that can be run on any computer that has the operating system for which the program was created. As a rule, the resulting file has the extension .EXE or .COM.

Recently, visual programming methods (using scripting languages) have become widespread, focused on creating Windows applications. This process is automated in rapid design environments. In this case, ready-made visual components are used, which are configured using special editors.

The most popular editors (programming systems using visual tools) for visual design:

Borland Delphi - designed to solve almost any application programming problem.

Borland C++ Builder is an excellent tool for developing DOS and Windows applications.

Microsoft Visual Basic is a popular tool for creating Windows programs.

Microsoft Visual C++ - this tool allows you to develop any applications that run in an OS environment such as Microsoft Windows

Thus, the essence of instrumental software is to create any executable program by converting formally logical expressions into executable machine code, as well as its control and correction.

Tasks and functions of the tool software

Tool software, as a special kind of software, is characterized by general and particular

functions, as for all software in general. We discussed the general functions above, and the specialized functions inherent only to this type of program are:

1. Creation of the text of the developed program using specially established code words (programming language), as well as a certain set of characters and their location in the created file - the syntax of the program.

2. Translation of the text of the created program into a machine-oriented code accessible for computer recognition. In the case of a significant volume of the created program, it is divided into separate modules and each of the modules is translated separately.

3. Connection of individual modules into a single executable code, in compliance with the necessary structure, ensuring the coordination of the interaction of individual parts with each other.

4. Testing and control of the created program, detection and elimination of formal, logical and syntactic errors, checking programs for prohibited codes, as well as assessing the performance and potential of the created program.

Types of tool software

Based on the tasks assigned to the instrumental software, a large number of different types of instrumental software can be distinguished:

Text editors

Integrated Development Environments

Compilers

Interpreters

Linkers

Parsers and parser generators (see Javacc)

Assemblers

Debuggers

Profilers

Document generators

Code coverage analysis tools

Continuous Integration Tools

Automated testing tools

Version control systems, etc.

It should be noted that shells for creating application programs are also created by tool programs and therefore can be referred to as application programs. Consider briefly the purpose of some instrumental programs.

Text editors.

A text editor is a computer program designed for processing text files, such as creating and making changes.

CAD composition

CAD is a system that combines technical means, mathematical and software, the parameters and characteristics of which are chosen with maximum consideration for the features of engineering design and construction tasks. In CAD, the convenience of using programs is ensured through the use of means of operational communication between an engineer and a computer, special problem-oriented languages, and the availability of an information and reference base.

The structural components of CAD are subsystems that have all the properties of systems and are created as independent systems. These are CAD parts selected according to some criteria, which ensure the fulfillment of some completed design tasks with the receipt of appropriate design solutions and design documents.

According to the purpose of the CAD subsystem, they are divided into two types: design and maintenance.

Designing includes subsystems that perform design procedures and operations, for example:

machine layout subsystem;

subsystem for designing assembly units;

Subsystem of parts design;

subsystem for designing a control scheme;

· technological design subsystem.

Servicing includes subsystems designed to maintain the performance of design subsystems, for example:

· subsystem of graphic display of design objects;

documentation subsystem;

Information retrieval subsystem, etc.

Depending on the relationship to the design object, two types of design subsystems are distinguished:

object-oriented (objective);

Object-independent (invariant).

Object subsystems include subsystems that perform one or more design procedures or operations that are directly dependent on a specific design object, for example:

subsystem for designing technological systems;

subsystem for modeling dynamics, designed structure, etc.

Invariant subsystems include subsystems that perform unified design procedures and operations, for example:

subsystem for calculating machine parts;

subsystem for calculating cutting conditions;

subsystem for calculating technical and economic indicators, etc.

The design process is implemented in subsystems in the form of a certain sequence of design procedures and operations. The design procedure corresponds to a part of the design subsystem, as a result of which a certain design decision is made. It consists of elementary design operations, has a firmly established order of their implementation and is aimed at achieving a local goal in the design process. A design operation is understood as a conditionally allocated part of the design procedure or an elementary action performed by the designer in the design process. Examples of design procedures can be the procedures for developing a kinematic or layout diagram of a machine tool, technology for processing products, etc., and examples of design operations are the calculation of allowances, the solution of an equation, etc.

Structural unity of CAD subsystems is ensured by strict regulation of links between different types of software, united by a common target function for this subsystem. There are the following types of security:

methodological support - documents that reflect the composition, rules for the selection and operation of design automation tools;

· linguistic support - design languages, terminology;

· software - methods, mathematical models, algorithms;

software - documents with program texts, programs on machine media and operational documents;

· technical support - devices of computer and organizational equipment, means of data transmission, measuring and other devices and their combinations;

· information support - documents containing a description of standard design procedures, standard design solutions, typical elements, components, materials and other data;

organizational support - regulations and instructions, orders, staffing and other documents regulating the organizational structure of units and their interaction with a set of design automation tools.

· 64 CALS technologies.

CALS-technologies serve as a means of integrating industrial automated systems into a single multifunctional system. The purpose of integrating automated design and control systems is to increase the efficiency of creating and using complex equipment.

In modern conditions of the formation of the global information society the role of information and information technologies in the preparation of a future specialist is growing significantly. In the near future, the strategic potential of society will not be energy resources, but information and scientific knowledge. Information becomes the main resource for the scientific, technical and socio-economic development of society, significantly affects the accelerated development of science, technology and various industries, plays a significant role in the process of modernizing education. The value-semantic characteristic of education at a university and the professional activity of specialists should be expressed in the formation of an intellectual professional environment that most fully implements the tasks of research and design activities.

Widespread computerization of all types of human activities: from traditional intellectual tasks of a scientific nature to the automation of production, trade, commercial, banking and other activities serves to increase the efficiency of production. In a market economy, competition is successfully maintained only by enterprises that use modern information technologies in their activities.

It is information technology, along with progressive technologies of material production, that can significantly increase labor productivity and product quality and at the same time significantly reduce the time for launching new products that meet the needs and expectations of consumers. All of the above primarily applies to complex science-intensive products, including products for technical purposes.

The experience gained in the process of implementing various autonomous information systems made it possible to realize the need to integrate various information technologies into a single complex based on the creation within an enterprise or group of enterprises (virtual enterprise) of an integrated information environment that supports all stages of the life cycle of products. The professional environment most fully reveals the opportunities for professional development, using new information technologies in science and in the field of production process management. Innovative technologies in the field of information processing industry with the introduction of CALS-(Continuous Acquisition and Life cycle Support) technology - continuous information support of the life cycle of the designed object, takes the automation of production process management to a new level.

The use of information technologies based on the CALS ideology is one of the factors contributing to a more efficient implementation of an automated enterprise management system.

The essence of the CALS concept is the application of the principles and technologies of information support at all stages of the product life cycle, based on the use of an integrated information environment that provides uniform methods for managing processes and interacting with all participants in this cycle: product customers (including government agencies and departments), suppliers (manufacturers) ) products, operating and maintenance personnel. These principles and technologies are implemented in accordance with the requirements of international standards governing the rules of management and interaction, mainly through electronic data interchange.

When using CALS-technology, the quality of products is improved due to a more complete consideration of available information in the design and management decisions, as well as material and time costs for designing and manufacturing products are reduced. In the process of implementing this technology, the validity of decisions made in an automated enterprise management system (AMS) will be higher if the decision maker and the corresponding control programs have online access not only to the AMMS database, but also to databases of other automated systems and , therefore, can optimize work plans, the content of applications, the distribution of performers, the allocation of finance, etc. At the same time, online access should be understood not only as the possibility of reading data from the database, but also as the ease of their correct interpretation, i.e. consistency in syntax and semantics with the protocols adopted in the APCS. Technological subsystems must accurately perceive and correctly interpret data coming from computer-aided design subsystems. This is not so easy to achieve if the main enterprise and related organizations work with different automated systems. In addition, the problem of protecting information along the entire perimeter of the operation of technological subsystems becomes relevant.

The use of CALS technologies can significantly reduce the amount of design work, since descriptions of previously completed successful developments of components and devices, many components of equipment, machines and systems designed earlier are stored in databases of network servers available to any user of CALS technology. Availability and protection are again ensured by the consistency of formats, methods, manuals in different parts of the overall integrated system. In addition, there are more opportunities for specialization of enterprises, up to the creation of virtual enterprises, which also helps to reduce costs.

In the process of implementing CALS technology, operating costs are significantly reduced due to the implementation of integrated logistics support functions. The solution of problems of maintainability, integration of products into various systems and environments, adaptation to changing operating conditions, etc. is greatly facilitated. These data integration benefits are achieved by using modern CALS technologies.

Industrial automated systems can work autonomously, and at present the organization of the production management process takes place on this basis. However, the efficiency of automation will be noticeably higher if the data generated in one of the systems is available in other systems, since the decisions made in them will become more informed.

The experience of implementing CALS technology shows that in order to achieve the proper level of interaction between industrial automated systems, it is necessary to create a single information space within both individual enterprises and, more importantly, within the framework of an association of enterprises. A single information space is provided through the unification of both the form and content of information about specific products at various stages of their life cycle.

The unification of the form is achieved by using standard formats and languages for representing information in interprogram exchanges and in documentation.

Content unification, understood as an unambiguous correct interpretation of data about a particular product at all stages of its life cycle, is ensured by the development of ontologies (meta-descriptions) of applications fixed in CALS application protocols.

CAD - what is it?

So, what are computer-aided design systems? CAD refers to automated systems that are designed to implement a particular information technology through design. In practice, CAD systems are technical systems that allow you to automate, ensure the functioning of the processes that make up the development of projects. CAD, depending on the context, may refer to:

software used as the main element of the relevant infrastructure;

A set of technical and personnel systems (including those that involve the use of CAD in the form of software) used in an enterprise to automate the project development process;

Thus, it is possible to single out a broader and narrower interpretation of the term in question. It is difficult to say which of these interpretations is more often used in business. It all depends on the specific scope of use of computer-aided design systems, as well as on the tasks for which these systems are supposed to be used. So, for example, in the context of a single workshop in production, CAD is supposed to be a specific program for computer-aided design. If we are talking about strategic planning for the development of an organization, then such a concept as CAD will most likely correspond to a large-scale infrastructure that is used to increase the efficiency of developing various projects. It should be noted that the term CAD itself is an abbreviation that can be deciphered in different ways. In the general case, this abbreviation corresponds to a combination of the words "computer-aided design system". There are also other options for deciphering this abbreviation. For example, the “design work automation system” option is quite common. In terms of the English equivalent of the term CAD is the abbreviation CAD, in some cases CAX is also used. Let's take a closer look at the following question: for what purposes can computer-aided design systems be created in mechanical engineering and other areas?

CAD: the purpose of creation

The main goal of CAD development is to increase the efficiency of the work of enterprise specialists who solve various production tasks, including those related to engineering design. In this case, efficiency can be improved through the following factors:

Reducing the complexity of the design process;

Reduction of project implementation time;

Reducing the cost of design work, and the costs associated with the operation;

Ensuring quality improvement of the design infrastructure.

Reduced testing and simulation costs.

CAD is a tool that allows you to achieve the noted benefits due to the following factors:

Effective information support of specialists involved in the development of projects;

Automation of documentation;

Application of the concepts of parallel design;

Unification of various solutions;

Application of mathematical modeling as an alternative to expensive tests;

Optimization of design methods;

Improving the quality of business management processes.

Now let's consider in what structure the automatic design system can be represented.

CAD: classifications

The most common criteria for classifying CAD systems include industry assignment. There are the following types:

Computer-aided design of machine building infrastructure;
CAD for electronic equipment;
CAD in the construction industry.

The first type of CAD systems can be used in a wide range of industries: aircraft, automotive, shipbuilding, consumer goods. Also, the corresponding infrastructure can be used to develop both individual parts and various mechanisms using various approaches in the framework of modeling and design.

CAD systems of the second type are used to design finished electronic equipment and its individual elements, such as integrated circuits, processors, and other types of hardware.

CAD of the third type can be used to design various structures, buildings, infrastructure elements.

Another criterion by which computer-aided design systems can be classified is the intended purpose. Here are distinguished:

Design tools used to automate two-dimensional or three-dimensional geometric models, to generate design documentation;

Systems used to develop various drawings;

Systems designed for geometric modeling;

Systems designed to automate calculations within engineering projects and dynamic modeling;

Automation tools used for the purpose of technological optimization of projects;

Systems designed for computer analysis of various parameters for projects.

This classification is considered conditional.

An automated process design system can include a wide range of functions from among those listed above. The specific list of CAD capabilities is primarily determined by the developer of this system. Let's look at what tasks it can solve.

Software Development Tool Systems

General characteristics of software development tools

General characteristics of software development tools

Programming technology tool systems

CASE tools. Characteristics of modern CASE-tools

Overview of Object-Oriented Tools

Object-oriented programming arose before object-oriented analysis and design, so today there are a fairly large number of languages that support this technology. The first of these, according to the date of occurrence, is the language Smalltalk, although many elements of the object-oriented approach were used in the language Simula in 1967 The most powerful tool for creating object-oriented programs today is the language C++, created on the basis of a structured programming language C. Successfully developing language Java, which was originally designed to be object-oriented.

Development of large software systems in modern conditions is impossible without the use of software development automation tools (CASE tools). There are not so many CASEs that support an object-oriented approach. The most well-known tool in this direction is the system Rational Rose , which supports, among other things, the stages of object-oriented analysis and design.

Rational Rose object-oriented CASE tool

Developer Rational Rose- Rational Software Corp., known for its developments in the field of object-oriented technologies, the main of which is the UML language. It is on the support of UML, as the main software design language, that this CASE system is oriented.

Like any modern CASE tool, this system supports all stages of the software life cycle and provides the user with a wide range of functions for analyzing, designing, building and maintaining software. In this case, object-oriented technologies are used and graphic models are widely used.

Rational Rose consists of the following main components: a repository, a graphical user interface, a project inspection tool (browser), a project control tool, a statistics collector and a document generator, and also extensions to support various programming languages.

The main possibilities include the following:

A powerful graphic domain modeling language with a high level of formalization and support for an object-oriented methodology.

Convenient navigation between model elements using the "project inspector".

Storage of design results in the form of a single model.

Support for the work on the project of the development team.

Powerful project reporting and documentation system.

Possibilities for synthesizing programs in almost all modern object-oriented languages, including the cross-platform language Java.

Support for component technologies for building software systems.

Wide opportunities for designing software of various architectures, from simple programs to large "client-server" systems and Internet applications.

The possibility of reengineering the model based on the source code of the program. This ensures that the unity of design information and implementation is maintained.

Customization and expansion of the functionality of the CASE environment by installing extension modules, primarily to support various programming languages.

Principles of developing software systems in Rational Rose

The construction of object-oriented systems has its own specifics. Obviously, for the greatest efficiency, a single technology should be used at all stages of the life cycle. This possibility is provided by the universal modeling language UML. Rational Rose supports all stages of system design that are defined in the UML specification.

The main design method is the creation of various kinds of diagrams and specifications that define the logical and physical structures of the system model, its static and dynamic aspects. These include diagrams of classes, states, scripts, modules, processes.

At all stages, it is possible to use specialized graphical editors for model elements and use the model inspector to navigate among its components. All design information is saved in a single model file (*.mdl).

The work begins with the construction of a use case diagram (Use Case Diagram), which characterizes the main tasks and the environment of the system being designed. Further, for each block of use (Use Case) presented in the diagram of use, sequence diagrams (Sequence Diagram) are developed that identify objects in the system and describe the sequence of events that occur in the process of communication between objects. Rational Rose allows you to automatically link sequence diagrams to usage blocks.

The objects present in sequence diagrams are defined in the system using classes. Classes and their relationships are defined using class diagrams, the development of which is also supported Rational Rose. Classes are grouped into packages. Rational Rose allows you to define a set of packages, the relationships between them, and present their constituent classes in nested class diagrams.

The composition of compiled and executable system modules is specified in Rational Rose using a component diagram. The diagram defines dependencies between components. Components can be given interfaces through which dependencies are implemented. Deployment diagrams in Rational Rose reflect the configuration of the executable software system and consist of nodes and interaction relationships between nodes. The nodes include the components shown in the system component diagram.

For a fully defined model, it is possible to generate source code in various object-oriented programming languages supported by Rational Rose, such as Java or C++.

The resulting program texts can be modified outside Rational Rose, and to take into account the changes made, the system allows you to reengineer texts into a model.

Software Design

Domain Modeling . The creation of a project begins with the formation of principles for using the system. Within Rational Rose this stage is called "Use Case View". The implementation of this stage makes it possible to identify external users, usage blocks, system objects and links between them.

A usage diagram is drawn up, reflecting the external functioning of the system being created. This model is in many ways similar to the data flow diagram in structural analysis. Its main components are external users (actors), blocks of use (use case) and connections between components. To create a chart in Rational Rose using a specialized graphics editor.

All elements of the usage diagram are identified by the system as independent components of the model within this stage and are subject to further specification. First of all, this concerns usage blocks, which reflect groups of system functions that are presented as a whole for an external user.

For each block of use, a sequence diagram is constructed, which displays the interaction in time of the objects that perform the task. In such diagrams, the objects of the system are identified and the messages by which these objects interact are defined. The construction of diagrams is carried out in a specialized editor.

Each object in the sequence diagram is accompanied by the name of the class to which it belongs. A particular object is an instance of some class. Classes form the logical structure of the system.

Development of a logical structure. After the completion of the formation of the principles of using the system, the stage of developing its logical structure begins. AT Rational Rose it is called "Logical View". The result of this stage should be the main diagram, and detailed diagrams for its elements.

At this stage, you should determine the classes that are needed in the system. Instances of these classes are already indicated in the sequence diagrams. Classes and their relationships are reflected in the model as a class diagram. The class groups in these diagrams can be combined into packages.

The design of the logical structure should begin with the definition of the main packages. A package is a universal tool for grouping model elements. The use of packages allows you to make the model more visible. Packages can be nested within each other. The classes that make up each package are detailed in the attached diagram.

Built in Rational Rose The class diagram editor provides a convenient means for such operations, and the model inspector facilitates navigation through the diagram hierarchy.

For each class, a specification is specified that describes the composition of attributes and methods, relationships, the template on which the class is based, and implementation features.

The presence of templates makes it easy to create classes of various structures.

Classes can be imported into the system from outside. Rational Rose supports the component structure of the software and allows binary components such as COM and ActiveX to be used in the model. Their representation in the model is performed using classes based on the interfaces of these components.

In addition to class diagrams, state diagrams, script diagrams and other elements of the UML language are used to describe the system logic at this stage.

Designing the physical structure of the application. The classes described in the previous step are associated with the physical components of the program using component diagrams.

A component is an executable module of the system, and is associated with a source code file, a library binary file, an object module, an executable file. Components may include other components.

Component diagrams are used to visualize the components of the system being designed. The component diagramming stage in Rose is called "Component View". It consists of building a general diagram and, if necessary, detailing individual components in nested diagrams.

These diagrams reflect the relationship between the components of the software. The relationship is implemented through interfaces, which are also displayed on the diagram.

The construction of diagrams is performed in a specialized editor. For a component, the classes that compose it are specified.

Source text can be generated for a component in various programming languages supported by Rational Rose, or be assigned software fragments developed outside the environment Rose. In the latter case, their interface must match that declared in the model.

The final step in software design is the preparation of a deployment diagram. AT Rose this stage is called "Deployment View". Deployment diagrams show the configuration of an executable software system. It consists of nodes and interaction relationships between nodes and components. Nodes can include components and objects. Nodes are the physical elements of runtime.

Building and maintaining the system

Source code generation . After the specific components of the system being developed are identified, it is time to generate the program code for each component.

Actually, Rose generates a program skeleton, which is subsequently transferred to programmers for revision. Definitions of classes and methods are automatically synthesized, the specific implementation of which must be done manually.

The initial information for this operation is information about the classes that make up this component and the selected implementation language of this component.

Before performing the operation, you should determine the composition and parameters of saving the received code. Next, run the generation by selecting the required language. If errors occur, the system will inform you about it.

It is possible to selectively generate program code for individual components of the model and customize the information placed in the program files. This achieves high flexibility when upgrading and modifying the model.

Rational Rose 98 Enterprise Edition allows you to generate source text in Visual Basic, C++, Java, as well as get a description of the component interfaces in the IDL language and create projects for the Oracle 8 system.

Reengineering a model based on source codes . The possibility of reengineering, or, as it is also called, "reverse engineering", models based on source code seems to be one of the important and, of course, useful functions. Rose. The need for such an operation often arises when performing modification and modernization of the project. The program templates generated by the model, after they are transferred to programmers, can be modified and these changes must be taken into account in the model. In addition, since Rational Rose supports the import of binary components (COM objects in the Win32 environment), then support for building classes based on the description of the interfaces of the binary component is simply necessary.

Classes can be reverse-engineered by selecting the programming language in which the classes are implemented and specifying the directory with the source files. Then you can select the necessary files or reengineer for all. When performing these actions, you must be careful and select only those elements that can really be converted into a model. During operation, the system will inform you about the presence of errors.

After the successful completion of the operation, a new element will appear on the component diagram ("Component View" stage) with a name that matches the source files directory. Moving to the "Logical View" stage will show that all the classes and packages that make up the new component have also appeared on the class diagrams.

Now it becomes possible to make changes to the model determined by the added components, and re-generate the source texts.

Development phase support

Components and templates. One of the possibilities Rose is a simulation of binary components that support the COM specification. In the model, such components are represented by interface classes created on the basis of IDL files accompanying the COM object. This allows you to include various ready-made components in the model.

Support for model element templates simplifies the design process. AT Rose you can create and use templates for most elements of the model, including: use blocks, packages, classes, components, as well as for operations on the model. When creating a new element, you specify which template is being used, and the element will include all of the template's properties. This approach allows you to get rid of routine work and concentrate on the project itself.

Working environments. A logical development of the idea of using templates and external binary components in Rational Rose was the emergence of the working environment (Framework).

The workbench is a kind of template that sets the environment for the model being created. This is done by loading the basic elements included in the working environment, which become an integral part of the model.

Rose provides a wide range of standard working environments, in addition, you can create your own. The set of standard working environments is as follows:

Distributed Application Design Environment (Application Performance Explorer)

Standard environment (Standard). Focused on creating applications in Visual Basic. Includes declaration of many standard VB objects.

Application design environment for the Internet (Internet). Includes definition of various ActiveX components and VB libraries.

Application design environment for working with local databases (Local Database). Contains declaration of DAO system objects

Application design environment using RDO (Remote Data Object). Allows you to use RDO objects to create client-server applications.

Application development environment for accessing SQL servers ( SQL Server Distributed Management Object (SQL-DMO) that supports access to SQL through OLE-Automation objects.

Microsoft Transaction Server Support Environment

Microsoft Outlook Support Environment

Java application development environments (Java JDK 114 Full and Java JDK 114 Quick). Includes Java class and interface models obtained through reverse engineering.

Oracle8 Support Environment

The development environment is assigned when the model is created. Development environments are stored as model files (*.mdl) intended for reading only (Read only). In the process of creating a new model, the necessary elements are loaded from the selected development environment, followed by a new model.

Development environments are a wonderful mechanism for customization Rose for a specific project. You can create your own development environment, which will include the elements you need from various standard environments. Part Rational Rose includes a "wizard" for creating working environments.

Development team support. Any large project is usually carried out by a development team, which includes analysts, designers, programmers. The development process is a series of iterations with a cycle of "analysis" - "design" - "implementation". At each stage, several developers work with the model and the stages are repeated cyclically. In such conditions, it is necessary to maintain the integrity of the project, take into account the changes made at different stages and coordinate the stages. All this requires the use of a common repository and a special design ideology.

Along with a handy model inspection tool that makes it easy to switch between stages, Rational Rose mechanisms for supporting the development team are defined.

Various workspaces for developers and a workspace for the entire project are created. Each developer makes changes in his part (submodel), and these changes become global (transferred to the general model) only after they are approved by the project management system. as project controllers in Rose external systems such as clear case and Microsoft SourceSafe.

Using expansion modules . AT Rational Rose a flexible mechanism for configuring and configuring system capabilities has been introduced. There are various expansion modules installed in Rose and solving various problems. Two main types of extension modules can be distinguished: extensions that support programming languages and extensions of the functionality of the environment.

When adding a new extension, it integrates with the system by adding items to the system menus and installing the necessary libraries and executable files. In addition, each extension can add its own types and templates to the system.

Adding the necessary extensions is usually done during the initial installation of the system, but they can be installed later. Supports distribution of extensions via the Internet

To manage extensions in Rose there is an extension manager. With it, you can activate and deactivate various extension modules.

Advantages and disadvantages of Rational Rose

This CASE tool can be used to create a variety of object-oriented software, primarily for the Windows platform, as well as in the Java cross-platform language.

At all stages of development, the UML language is used, and the software project is a single model.

Important advantages are customization for various programming languages and architectures of software systems, as well as the possibility of "reverse engineering" based on source texts in various programming languages. There is support for various ways of physical implementation for the components of the system being designed.

Very useful is the ability to configure the system using expansion modules. In fact, the only way to write an application for a non-Windows operating system is to use the Java language.

Subject: Software development technology.

Topic: Collaborative software development tools.

educational

Acquaintance with the tools of collective software development.

Developing:

Develop the ability to listen to others, draw conclusions and generalize the knowledge gained

Educational:

Cultivate a sense of the importance of the subject in professional activities, accuracy in work

Interdisciplinary connections:

English language

Operating Systems

Information Technology

Fundamentals of algorithmization and programming

Equipment: board, chalk, writing instruments, projector, PC

Lesson type: combined

Teaching Method: Explanatory Illustrative

During the classes:

1. Organizational moment

Checking the readiness of the office

Theme announcement

2. Setting the goal of the lesson

3.Repetition of the material covered

Software development tools.

Tool environments for the development and maintenance of software tools and the principles of their classification

The main classes of tool development environments and software maintenance

Programming environments

4. Communication of new knowledge

The concept of computer software development technology and its jobs

Programming technology tool systems

Software development tools

5. Students' perception and awareness of new material

6. Comprehension generalization and systematization of knowledge

7. Summing up the lesson and setting homework

Learn topic content

Gagarina L.G. pp. 257-259.

Answer the questions:

16.4. The concept of computer software development technology and its jobs

There are some difficulties in developing a rigorous definition of CASE-technology (computer technology for the development of PS). CASE is an abbreviation for Computer-Aided Software Engineering (Computer-Assisted Programming Engineering). But without the help (support) of a computer, PSs have not been developed for a long time (at least a compiler is used). In fact, a narrower (special) meaning is put into this concept, which is gradually blurred (as it always happens when a concept does not have a strict definition). Initially, CASE was understood as engineering of the early stages of software development (definition of requirements, development of an external description and architecture of the PS) using software support (software tools). Now, CASE can also be understood as the engineering of the entire life cycle of the software system (including its maintenance), but only in the case when the programs are partially or completely generated according to the documents obtained at the indicated early stages of development. In this case, the CASE technology has become fundamentally different from the manual (traditional) technology of software development: not only the content of technological processes has changed, but also their totality.

Currently computer technology PS development can be characterized by the use

software support for the development of graphical requirements and graphical specifications of the PS,
automatic generation of programs in any programming language or in machine code (partially or completely),
software support for prototyping.

It is also said that the computer technology for the development of PS is "paperless", i.e. designed for computer representation of program documents. However, it is quite difficult to confidently distinguish manual software development technology from computer technology based on these features. This means that the most essential in computer technology has not been singled out.

In our opinion, the main difference between manual software development technology and computer technology is as follows. Manual technology is focused on the development of documents that are equally understood by different PS developers, while computer technology is focused on providing semantic understanding (interpretation) of documents with software support for computer technology. The semantic understanding of documents gives software support the ability to automatically generate programs. In this regard, an essential part of computer technology is the use of formal languages already at the early stages of developing a software system: both for the specification of programs and for the specification of other documents. In particular, formal graphic specification languages are widely used. This is what makes it possible to rationally change the very set of technological processes for the development and maintenance of software.

From the discussion, it can be determined software development computer technology as a programming technology that uses software tools to develop formalized specifications for programs and other documents (including graphical specifications) with subsequent automatic generation of programs and documents (or at least a significant part of them) according to these specifications.

Now the main changes in the software life cycle for computer technology are becoming clear. If, when using manual technology, the main efforts in developing the PS were made at the stages of actual programming (coding) and debugging (testing), then when using computer technology, it was at the early stages of developing the PS (defining requirements and functional specification, developing architecture). At the same time, the nature of the documentation has changed significantly. Instead of a whole chain of informal documents focused on the transfer of information from the customer (user) to various categories of developers, a PS prototype is formed that supports the selected user interface and formal functional specifications (sometimes formal PS architecture specifications) sufficient for automatic synthesis (generation) of programs PS (or at least a significant part of them). At the same time, it became possible to automatically generate part of the documentation necessary for developers and users. Instead of manual programming (coding) - automatic generation of programs, which makes independent debugging and testing of programs unnecessary: rather deep automatic semantic control of documentation is added instead. It becomes possible to automatically generate tests according to formal specifications for a complex ( systemic) PS debugging. The nature of PS maintenance also changes significantly: all changes are made by the maintainer only to the specifications (including the prototype), other changes to the PS are made automatically.

With that said software life cycle for computer technology can be represented by the following diagram (Fig. 16.3).

Rice. 16.3. The life cycle of a software tool for computer technology.

prototyping PS is an optional stage of the life cycle of the PS with computer technology, which in Fig. 16.3 is shown by a dotted arrow. However, the use of this step in many cases and the corresponding computer support for this step is characteristic of computer technology. In some cases, prototyping is done after (or during) the development of specifications. PS, for example, in the case of user interface prototyping. This is shown in fig. 16.3 dotted return arrow. Although we allow a return to the previous stages at any stage, but here it is shown explicitly, since prototyping is a special approach to the development of PS (see lecture 3). User interface prototyping allows you to replace the indirect description of the interaction between the user and the PS in manual technology (when developing an external description of the PS) by the user's direct choice of the method and style of this interaction, fixing all the necessary details. In essence, at this stage, an accurate description of the user interface is produced, understandable by the software support of computer technology, and with the responsible participation of the user. All this is based on the presence in the software support of computer technology of a customizable shell with an extensive library of blanks for various fragments and screen details. This kind of prototyping seems to be the best way to bridge the barrier between user and developer.

Development of PS specifications breaks down into several different processes. If we exclude the initial stage of developing specifications (determining requirements), then these processes use methods that lead to the creation of formalized documents, i.e., formalized specification languages are used. At the same time, graphical methods of specifications are widely used, leading to the creation of various schemes and diagrams that determine the structure of the information environment and the management structure of the PS. Fragments of data and program descriptions, presented in algebraic specification languages (for example, using operational or axiomatic semantics), or logical specification languages (based on a logical approach to program specification) are attached to such structures. Such specifications allow programs to be generated largely or completely automatically. An essential part of specification development is the creation of a dictionary of named entities used in specifications.

Automated specification control PS uses the fact that a significant part of the specifications are presented in formal languages. This allows you to automatically perform various types of control: syntactic and partial semantic control of specifications, control of the completeness and consistency of schemes and diagrams (in particular, all their elements must be identified and reflected in the dictionary of named entities), end-to-end control of the balance of specification levels and other types of control in depending on the capabilities of the specification languages.

Generation programs PS. At this stage, it automatically generates code skeletons for PS programs or completely codes for these programs according to formal PS specifications.

Automated documentation of PS. Assumes the possibility of generating various forms of documents with partial filling of them according to the information stored in the repository. At the same time, the number of types of documents is reduced compared to traditional technology.

Comprehensive testing and debugging of PS. At this stage, all PS specifications are tested and the errors found during this are corrected. Tests can be created both manually and automatically (if the specification languages used allow it) and are passed through the generated PS programs.

PS certificationhas the same content.

PS support is greatly simplified, since the main changes are made only in the specifications.

Workplace of computer technology of software development is a tool environment that supports all stages of the life cycle of this technology. This environment makes significant use of the repository. The repository stores all the information created during the development of the PS (in particular, the dictionary of named entities and all specifications). As such, the computer technology workplace is integrated, at least in terms of user interface and data. The main tools of such a workplace are:

user interface designers;
a tool for working with a dictionary of named entities;
graphical and test editors of specifications;
specification analyzers;
program generator;
documenters.

14.5. Programming technology tool systems

Programming technology tool system - this is an integrated set of software and hardware tools that supports all the processes of development and maintenance of large PS throughout its entire life cycle within a certain technology. It has already been noted above (see clause 14.3) that, in addition to being integrated, it also has the properties of complexity and focus on collective development. This means that it is based on the consistency of the products of technological processes. Thus, the instrumental system is able to provide, at least, control over the completeness (completeness) of the created documentation (including a set of programs) and the consistency of its change (versioning). The support of the PS maintenance phase by the instrumental system means that it must provide PS configuration management. In addition, the instrumental system supports the management of the work of the team and for different members of this team provides different access rights to various fragments of the production of technological processes and supports the work managers for managing a team of developers. Programming technology tool systems are large enough and expensive software systems to somehow justify their tool overload. Therefore, the set of tools included in them is carefully selected taking into account the needs of the subject area, the languages used and the chosen programming technology.

Taking into account the discussed properties of instrumental systems of programming technology, three of their main components can be distinguished:

repository,
tools,
interfaces.

Tools- a set of tools that defines the capabilities provided by the system to the development team. Usually this set is open and structured. In addition to the minimum set ( built-in tools), it contains the means of its extension ( imported instruments). In addition, due to the integration over actions, it consists of some common part of all tools ( nuclei) and structural (sometimes hierarchically related) tool classes.

Interfacesdivided into user and system. Custom The interface provides developers with access to the toolkit. It is implemented shell systems. Systemic interfaces provide interaction between tools and their common parts. System interfaces stand out as architectural components due to the openness of the system - they must be used by new ( imported) tools included in the system.

The most general architecture of instrumental systems of programming technology is shown in Fig. 16.4.

Rice. 16.4. General architecture of instrumental systems of programming technology.

There are two classes of programming technology tool systems: project support tool systems and language-dependent tool systems.

Project support tool system - this is an open system that can support the development of PS in different programming languages after its appropriate extension with software tools oriented to the selected language. The set of tools of such a system supports the development of PS, and also contains tools independent of the programming language that support the development of PS (text and graphic editors, report generators, etc.). In addition, it contains system extension tools. The core of such a system provides, in particular, access to the repository.

Language-Dependent Tool System - this is a system for supporting the development of software in any one programming language, which essentially uses the specifics of this language in the organization of its work. This specificity can affect both the capabilities of the kernel (including the structure of the repository), and the requirements for the shell and tools. An example of such a system is the Ada Programming Support Environment (APSE).

7.1. Software development tools

Tool software (Software tools) - software used in the course of development, correction or development of other programs:

editors, compilers, debuggers, auxiliary system programs, graphics packages, etc.

This includes programming languages, integrated program development environments, CASE systems, etc.

7.1.2. Choosing a programming language

The currently existing programming languages can be divided into the following groups:

Universal high-level languages;

Specialized software developer languages;

Specialized user languages;

Low level languages.

In the group of universal high-level languages, the undisputed leader today is the C ++ language. Indeed, it has a number of advantages:

Scalability. In the C++ language, programs are developed for a wide variety of platforms and systems;

The ability to work at a low level with memory, addresses, ports, which, if used carelessly, can easily turn into a disadvantage;

C++ has a powerful preprocessor inherited from C, but like any other powerful tool, it needs to be used with care;

The ability to create generalized algorithms for different types of data, their specialization and calculations at the compilation stage using templates.

At the same time, the C++ language has a number of significant drawbacks:

Connecting the interface of an external module through the preprocessor insertion of a header file (#include) seriously slows down compilation when a large number of modules are included;

Lack of data type information at compile time;

Difficulty to learn and compile;

Some type conversions are non-intuitive. In particular, the operation on unsigned and signed numbers produces an unsigned result.

For C++, there are a large number of class libraries that support creating a user interface, client-server applications, working with databases, etc.,

so for now there is no alternative to C++. For secondary projects, Visual Basic is sometimes used. The Java language was considered as an alternative to Basic, but due to the lack of a visual

means of developing forms, it still remains of little use.

Modern Object Pascal, like Pascal, proposed by N. Wirth in the mid-70s of the XX century, remains the most attractive for teaching the basics of programming due to its

simplicity, structuredness and detection by the compiler of a large number of not only syntactic, but also semantic errors.

Today, unlike in the 1960s, programming languages are rarely created. Over the past 15 years, only two novelties that have become widespread can be noted - this is Java (Sun Microsystems, 1995), which has become popular largely due to the technology of its use on the Internet and the emergence of such a concept as the Java virtual machine, and C # (Microsoft, 2000), based on C++.

The creator of the language is Microsoft employee Andreas Hejlsberg. He became famous in the world of programmers long before he came to Microsoft. Hejlsberg was among the leading

developers of one of the most popular development environments - Delphi. At Microsoft, he was involved in the creation of a version of Java - J++, so he has no shortage of experience in writing languages and programming environments. As Andreas Hejlsberg himself noted, C# was created as a component programming language, and this is one of the main advantages of the language, aimed at the possibility of reusing the created components.

Other advantages of the C# language:

It retains the best features of the popular C/C++ programming languages it is based on. In this regard, the transition of programmers from C ++ to C # is facilitated;

It is simpler and more reliable than C++. Simplicity and reliability are mainly due to the fact that C#, although allowed, does not encourage such dangerous features of C ++,

like pointers, addressing, dereferencing, address arithmetic;

Is a fully object-oriented language, where even the types built into the language are represented by classes;

Implements inheritance and universalization capabilities;

Takes into account all the features of Framework .Net, since C# was created in parallel with this environment;

With the .Net framework built on top of the operating system, C# programmers get the same benefits of working with a virtual machine as

Java programmers. Code efficiency is even improved because the CLR runtime is an intermediate language compiler, while

the Java virtual machine is the bytecode interpreter;

Powerful framework library supports buildability various types applications in C#, making it easy to build Web services, other kinds of components,

it is enough to simply store and retrieve information from the database and other data storages;

It is a source of reliable and efficient code.

In addition to the languages described above, Modula, Ada, COBOL, FORTRAN, and some others also belong to the universal group. Each of the above languages has its own characteristics and, accordingly, its own scope. Currently, universal programming languages are used in various areas of human activity, such as:

Scientific computing (languages C++, FORTRAN, Java);

System programming (languages C++, Java);

Information processing (languages C++, COBOL, Java);

Artificial intelligence (LISP, Prolog);

Publishing (Postscript, TeX);

Remote information processing (Perl, PHP, Java, C++);

Description of documents (HTML, XML).

Over time, some languages developed, acquired new features and remained in demand, others lost their relevance and today are of purely theoretical interest at best (Focal, PL / 1, etc.). This is largely due to the following factors:

Availability of a programming environment that supports the development of applications in a specific programming language;

Ease of maintenance and testing of programs;

The cost of development using a specific programming language;

Clarity and orthogonality of language constructions;

Applying an object-oriented approach.

Specialized developer languages are used to create specific types of software. They include:

Database languages;

Languages for creating network applications;

Languages for creating artificial intelligence systems, etc.

Specialized user languages are usually part of professional user environments, are narrowly focused and not used by software developers.

Low-level languages allow programming almost at the level of machine instructions. At the same time, they get the most optimal both in terms of time

execution, and in terms of the amount of memory required for the program. The disadvantage of them is that they do not support the principles of structured programming.

Nowadays, assembly type languages usually use:

When writing relatively simple programs, to refer to technical means, such as drivers;

In the form of inserts into programs in high-level languages, for example, to speed up data transformation in loops with a large number of repetitions.

To a greater extent, the choice of programming language is determined by the experience of the developer, the requirements of the organization leading the development, or simply an established opinion.

7.7.3. Choosing a programming environment

An integrated software development environment is a system of software tools used by programmers to develop software.

Typically, a development environment includes a text editor, a compiler and/or interpreter, a linker, a debugger, and a help system. Sometimes also contains a version control system and various tools to simplify the construction of a graphical user interface.

Many modern development environments also include an object inspector, a class browser, and a class hierarchy diagram that are used for object-oriented software development.

Typically, a development environment is designed for one specific programming language, such as Visual Basic or Deiphi, but there are development environments for multiple languages, such as Eclipse or Microsoft Visual Studio.

Examples of development environments are Turbo Pascal, Borland C++, GNU toolchain, DrPython.

Recently, with the development of object-oriented programming, the previously mentioned visual programming environments have become widespread, in

which the most common blocks of program code are represented as graphical objects.

The most commonly used visual environments are Delphi, C++ Builder from Borland (Inprise Corporation), Visual C++, Visual Basic from Microsoft, Visual Ada from IBM, etc.

The .NET Framework technology, proposed by Microsoft as a platform for creating both regular programs and web applications, has gained great popularity these days. The main advantage of .NET is the compatibility of different services written in different languages.

For example, a service written in C++ for .NET might access a class method from a library written in Delphi; in C#, you can write a class that inherits from a class written in Visual Basic .NET, and an exception thrown by a method written in C# can be caught and handled in Delphi.

As in the case of choosing a programming language, the choice of a programming environment is determined by the nature of the project, the habits and skills of the developer, the trends of the time, the requirements of the customer, and simply public opinion: “All such development should be carried out in the environment ...

Introduction

In the process of software development, a large number of the most versatile software (SW) is used. This lecture course examines when and what is used throughout the application development phase.

To give a more complete picture of the role of each utility or development slices in the software development process, all the tools discussed in this course of lectures will be considered using the example of application development using one of their high-level languages. For simplicity, all used tools can be divided into 4 groups. Let's take a closer look at each of the groups.

Required

Necessary tools are those without which, in principle, it is impossible to obtain executable code; This group includes:

§ text editors;

§ compilers and assemblers;

§ linkers or editors links (linkers);

Often used

These are means, the use of which, unlike the necessary ones, can be avoided. But without them, the development process is very difficult and lengthened; Commonly used tools include:

§ utilities for automatic assembly of the project;

§ debuggers;

§ programs for creating installers;

§ resource editors;

§ profilers;

§ version support programs;

§ programs for creating help files (documentation).

Specialized

These tools are used in exceptional cases, they solve rather specific tasks:

§ dependency tracking programs;

§ disassemblers;

§ decompilers;

§ hex editors;

§ programs for tracking system activity and changes occurring in the system;

§ verification programs and containers (create a virtual environment for individual classes of programs in which you can explore the behavior of the program);

Integrated Development Environments

IDEs contain most of the above programs and make it easy to create applications. By and large, a development environment is a program that brings together several tools from the first and second (and sometimes third) groups.

In the future, we will get acquainted with the main representatives of each group in more detail, as well as consider how it all works in an integrated development environment.

CLASSIFICATION OF TOOLS

TOPIC 1 THE CONCEPT OF TOOLS.

CLASSIFICATION OF TOOLS.

Tool systems of programming technology can be divided into three main components:

the repository

the toolkit,

interfaces.

Interfaces divided into user and system. Custom The interface provides developers with access to the toolkit. It is implemented shell systems. Systemic interfaces provide interaction between tools and their common parts. System interfaces stand out as architectural components due to the openness of the system - they must be used by new ( imported) tools included in the system.

The most general architecture of instrumental systems of programming technology is shown in Fig.

Rice. General architecture of instrumental systems of programming technology.

There are two classes of programming technology tool systems: project support tool systems and language-dependent tool systems.

Project support tool system- this is an open system that can support the development of PS in different programming languages after its appropriate extension with software tools oriented to the selected language. The set of tools of such a system supports the development of PS, and also contains tools independent of the programming language that support the development of PS (text and graphic editors, report generators, etc.). In addition, it contains system extension tools. The core of such a system provides, in particular, access to the repository.

Language-Dependent Tool System- this is a system for supporting the development of software in any one programming language, which essentially uses the specifics of this language in the organization of its work. This specificity can affect both the capabilities of the kernel (including the structure of the repository), and the requirements for the shell and tools.

Software development is carried out using various tools that provide:

original programming;

use of application software packages - typical programs that implement data processing functions;

automation of the main stages of program development.

The most traditional development tools are programming languages and systems. Programming languages are usually divided into machine and algorithmic languages.

Machine languages contain machine instructions corresponding to the simplest processing operations. Machine instructions are tied to a particular class of computers and/or operating systems.

Algorithmic programming languages describe the algorithm of the problem, ensure the visibility of the algorithm and the convenience of maintaining the program. Algorithmic languages are divided into machine-oriented, procedure-oriented and problem-oriented languages.

machine-oriented Programming languages are low-level languages because they take into account the architecture and type of computers. Programming in such languages is laborious, but the programs are optimal in terms of the required computer resources. Examples of machine-oriented programming languages are various assemblers 1 (Macro Assembler, Turbo Assembler, etc.) of a certain class of computers.

procedural-oriented programming languages such as Visual Basic, Pascal, C++, Ada, Cobol, PL1, etc. make it possible to describe a set of processing procedures and implement typical computational structures:

1. Sequences of blocks (instructions): 1, 2, 3, 4, etc.

All blocks (instructions) are executed in strict sequence (Fig. 5 A)

2. Conditional transition (Fig.5 B) - checking the given condition (2) and choosing an alternative action: if the condition is true - 3, otherwise - 4. After that, control is transferred to block 5.

3. Alternative choice (Fig.5 C) - checking condition (2), if the condition is true - performing action 3, otherwise checking condition (4); if the condition is true, action 5 is performed, and so on. If none of the conditions were met or actions were performed (3 or 5, etc.), control is transferred to block 6.

A B C

Figure 5

4. Cyclic process - cycle "bye" (Fig. 6A). The loop is repeated until condition (2) is true - block 3. If condition (2) is false, transfer control to block 4.

5. Cyclic process - cycle "before" (Fig. 6B). The loop is executed at least once - block 2. After checking condition (3), if it is true, block (2) is executed, otherwise control is transferred to block 4.

Figure 6

Programming languages objective types are also used in the program code of a class of objects or in event procedures, elements of structured programming.

problematic-oriented programming languages - high-level relational query languages, report generators, etc. allow you to identify the problem, input and output information, without specifying specific processing procedures.

Application software packages (APP) are divided into classes:

Problem-oriented SPP - provide a solution to the problems of a specific subject area;

Method-oriented SPP - support a certain type of model and methods for solving problems, are applied regardless of the subject area;

RFP general purpose– provide support for information technology (text works, graphic works, standard calculations, etc.).