The report for practical work contains 23 pages, 2 figures, 7 tables, 9 appendices and 3 sources.

Object of study - Development environment and programming language Delphi, its graphical tools.

The purpose of this work is to study the Delphi programming language, use the Delphi syntactic and graphical tools, compare the development environments and syntax of the C++ and Delphi programming languages. For comparison, the Microsoft Visual C++ and Delphi 7 programming environments are used. The comparison is carried out by implementing the solution of nine specific tasks in Delphi.

DELPHI 7, OBJECT-ORIENTED PROGRAMMING, MICROSOFT VISUAL C++, DEVELOPMENT ENVIRONMENT, COMPARISON OF C++ AND DELPHI

Introduction

1. Comparison of c/c++ and pascal/Delphi languages

1.1 Simple data types

1.2 Structural data types

1.2.1 String variables

1.2.2 Arrays

1.2.3 Sets

1.2.4 Files

1.2.5 Classes

1.3 Pointers

2. Comparison of development environments

2.1 Borland Delphi 7

2.2 Microsoft Visual C++

Conclusion

Link List

Annex A

Annex B

Annex B

Annex D

Annex D

Appendix E

Annex G

Annex H

Annex I

INTRODUCTION

At the moment, a significant part of the software is implemented using object-oriented programming methods. Now this area of ​​programming is in great demand. Therefore, mastering this style of programming is very relevant.

To study this programming style, the Delphi 7 language was chosen, with the help of which the method of object-oriented design of programs was studied by formalizing and solving the problem, technological methods for developing object-oriented programs.

The reason for choosing this programming language also lies in its graphical means.

Delphi is a programming development tool that takes place within Microsoft Windows applications. Delphi is an up-to-date and easy-to-use program that is needed to generate standalone GUI programs or 32-bit console applications -- programs that exist outside of the GUI, instead, according to the so-called "DOS box".
Delphi is the first programming language to break down the barrier between complex and easy-to-use applications and low-level bit programming.

1. COMPARISON OF C/C++ AND PASCAL/DELPHI LANGUAGES

1.1 Simple data types

The type defines the set of values ​​that program elements can take, and the set of operations allowed on these values.

Data types can be divided into the following groups:

Structural;

pointers;

Procedural (only in Delphi);

Simple types do not contain other types, and the data of these types can contain one value at a time. Simple types include:

Integers;

Literal (Character);

Logical (Boolean);

Real.

Table 1.1 compares the most common simple types in the C++ and Delphi programming languages.

Table 1.1 - Comparison of simple data types in C++ and Delphi

There are separate functions for each data type that make it easier to work with them. Table 1.2 lists some functions for variables with simple data types in C++ and Delphi syntax.

Table 1.2 - Functions for simple data types in C++ and Delphi

Differences can be seen not only in the data types themselves, but also in working with variables. To create a variable in C++, you need to type the name of the variable. In Delphi, the creation of a variable looks like this: variable name, colon, type name. Moreover, in C++ a variable can be declared anywhere in the program, but in Delphi only in the var section. For assignment in C++, the = sign is used, in Delphi - :=. The assignment operator in both programming languages ​​takes whatever is to the right of the sign and puts it into the variable to the left of the assignment sign.

Let us consider the basic operations for working with variables of simple data types. Table 1.3 compares them in C++ and Delphi.

Table 1.3 - Basic operations

Operation
Addition
Subtraction
Multiplication
Division(integer, prime)	/ (depends on data type)
Remainder of the division
Assignment
Equality check
Composite addition		Missing
Compound subtraction		Missing
Compound multiplication		Missing
Compound division		Missing
Compound definition of the remainder of a division		Missing
Increment
Decrement
Logical NOT
Greater than or equal
Less than or equal
Logical OR
logical AND
Logical XOR
Pointer
structure pointer
Determining the size in bytes
Bitwise NOT
Bitwise AND
Bitwise OR
Bitwise XOR
Bitwise Left Shift
Bit shift right

When comparing operators, you can notice a clear drawback of Delphi, which manifests itself in the absence of compound operations (>=,<=, +=, -=, *=, /=, %=).

1.2 Structural data types

Now let's move on to comparing structural data types. Struct types are based on one or more other types, including struct types. Structural types include:

Sets;

1.2.1 String variables

In Delphi, strings provide the string type, which represents a string with a maximum length of about 2 characters. The characters of the string are encoded in ANSI code. Since strings are actually arrays of characters, to refer to a single character in a string, you can specify the name of the string variable and the number (position) of this character in square brackets, for example, strName [i].

There are 2 types of strings in C++: an array of char variables and a special string class. Unlike the char type, string is a class. This explains the need to include the header file and the presence of many functions for working with a variable of type String. An element of a string can also be accessed through its number in the string, indicated in square brackets. For example, strName[i].

1.2.2 Arrays

Arrays in the compared languages ​​are similar. Array elements can be data of various types, including structured ones. Each array element is uniquely identified by the array name and index (number of this element in the array) or indexes if the array is multidimensional. To refer to a single element of an array, the name of this array and the number (numbers) of the element enclosed in square brackets are specified. However, in Delphi, the array declaration is done in the data type declaration section, while in C++ it is done at any point in the program.

1.2.3 Sets

"Set" data types are similar to enumeration and interval data types, however, variables of set types can have several values ​​from the described enumeration at any given time of program execution, and each value cannot be present in the set twice at the same time. The definition of a multiple type variable in Delphi is as follows:

<Переменная>: Set Of<Тип>;

set<Тип> <Переменная>;

In C++, a Set is an STL associative container that holds a sorted set of unique objects. The set container contains many elements. Strictly speaking, set provides the following functionality:

1. Add an element to the set under consideration, while excluding the possibility of duplicates;

2. Remove an element from the set;

3. Find out the number of (different) elements in the container;

4. Check if some element is present in the container.

1.2.4 Files

A file is a way of storing information on a physical device. There are no file operators in C++. All necessary actions are performed using the functions included in the standard library. Working with files in C++ and in Delphi is similar, and consists of three steps:

The file opens. This means that the program "captures" the file given by name, tells Windows that it will work with it further. This step is necessary so that there are no conflicts when several programs simultaneously want to write information to the same file. True, it is obviously possible to read data from a file simultaneously by many programs, therefore, in the operation of opening a file, it is usually specified that the file is opened "for reading" (reading information that does not change) or "for writing" (the data in the file is modified).

The operation of opening a file returns a certain identifier (usually an integer), which identifies the desired open file in the program in the future. This identifier is stored in a variable; usually such a variable is called a file variable.

The file is being processed. Data is either read from it or written to it.

The file is closed. After this operation, it is again available to other programs for processing.

Table 1.4 compares file handling in C++ and Delphi.

Table 1.4 - comparison of file handling in C++ and in Delphi

Action
File Declaration	FILE *identifier;	var identifier: File ;
Opening a file for writing	fopen(physical filename, “w”) fopen(f, "w");	AssignFile(logical file name, file name); ReWrite(logical file name); AssignFile(myFile, "Test.txt"); ReWrite(myFile);
Write to file	fwrite(address of value to be written, size of one instance, number of values ​​to be written, logical file name); fwrite(&dat, sizeof(int), 1, f);	WriteLn(logical file name, text); WriteLn(myFile, "Hello World");
Closing a file	fclose(logical filename);	CloseFile(logical file name); CloseFile(myFile);
Opening a file for reading	fopen(physical filename, “r”)
Reading from a file	fread(address of value, size of one instance, number of values ​​to read, logical file name); fread(&dat, sizeof(int), 1, f);	ReadLn(logical file name, read variable); ReadLn(myFile, text);
End of file check
Opening a text file to add entries to the file (appends to the end of the file)	fopen(physical filename, “a”)	append(logical file name);

1.2.5 Classes

The class mechanism in C++ allows users to define their own data types. For this reason, they are often referred to as user-defined types. A class can add additional functionality to an already existing type.

A class definition in C++ has two parts: a header, which includes the class keyword followed by the name of the class, and a body, enclosed in curly braces. This definition must be followed by a semicolon:

class ClassA ( /* ... */ );

Inside the body, data members and member functions are declared and their access levels are specified. Thus, the body of a class defines a list of its members. Each definition introduces a new data type. Even if two classes have the same member lists, they are still considered different types. Once a class type is defined, it can be referenced in two ways:

1. write the class keyword followed by the class name;

2. specify only the class name.

Both ways to refer to a class type are equivalent. The former is borrowed from C and remains the correct method for setting a class type, while the latter was introduced in C++ to simplify declarations.

Member functions of a class are declared in its body. This declaration looks exactly like a function declaration in the scope of a namespace.

Member functions differ from regular functions in the following ways:

1. A member function is declared in the scope of its class, so its name is not visible outside of that scope. A member function can be accessed using one of the member access operators, dots (.) or arrows (->):

ptrScreen->home();

myScreen.home();

2. Member functions have the right to access both public and private members of the class, while ordinary functions have access only to public ones. Of course, member functions of one class generally do not have access to data members of another class.

In Delphi, the description of classes is divided into two parts - interface (“header”) and descriptive. The interface part contains the class header, which contains the name of the class that identifies it in the program, as well as descriptions of properties and method headers. The descriptive part contains the program code (implementation) of the methods whose headings are specified in the interface part of the class description. The interface part of the class description is located in the sections describing the data types of modules and the main parts of programs. It looks like this:

<Имя класса>= class(Description Title)

<Имя свойства 1>: <Тип свойства 1>; (Property description 1)

