Modern application development tools
At present, not separate tools (for example, a compiler) are associated with each programming system, but some logically related set of software and hardware tools that support the development and maintenance of PS in a given programming language or focused on any specific subject area. We will call such a collection tool environment for the development and maintenance of PS. Such tool environments are characterized, firstly, by the use of both software and hardware tools, and, secondly, by a certain orientation either to a specific programming language or to a specific subject area.
The tool environment does not have to function on the computer on which the PS developed with its help will be used. Often such a combination is quite convenient (if only the power of the computer used allows it): there is no need to deal with computers of different types, components of the tool environment itself can be included in the developed PS. However, if the computer on which the PS is to be used is not available to the developers of this PS (for example, it is constantly busy with other work that cannot be interrupted, or it is still under development), or is inconvenient for developing the PS, or the power of this computer is insufficient for ensure the functioning of the required instrumental environment, then the so-called instrumental-object approach. Its essence lies in the fact that the PS is developed on one computer, called instrumental, and will be applied on another computer, called target(or objective).
There are three main classes of tool development environments and maintenance of the PS (Fig. 16.1):
programming environments,
computer technology jobs,
instrumental systems of programming technology.
Programming environment is intended mainly to support the processes of programming (coding), testing and debugging the PS. Computer technology workplace focused on supporting the early stages of the development of PS (specifications) and automatic generation of programs according to specifications. Programming technology tool system is designed to support all development and maintenance processes throughout the life cycle of the software and is focused on the collective development of large software systems with a long life cycle. For such systems, the cost of maintenance usually exceeds the cost of development.
Rice. 16.1. The main classes of tool environments for the development and maintenance of PS.
Tool programming environments.
Programming tool environments contain, first of all, a text editor that allows you to design programs in a given programming language, tools that allow you to compile or interpret programs in this language, as well as test and debug the resulting programs. In addition, there may be other tools, for example, for static or dynamic program analysis. These tools interact with each other through ordinary files using standard file system capabilities.
There are the following classes of programming tool environments (see Fig. 14.2):
general purpose environments,
language-oriented environments.
Programming environments general purpose contain a set of software tools that support the development of programs on different languages programming (for example, a text editor, a linker, or an interpreter for the language of the target computer) and usually represent some extension of the capabilities of the operating system being used. To program in such an environment in any programming language, you will need additional tools that are oriented to this language (for example, a compiler).
Fig.16.2. Classification of programming tool environments.
Language oriented the programming tool environment is designed to support the development of a software system in any one programming language, and knowledge about this language was significantly used in building such an environment. As a result, quite powerful features that take into account the specifics of this language can be available in such an environment. Such environments are divided into two subclasses:
interpretive environments,
syntactically-driven environments.
interpretive programming tool environment provides interpretation of programs in a given programming language, i.e. contains primarily an interpreter of the programming language to which this environment is oriented. Such an environment is necessary for interpretive-type programming languages (such as Lisp), but can be used for other languages (such as on an instrumental computer). Syntactically-driven programming tool environment is based on knowledge of the syntax of the programming language to which it is oriented. In such an environment, a syntactically-driven editor is used instead of a text editor, allowing the user to use various patterns of syntactic constructions (as a result of this, the program being developed will always be syntactically correct). Simultaneously with the program, such an editor forms (in the computer's memory) its syntax tree, which can be used by other tools.
Alexey Fedorov, Natalia Elmanova
The previous article of this series was devoted to the consideration of the logical and physical design of data and the tools used in this process. We are convinced that data engineering plays a key role in the development of information systems, because the quality of this work determines the costs associated with creating applications for end users, as well as with the subsequent maintenance and modernization of the created product. The result of this step is an "empty" database (i.e., a database whose tables contain mostly no records, with the possible exception of tables of a reference nature such as a list of subjects Russian Federation or telephone area codes).
Next stage life cycle information system - development of client applications. The result of this stage is a finished product, consisting of a number of applications that allow users to enter data into tables or edit existing data, analyze the entered data and present them in a more readable form - graphs, pivot tables or reports (including " paper documents).
The process of designing data for relational DBMS is to a certain extent a logical process and is subject to a single standard methodology. This causes a low degree of dependence of the sequence of actions performed during the design of these actions both on which particular data design tool is used, and on whether it is used at all. Actually, this is why data design tools are more or less similar in their interface, which essentially reflects the process of drawing data models on paper.
The process of creating client applications that work with databases is rather difficult to describe in the form of such a universal sequence of actions, since the logic of a particular application almost completely depends on the logic of the business process being modeled. Application development tools as a category of software products have existed much longer than data design tools, and they are more diverse - from a compiler run from the command line to tools where the finished application is assembled by "mouse" from ready-made components, and the code is generated automatically. With such a variety of development tools, they should be classified in some way, which we will try to do in this article, telling along the way which of them are convenient to use in a particular case.
Classification of application development tools
Development tools can be classified from various positions, for example, based on the programming language they support, or the performance of the created applications on a particular platform, or the presence of certain libraries and visual tools in them. We will try to classify application development tools, based on the convenience of their use to create products that are a user interface to the database.
Almost any development tool that claims to be universal can be made to work with any database - it is enough to support the use of third-party libraries in this development tool and this database has a set of client interfaces (API) for the platform on which the created applications should operate . However, not every pair of "development tool plus DBMS" products is attractive in terms of labor costs associated with the creation of such applications. You can write a complete application that calls the client API functions and implements a convenient user interface using a C compiler and a simple graphics library (for example, allowing you to change the color of pixels on the screen) for the operating system on which this application will run. But the costs associated with implementing such a project may be completely unjustified, because in this case, developers will have to implement functions that are already contained in the class libraries and components of development tools that are more deeply focused on creating database applications or include support for creating such applications.
Development tools focused on specific DBMS
Ten or twenty years ago, in many applications using databases, client API functions were called from code written in one of the programming languages, most often in C. Just look at the description of the API of the client part of almost any server DBMS - and you will find many examples of the most typical code fragments, for example, for registering a user, executing queries, etc. However, it quickly became clear to DBMS developers that the labor costs associated with writing such code can be significantly reduced by collecting the most typical code fragments and the most common user interface elements (even for alphanumeric terminals) into libraries, arranging these libraries in as a separate product and adding to it a development environment and user form design utilities for viewing and editing data, as well as reports. This is how the first DBMS-specific development tools appeared, such as Oracle * Forms (the predecessor of the current Oracle Forms Developer).
Products of this class are still available on the development tools market today. Almost all server database vendors also produce application development tools. In the vast majority of cases, modern versions of these development tools support access to DBMS of other manufacturers using at least one of the universal data access mechanisms (ODBC, OLE DB, BDE). However, access to "own" DBMS is usually carried out in the most efficient way, that is, using client APIs, objects contained in the libraries of the client part of server DBMSs, special classes for accessing the data of this DBMS, or by implementing drivers for universal data access mechanisms, able to take into account the specific features of this DBMS.
AT separate category desktop DBMS development environments can be distinguished. In the article of this series devoted to desktop DBMS, we already noted that the vast majority of desktop DBMS that survived to today, such as Microsoft Visual FoxPro, Microsoft Access, Corel Paradox, Visual dBase, support access to server DBMS, at least with the help of universal data access mechanisms, which allows them to be conventionally classified as development tools. Note, however, that at present the creation of applications in the "client-server" architecture with their help is an infrequent phenomenon. The exception, perhaps, is the pairs Microsoft Access - MSDE, Microsoft Access - Microsoft SQL Server and Microsoft Visual FoxPro - Microsoft SQL Server. This is the result of a competent policy of Microsoft, striving for maximum compatibility of its products and providing the most painless for users to replace their desktop DBMS with their own database servers (Access->MSDE->Microsoft SQL Server, FoxPro->Visual FoxPro->Microsoft SQL Server) .
Development tools that are universal in relation to the DBMS
Development tools that are universal in relation to the DBMS (or claiming to be similar universality) are, as a rule, followers of conventional application development tools that are not directly related to databases. Typical examples of such development tools are Borland Pascal, Borland C++, Microsoft QuickC. Capable of using third-party libraries, these tools made it possible to access the functions of client APIs, and with the development of universal data access mechanisms (such as ODBC), also the API functions of libraries that implement such mechanisms. It should be noted that desktop DBMS environments (such as dBase, FoxBase) or pseudo-compilers for languages of the xBase family (such as Clipper) were often created with the help of these development tools.
Later versions of the aforementioned development tools acquired libraries of functions and classes designed to access data using certain universal mechanisms. Further development of development tools led to the emergence of two categories of products for this purpose.
The first category includes development tools that have extensive class libraries, a large number of "wizards" and code generators, but are focused on "manual" code creation and are rarely used to create "standard" database applications (here under the phrase "standard application "we mean an application that has direct access to the database with which the user interacts, that is, it is a "classic" client of the server DBMS). A typical (and the only really popular on the software market) representative of this class of products is Microsoft Visual C++. With the help of Microsoft Visual C++ and the MFC (Microsoft Foundation Classes) library, you can create any application if you have the skill, knowledge, skill and time. Nevertheless, applications with a complex user interface (for example, those using databases) are not often developed with its help (although examples of its use can be found even in Russian literature). Basically, this product is used to create client applications in case of presenting special requirements to them, such as high performance, the ability to perform any non-standard operations, etc.
The second category includes development tools with advanced visual tools that allow you to literally "draw" the user interface, partially erasing the differences between the work of the programmer and the user and reducing the cost of the final product by attracting developers who are not of the highest qualification to the design of the interface (if you carefully study the course programs training centers that specialize in teaching Microsoft, Borland, and Sybase development tools, you may find that the duration of the training course, after listening to which a typical Windows user must learn how to create client applications for server DBMS, is from 5 to 10 working days).
It is this category of development tools that is most often used when creating client applications. The most popular products of this class include Microsoft Visual Basic, Borland Delphi , Sybase PowerBuilder and Borland C++Builder. The development environments for such products are very similar in appearance (up to the location of windows on the screen, which is set "by default"): as a rule, the development environment for such a product contains a "blank" of the designed form (analogous to a window), a separate panel with icons of user interface elements and other objects used in the application that can be selected and placed on the form, a window in which the properties of one of the elements selected on the form are displayed and edited (and sometimes a list of events to which this element reacts), a code editor window where you can enter code snippets , associated with the processing of certain events, as well as the code that implements the logic of this application. As a rule, modern development tools of this class allow you to create simple data editing applications with little or no code.
Recently, it has also become very popular to create applications that use database access, but located inside ordinary documents. The development tools for such applications are based on the macro languages of the corresponding editors. The most typical and practically the only popular representative of this category of development tools is Visual Basic for Applications, which is similar to the visual development tools listed above and differs from them in that the applications created with it are contained within Microsoft Office documents and are not alienated from them.
Note, however, that the above division of development tools into these two classes is rather conditional. As we said above, almost all database application development tools, including those focused on specific DBMS, support at least one of the universal data access mechanisms. And almost all "universal" application development tools, if they belong to the manufacturer of any server DBMS, support "their" DBMS better than third-party DBMS (this can be expressed, for example, in special class libraries or components for accessing this server, and also in the presence of common repositories of objects and data models, and sometimes editors of data access parameters or data schemas common with the client part of the server DBMS)
Classification of applications that use databases
Applications in client-server architecture
In the previous articles of this series, we have already talked about what constitutes a "client-server" architecture in the traditional sense. Therefore, we will only briefly recall that information systems created in this architecture are a database server that manipulates data, and a client application that accesses it and uses either client APIs (or classes and components that encapsulate their calls), or one from universal data access mechanisms. Typically, when using such an application architecture, the database server is also responsible for enforcing business rules implemented in the form of stored procedures, triggers, server constraints, and other database objects.
In this case, development tools with advanced visual tools, such as Microsoft Visual Basic, Borland Delphi, Sybase PowerBuilder, Borland C++Builder, are most often used to create client applications.
Note, however, that the choice of modern application architectures is currently quite wide and is not limited to the "classical" client-server architecture, which implies that the application consists of a database server and client applications interacting with this server. Therefore, below we will discuss which development tools are convenient to use when creating distributed applications.
Distributed Applications
Distributed (or multi-tier) applications usually consist of presentation services (or "thin" clients that end users usually interact with), business logic services implemented as business objects (or middle tier services; often to describe a collection of such services are termed middleware), and data services (usually consisting of a database server and data access mechanisms). Business logic services are designed to receive user input from presentation services, interact with data services to perform business operations (such as order processing or balance sheet calculation), and return the results of these operations to presentation services.
Unlike conventional client-server applications, in multi-tier systems, thin clients typically do not have direct access to data. Instead, clients send requests to business objects specifically designed for this purpose. Those, in turn, can perform business operations requested by the client (such as processing an order, executing a banking transaction, etc.).
Some of the business objects may access data services using some sort of data access mechanism. Since the end user does not interact directly with business objects, the latter usually do not have a user interface in the usual sense. Physically, business objects can be implemented as operating system services, console applications or Windows applications, as well as libraries loaded into the address space of a server application specially designed for this purpose (Web server, application server, transaction monitor, etc.). ). It is not uncommon for a single business entity to serve many customers.
To create business objects, both development tools with advanced visual tools and development tools focused on the "manual" creation of application code (such as Visual C ++) are used. Note that the latest versions of almost all the most popular Windows application development tools (Microsoft Visual Basic, Visual FoxPro and Visual C++, Borland Delphi and C++Builder, Sybase PowerBuilder) support the creation of various types of business objects (Web applications, ASP- objects, COM servers, etc.), with the possible exception of Microsoft Access - this product is designed more for qualified users than for developers of distributed systems. Often, Java application creation tools (such as Borland JBuilder) are also used for this purpose.
Note that, in addition to the above-mentioned "universal" tools for creating both applications in the "client-server" architecture and business objects for distributed systems, there are also specialized tools on the development tools market designed specifically for creating business objects (usually , Web applications). Of the development tools of this class for the Windows platform, the most popular is Microsoft Visual InterDev, the first version of which appeared in 1998. We can also mention another interesting product belonging to the same category of development tools - Borland IntraBuilder, which appeared two years earlier, but for some reason, despite the growing need for products of this class, it did not receive further development. Development tools of this class, as a rule, allow you to create applications that dynamically generate HTML code or code in one of the scripting languages (VBScript or JavaScript), which is transmitted by the Web server to the user's browser as part of a Web page, and accepting data entered by the user in HTML form and passed by the browser to the Web server.
Conclusion
In this article, we discussed the process of creating applications that use databases, as well as the various categories of tools used in their development. We have seen that development tools can be conditionally divided, on the one hand, into tools focused on the use of specific DBMS, tools that are universal in relation to DBMS, and desktop DBMS environments used to develop applications. On the other hand, they can be divided into tools focused on visual user interface design (this category includes Microsoft Visual Basic, Borland Delphi, Sybase PowerBuilder, Borland C++Builder) and tools focused on writing application code (Visual C++ ).
After reviewing some of the most popular application development tools, we found that most of these products, as a rule, support:
- at least one of the universal data access mechanisms, which allows using data from various DBMS in the applications being created;
- creation of several types of distributed applications;
- automatic generation of application code based on models created using the most popular data design and business process modeling tools.
We also discussed how client-server applications differ from distributed systems and what development tools can be used to create both types of applications.
The life cycle of an information system does not end with the development of applications. Once created, they are supposed to be tested, implemented, trained to use them, and finally exploited for a number of years. As a result of such exploitation, data is accumulated, which, as a rule, is much more valuable than the applications themselves. These data often represent the material necessary for making important management decisions, so it is important to be able to convert them to a form suitable for such a purpose. To do this, there are tools related to the Business Intelligence category - report generators, tools for analytical data processing and searching for patterns. We will talk about them in the next article of this series.
The appearance of the Makefile can be considered the first step in the creation of programming systems. The Makefile language has become a standard tool, common to compilers of all developers. It was a convenient, but rather complex technical tool that required a high degree of training and professional knowledge from the developer, since the Makefile command language itself was comparable in complexity to a simple programming language.
This structure of development tools has existed for quite a long time, and in some cases it is still used today (especially when creating system programs). Its widespread use was due to the fact that this whole structure of development tools in itself was very convenient for batch execution of programs on a computer, which contributed to its widespread use in the mainframe era with operating systems Unix type.
4.5. Integrated Development Environments
- Visual Studio 97 is the first released version of Visual Studio. It brought together various software development tools for the first time. 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, and the first ASP development environment, Visual InterDev. Visual Studio 97 was Microsoft's first attempt at creating a unified development environment for multiple programming languages: Visual C++, Visual J++, Visual InterDev, and MSDN used one environment called Developer Studio. Visual Basic and Visual FoxPro used separate development environments.
- Visual Studio 6.0 was released in June 1998. This latest version Visual Studio running on the Win9x platform. Still popular with programmers using Visual Basic. This version was the main development environment for Windows applications from Microsoft, before the advent of the .NET platform.
- Visual Studio .NET (codenamed Rainier; internal version 7.0) released February 2002 (includes .NET Framework 1.0). Service Pack 1 for Visual Studio .NET (2002) released March 2005
- Visual Studio .NET 2003 (codename Everett; internal version 7.1) was released in April 2003 (includes the .NET Framework 1.1). Service Pack 1 for Visual Studio .NET 2003 was released on September 13, 2006.
- Visual Studio 2005 (codenamed Whidbey; internal version 8.0) was released in late October 2005, the last to officially run on Windows 2000 (includes the .NET Framework 2.0). In early November 2005, a series of products in the Express edition was also released: Visual C++ 2005 Express, Visual Basic 2005 Express, Visual C# 2005 Express, and others. On April 19, 2006, the Express edition became free. Service Pack 1 for VS2005 and all Express editions was released on December 14, 2006. An additional patch for SP1 that resolves the compatibility issue with Windows Vista was released on March 6, 2007.
- Visual Studio 2008 (codenamed Orcas) was released on November 19, 2007, alongside .NET Framework 3.5. Aimed at creating applications for Windows Vista (but also supports XP), Office 2007 and web applications. Includes LINQ, new versions of C#, and Visual Basic. The studio did not include Visual J#. Since October 28, 2008, a version in Russian has been available for the first time.
- Visual Studio 2010 (codename Hawaii, Ultimate Rosario) was released on April 12, 2010 with .NET Framework 4.0. Visual Studio includes support for C# 4.0 and Visual Basic .NET 10.0, as well as F#, which was not available in previous versions.
Visual Studio 2010 enables you to efficiently build complex applications in a short amount of time. The model of this environment is much richer than earlier versions and uses concepts such as solution (solution), project, namespace ( namespace ) and assembly (assembly). The concept of a project is present in many environments, such as Delphi. The project file contains a list of source files and other resources from which the system will build the application. A Visual Studio solution contains several projects, which can be dependent or independent of each other. stands out start project. The concept of an assembly comes from the Common Language Runtime (CLR). The common language runtime (CLR) is the most revolutionary invention, with the advent of which the process of writing and running applications becomes fundamentally different.
The compiler converts source files into codes in intermediate language MSIL ( Microsoft Intermediate Language). Along with the metadata, these codes write PE files (Portal Executable) that have an .exe or .dll extension, depending on the project type. A module with a netmodule extension that does not contain metadata can also be obtained.
There are 12 project types in total. When loaded, PE files are translated "on the fly" into instructions for a real processor. Framework. NET that runs programs is not part of Visual Studio, but is a setting on top of the operating system. It is analogous to the Java virtual machine.
An assembly is the minimum unit for deploying applications. Each assembly type is characterized by a unique identifier, identified by the author's digital signature and a unique version number. There is the following relationship between assemblies and namespaces. An assembly can contain multiple namespaces. At the same time, a namespace can span multiple assemblies. An assembly can include one or more files, which are combined in the so-called manifest or assembly description.
At the C# language level, namespaces, like Java packages, are used to structure a project. A namespace includes one or more classes. A single source file can define multiple namespaces, and at the same time, a single namespace can be defined in multiple files. And even a class can be located in several files (partial classes).
For novice programmers, such an abundance of possibilities can cause considerable difficulties. The scale and complexity of the environment can be judged by the following comparative table of the three environments.
It seems interesting and promising operating environment Eclipse, developed by IBM. The original goal of the project was to create a corporate IDE standard for developing programs in different languages for different platforms. Then the project was renamed to Eclipse and made available to the public. The license allows you to use the code and development environment free of charge and at the same time create closed commercial products. Thanks to this, the system has become widespread and has become the corporate standard for application development for many organizations.
The Eclipse ecosystem is a consolidated technology, with 2007 being the year of widespread adoption. The system is implemented in Java and initially was a full-fledged integrated environment for the Java language. In the future, other languages \u200b\u200bbegan to be supported. The first versions were inconvenient, because the target product was forced to include unnecessary functionality. Starting with the third version, the architecture of the entire system was redesigned in order to maximize the separation of modules and the relationship between them. At the same time, Eclipse modules, formed from consistent sets of classes, provided the functionality of entire subsystems, such as help subsystems, product updates, training, presentation, multilingual support, and many others. When developing an application, now you can gradually increase the functionality by connecting ready-made free components. In Eclipse terminology, these components are called "plug-ins" or "plugins" (Plugins). This technology is becoming common in advanced operating environments. The platform based on this technology is called
An integrated development environment (IDE) is a system of software tools used by programmers to develop software. AT English language such an environment is called the Integrated development environment or IDE for short.
An IDE usually includes a text editor, a compiler, an interpreter, software development and build automation tools, and a debugger. Sometimes also contains tools for integration with version control systems and various tools to simplify the construction of a graphical user interface. Many modern development environments also include a program class browser, an object inspector, and a class hierarchy diagram for use in object-oriented software development. Most modern IDEs are designed to develop programs in several programming languages at the same time.
One of the special cases of IDEs is visual development environments, which include the ability to visually edit the program interface.
The main window is a text editor that is used to enter source code into the IDE and is focused on working with character sequences in text files. Such editors provide advanced functionality - syntax highlighting, string sorting, templates, encoding conversion, displaying character codes, etc. They are sometimes called code editors, since their main purpose is to write source codes for computer programs.
Syntax highlighting - highlighting syntactic constructions of text using different colors, fonts and styles. Usually used in text editors to make it easier to read the source text, improve visual perception. Often used when publishing source codes on the Internet.
The concept of translation, compiler and interpreter was given in previous lectures.
One of the most important parts of the IDE is the debugger, which is a development environment module or standalone application designed to find errors in a program. The debugger allows you to step through the trace, monitor, set or change the values of variables during program execution, set and remove breakpoints or break conditions, and so on.
The most common debuggers are:
- GNU Debugger - a program debugger from the GNU project;
- IDA is a disassembler and low-level debugger for Windows and GNU/Linux operating systems;
- Microsoft Visual Studio is a software development environment that includes debugging tools from Microsoft Corporation;
- OllyDbg is a free low-level debugger for operating systems of the Windows family;
- SoftICE is a low-level debugger for operating systems of the Windows family;
- Dr. Watson - a standard Windows debugger that allows you to create memory dumps;
- WinDbg is a free debugger from Microsoft.
The main debugging process is tracing. Tracing is the process of executing a program step by step. In tracing mode, the programmer sees the sequence of commands execution and the values of variables at a given step of program execution, which makes it easier to detect errors. Tracing can be started and ended anywhere in the program, program execution can stop at each command or breakpoints, tracing can be performed with or without entering procedures/functions.
The most important module of the ISW in the joint development of projects of medium and high complexity is the version control system. Version control system (English abbreviation CVS) - software for facilitating work with changing information. It allows you to store several versions of the same document, if necessary, return to earlier versions, determine who and when made this or that change, and much more.
Such systems are most widely used in software development, for storing the source codes of the program being developed. However, they can also be successfully applied in other areas that work with a large number of constantly changing electronic documents, in particular, they are increasingly used in CAD, usually as part of product data management systems. Versioning is used in the configuration management tools of various devices and systems.
In our country, perhaps due to the small number of large-scale projects, version control systems have not received distribution, despite the fact that their use is the key to the successful implementation of large projects. In this regard, let us dwell in more detail on this possibility of the ISR.
Most version control systems use a centralized model, where there is a single document repository managed by a special server that performs most of the version control functions. The user working with documents must first obtain the version of the document he needs from the repository; usually a local copy of the document is created, the so-called "working copy". The latest version or any of the previous versions may be obtained, selected by version number or date of creation, sometimes by other criteria. After the desired changes are made to the document, the new version is placed in the repository. Unlike simply saving a file, the previous version is not erased, but also remains in the repository and can be retrieved from there at any time. The server can use delta compression, a method of storing documents that retains only changes between successive versions, thus reducing the amount of data stored.
Sometimes the creation of a new version is done invisibly to the user (transparently) - either with the help of 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 simply works with the file as usual, and when the file is saved, a new version is automatically created.
It often happens that several people are working on the same project at the same time. If two people modify the same file, one of them may accidentally undo the changes made by the other. Version control systems keep track of such conflicts and offer tools to resolve them. Most systems can automatically merge (merge) changes made by different developers. However, such automatic merging of changes is usually possible only for text files, and then only on the condition that different (non-overlapping) parts of this file have been changed. This limitation is due to the fact that most version control systems are focused on supporting the software development process, and the source codes of programs are stored in text files. If automatic merging fails, the system may offer to resolve the issue manually.
It is often impossible to merge either automatically or manually, for example, if the file format is too complex or completely unknown. Some version control systems give you the option to lock a file in the vault. A lock prevents other users from obtaining a working copy or from modifying the working copy of a file (for example, by means of the file system) and thus provides exclusive access only to the user who works on the document.
Other features of the version control system are:
In creating different versions of the same branch document, with a common history of changes before the branch point and with different ones after it.
Keeping a change log, where users can write explanations about what and why they changed in this version;
Controls user access rights, allowing or denying reading or modifying data, depending on who is requesting this action.
Distributed version control systems are a separate class. Such systems use a distributed model instead of the traditional client-server model. In general, they do not need a centralized repository: the entire history of document changes is stored on each computer in local storage, and, if necessary, individual fragments of the local storage history are synchronized with a similar storage on another computer. In some of these systems, local storage resides directly in the working copy directories.
When a user of such a system performs normal actions, such as checking out a certain version of a document, creating a new version, and so on, he works with his local copy of the repository. As changes are made, repositories belonging to different developers begin to differ, and it becomes necessary to synchronize them. Such synchronization can be carried out by exchanging patches or so-called change sets between users.
The main advantage of distributed systems is their flexibility. Each developer can work independently, as he sees fit, saving intermediate versions of documents and transferring the results to other participants when he sees fit. In this case, the exchange of sets of changes can be carried out according to various schemes. In small teams, work participants can share changes on a one-to-one basis, eliminating the need for a dedicated server. A large community, on the contrary, may use a centralized server, with which copies of all its members are synchronized. More complex options are also possible, for example, with the creation of groups to work in separate areas within a larger project.
To use version control systems, you must know the terminology of these systems. There is no generally accepted terminology; different systems may use different names for the same actions.
Below are some of the more commonly used options. Due to the fact that the systems were developed by the English-speaking community, and the Russian-language terminology has not yet been developed, English terms are used.
branch (branch) - the direction of development, independent of others. A branch is a copy of a part (usually one directory) of the repository, in which you can make your own changes without affecting other branches. Documents in different branches have the same history before the branch point and different history after it.
check-in, commit, submit - creating a new version, publishing changes. Propagating the changes made in the working copy to the document repository. At the same time, a new version of the modified documents is created in the repository.
C heck-out, clone - Retrieve a document from storage and create a working copy.
C onflict - a conflict situation when several users made changes to the same section of the document. A conflict is detected when one user has already published his changes, and the second one is only trying to publish them, and the system itself cannot correctly merge the conflicting changes. Since the program may not be intelligent enough to determine which change is "correct", the second user needs to resolve the conflict himself (resolve).
M erge, integration (merge) - combining independent changes into a single version of the document. Happened when two people have changed the same file or when moving changes from one branch to another.
R epository (document repository) - a place where the version control system stores all documents along with their change history and other service information.
R edition (document version). Version control systems distinguish versions by numbers, which are assigned automatically.
T ag, label (label) - which can be assigned to a specific version of the document. A label is a symbolic name for a group of documents, and it describes not only a set of file names, but also the revision of each file. The revisions of the documents included in the label may belong to different points in time.
T runk, mainline (trunk) - the main branch of the project development. The trunk policy may differ from project to project, but in general it is as follows: most changes are made to the trunk; If you want to major change, which can lead to instability, a branch is created that merges with the trunk when the innovation has been 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 storage state. Most often, this action means updating the working copy to the latest vault state. However, if necessary, you can synchronize the working copy to an older state than the current one.
W orking copy (working copy) - working (local) copy of documents.
Consider the capabilities of the ISR using the most accessible and popular versions as an example.
Eclipse (from the English eclipse) is a free integrated development environment for modular cross-platform applications (Figure 69). Developed and maintained by the non-profit Eclipse Foundation (http://www.eclipse.org/).
Initially, Eclipse was developed by IBM as a corporate IDE standard for development in different languages for platforms from this company. According to IBM, the design and development cost $40 million. The source code was fully open-sourced and made available after Eclipse was turned over to the IBM-independent community for further development.
Eclipse is based on the OSGi framework and SWT / JFace, on the basis of which the next layer is developed - RCP (Rich Client Platform, a 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 Eclipse itself, which is a set of RCP extensions: editors, panels, perspectives, a CVS module, and a Java Development Tools (JDT) module.
Eclipse is, first of all, a full-fledged Java IDE aimed at group development: CVS support is included in the delivery of Eclipse, several variants of SVN modules are actively developed, there is support for VSS and others. Due to its free and high quality, Eclipse is the corporate standard for application development in many organizations.
The second purpose of Eclipse is to serve as a platform for the development of new extensions, which is what made it popular: any developer can extend Eclipse with their own modules. There are already C/C++ Development Tools (CDT) being developed by QNX engineers in collaboration with IBM, and tools for COBOL, FORTRAN, PHP, and others from various developers. Many extensions complement the Eclipse environment with managers for working with databases, application servers, etc.
Figure 69 . Eclipse main window interface
Eclipse is written in Java, therefore it 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 the standard Java Swing library. It relies entirely on the underlying platform (operating system) for a responsive and natural looking user interface, but sometimes causes compatibility and application stability issues across platforms.
The basis of Eclipse is the rich client platform (RCP). Its components:
OSGi (standard bundle delivery environment);
SWT (portable widget toolkit);
JFace (file buffers, text manipulation, text editors);
Eclipse working environment (panels, editors, projections, wizards).
Another popular free IDE is KDevelop (http://www.kdevelop.org, Figure 70). KDevelop is a free software development environment for UNIX-like operating systems. The project started in 1998. KDevelop is distributed under the GNU General Public License.
Figure 70. KDevelop Interface
KDevelop does not include a compiler, instead it uses any compiler to generate executable code.
The current stable version supports a large number of programming languages such as Ada, Bash, C, C++, Fortran, Java, Pascal, Perl, PHP, Python, Ruby and SQL.
KDevelop uses a built-in component - a text editor - through KParts technology. The main editor is Kate.
KDevelop functions:
Highlighting the source code, taking into account the syntax of the programming language used, which is determined automatically;
Project manager for projects of various types, such as Automake, qmake for projects based on Qt technologies and Ant 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 class and platform definitions (framework);
Automatic code completion system (C/C++);
Built-in support for source code documentation system (Doxygen);
One of the version control systems: SCM, CVS, Subversion, Perforce and ClearCase;
The Quick Open feature allows you to quickly navigate through files.
KDevelop is a "pluggable" architecture. When a developer makes changes, he only needs to compile the plugin. It is possible to save profiles indicating which plugins should be loaded. KDevelop does not come with a built-in text editor, it comes as a plugin. KDevelop does not depend on the programming language and on the platform on which it runs, supporting KDE, GNOME and many other technologies (for example, Qt, GTK+ and wxWidgets).
Built-in debugger KDevelop allows you to work graphically with all debugging tools, such as breakpoints and tracebacks. It can also work with dynamically loaded plugins, unlike console gdb.
At the moment there are about 50 to 100 plugins for this IDE. Among the most useful are persistent project-wide code bookmarks, Code abbreviations that allow you to quickly expand text, Source formatter that reformats the text for the style guide before saving, regular expression search, and project-wide search/replace.
The last considered ISR is Microsoft Visual Studio (Microsoft Visual Studio, Figure 71). In fact, Microsoft Visual Studio is a line of Microsoft products that 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 of the following: Visual Basic.NET, Visual C++, Visual C#, Visual F#, Microsoft SQL Server, Visual InterDev, Visual J++, Visual J#, Visual FoxPro, Visual Source Safe.
One of the main advantages of Microsoft Visual Studio is the high quality of documentation of the development process and description of possible problems in the MSDN Library. However, the most interesting part for a professional, dedicated to the intricacies of development, exists only in English.
Microsoft also offers a free alternative to Visual Studio Express.
Choosing a Development Environment
Integrated development environment, ISR (eng. IDE, Integrated development environment or integrated debugging environment) is a software system used by programmers to develop software (software).
The development environment includes:
Text editor;
Compiler and/or interpreter;
Assembly automation tools;
Debugger.
The IDE sometimes also contains tools for integration with version control systems and a variety of tools to simplify the construction of a graphical user interface. Many modern development environments also include a class browser, an object inspector, and a class hierarchy diagram for use in object-oriented software development. While there are IDEs used for multiple programming languages such as Eclipse, NetBeans, Embarcadero RAD Studio, Qt Creator or Microsoft Visual Studio, IDEs typically use one specific programming language such as Visual Basic, Delphi, Dev -C++.
A special case of ISR is visual development environments, which include the ability to visually edit the program interface.
IDEs were created to maximize programmer productivity through tightly coupled components with simple user interfaces. This will allow the developer to make fewer steps to switch between different modes, as opposed to discrete development programs. However, since the IDE is a complex software package, only after a long learning process, the development environment will be able to qualitatively speed up the software development process.
The IDE is usually the only program in which all development has been done. It usually contains many functions for creating, modifying, compiling, deploying, and debugging software. The goal of a development environment is to abstract away the configuration needed to combine command line utilities into a single module, which will reduce the time to learn the language and increase developer productivity. It is also believed that difficult integration of development tasks can further improve productivity. For example, the IDE allows you to analyze the code and thereby provide instant feedback and notify you of syntax errors. While most modern IDEs are graphical, they have been around since before there were windowing systems (which are implemented in Microsoft Windows or X11 for *nix systems). They were text based, using function keys or hotkeys to perform various tasks (eg Turbo Pascal). Using an IDE for software development is the exact opposite of the way that unrelated tools such as vi (text editor), GCC (compiler), etc. are used.
At the moment, there are several environments for developing applications in the C # language, the main ones are shown in Table 1.1.
Table 1.1 - Comparison of C# development environments
The GPL license grants the user the rights to copy, modify, and distribute (including commercially) the programs (which by default is prohibited by copyright law), and also guarantees that users of all derivative programs will receive the above rights.
The LGPL license allows programs under any license that is incompatible with the GNU GPL to be linked to this library or program, provided that such program is not derived from an object distributed under the (L)GPL, other than by linking. The main difference between the GPL and the LGPL is that the latter also allows linking with a given object by others that creates a derivative work of the given object, if the license of the linked objects allows "modifications for internal use by the consumer and reverse engineering for debugging such modifications." Those. The LGPL, unlike the GPL, allows a library to be linked to any program, not necessarily free.
Closed (proprietary) software (eng. Proprietary software) - software that is the private property of authors or copyright holders and does not meet the criteria for free software (the availability of open source code is not enough). The owner of the proprietary software retains a monopoly on its use, copying and modification, in whole or in significant moments. It is common to refer to proprietary software as any non-free software, including semi-free software.
Geany is a free software development environment written using the GTK2 library. Available for the following operating systems: BSD, Linux, Mac OS X, Solaris and Windows. Geany is distributed under the GNU General Public License. Geany does not include a compiler. Instead, the GNU Compiler Collection (or any other compiler) is used to generate executable code.
Microsoft Visual Studio is a line of Microsoft products that includes an integrated software development environment and a number of other tools. These products allow you to develop both console applications and applications with a graphical interface, including those with support for Windows Forms technology, as well as websites, web applications, web services in both native and managed code for all platforms, supported by Microsoft Windows, Windows Mobile, Windows CE, .NET Framework, .NET Compact Framework, and Microsoft Silverlight. Visual Studio includes a source code editor with IntelliSense technology and easy code refactoring. The built-in debugger can work as both a source code level debugger and a machine level debugger. Other embeddable tools include a form editor to simplify the creation of an application's GUI, a web editor, a class designer, and a database schema designer. Visual Studio allows you to create and connect third-party add-ons (plugins) to extend functionality at almost every level, including adding support for source code version control systems (such as Subversion and Visual SourceSafe), adding new toolkits (for example, for editing and visual code design). in domain-specific programming languages or tools for other aspects of the software development cycle (for example, the Team Explorer client to work with Team Foundation Server).
MonoDevelop is a free development environment for building C#, Java, Boo, Nemerle, Visual Basic .NET, Vala, CIL, C and C++ applications. Support for Oxygene by Embarcadero Technologies is also planned. It was originally a Mono/GTK+ port of SharpDevelop, but since then the project has moved far from its original state. MonoDevelop is part of the Mono project.
SharpDevelop is a free development environment for C#, Visual Basic .NET, Boo, IronPython, IronRuby, F#, C++. Typically used by those who don't want to use Visual Studio .NET. There is also a Mono/Gtk+ fork called MonoDevelop. SharpDevelop 2.0 provides an integrated debugger that uses its own libraries and interacts with the .NET runtime through COM Interop. Although SharpDevelop 2.0 (like VS2005) uses MSBuild project files, it can still use compilers from the .NET Framework 1.0 and 1.1, as well as from Mono.
For development, it is necessary to actively use all the tools of the programming language. However, the MonoDevelop environment uses its own compiler, which does not fully support the C# language due to the fact that it is a free multi-platform development independent of the creators of the language. Although it provides multi-platform, it is impossible to predict the behavior of the language in new versions. And one of the key components of the project is its fault tolerance and stability, and at the same time, multiplatform is not required (there are vanishingly few users of 1C on Linux). Therefore, this environment is not suitable for the development of this project.
SharpDevelop and Geany do not have their own compilers. Therefore, to develop using these environments, you still have to use proprietary software, which makes their use justified only in some cases. For example, on low-performance computers or with a very limited project budget. Despite the fact that they can be launched and run on Linux, these development environments, due to the lack of their own compilers, will not be able to create a multiplatform application, and development will still be limited to Windows operating systems.
Microsoft Visual Studio is also not without flaws. The main ones are heaviness, which requires a fairly large computing power of the computer; payment; lack of multiplatform. Despite these shortcomings, Visual Studio remains the development environment of choice for most C# programmers. The reason for this is full language support, advanced development tools, vibrant documentation, and the environment itself. This development environment will be used in the project.