<Имя свойства М>: <Тип свойства N>; (Description of property N)

<Заголовок метода 1>; (Method description 1)

<Заголовок метода М>; (Description of method M)

The descriptive part of the class is in the local subprograms description section. The methods declared in the interface part are implemented according to the usual rules for describing procedures and functions. To associate subprograms with the class of which they are methods, the name of the class is indicated before the name of the subprogram itself:

procedure<Имя класса>.<Имя метода>(<Список параметров>);

or for function methods:

function<Имя класса>.<Имя метода>(<Список параметров>):

<Тип значения>;

Methods differ from ordinary procedures and functions in that they can access class properties by name without specifying objects. At the program execution stage, such calls will be redirected to the properties of the objects from which the corresponding methods are called.

Table 1.5 shows a comparison of object-oriented programming paradigms in the C++ and Delphi programming languages ​​with examples.

Table 1.5 - Comparison of OOP paradigms in C++ and Delphi

Name of the paradigm
Encapsulation	int a, b; //public interface data int ReturnSomething(); //public interface method int Aa, Ab; //hidden data void DoSomething(); //hidden method	TMyClass = class FMyField: Integer; procedure SetMyField(const Value: Integer); function GetMyField: Integer; property MyField: Integer read GetMyField write SetMyField;
Inheritance	class A( //base class class B: public A( //public inheritance class C: protected A( //protected inheritance class Z: private A( //private inheritance	Dancer = class // virtual procedure procedure VirtualProcedure; virtual; abstract; procedure StaticProcedure; Heir: TDescendant = class(TAncestor) // Override virtual procedure procedure VirtualProcedure; override; procedure StaticProcedure;
Polymorphism	//Overloaded function virtual void f() std::out<< "A::f"; class B: public A //Overloaded function std::out<< "B::f";	// base class constructor Create(name:string); function f:string; virtual; // derived from base constructor Create(name:string;gr:integer); // Overloaded function function f:string; override; // derived from base constructor Create(name:string;dep:string); // Overloaded function function f:string; override;

A detailed description of the concept of encapsulation is related to the concept of identifier scope. The scope of an identifier (name of a variable, procedure, function or data type) is the part of the program code in which access to this identifier is possible. The scope of a component identifier declared in a class declaration extends from its declaration to the end of the class definition, and also extends to all descendants of this class and to all implementation blocks of class methods. The scope of a bean identifier depends on the visibility attribute of the section in which the identifier is declared.

Table 1.6 lists the visibility attributes in Delphi and C++.

Table 1.6 - Visibility Attributes

visibility attribute
Private - access is open to the class itself (i.e. member functions of this class)
Protected - access is open to classes derived from this
Public - access is open to anyone who sees the definition of this class
Published - The fields, properties, and methods described in this section are referred to as published. Their scope is equivalent to that of public declarations. The difference is that information about them, with the exception of a number of types, such as real, is placed in the object inspector at the design stage of the program. Descriptions located immediately after the class header, when the compiler directive ($M+) is included, are accepted as published by default.

1.3 Pointers

Pointer (pointer, English pointer) is a variable whose range of values ​​consists of addresses of memory cells and a special value - zero address. The value of address zero is not a real address and is only used to indicate that the pointer cannot currently be used to access any memory location.

Pointers are used in two different areas. First, they allow some of the benefits of indirect addressing, which is widely used in assembly language programming. Second, pointers offer a method of dynamic memory management: they can be used to access a dynamically allocated memory area, commonly called the heap, or dynamic memory.

Variables allocated on the heap are called dynamic variables. Often they do not have associated identifiers and can only be referenced by pointers and links.

Both C++ and Delphi contain two basic operations on pointers: assignment and dereference. The first of these operations assigns some address to the pointer. The second is used to access the value in memory pointed to by the pointer.

When declaring a variable of pointer type in C++, you must define the type of data object whose address the variable will contain, and the name of the pointer preceded by an asterisk (or a group of asterisks). Pointer declaration format:

type-specifier [ modifier ] * descriptor.

The type-specifier specifies the type of the object and can be any basic type, structure type, mixture (this will be discussed below). By specifying void instead of a type-specifier, you can somehow defer the specification of the type referenced by the pointer. A variable declared as a pointer to a void type can be used to refer to an object of any type. However, in order to be able to perform arithmetic and logical operations on pointers or on the objects they point to, it is necessary to explicitly define the type of objects when performing each operation. Such type determinations can be performed using a cast operation.

The keywords const, near, far, huge can act as modifiers when declaring a pointer. The const keyword indicates that the pointer cannot be changed in the program. The size of a variable declared as a pointer depends on the computer architecture and on the memory model used for which the program will be compiled. Pointers to different data types do not have to be the same length.

The near, far, huge keywords can be used to modify the pointer size.

Below are some examples of declaring pointers in C++.

unsigned int * a;

addres = &number;

(double *) addres ++;

The addres variable is declared as a pointer to an object of any type. Therefore, it can be assigned the address of any object (& is the address calculation operation). However, no arithmetic operation can be performed on a pointer until the type of the data it points to is explicitly defined. This can be done by using a cast operation (double *) to convert addres to a pointer to a double and then incrementing the address.

There are 2 kinds of pointers in Delphi: typed and untyped. An untyped pointer is a variable that stores the address of some memory area of ​​a certain size, and is designed to store arbitrary data. Typed references point to a location in memory where data of a particular type is stored.

Variables - untyped pointers are described with an indication of the Pointer type, and the allocation and release of memory for them is carried out, respectively, by the GetMem and FreeMem commands. The use of untyped pointers is limited to standard functions that take such variables as parameters, as well as to low-level programming.

There is no special data type to describe a typed reference, unlike untyped pointers, which are of type Pointer. Since a reference variable of this kind always points to data of a specific type, its description is built on the basis of this type. The "^" operator is used to indicate the referential nature of variables, and the description is as follows:

Var<Переменная>:^<Название типа>;

Or in the data type description section:

Toure<Новый тип данных> =^<Тип данных>;

After the pointer variable has been declared, memory is allocated for it only to store the address, and no memory is allocated for the data itself, to which the variable points. To initialize a variable, the New procedure is used, which differs from the similar GetMem procedure used to work with untyped pointers in the absence of a second parameter that determines the size of the allocated memory. This is because a typed reference points to data of a known type, so the size of that data is also known to the compiler.

Table 1.7 shows some differences between C++ and Delphi syntaxes in the area of ​​pointers.

Table 1.6 - Difference between pointers in C++ and Delphi

As we can see, there are some differences in working with pointers and addresses in C++ and in Delphi, however, the general structure of working with them is characteristic of both languages.

2. COMPARISON OF DEVELOPMENT ENVIRONMENTS

2.1 Borland Delphi 7

After loading the Delphi 7 programming environment, the main window will appear on the screen.

The upper part of the window is occupied by the menu and toolbar. On the left side of the window are the Object TreeView and the Object Inspector. In the center is the form of the application being developed and the form for entering the code.

Object TreeView - serves to display all objects located on the current form of the project being developed.

Object Inspector - serves to display and edit the properties of components located on the form of the application being developed.

A project is a collection of files that are used by the development environment for the final generation of a program. When we create the first project with you, we will get acquainted with all the components of the project and its structure.

Now let's look at the composition of the main menu. It allows you to call all the tools you need to work with the project. The purpose of the menu section and related functions are as follows:

File - contains a set of commands for working with files, allows you to create new projects, add new files to the project based on various templates, rename project files, and print them. This also includes a command to close the development environment;

Edit - here, in accordance with the name, there are commands for editing text, deleting and moving it to the clipboard, pasting text from the clipboard and canceling editing operations. Search - contains a set of commands for working with text, its search and replacement, and both can be performed both in one file and in all project files, or in any directory and its subdirectories;

View - under this name, the commands for calling the project management tool, such as the object inspector, form designer, project manager, etc., are combined;

Project - designed to add and remove project modules, save the project, add projects to the group and remove them from it, compile both individual projects and all projects in the group, load the project file into the code editor, and also call the settings dialog project properties;

Run - allows you to run the project for execution both under the debugger and without it, configure the project parameter line at startup, debug, set breakpoints, step through the code, view the values ​​of variables and change them;

Component - commands for installing new components and component packages and creating new components and component templates are concentrated here;

Database - commands for managing databases of melons are concentrated here;

Tools - allows you to configure the properties of the Delphi working environment and the debugger, configure the repository, add and remove additional utilities, as well as launch commands for these same utilities;

Window - allows you to switch between windows if you open any module for editing in a new window;

Help - combines commands for calling the Delphi help system and its settings, and also allows you to refer to Borland's Web resources for more information.

You can manually customize the toolbar. This was done for ease of use. To do this, call the dialog box using the View-Toolbars-Customize link.

The compilation process consists of two steps. At the first stage, the program text is checked for errors, and at the second stage, an executable program (exe file) is generated.

After entering the text of the event handling function and saving the project, you can select the Compile command from the Project menu and compile. The compilation process and result are reflected in the Compiling dialog box (FIG. B38). The compiler displays errors (Errors), warnings (warnings) and hints (Hints) in this window. The error messages, warnings, and hints themselves are displayed at the bottom of the code editor window.

Figure 2.1 shows the main window of the Delphi 7 development environment.

Figure 2.1 - Main window of Delpi 7

2.2 Microsoft Visual C++

The Visual Studio family of products uses a single integrated development environment (IDE) that consists of several elements: the menu bar, the Standard toolbar, various docked or auto-hide tool windows in the left, bottom, or right panes, and the editors pane. The available tool windows, menus, and toolbars depend on the type of project or file being developed.

Figure 1. MV C++ Welcome Page

The arrangement of tool windows and other elements of the integrated development environment may vary depending on the applied parameters and settings performed by the user in the process of work. Settings can be changed using the Import and Export Settings Wizard. By selecting the Reset all settings option, you can change the default programming language.

You can easily move and dock windows with the visual diamond guide, or hide windows temporarily with the auto-hide feature. For more information, see How to. Positioning and fixing windows.

The IDE can be automated and extended using the Visual Studio automation model.

Solutions and projects contain elements that represent the links, data connections, folders, and files needed to create an application. A solution container can contain multiple projects, while a project container usually contains multiple items.

The Solution Explorer displays the solutions, the projects they contain, and the elements of those projects. In Solution Explorer, you can open files for editing, add new files to a project, and view the properties of solutions, projects, and items.

Visual Studio provides a powerful set of building and debugging tools. With build configurations, you can select components to build, exclude components that you don't want to include in the build, and determine how the selected projects will be built and for which platform. Build configurations are available for both solutions and projects.

When building, the debugging process begins. Building applications allows you to detect compile-time errors. These errors can include invalid syntax, reserved word errors, and type mismatches. These types of errors are displayed in the Output Window. After you finish building your application, you can use the debugger to find and fix issues such as logical and semantic errors found during runtime. While in break mode, you can view local variables and other related data using tools such as Variable Windows and Memory Window.

CONCLUSION

delphi programming class array

When performing this practical work, the tools of the Delphi programming language were studied and mastered. Also, the result of this work is a comparison of C ++ and Delphi languages. The graphical means of the language were mastered. In the course of the work, methods of object-oriented programming and design, the enumeration method, and the accumulation method were used.

Work with direct access text and binary files, work with dynamic data structures, work with character and clock data, recursion, inheritance, encapsulation, polymorphism, work with Delphi components such as StringGrid, Memo, Edit, RichEdit, Label, Button , GroupBox, Timer, etc.

The result of the work are nine programs written in the Delphi programming language using graphical tools and an object-oriented system.

LIST OF LINKS

Sukharev M. Fundamentals of Delphi professional approach.- NiT - St. Petersburg, 2004-596.

Stevens R. Delphi Ready made algorithms. - DMK - Moscow, 2004 - 380.

Bankel D., Fundamental algorithms and data structures in Delphi.-DS - Moscow, 2003. - 555s.

Similar Documents

Learning the general structure of the Delphi programming language: the main and additional components of the programming environment. Syntax and semantics of the Delphi programming language: language alphabet, elementary constructions, variables, constants and operators.

term paper, added 05/17/2010


Delphi is a rapid development environment that uses the typed object-oriented language Delphi as the programming language. Software package options. Features of work, screen view after launch. Description of the program structure.

term paper, added 11/25/2014


Designing a program module in the Borland Delphi 7.0 programming environment. Schemes of algorithms for solving problems on the topics "Character variables and strings", "Arrays", "Working with files", "Creating animation". Implementation of a program module, program code.

practice report, added 04/21/2012


Effective software development tools. Technology of visual design and event programming. Designing dialog boxes and event handling functions. Verbal algorithm and procedures of the program Borland Delphi 7 Studio.

thesis, added 05/21/2012


Delphi as a development environment for Windows-based programs. Purpose and advantage of using electronic textbooks. Description of the capabilities of the Delphi 5 environment for developing an electronic textbook. Options for using Internet services.

thesis, added 07/13/2011


The subject of object-oriented programming and features of its application in Pascal, Ada, C++ and Delphi environments. Delphi Integrated Development Environment: general description and purpose of the main menu commands. Procedures and functions of the Delphi program.

term paper, added 07/15/2009


Basic methods of working in the Delphi programming environment. Features of technology for creating simple applications. Working with application development environment components. Input, editing, selection and output of information. Aspects of using the branching structure.

manual, added 11/17/2011


Features of developing applications for the operating system using the imperative, structured, object-oriented programming language Delphi. Formal start of the program. Highlighting the end of a program block. Listing and description of the program.

term paper, added 08/04/2014


Borland Delphi 7 as a universal development tool used in many areas of programming, functions: adding information about applicants to the database, generating reports. Consideration and characteristics of the main components of Delphi.

test, added 10/18/2012


Survey of programming facilities. Description and properties of the Delphi language. Grounds for development, its purpose, requirements, stages of development. Description of the scheme of the main module, procedures, program. Used hardware and software.

1. Familiarity with the Delphi programming environment

1.1 Structure of the programming environment

Delphi- a system for rapid development of applications for the Windows operating system. Concept Delphi was implemented at the end of 1994, when the first version of the development environment was released. This software product is based on the concepts of object-oriented programming and a visual approach to building an application interface. To date, the seventh version of the environment has been released. From version to version, developers improve the tools for developing applications.

Delphi – it is a combination of several key technologies:

o High performance compiler to native code

o Object-oriented component model

o Visual building applications from software prototypes

o Scalable database building tools

A Windows application is a special type of program that:

Ø Has a special executable file format (*.exe)

Ø Only works with Windows

Ø Usually works in a rectangular window on the screen

Ø Can run simultaneously with other Windows programs, including other instances of the same application

Ø DIV_ADBLOCK441">

The main parts of Delphi are listed below:

1. Main window

2. Form Designer

3. Source Editor Window (Editor Window)

4. Component Palette

5. Object Inspector

6. Directory (On-line help)

There are, of course, other important parts of Delphi, such as the toolbar, the system menu, and many others, that are needed to fine-tune the program and programming environment. Consider the functions of each component.

Main window manages the application development process. It manages the files included in the application and does all the work related to maintaining, compiling, and debugging them. The main window has

§ Main menu(MenuBar), located directly below the title bar of the main window and allows you to access all the features of the development environment.

§ Toolbar(SpeedBar) provides quick access to most of the main menu commands. Located below the main menu.

§ Component Palette(Component Palette) provides access to visual components that can be placed on the form.

Delphi programmers spend most of their time switching between the Form Designer and the Source Editor Window (called the Editor for short).

Form Designer Delphi is so intuitive and easy to use that creating a visual interface is child's play. The form window is a project of the Windows-window of the future program. At first, this window is empty. More precisely, it contains interface elements standard for Windows - buttons for calling the system menu, maximizing, minimizing and closing the window, a title bar and an outlining frame. The entire working area of ​​the window is usually filled with points of the coordinate grid, which serves to arrange the components placed on the form (you can remove these points by calling the corresponding settings window using the Tools | Environment options menu and unchecking the Display Grid switch on the window associated with the Preferences tab) . A significant part of the time, the programmer is busy with an exciting activity, reminiscent of working with a set of Lego parts: he “pulls out” the required component from the palette of components, as if from a box with parts, and places it on the “typesetting field” of the form window, gradually filling the form with interface elements. Actually, it is in this process of filling out the form that the main highlight of visual programming lies. The programmer at any time controls the content of the window of the program being created and can make the necessary changes to it. Despite all the importance Form Designer, the place where programmers spend most of their time is Editor. Logic is the driving force of the program and Editor - the place where you "code" it.

Component Palette - this is the main wealth of Delphi. It occupies the right side of the main window and has tabs that allow you to quickly find the desired component. A component is a functional element that contains certain properties and is placed by the programmer in the form window. With the help of components, a program framework is created, in any case, its external manifestations visible on the screen: windows, buttons, selection lists, etc. Palette Component allows you to select the desired objects to place them on the Form Designer. For use Palettes Component just click on one of the objects for the first time and then on the second time Form Designer. The object you selected will appear on the projected window and can be manipulated with the mouse. Palette Component uses pagination grouping of objects. At the bottom Palettes there is a set of bookmarks - Standard, Additional, Dialogs, etc. If you click on one of the bookmarks, you can go to the next page Palettes Component. The principle of pagination is widely used in the Delphi programming environment and can be easily used in your program.

On the left of Form Designer You can see Object Inspector. Any component placed on the form is characterized by a certain set of parameters: position, size, color, etc. Some of these parameters, for example, the position and size of the component, the programmer can change by manipulating the component in the form window. To change other parameters, use the Object Inspector window. This window contains two pages - Properties (Properties) and Events (Events). The properties page is used to set the necessary properties of the component, the Events page allows you to determine the component's reaction to a particular event. The set of properties displays the visible side of the component: position relative to the upper left corner of the form workspace, its size and color, font and text of the inscription on it, etc.; a set of events - its behavioral side: whether the component will respond to a mouse click or keystroke, how it will behave when it appears on the screen or when the window is resized, etc. Each page of the Object Inspector window is a two-column table, the left column contains the name of the property or event, and the right column contains the specific value of the property or the name of the subroutine [If you are not already familiar with this term, consider that a subroutine is just a relatively small piece of program.] that handles the corresponding event. At the top of the Object Inspector window is a drop-down list of all components placed on the form. Because the form itself is a component, its name is also in this list.

The event page is linked to editor; If you double-click on the right side of an item, the code corresponding to this event will automatically be written to Editor, myself Editor immediately receives focus, and you immediately have the opportunity to add code for this event handler. The code window is intended for creating and editing program text. This text is compiled according to special rules and describes the algorithm of the program. The set of rules for writing text is called a programming language. The Delphi system uses the Object Pascal programming language, which is an extended and improved version of the widely used Pascal language, first proposed by the Swiss scientist N. Wirth back in 1970 and improved by employees of the Borland Corporation (the languages ​​they created were called Turbo Pascal, Borland Pascal and Object Pascal). Initially, the code window contains minimal source code to ensure that the empty form functions properly as a full-fledged Windows window. During the work on the project, the programmer makes the necessary additions to it in order to give the program the desired functionality. Since you will need to create and modify (edit) program code to create even simple programs, the following describes the basic techniques for working with the code window. Immediately after opening a new project, it will contain the minimum required lines of code to describe the form.

The last important part of the Delphi environment is − Directory (on-line help). To access this tool, simply select Help and then Contents from the system menu. The screen will show Directory. Directory is context-sensitive; when you press the F1 key, you will get a prompt corresponding to the current situation. For example, while in the Object Inspector, select a property and press F1 - you will get help on the purpose of this property. If at any moment of work in the Delphi environment there is an ambiguity or difficulty - press F1 and the necessary information will appear on the screen.

1.2 The Delphi project

The main program that uses modules written by the programmer is called project. A project may include forms, modules, project settings, resources, graphical information, etc. All this information is stored in various files that are used in the host program, i.e., in the project.

Any project has at least six files associated with it. Three of them relate to project management from the environment and are not directly changed by the programmer. The following is a list of files that must be included in a project.

· The main project file, originally called PROJECT1.DPR.

· The first module of the program (unit), which automatically appears at the beginning of work. The file is called UNIT1.PAS by default, but it can be called any other name, such as MAIN. P.A.S.

· The main form file, which is called UNIT1.DFM by default, is used to store information about the appearance of the main form.

· The file PROJECT1.RES contains the icon for the project, it is created automatically.

· The file, which is called PROJECT1.DFO by default, is a text file for saving the settings associated with this project. For example, compiler directives set by the developer are saved here.

· The PROJECT1.CFG file contains information about the state of the workspace.

Of course, if you save the project under a different name, then the name and files with the extension RES, DFO and CFG will change. In addition, backup files (i.e. files with extensions *.~df, *.~dp, *.~pa) are stored in the project. Since the project contains many files, it is recommended to create a separate directory for each project. All manipulations with files (saving, renaming, editing, etc.) are recommended to be done only in the development environment.

After compiling the program, files with extensions are obtained: DCU - compiled modules EXE - executable file

1.3 Main menu of the environment

Menu item “File”

New prompts you to select the type of new application

NewApplication starts a new project for a windowed application

new form creates a new form and a module associated with it

open opens, if necessary, any module or just a text file. If the module describes a form, then this form will also appear on the screen.

open project opens an existing project.

Reopen opens a previously opened project

Save saves only the edited file, not the whole project.

Save As saves the edited file under a different name.

Save ProjectAs saves the project

close removes the current file from the Editor window.

close All closes all project files

Figure 2

Menu item “Edit”

"Edit" contains commands Undo and redo, which can be very useful when working in the editor to eliminate the consequences of incorrect actions, for example, if a necessary piece of text is accidentally deleted.

Teams Cut, Copy, Paste and Delete- as in all other Windows applications, but they can be applied not only to text, but also to visual components. bring To Front, send To Back, Alignandsize are used to align and control the appearance of components on a form.

Menu item " view ”

project manager allows you to see the contents of the project.

Object Inspector shows the Object Inspector window.

Paragraph menu “project”

Add to project allows you to add a form to the project.

Remove from project removes the form from the project.

view Source shows the contents of the project file.

Syntax Check only checks the correctness of the program code, but does not update DCU files.

Menu item “Run”

RunF9 compiles and runs the application for execution

program reset removes the application from execution.

1.4 First Delphi application

Consider the process of building a simple application that works as follows. When the button is pressed, the message "Hello, world!" appears.

Procedure:

1. Run Delphi. (Start/ Programs/Borland Delphi 5 ) This automatically opens a new project for a window application with one main form and a module corresponding to this form.

2. Select the tab in the Component Palette standard. and drag from the Components Palette to the form components and TButton. To do this, move the mouse cursor to the components one by one, reading the hints, until the TButton. Select it by pressing the left mouse button, and then move the pointer to the shape and click again on the mouse button. The component placed on the form will have the name button1 . In this case, the text of the module will look like

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

TForm1 = class(TForm)

Button1: TButton;

(Private declarations)

(Public declarations)

3. In order for any actions to take place when the button is clicked, you need to write an event handler button1 Click. To do this, select on the form button1 and double click on it. You will be in the editing window.

4. Make the button click event handler look like this:

procedure TForm1.Button1Click(Sender: TObject);

ShowMessage('Hello, peace!");

end;

5. Save the Application by selecting the item in the main menu File -> Save All . The name of the project and the name of the program module must not match! It is recommended to create a separate directory for project files.

6. Run your Application. To do this, select the item in the main menu. run-> Run , or press the key F 9 .

Unit1.pas" (Form1);

application. initialize;

application. CreateForm(TForm1, Form1);

Each project has an associated global Application object that encapsulates the properties and methods of a Windows application. In the project file that the environment generates automatically, the methods of this object are called: initialization, form creation, application operation.

1.5 Security questions

1. Name the main components of the DELPHI environment and their purpose.

2. Name the composition and purpose of the main menu items of the system.

3. What is the purpose of the Object Inspector?

4. What are the main files of an application project?

5. How are components placed, moved, resized on the form?

6. How to run an application from the DELPHI environment?

2. Visual Component Library (VCL)

2.1 VCL Base Class Hierarchy

The Visual Component Library includes many classes that you can use when developing applications. VCL is closely related to the development environment (all visual components are located on the Component Palette) and allows you to quickly create an application interface. The set of classes included in the visual component library is organized in a hierarchy. At the top level of the hierarchy is the TObject class, which is the ancestor of any class. From it, each class inherits the mechanisms for creating and destroying an instance of the class. All classes in the Visual Component Library are descended from a group of base classes that form the basis of the hierarchy.

The TComponent class is the most important class because it is the ancestor of visual components. It is endowed with the interaction of the component with the development environment, with the Component Palette and the Object Inspector. Thanks to these features, the components start working already during the development of the application interface. Visual components can be divided into two groups: visible and invisible. Visible components are visible not only during interface design, but also during application operation. Invisible components are not visible while the program is running; they interact with resources or with other components. Invisible visual components can be generated directly from the TComponent class.

The TControl class is the direct ancestor of the visible visual components and has the appropriate properties and methods to control the appearance of the components. Visible components that have input focus, i.e., have the ability to receive and process Windows messages (for example, from the keyboard), are derived from the TWinControl class.

2.2 Types of component properties. Change properties

Each component has its own set of characteristics or properties. For the user (programmer), the property looks like a simple field of some structure containing some value. However, unlike “just” a field, any change in the value of some property of the component immediately leads to a change in the visual representation of this component, since the property encapsulates the methods (actions) associated with reading and writing this field (which, in turn, include necessary redrawing). Each component that is placed on the form is reflected in the Object Inspector window. The Object Inspector has two "pages" - "Properties" (Properties) and "Events" (Events), where you can change the characteristics of the component.

There are several types of properties, depending on their “nature”, i.e. internal structure.

o Simple properties are those whose values ​​are numbers or strings. For example, the Left and Top properties take integer values ​​that specify the position of the top left corner of a component or form. The Caption and Name properties are strings and define the title and name of the component or form.

o Enumerated properties are those that can take values ​​from a predefined set (list). The simplest example is a property of type Boolean, which can take the values True or False.

o Nested properties are those that support nested values ​​(or objects). The Object Inspector displays a “+” sign to the left of the name of such properties. Some properties, such as Font, have the ability to call a dialog box to change their values. To do this, just click on the small button with three dots on the right side of the line in the Object Inspector that shows this property.

Delphi makes it easy to manipulate component properties both in design time (design time) and run time (run time). In design mode, properties are manipulated using the Forms Designer or on the “Properties” page of the Object Inspector. For example, in order to change the Height (height) and Width (width) properties of a button, it is enough to “hook” the mouse over any of its corners and move it to the desired view. The same result can be achieved by simply substituting new values ​​for the Height and Width properties in the Object Inspector window.

On the other hand, in runtime mode, the user (programmer) has the ability not only to manipulate all the properties displayed in the Object Inspector, but also to manage a more extensive list of them, including properties of other classes that are not visual components and, therefore, are not displayed in the Object Inspector.

All changes to component property values ​​in runtime must be done by directly writing lines of code in Pascal. It is not possible to use the Object Inspector in runtime. However, it is quite easy to access component properties programmatically. All that needs to be done to change any property is to write a simple line of code similar to the following:

MyComponent. Width:= 35;

The above line sets the width (Width) of the component to 35. If the component's Width property was not already set to 35 by the time this line of code is executed, you can see how the component visually changes its width.

Thus, there is nothing magical about the Object Inspector. The Object Inspector is simply a convenient way to do things in design mode that can be done programmatically in runtime. Moreover, as mentioned above, a component may have properties that are not displayed in the Object Inspector window.

The object-oriented language Pascal, which underlies Delphi, has as its base the principle of matching visual components to the things they represent. The Delphi developers have set themselves the goal that, for example, the representation of a Button component (button), encapsulating some code, matches the visual image of the button on the screen and is as close as possible to the real button that can be found on the keyboard. And it is from this principle that the concept of property was born.

If you change the Width and Height properties of the Button component, the button will change its width and height accordingly. However, after changing the Width property, there is no need to tell the object to redraw itself, although in normal programming this is exactly what should be done.

2.3 Some general properties of components

Let's look at some of the properties that each visual component has, since these properties are inherited from the base classes of the visual component library hierarchy. The TComponent class is the ancestor of all visual components, and components get the following properties from it.

Table 1 Properties of the TComponent class

Property	Purpose
	component ID
	a four-byte integer property that the programmer can use at will

All visible visual components are derived from the TControl class and inherit properties related to the location and appearance of the component. These properties can be divided into several groups.

Table 2 Component size and location

Property	Purpose
	vertical position of the top left corner of the component
	horizontal position of the upper left corner of the component
	component height
	component width

Table 3 Alignment and scaling

Property	Purpose
	alignment of the component relative to the parent component's bounds
Alignment	alignment of the label on the component
	anchoring the component to the sides of the parent component
Constraints	a complex property that determines the maximum and minimum allowable dimensions of the component
autosize	Boolean property that enables or disables automatic resizing of the component according to the size of its content

Table 4 Appearance

Property	Purpose
	component color
	cursor appearance when hovering the mouse over the component
	label on the component
	a complex property that determines the font type of the inscription
	a boolean property that determines the visibility of the component
PopupMenu	a boolean property that enables or disables the use of the popup menu
	a boolean property that determines the availability of the component
	tooltip text that appears when the mouse cursor is hovered over the component
ShowHint	a boolean property that enables or disables the hint

2.4 Events in Delphi

One of the key goals of a visual programming environment is to hide the complexity of Windows programming from the user. At the same time, however, it would be desirable that such an environment would not be simplified to such an extent that programmers lose access to the operating system itself.

Event-driven programming is an integral part of Windows. Delphi provides full access to a substructure of events that occur in the Windows operating environment. On the other hand, Delphi makes it easy to program handlers for such events.

Objects from the Visual Component Library (VCL) Delphi, as well as real world objects, have their own set of properties and their own behavior - a set of responses to events that occur to them. The list of events for a given object to which it responds can be viewed, for example, in the Object Inspector on the events page. (Actually, this page provides a list of properties that are links to event handler procedures.) Among the set of events for various objects from the VCL, there are both events ported from Windows (for example, events that are generated by the mouse or keyboard) , and events generated as a result of running the application by changing the properties of objects).

The behavior of an object is determined by what handlers and for what events it has. Creating an application in Delphi consists of setting the properties of the objects used and creating event handlers.

This programming environment was chosen by me due to the fact that I know the Delphi programming language best and this language is taught in our college, besides, this environment has a very convenient interface for development and all the functions that I need when developing a system are supported to create and edit tests.

The main emphasis of the model in Delphi is on the maximum use of code. This allows developers to build applications very quickly from prefabricated objects, and also gives them the ability to create their own objects for the Delphi environment. There are no restrictions on the types of objects that developers can create. Indeed, everything in Delphi is written in it, so developers have access to the same objects and tools that were used to create the development environment. As a result, there is no difference between objects supplied by Borland or third parties and objects that can be created.

Rice. Visual application development environment

Delphi comes standard with core objects that form a well-chosen hierarchy of 270 base classes. Delphi can be used equally well for writing both applications for corporate databases and programs for measuring systems. Designing an interface in Delphi is a fairly easy task for a programmer.

Delphi provides a comprehensive class library - the Visual Component Library (VCL), the Borland Component Library (CLX), and the Rapid Development (RAD) toolkit, including application and form templates, and wizards. Delphi object-oriented programming.

Of the non-standard improvements Borland made to object Pascal, properties (Properties) and reloading of procedures and functions (Overloading) should be noted.

The advantage of Delphi is simplicity, speed and efficiency. Delphi has the fastest compiler of all. Another advantage is the ease of learning Object-Pascal. The VCL library also allows programming in the Windows API environment. The programming model in Delphi is component-based, which allows you to use a lot of already created components, create your own and use additional others. The advantages include a fairly fast class browser and instant output of a code completion tooltip.

The disadvantage of Delphi is that it has fewer features than C++: it lacks templates, operator overloading, and an object model similar to C++. After using the objects, they must be destroyed by calling the Free method. In C++, objects are destroyed automatically when they go out of scope. In addition, the growth of exe-files generated by Delphi is noticeable.

Compiler built into Delphi provides translation of the Object Pascal program into object code, detects syntax errors, handles exceptions, allows debugging, performs linking and creates an executable module. Delphi compiles directly to machine code.

Features of CodeInsight technology in the code editor this is an intelligent editor that allows you to copy / paste, select from a list of reserved words, indicate the type and location of syntax errors.

Delphi uses Encapsulation (combining records with procedures and functions), Inheritance (using an object to build a hierarchy of child objects), Polymorphism (giving one name to an action that is passed up and down the hierarchy of objects) - traditional for OOP.

Visual Component Librares (VCL) - it is a hierarchy of 270 base classes. user interface building, data management objects, graphical objects, multimedia objects, dialogs and file management objects, DDE and OLE management

Borland Database Engine (BDE) - The operating system preprocessor provides access to database objects in Delphi based on SQL: Oracle, Sybase, Informix and InterBase format files. dbf or. db (Paradox) or. mdb (Access).

Delphi's unique features are that developers can add CASE tools, code generators, and author help's available through the Delphi menu.

Technology Two-way tools provides a one-to-one correspondence between visual design and classical writing of program text. This means that the developer can always see code that matches what he has built with visual tools and vice versa.

Object Inspector is a separate window where you can set the values ​​of properties and events of objects (Properties & Events) during the design of the program.

Project Manager allows the developer to view all modules in the corresponding project and provides a convenient mechanism for project management.

Basic Object Pascal it is a Run-Time Type Information (RTTI) mechanism, i.e. information about types at the stage of program execution and properties of object types - classes, with the concept of property (property); and exception handling.

Event Delegation means attaching code that handles the action of some interactive element, such as a button, which, when clicked, actually uses code delegation to associate code with the onclick event.

Core Delphi Project Files this is PROJECT1. DPR, UNIT1. PAS, UNIT1. DFM - form information, PROJECT1. RES contains the icon for the project, PROJECT1. OPT by default, is a text file for saving the settings associated with this project. After compiling the program, files with extensions are obtained: DCU - compiled modules, EXE - executable file. Editor Options settings are stored in a DELPHI. INI located in the Windows directory.

Program error editing technology provides for a transition to a code fragment that contains an error, in this case, you must place the cursor in the line with the error message and select the Edit source command from the context menu.

Warnings and hints appear when inaccuracies are found in the program that are not errors, the compiler displays hints (Hints) and warnings (warnings).

Run-time errors or exceptions.

Linker Options Page allows you to select settings that directly affect the current project, for example, stack checking or rangechecking compiler directives.

Directories/Conditionals Options page makes it possible to expand the number of directories in which the compiler and linker look for DCU files.

Editor Options Page allows you to fine-tune the finer details of how the Editor works.

EditorOptions, EditorDisplay, and EditorColors Settings Pages allow you to change the colors and hotkeys used by the IDE.

The five main OOP windows of the Delphi programming environment are:

Form Designer;

Source Editor window (Editor Window);

palette Component (Component Palette);

Object Inspector;

reference book (On-line help).

Structural Exception Handling this is a system that allows the programmer, when an error (exception) occurs, to contact the program code prepared to handle such an error. This is done with the help of directives, which, as it were, “guard” a fragment of the program code and define error handlers that will be called if something goes wrong in the “protected” section of code.

Main components of Delphi:

Edit component. Text allows you to read text from the Edit window

The TCheckBox component displays a line of text with a small box next to it.

The TRadioButton component allows you to select only one option out of several.

The TListBox component is needed to show a scrollable list.

The TStringGrid component is used to represent text data in the form of a table.

The TMainMenu component allows you to place the main menu in the program.

The TPopupMenu component allows you to create popup menus.

The TBitBtn component represents a button on which you can place an image.

The TDrawGrid component serves to present data of any type in the form of a table. Each element of the table is accessed through the CellRect property.

The TImage component displays a graphic image on the form. Accepts BMP, ICO, WMF formats. If the image is connected during the design of the program, then it will be compiled to the EXE file.

The TShape component is used to display the simplest graphical objects on the form: a circle, a square, etc.

Windows dialogs are organized by dialog components: OpenDialog - select file, SaveDialog - save file, FontDialog - set font, ColorDialog - color selection, PrintDialog - printing, PrinterSetupDialog - printer setup.

The System - TTimer page component is a timer, the OnTimer event is periodically called after a period of time specified in the Interval property. The time period can be from 1 to 65535 ms.

The System - TFileListBox page component is a specialized ListBox that displays files from a specified directory (Directory property).

The System - TDirectoryListBox page component is a specialized ListBox that displays the directory structure of the current drive. In the FileList property, you can specify TFileListBox, which will automatically track the transition to another directory.

The System - TDriveComboBox page component is a specialized ComboBox for selecting the current drive. It has the DirList property, in which you can specify a TDirectoryListBox that will track the transition to another disk.

The System - TMediaPlayer page component is used to control multimedia devices (such as CD-ROM, MIDI, etc.). Made in the form of a control panel with buttons Play, Stop, Record, etc.

Integrated development environment for the project. Five main windows of the integrated development environment: main, form, code editing window, object inspector, browser.

A feature of the integrated development environment is the visual (and, consequently, high-speed) construction of applications from software prototypes.

Compiling, linking and running programs. The task of converting the source program into machine code is performed by a special program - the compiler.

The compiler performs two tasks in sequence:

1. Checks the text of the source program for the absence of syntax errors.

2. Creates (generates) an executable program - machine code.

When an error occurs in a program launched from Delphi, the development environment interrupts the program, as evidenced by the parenthesized word Stopped in the title of the main Delphi window, and a dialog box appears on the screen that contains an error message and information about the type (class) of the error .

A program that has an algorithmic error compiles successfully. During test runs, the program behaves normally, but when analyzing the result, it turns out that it is incorrect. In order to eliminate the algorithmic error, one has to analyze the algorithm, manually "scroll" its execution.

Data types and expressions. Data types include integer, real, boolean, string, and character:

Shortint - 128-127 8 bits

Smallint - 32768 - 32767 16 bits

Longint - 2 147 483 648 - 2 147 483 647 32 bits

Int64 - 263 - 263 - 1 64 bits

Byte 0-255 8 bits, unsigned

Word 0-65 535 16 bit, unsigned

Longword 0 - 4 294 967 295 32 bit unsigned

generic integer type - Integer

generic real type - Real

the Ansichar type is ANSI characters, which correspond to numbers in the range from 0 to 255;

widechar are Unicode characters and correspond to numbers from 0 to 65535.

ObjectPascal also supports the most versatile character type -

the shortstring type represents strings statically placed in the computer's memory, from 0 to 255 characters in length;

the Longstring type represents dynamically allocated strings in memory, the length of which is limited only by the amount of free memory;

the WideString type represents dynamically allocated strings in memory, the length of which is limited only by the amount of free memory. Each character in a WideString is a Unicode character.

the string type is equivalent to the shortstring type.

Designing and initializing common controls involves the use of:

Drag-and-Dock interface;

Drag-and-Drop transfer interface;

advanced scaling;

focus control;

mouse control;

Creating tooltips. If you hold the cursor, for example, over a button or palette component of the Delphi environment itself, a small bright-colored rectangle (hint box) appears, in which one line says about the name of this element or the action associated with it. Delphi supports mechanisms for creating and displaying such shortcuts in programs you create.

The technology for developing a program in Delphi for wide application includes the following steps:

Specification (definition, formulation of requirements for the program).

Algorithm development.

Coding (writing an algorithm in a programming language).

Testing.

Creating a help system.

Creation of an installation disk (CD-ROM).

In the process of building an application, the developer selects ready-made components from the component palette. Even before compilation, he sees the results of his work - after connecting to the data source, you can see them displayed on the form, you can navigate through the data, present them in one form or another. The user can also attach his own components to the library, which he develops in the Delphi environment.

The Delphi work screen (Delphi-6 version) has 4 main windows: the main Delphi window; form window Form1; the Object Inspector window and the Unit1 code editor window. pas

Features of MySQL DBMS

MySQL is a free database management system (DBMS). MySQL is owned by Oracle Corporation, which received it along with the acquired Sun Microsystems, which develops and maintains the application. Distributed under the GNU General Public License or under its own commercial license. In addition, developers create functionality on the order of licensed users, it was thanks to such an order that the replication mechanism appeared in almost the earliest versions.

MySQL is the solution for small and medium applications. Included in WAMP, AppServ, LAMP servers and in portable assemblies of Denver, XAMPP servers. MySQL is typically used as a server accessed by local or remote clients, but the distribution includes an internal server library that allows you to include MySQL in standalone programs.

The flexibility of the MySQL DBMS is supported by a large number of table types: users can choose between MyISAM tables that support full-text search, and InnoDB tables that support transactions at the level of individual records. Moreover, MySQL comes with a special EXAMPLE table type that demonstrates how to create new types of tables.

Thanks to its open architecture and GPL licensing, new types of tables are constantly being added to the MySQL database.

The software I have chosen is simple and convenient, and it also has all the components that I will need when developing my own program, therefore, I chose these development environments.

Encyclopedic YouTube

• 1 / 5

  The environment is designed for rapid (RAD) development of application software for operating systems Windows, Mac OS X, as well as iOS and Android. Due to the unique combination of language simplicity and machine code generation, it allows direct and, if desired, rather low-level interaction with the operating system, as well as with libraries written in C / C ++. The programs created are independent of third-party software such as Microsoft .NET Framework or Java Virtual Machine. The allocation and release of memory is controlled mainly by user code, which, on the one hand, tightens the requirements for code quality, and on the other hand, makes it possible to create complex applications with high requirements for responsiveness (real-time operation). Cross compilers for mobile platforms provide automatic counting of object references, which makes it easier to manage their lifetime.

  Pronunciation

  Regarding the "correct" pronunciation of the name of the development environment, many copies were broken not only in Russia. Interestingly, there is no unity even among English-speaking countries. In particular, according to this source, the pronunciation "del-fi" dominates in the UK, and "del-fi" in the USA.

  codegear

  Delphi version history

  Borland Delphi

  The first version of Borland Delphi (later known as Delphi 1) was released in 1995 and was designed to develop 16-bit applications for Windows 3.1. It was one of the first RAD systems.

  Delphi 2

  Delphi 2 appeared in 1996 and allowed the development of 32-bit applications. For programming under Windows 3.1, Delphi 1 was included in the package.

  Delphi 3

  Delphi 3 was released in 1997. This version introduced Code Insight technology, component packages, support for ActiveForms, MIDAS, and COM interfaces.

  Inprise Delphi 4

  Inprise Delphi 4 was released in 1998. The IDE has been completely redesigned with Drag-and-Dock interfaces. Support for ActionLists has been added to the VCL. Procedure and function overloading, dynamic arrays, support for Windows 98, CORBA, and Microsoft BackOffice were introduced. This was the last version shipped with Delphi 1 for 16-bit programs.

  Borland Delphi 5

  Borland Delphi 5 appeared in 1999. Added frameworks, parallel programming, advanced integrated debugger, XML support, ADO database support.

  Kylix

  In 2001, Borland released a Linux version of Delphi, called Kylix. Instead of the VCL library, the cross-platform CLX (wrapper for ) was used. The Kylix IDE was based on the Wine libraries. Since kylix was previously called GRODT in a different way, then N. Nikos changed the name to kyluix. [ ]

  Borland Delphi 6

  Supported the cross-platform CLX library.

  Borland Delphi 7

  Delphi 7, released in August 2002, has become the standard for many Delphi developers.

  It is one of the most successful Borland products due to its stability, speed, and low hardware requirements. Delphi 7 adds new components for Windows XP and increases the number of components for building web applications.

  Borland Delphi 8

  Delphi 8 was released in December 2003. Had a new fixed Galileo interface similar to Microsoft's Visual Studio .NET. Supported application development for .NET only. It was positioned as the first programming system for .NET, released not by Microsoft, but by a third-party developer.

  Borland Delphi 2005

  Also Delphi 9 and Borland Developer Studio 3.0. This version brought back the ability to develop applications for Win32, removed from the previous Delphi 8. But if the VCL library was brought back, then CLX was no longer supported.

  Borland Delphi 2006

  Delphi 2006 (Delphi 10, Borland Developer Studio 4.0) was released in December 2005. One IDE supported the development of C#, Delphi.NET, Delphi Win32, and C++ projects.

  Code Gear Delphi 2007

  Delphi 2007 (Delphi 11, part of CodeGear RAD Studio 5.0 IDE) was released in September 2007. It is the latest non-unicode version of Delphi.

  New in Delphi 2007

  • Standard components in the new Delphi now automatically support Windows themes. In previous versions, it was necessary to throw the XPManifest component onto the form. XPManifest worked incorrectly (color disappeared on some components) in Windows Vista and above;
  • VCL has undergone some changes. Along with the usual, standard "Dialogs" tab, there is a new one - "Vista Dialogs". It contains only three components: TFileOpenDialog, TFileSaveDialog and TTaskDialog;
  • The VCL added Vista-oriented dialogues classes (TCustomFileDialog, TCustomFileOpenDialog, TCustomFileSaveDialog, TCustomTaskDialog, TFavoriteLinkItem, TFavoriteLinkItems, TFavoriteLinkItemsEnumerator, TFileTypeItem, TFileTypeItems, TTaskDialogBaseButtonItem, TTaskDialogButtonItem, TTaskDialogButtons, TTaskDialogButtonsEnumerator, TTaskDialogProgressBar, TTaskDialogRadioButtonItem) and revised some existing classes under Windows Vista;
  • The Delphi help system is made in the Microsoft Document Explorer format. Many of its points have been revised and expanded. Visually, it looks better;
  • DBExpress has undergone some changes. There was support for Interbase 2007, MySQL 4.1 and 5. There was also support for Unicode in the Oracle, Interbase and MySQL drivers.

  Delphi 2009

  New in Delphi 2009
  • full Unicode support. Applications can run on any language version of Windows. Using Unicode ensures that applications look and function the same across all language versions of Windows and support both Unicode and ANSI strings. New and improved localization tools help you translate applications into different languages. All Windows API functions have been replaced with their unicode counterparts (for example, MessageBox was previously defined as MessageBoxA, now it is MessageBoxW); the type String is now actually UnicodeString and Char is WideChar, PChar is now declared as PWideChar. The old types and descriptions of the ANSI variants of system functions have been preserved, but now they will need to be specified directly (for example, Set of Char in Delphi 2009 will be Set of AnsiChar, and MessageBox will be MessageBoxA). Delphi 2009 is the first version of Delphi for Win32 that requires serious reworking of projects when moving to a new version, which is especially critical for system programmers who widely used direct processing of data types;
  • new elements of programming languages, including Generics and anonymous methods for Delphi, allow you to create more flexible and high-quality code and provide new opportunities for refactoring;
  • the new VCL library includes many improvements and new components to create an advanced graphical interface;
  • the VCL web library allows you to create web applications with a developed interface with AJAX support;
  • reduced the time for the application to send messages to the operating system;
  • visual design and database development with Embarcadero ER/Studio, a professional modeling tool included with the Delphi Architect edition.

  Delphi 2010

  On August 25, 2009 the Embarcadero Technologies company announced sale of the Embarcadero Rad Studio 2010 integrated development environment which included the new version of Delphi 2010.

  New in Delphi 2010

  • Support for Windows 7 API, Direct2D and multi-touch input.
  • Touch and gesture support for Windows 2000 , , Vista and 7.
  • IDE Insight in Delphi 2010 - instant access to any function or parameter.
  • Delphi 2010 includes over 120 performance enhancements.
  • Debugger visualizers.
  • Delphi 2010 includes Firebird support with dbExpress .
  • Classic Delphi 7 interface and tabbed toolbar as an option.
  • RTTI extension - support for attributes that can be applied to types (including classes and interfaces), fields, properties, methods, and enum members.
  Delphi 2010 Professional Edition
  • Local connection to InterBase, Blackfish SQL and MySQL databases
  • Deploying Blackfish SQL on systems with a single user and a 512 MB database.
  • Web VCL with a connection limit of 5.
  Delphi 2010 Enterprise Edition
  • Delphi 2010 Enterprise includes all the features of the Delphi 2010 Professional edition plus a number of additional features.
  • Connecting to InterBase , Firebird , Blackfish SQL, MySQL , Microsoft SQL Server , Oracle , DB2 , Informix and Sybase database servers when connected via dbExpress.
  • Development of multi-tier DataSnap database applications.
  • Deploying Blackfish SQL on systems with five users and a 2 GB database.
  • Web VCL with no connection limit.
  • Additional features of UML-modeling.
  Delphi 2010 Architect Edition
  • Delphi 2010 Architect includes all the features of the Delphi 2010 Enterprise edition plus a number of additional features.
  • Reverse engineering, analysis and optimization of databases.
  • Create logical and physical models based on information retrieved from databases and script files.
  • Easy-to-read and navigate charts.
  • Delphi 2010 Architect enables direct design by automatically generating database code from models.
  • Delphi 2010 Architect has improved bi-directional comparison and merging of database models and structures.

  Delphi XE

  What's New in Delphi XE

  • Subversion integration.
  • New VCL and RTL features.
  • Improvements in the code editor.
  • Updating DataSnap, in particular in terms of support for new versions of the DBMS.
  • Update of modeling tools, support for sequence diagrams.
  • New features for IDE extension, updated Open Tools API.

  Delphi XE2

  On September 1, 2011, Embarcadero released RAD Studio XE2 which includes Delphi XE2 as well as C++Builder XE2, Prism XE2 and RadPHP XE2.

  New in Delphi XE2;

  Delphi XE3

  Delphi XE3 supports 32-bit and 64-bit editions of Windows (including Windows 8) and improved support for Apple Mac OS X with the Firemonkey 2/FM² framework. Support for iOS has been dropped (with the intention of bringing it back in a separate product - Mobile Studio), but applications for this platform can still be developed in Delphi XE2.

  Delphi XE4

  Innovations
  • Support for iOS has returned, which was missing in RAD Studio XE3.
  • To replace RAD Studio XE3 Mobile, which was expected to be released in early 2013, RAD Studio XE4 has been enhanced with functionality for developing mobile applications.
  • Programming directly for iPhone and iPad, taking into account all software and technical features.
  • Code generation for the Apple iOS emulator.
  • Improved interaction with databases such as InterBase, SQLite, MySQL, SQL Server, Oracle, PostgreSQL, DB2, Advantage DB, Firebird, Access, Informix, DataSnap, etc.

  Delphi XE5

  RAD Studio XE5 went on sale September 11, 2013. The new version adds support for software development for devices with ARM architecture running Android.

  Delphi XE6

  On April 15, 2014, Embarcadero released RAD Studio XE6. The developers called it a "quality release" as hundreds of design and performance bugs were fixed.

  New in IDE XE6

  • Google Glass device design added in form builder.
  • New icons in the IDE. Icons have been updated throughout the product.
  • New features in the deployment manager. New option Rewriting allows you to select files that do not need to be deployed, specifically so that you can avoid overwriting files on the target device. Option Rewriting installed in Is always default.
  • Changes in the SDK manager for Android platforms. Properties for the Android SDK are now organized in three different tabs: SDK, NDK, and Java.
  • Changed and added some options in the Project Options window (new page orientation for mobile apps, new feature Use MSBuild externally to compile for Delphi compiler, new key hardware accelerated on Info Version Page for Android, new features for C++ Linker for all mobile platforms).
  • Run commands provide a new parameter -cleaninstall for mobile platforms.
  Key New Delphi XE6 Features
  • Application Tethering Components
  • Taskbar component: Components for implementing multiple window previews that can be selected in applications using control buttons. Automatic or custom previews. Show progress in taskbar buttons for apps. Overlapping icons on taskbar buttons.
  • Interaction with services in the clouds (BaaS), components for Kinvey and Parse: Interaction with leading backend-as-a-service providers to add this functionality to mobile applications. Easy access to services in the clouds, which eliminates the need to create and maintain your own "backend services". Using push notifications to engage any device and platform users. Access to data and object storage in the clouds. User authentication. Support for REST clients, the creation of which has been available since XE5. Support for the three most popular BaaS providers - Kinvey and Parse based on a set of API access components.
  • New VCL Styles : Give the application an updated look for current versions of Windows or create a unique design for them. Includes Windows Tablet style. Supports Windows 7 and Windows 8. Complete application styling, including menus and window borders.
  • VCL components for working with sensors: Delphi applications can use the capabilities of position sensors, displacement sensors, and others. Access to device sensors from VCL applications for Windows tablets. Capabilities of accelerometer, GPS and gyroscope.
  • In-app purchases and in-app advertising: Mobile apps provide an opportunity to earn money for their developers. You can monetize mobile apps by embedding in-app purchases and ads. Sale of content, functionality, services and subscriptions in iOS and Android. Support for major advertising networks (Google AdMob and Apple iAd).
  • Apps for Google Glass: With Delphi, multi-device development now extends beyond PCs, tablets and smartphones to wearables. Ability to create Andorid applications for Google Glass . New custom styles to optimize app design and resolution for Google Glass. Designer templates for the Google Glass device.
  • Accessibility: You can make applications more usable by more users, including those who use screen readers. New accessibility features for FM-based desktop applications. Support for JAWS on Windows and VoiceOver on Mac OS X.
  • Quality, Performance and Stability: The best in developing and delivering applications with the highest level of user experience. Over 2000 reported bugs fixed. Improved overall application runtime performance for all platforms.
  • Key features and work with databases: Expansion of key features of the product. Improvement in the FireDAC library for working with databases, FDMemTable. "Data Explorer" (Database Explorer) for FireDAC. Apache support (WebBroker). Support for DirectX 11, OpenGL 4.3 and earlier. DataSnap performance and updated wizards. Refactoring and improvements in RTL. FireDAC driver update for Informix. Apache C++ support.

  Delphi XE7

  Major changes

  Delphi XE8

  • Now you can develop 64-bit applications for iOS;
  • Preview app design on different devices at the same time;
  • The ability to run iOS applications on any iOS simulator registered with RAD Studio (iPad, iPad Air, iPhone 4 and above);
  • Ability to disable built-in RAD Studio Android libraries;
  • RAD Studio now supports the new version control system integrated into the IDE for managing and tracking changes in projects: Mercurial Version Control System Integrated;
  • Allows you to create universal applications for iOS with different bitness - in one executable file there are two codes: 32 bit and 64 bit (ARMv7 + arm64);
  • Integrated Castalia (adds functionality that allows you to perform some tasks in an easier way);
  • Two new platform-independent data types have been added: FixedInt and FixedUInt. (FixedInt- 32-bit signed integer, FixedUInt is a 32-bit unsigned integer).

  Delphi 10 Seattle

  The main innovations of the development environment

  Delphi 10.1 Berlin

  Added support for Android 6.0.

  Delphi 10.2 Tokyo

  Key new features in Delphi 10.2 Tokyo:

  • Delphi includes an application compiler for Linux (Ubuntu Server (LTS 16.04) and RedHat Enterprise (V7));
  • support for MariaDB DBMS is included.

  Delphi for PHP

  In March 2007, CodeGear released the Delphi for PHP development environment for developing web applications using the PHP programming language. Now the Delphi environment is focused not only on the Delphi language. Versions 1 and 2 were released, after which Delphi for PHP was renamed to RadPHP XE (essentially version 3), then RadPHP XE2, and with the release of Delphi XE3, this product was heavily redesigned and named HTML5 Builder.

  Delphi for .NET

  The first version of a full-fledged Delphi environment for .NET is Delphi 8. The environment allows you to write applications only for .NET.

  In Delphi 2005, you can write .NET applications using the .NET Standard Class Library and the .NET VCL. The environment allows you to write .NET applications in . Delphi 2005 also allows you to write common applications using the VCL and CLX libraries.

  Delphi 8, 2005, 2006 use .NET Framework version 1.1. Delphi for .NET 2007, included with CodeGear RAD Studio 2007, is designed for the .NET Framework 2.0.

  As of version 2009, support for Delphi.NET has been dropped. For .NET development, Delphi Prism is offered.

  Delphi Prism

  Delphi Prism- development environment for .NET and Mono in the Oxygene language, using the Visual Studio Shell (with the ability to integrate into Visual Studio).

  see also

  Notes

  1. “The strength independent vendor development - in support multi-platform” (indefinite) (September 18, 2015). - "we have only three such centers outside the USA (one in Canada, and recently appeared in Spain instead of the closed one in Romania)". Retrieved 4 October 2015.

  2. Delphi Integrated Development Environment: purpose and general description of the environment

  Delphi is a descendant of the Turbo Pascal programming environment. The name of the environment comes from the name of the city in ancient Greece, where the famous Delphic oracle was located (the temple of Apollo in the city of Delphi, whose priests were engaged in predictions).

  The Delphi visual object-oriented design system allows you to:

  1. Create complete applications for Windows of various kinds.

  2. Quickly create a professional-looking window interface for any application; The interface meets all Windows requirements and automatically adjusts to the system that is installed because it uses Windows functions, procedures, and libraries.

  3. Create your own dynamically attached libraries of components, forms, functions, which can then be used from other programming languages.

  4. Create powerful systems for working with databases of any type.

  5. Generate and print complex reports, including tables, graphs, etc.

  6. Create help systems, both for your applications and for any others.

  7. Create professional installers for Windows applications that take into account all the specifics and all the requirements of the operating system.

  Delphi is a rapidly developing system. The first version of Delphi was released in February 1995, in 1996 the second version was released, 1997 - the third, 1998 - the fourth, 1999 - the fifth, 2001 - the sixth. All versions since Delphi 2.0 are designed for the development of 32-bit applications, ie. applications for operating systems Windows 95/98, NT, etc. In 2002, the seventh version was released, the main innovation in which were Internet technologies.

  General description of the environment.

  The Delphi Integrated Development Environment is an environment that has everything you need to design, run, and test your applications. Most versions of Delphi come in several flavors: a) standard, b) professional, c) domain database development. These options differ, mainly by different levels of access to database management systems. The last two options are the most powerful in this regard. Libraries of components in various variants are almost the same.

  1) The main menu bar is displayed at the top of the environment window. The purpose of each menu item can be clarified in the Delphi help system. To get help, select the menu item of interest and press the F1 key. Selecting a menu command is done using any of the standard methods: F10, Alt+hot key, or by clicking on the desired menu item.

  The purpose of the menu commands is presented in the table:

  Menu section	Purpose
  1) File menu	The menu sections allow you to create a new project, a new form, open a previously created project or form, save projects or a form in files with given names.
  2) Edit menu	The sections of this menu allow you to perform common clipboard operations for Windows applications, and also provide the ability to align groups of components placed on the form by size and location.
  3) Search menu	The sections of this menu allow you to search for snippets of text, errors, objects, modules, variables, and symbols in the code editor.
  4) Menu View (View)	The sections of this menu allow you to display or hide various elements of the design environment and open windows associated with the integrated debugger.
  5) Project menu	Menu sections allow you to add and remove forms from the project, set project options, compile the project without running it, give information about the size of the application.
  6) Run Menu	Provides the ability to run the project in normal or debug mode, step by step, stopping at specified points, viewing variable values, etc.
  7) Menu Component (Component)	Contains a drop-down menu that allows you to work with components: create new components, change the palette of components, etc.
  8) Menu Database (Database)	The menu section allows you to use the tools for working with databases.
  9) Menu Tools (Service)	Includes a number of sections that allow you to run various auxiliary programs: an image editor, programs that configure databases and networks, etc.
  10) Windows Menu (Window)	Contains a list of open windows in the environment and provides the ability to switch from one window to another.
  11) Help Menu	Contains topics that help you work with the help system of the Delphi programming environment.

  2) Below the main menu bar are two toolbars. The left panel (consisting, in turn, of three panels) contains two rows of buttons duplicating some of the most commonly used menu commands (open, save, save all, etc.). The right panel contains the Visual Component Library panel (or palette). The Component Palette contains a number of pages whose tabs are visible at the top. Pages are grouped according to their meaning and purpose. Since the number of provided components grows from version to version, we will focus on the main ones (12 pages).

  The main Palettes of components are presented in the table:

  Component Palette	Purpose
  1. Component palette Standard (Standard)	Most of the components on this page are analogous to the on-screen elements of the Windows operating system: menus, buttons, scroll bars, panels, and so on. Component names can be found in the tooltip. The purpose of the components can be clarified using the Delphi context help system.
  2. Palette components Additional (Additional)	Contains more advanced components: a) playback of sound, music and video; b) display of graphical information.
  3. Palette of components System (System)	Provides the ability to combine individual items, such as lists of directories and files, as well as generate events at regular intervals.
  4. Win32 Component Palette	Contains components that allow created programs to use the Windows interface.
  5. Palette of components Dialogs (Dialogue)	Contains standard dialog boxes for operations on files, search and replacement of text, selection of fonts, colors, etc.
  6. Palette of components Data Access, Data Controls (Database service)	Uses the database mechanism to organize access to database files of various formats.
  7. Palette of components QReport (Reports)	Provides components for visually designing database reports.
  8. Palette of components Servers (Service)	Provides descendant components for accessing all Microsoft Office server objects.
  9. Palette of components Samples (Examples)	Contains sample components that you can add to your own applications.
  10. Internet Component Palette	Provides components for developing applications that allow you to create HTML files directly from database files and other file types that interact with other web applications.

  3) To the right of the main menu bar is another small toolbar containing a drop-down list and two buttons. This panel is used to save and select various environment window configurations that you can create and remember.

  4) Under the components palette there is a form window with components placed on it. The form is the basis of almost all Delphi applications. A form can be understood as a typical Windows window. It has the same properties as other windows. During design, the shape is covered with a grid of dots. The nodes of this grid contain those components that are placed on the form. This grid is not visible during application execution.

  5) In the main field of the window on the left is the Object Inspector window, with the help of which you can later set the properties of components and event handlers. The Object Inspector consists of two pages, each of which can be used to define the behavior of the active component. The first page is Properties, the second is Events.

  Consider some properties of any component:

  Each component has its own set of properties, which corresponds to the purpose of this component.

  The Events page is the second part of the Object Inspector. It lists all the events that the selected object can respond to.

  6) One of the most important elements of the Delphi environment is the Code Editor window. It is located below the form window, usually invisible at first glance at the screen, because its size is equal to the size of the form and the Code Editor window is almost completely covered by the form window. The code editor is a complete programmatic editor. The title of the code editor window displays the name of the current file whose text is being worked on (the standard name is Main.pas). At the bottom of the Code Editor window is the status bar. In its leftmost position, the position of the cursor is displayed: the number of the line and column.

  7) Above the Object Inspector window is the Object Tree window, which displays the structure of the application components in terms of their belonging to each other.

  Note: The event page is linked to the Code Editor, if you double-click on the right side of any item, then the code corresponding to this event will be automatically placed in the Code Editor window.

  Automated information system "Aircraft"

  Delphi 7 - Integrated Development Environment for Microsoft Windows in Delphi (formerly ObjectivePascal). Delphi 7 is distributed commercially, but at the moment it is not possible to buy it separately from the DelphiXE package. DelphiXE package price...

  Huffman algorithm

  The appearance of the Delphi programming environment is different from many others seen on Windows. For example, Borland Pascal for Windows 7.0, Borland C++ 4.0, Word for Windows, Program Manager are all MDI applications and look different than Delphi...

  Analysis of methods for building user interfaces

  The appearance of the XAML user interface description language and the new Expression Blend development environment make it possible to significantly speed up and facilitate the design and construction of user interfaces for both web and desktop applications...

  PC hardware specification

  Embarcadero Delphi, formerly Borland Delphi and CodeGear Delphi, is an integrated software development environment for Microsoft Windows in Delphi (formerly known as Object Pascal)...

  Description of visual development tools

  Delphi - Integrated Development Environment (IDE). This programming language makes it possible to create programs in the style of visual design of a form by placing any visual elements on it ...

  Building a database "Applicant" for an educational institution

  A programming language is a formal sign system designed to write computer programs. A programming language defines a set of lexical, syntactical, and semantic rules that define the program's appearance and actions...

  Messenger program (telecommunication) in Java programming language

  Software package for calculating the complex non-transitivity of the superiority relation on a group of objects

  The Kontur software package is written in the Delphi programming language as a separate program and does not require the installation of any additional packages. However, the Microsoft Office Excel application server is used to save the reports...

  Designing an automated information system for a book warehouse

  ImageDelphi is Borland's integrated software development environment. Delphi is a RAD (rapid application development) environment...

  Development of a desktop and mobile version of the "Organizer" application

  Cross-platform free IDE for C, C++ and QML development. Developed by Trolltech (Digia) to work with the Qt framework. Includes a GUI debugger and visual interface development tools using both QtWidgets and QML...

  Development of the program "Domain name, IP" for a technical institute

  Delphi is a rapid development environment that uses Delphi as its programming language. Delphi is a strongly typed object-oriented language based on the well-known Object Pascal...

  Solving a system of linear equations by the Gauss and Jordan-Gauss method

  The Delphi environment is a complex mechanism that provides a highly efficient programmer. Visually, it is realized by several windows simultaneously opened on the screen. Windows can move around the screen...

  Creation of an accounting information system in a second-hand bookstore

  Delphi is Borland's integrated software development environment. Delphi is a RAD (rapid application development) environment. In fact, it is the successor of the Pascal language with object-oriented extensions...

  Creating software for a small supermarket

  Controlling the 1C program interface using OLE

  Delphi programming language - programming language...