Ada is a particularly good programming language. Ada (programming language) The first formatting language of Ada

The language of Hell has more or less always been around. At school we laughed at its name, in the university curriculum it was dryly mentioned as a language developed at the request of the US Department of Defense, but only rare programmers actually got to study the syntax or application. This led to the erroneous opinion that the Ada language functions only on centuries-old equipment, and the need for it will disappear along with natural modernization.

And this is very far from the truth.

Appearance

In the 70s of the 20th century, at the height of the Cold War, the US Department of Defense arranged international competition, based on the results of which it was necessary to select a programming language for use for military purposes. However, none of existing languages did not suit the members of the commission, so through a long selection and several modifications, the language of Ada was born, named after Ada Lovelace. Then began many years of red tape with standardization, registration trademark, bans on custom translators and other actions that discouraged the mass audience from working with Ada.

The result was a fairly niche language intended for complex computing systems with increased security requirements. Again, due to Pentagon requirements and strict standards, interaction with other programming languages ​​is extremely difficult, so until recently Ada had virtually no chance of moving to the mass market. But as equipment becomes cheaper and the technologies used become more complex, such a chance appears.

Syntax

Initially, Ada is a modular programming language with strong typing, inheriting the syntax from Pascal and Algol. If you learned the first one at school or college, then looking at “Hello, World!” should feel nostalgic:

with Ada.Text_IO;

Procedure Hello is
use Ada.Text_IO;
begin
Put_Line("Hello, world!");
end Hello;

One of the main requirements for the language was the reliability of its use. Accordingly, this entailed strict restrictions on structure, types, spelling and much more. In addition, almost all errors here are caught at the compilation stage.

Another requirement was maximum readability of the code in printed form, which entailed the heaviness of the resulting language and low flexibility.

Later standards partially solved these problems, but for obvious reasons, they did not make a second Python out of Hell.

Ada today

Contrary to the opinion of a wide audience, the language of Hell is still actively used, not only in the United States and not only in the military industry. For example, part of the software of the Beriev Be-200 amphibious aircraft is written in Ada. Driverless subway trains that operate in many major cities (Paris, London, New York, etc.) also use US military language equipment.

And yes, of course, among the “clients” were military and civil aviation (in particular, the Boeing 777), rockets, shuttles, satellites - in general, almost the entire list of endlessly expensive American products that require the highest degree of safety.

Prospects

The Language of Hell was criticized both at the time of its appearance and when it became clear that the Pentagon’s grandiose plans do not quite fit in with reality, and even more so now. The reason for this is the inconvenient language, the complexity of the standards written in 1983 and 1995, as well as the shortsightedness of the developers who deprived the Ada language of a mass audience.

However, almost 40 years of active use confirm that the Ada language has perhaps coped with its main task - with its help it is still possible to create reliable code for systems with increased security requirements. However, if you look at modern tendencies, the number of such products is growing steadily: cars with autopilot and hybrid engines, private spacecraft and small aircraft, high-speed trains, as well as a huge number of embedded systems. All this is a potential field for the activity of the language of Hell. Add to this the fact that the standard was seriously revised and modernized in 2012, tools for the job are also being released and updated.

Thus, the language of Hell is both a fragment from a not very pleasant past, and one of the tools for building a bright future. And he's definitely not planning on retiring.

(Ada 2005), Eiffel (Ada 2012)

Features of Ada include: strong typing, modularity mechanisms (packages), run-time checking, parallel processing (tasks, synchronous message passing, protected objects, and non-deterministic selection statements), exception handling, and generics. Ada 95 added support for object-oriented programming, including dynamic dispatch.

Ada syntax minimizes the choice of ways to perform basic operations, and prefers English keywords(such as "or" and "and then") into symbols (such as "||" and "&&"). Ada uses the basic arithmetic operators "+", "-", "*" and "/", but avoids the use of other symbols. Blocks of code are delimited by words such as "declare", "begin" and "end", where "end" (in most cases) is followed by the identifier of the block it closes (e.g. if it's the end, if... , loop... end of cycle). In the case of conditional blocks, this avoids still torn, which can pair with incorrectly nested if statements in other languages ​​such as C or Java.

Ada is designed for developing very large software systems. Ada packages can be built separately. Ada package specifications (package interface) can also be compiled separately without checking for conformance. This allows problems to be detected early during the design stage, before implementation begins.

A large number of compile-time checks are supported to help avoid errors that will not be detected until runtime in some other languages, or that require explicit checks to be added to the source code. For example, the syntax requires an explicit block name to prevent errors due to mismatched end markers. Maintaining strict typing allows you to detect the presence of standard errors software(bad parameters, range violations, invalid references, mismatched types, etc.) either at compile time or otherwise at run time. Since concurrency is part of the language specification, the compiler may in some cases detect potential deadlocks. Compilers will also typically check for misspellings of identifiers, package visibility, redundant declarations, etc., and may provide warnings and useful tips on how to fix the error.

Ada also supports runtime checks to protect against unallocated memory access, buffer overflow errors, range violations, out of sequence errors, array access errors, and other detectable errors. These checks can be disabled in the interest of execution efficiency, but can often be assembled efficiently. It also includes tools to help verify the program. For these reasons, Ada is widely used in critical systems where any anomaly can lead to very serious consequences, such as accidental death, injury or severe financial loss. Examples of systems that use Ada include avionics, air traffic control, railroads, banking, military, and aerospace.

Ada's dynamic memory management is high level and type-safe. Ada does not have generic or untyped pointers; and don't implicitly declare any pointer type. Instead, all dynamic memory allocation and deallocation must occur through explicitly declared access types. Each access type has a corresponding storage pool, which handles the low-level details of memory management; the programmer can use either the default storage pool or define new ones (this is especially true for Non-Uniform Memory Access). You can even declare several various types accesses, which all denote the same type but use different storage pools. In addition, the language provides availability of checks, both at compile time and at run time, which ensures that access cost cannot erase the type of object it specifies.

Although the semantics of the language allow automatic garbage collection of inaccessible objects, most implementations do not support it by default, as it will lead to unpredictable behavior on real-time systems. Ada supports a limited form of scope based on memory management; Additionally, creative use of storage pools can provide a limited form of automatic garbage collection, since destroying a storage pool also destroys all objects in the pool.

story

Work continues to improve and update the technical content of the language Ada programming. A technical corrigendum to Ada 95 was published in October 2001, and the main amendment, ISO/IEC 8652:1995/Amd 1:2007 was published on March 9, 2007. At the Ada-Europe 2012 conference in Stockholm, the Ada Resource Association (ARA) and Ada -Europe announced the completion of the design latest version Ada programming language and presentation reference guide to the International Organization for Standardization (ISO) for approval. ISO/IEC 8652:2012 was published in December 2012.

Other relevant standards include ISO 8651-3:1988 Information processing systems, computer graphics, graphics core systems (GKS) language of bindings-Part 3: Ada .

Language constructs

"Hello World!" in Ada

A typical example of such a language in syntax is the Hello world program: (hello.adb)

with Ada.Text_IO ;

use Ada.Text_IO ;

procedure Hello is begin Put_Line ("Hello, world!" );

end Hello ;

This program can be compiled using the free and open source GNAT compiler by running gnatmake hello.adb Data types Ada's type system is not based on a set of predefined primitive types, but allows users to declare their own, and to check for the presence of a type definition violation at compile time and run time (i.e. range violation, buffer overflow, type consistency, etc.). Ada supports numeric types defined in range, modulo types, aggregate types (records and arrays), and enumeration types. Access types define a reference to an instance of a specified type; untyped pointers are not allowed. Special types provided in the task type language and protected types.

For example, a date could be represented as:

type Day_type is range 1 .. 31 ;

type Month_type is range 1 .. 12 ;

type Year_type is range 1800 .. 2100 ; type Hours is mod 24 ; type Weekday is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday); type Date is record Day : Day_type ;

Month: Month_type; Year: Year_type; end record ; Types can be further refined by declaring subtypes: subtype Working_Hours is Hours range 0 .. 12 ;

-- at most 12 Hours to work a day

subtype Working_Day is Weekday range Monday .. Friday ; -- Days to work Work_Load : constant array (Working_Day ) of Working_Hours -- implicit type declaration := (Friday => 6 , Monday => 4 , others => 10 );-- lookup table for working hours with initialization

A protected object consists of encapsulated personal data (which can only be accessed within the protected object), as well as procedures, functions and records that are guaranteed to be mutually exclusive (with the sole exception of functions that are required to be a side-effect free Thus, and can work simultaneously with other functions). The task of calling a protected object blocks if another task is running in this moment in the same securable object, and is released when that other task leaves the securable object. Blocked tasks are queued at the protected object of the ordered arrival time.

Protected object data is similar to procedures, but additionally has security. If the guard evaluates to false, the calling task is blocked, and added to that entry's queue; Now another task can be allowed into the securable object, since no task is currently running inside the securable object. Guards are overrated whenever a task leaves a guarded facility, as this is the only time a guard's rating can be changed.

Recording calls may be requested for other entries with the same signature. The task that is requeued is blocked and added to the target entry queue; this means that the protected object is released and allows another task to be accepted.

Select operator in Ada can be used to implement non-blocking login calls and accepts, non-deterministically selecting entries (also guarded), timeouts and aborts.

The following example illustrates some of the concepts of parallel programming in Ada.

with Ada.Text_IO ; use Ada.Text_IO ; procedure Traffic is type Airplane_ID is range 1. . 10 ; -- 10 airplanes task type Airplane (ID: Airplane_ID); -- task representing airplanes, with ID as initialization parameter type Airplane_Access is access Airplane ; -- reference type to Airplane protected type Runway is-- the shared runway (protected to allow concurrent access) entry Assign_Aircraft (ID : Airplane_ID );-- all entries are guaranteed mutually exclusive entry Cleared_Runway(ID: Airplane_ID); task type Controller (My_Runway : Runway_Access ) is -- task entries for synchronous message passing entry Request_Takeoff (ID : in Airplane_ID ; Takeoff : out Runway_Access ); entry Request_Approach (ID : in Airplane_ID ; Approach : out Runway_Access ); endController ;-- allocation of instances Runway1: aliased Runway;-- instantiate a runway Controller1: Controller (Runway1 " Access); -- and a controller to manage it------the implementations of the above types ------ protected body Runway is entry Assign_Aircraft (ID : Airplane_ID ) when Clear is -- the entry guard - calling tasks are blocked until the condition is true begin Clear := False ; Put_Line (Airplane_ID " Image (ID ) & " on runway " ); end ; entry Cleared_Runway (ID : Airplane_ID ) when not Clear is begin Clear := True ; Put_Line (Airplane_ID " Image (ID ) & " cleared runway " ); end ; entry Wait_For_Clear when Clear is begin null ;-- no need to do anything here - a task can only enter if "Clear" is true end ; end Runway ; task body Controller is begin loop My_Runway . Wait_For_Clear ;-- wait until runway is available (blocking call) select-- wait for two types of requests (whichever is runnable first) when Request_Approach " count = 0 =>-- guard statement - only accept if there are no tasks queuing on Request_Approach accept Request_Takeoff (ID : in Airplane_ID ; Takeoff : out Runway_Access ) do -- start of synchronized part My_Runway . Assign_Aircraft(ID);-- reserve runway (potentially blocking call if protected object busy or entry guard false) Takeoff := My_Runway ; delay 5.0 ; -- fly around a bit... loop select -- try to request a runway Controller1 . Request_Approach(ID, Rwy);-- this is a blocking call - will run on controller reaching accept block and return on completion exit ;-- if call returned we"re clear for landing - leave select block and proceed... or delay 3.0 ;-- timeout - if no answer in 3 seconds, do something else (everything in following block) Put_Line (Airplane_ID " Image (ID ) & " in holding pattern" ); -- simply print a message end select ; end loop ; delay 4.0 ; -- do landing approach... Put_Line (Airplane_ID " Image (ID ) & " touched down!"); Rwy. Cleared_Runway(ID); -- notify runway that we're done here. end ; New_Airplane : Airplane_Access ; begin for I in Airplane_ID " Range loop

-- create a few airplane tasks

New_Airplane := new Airplane (I );

-- will start running directly after creation delay 4.0 ; end loop ;

• end Traffic ;
• Pragmas
• A pragma is a compiler directive that passes information to the compiler to allow specific manipulation of the compiled output. Some pseudo-comments are built into the language, while others are implemented.

Examples

The history of this language does not begin in 1975, when the US Department of Defense (DoD) decided to begin developing a unified programming language for the American armed forces, and subsequently for the entire NATO. Its history begins with the name, for Ada is the name of Augusta Ada Lovelace, considered the first programmer, the daughter of the English poet Byron and a certain Anabella Milbank, with whom her husband separated forever a month after the birth of her daughter, who was born on December 10, 1815. In general, the history of cybernetics is shrouded in a dark mystery, and only from fragmentary facts can one judge that the founders of this science in the last two hundred years were various mystics and occultists, starting from Augustus de Morgan, one of Ada’s teachers, and ending with the associates of Norbert Wiener, who studied methods of forming public opinion and its manipulation.

After Charles Babbage built his mechanical computer, Ada wrote the first program for calculating Bernoulli coefficients. Subsequently, she developed a real theory of programming, introduced the concept of a cycle and several other key terms that students of cybernetic faculties study almost verbatim today! Today Ada is known to everyone as the first programmer - and that’s all, but one wonders where a young girl gets such unique abilities? She herself answered this question frankly: “I swear to the Devil that within 10 years I will suck a certain amount of life blood from the mysteries of the Universe, and in a way that ordinary mortal minds and lips could not do. No one knows what terrifying energy and strength lie still unused in my small flexible creature...". However, sponsors for the project computer was not found - there were no nuclear missiles at that time, and Ada, having lost all her fortune at the races and got into a dirty story, died at the age of 37, like her famous father.

Therefore, whether the Americans should have praised Ada so much, using her name as the name for such an ambitious project, is a highly controversial issue.

But let's return to the history of the language itself. Five years after the start of the project, hundreds of experts selected from 17 options the only language that satisfied the requirements of ML, developed by a small team led by the talented scientist Jean Ishbia. The final version of the international standard ISO 8652:1987 was published in 1987. According to official reports, all the best programming specialists in the world participated in the creation and refinement of this language, which, however, raises doubts. This, for example, is confirmed by the absence of the concept of an object in the original version of Ada and the non-participation, for obvious reasons, of Soviet programmers in this project.

Tens of billions of dollars have been invested in developing Ada's infrastructure around the world. This led to the emergence of ambitious statements such as “The 20th century will pass under the sign of Ada,” however, as usual, life put everything in its place.

Unfortunately for the US Department of Defense (and, accordingly, fortunately for America’s “potential adversaries”), the development of a clear standard for this language and the creation of effective compilers were completed precisely at the time (early 80s) when the software industry began to emerge on the horizon new language C++ with object ideology. Now it is difficult to say what the Ada development committee felt, seeing how the popularity of C++ and the old, well-forgotten, object-based thinking paradigm was growing. But the allocated funds had already been spent, the standard had been created, and there was no turning back.

The structure of Ada is very similar to Pascal, and more precisely, to Modula. The syntax of most statements and descriptions is almost identical to the syntax of Modula, although it appeared almost at the same time as Ada, and it is difficult to say who influenced whom, if at all. In Ada, in particular, quite a lot of different extensions were added, so this language cannot be called compact in comparison with Pascal. In terms of the number of possibilities, it is more likely to resemble PL/1. But since the creators of Ada placed the main emphasis on meeting the wishes of the American “first departments,” the means of data closure (visibility) and the ability to create separate blocks using only specifications (interface descriptions of modules) of other developers were the most advanced for their time. For example, the programmer who actually wrote the code to calculate the flight path of a cruise missile had no idea where and for what purposes his module would be used, although he had access to the required specifications of other employees and could debug his section of the code without any problems. Due to the strict differentiation of access to different levels of specifications, it is sometimes even impossible to determine why and by what means a given procedure will be called. However, this desire for independent program development led to a very complex system of relationships between module specifications and the appearance of some “holes” that could cause side effects, the presence of which, however, was even considered useful by the US Department of Defense.

Elements of data typing have been significantly strengthened, and the types themselves have been more formalized. All I/O functions were removed from the standard syntax, and exception handling became an integral part of the language. In addition, the power of control structures was brought to the limit, which made Ada the most advanced among other Pascal-like languages.

Borland soon released its Turbo Pascal, in which the concept of a module was built-in, and brought its version of Pascal closer in capabilities to Ada, but fortunately, no further attempts were made to create 3rd generation non-objective programming languages ​​intended for the development of very large projects. Therefore, Ada marked the end of a long line of simple procedural languages, starting with Fortran and Algol. In fact, everything that could be thought of within the framework of ideology structured programming, was embodied in Hell. Then object programming exploded and Ada faded into the background.

However, this language still occupies one niche in which it has no equal yet. In addition to separate compilation of modules and ensuring hierarchical secrecy of specifications, this language implemented such a property as support for parallel programming. Attempted more or less high level in ALGOL-68, then developed in Module-2, it was embodied in very powerful Ada tools, the so-called tasks that can be executed independently of each other on parallel computers. This led to the birth of an entire programming ideology based on tasks that could be performed “pseudo-parallel” - on a computer with a single processor. At the same time, the problem being solved was divided into a set of simultaneously working procedures that independently interacted with each other. This was a little reminiscent of the way to solve a problem in Prolog: a certain virtual world is simply described, and then it is, as it were, “launched” into operation, and the solution is found by itself.

It is all the more surprising that the US Defense Ministry, for one reason or another, abandoned the objective ideology, perfectly embodied in

60s in Simula-67, and probably regretted it more than once. True, a certain pathetic replacement for a number of possibilities provided by object-oriented programming was introduced into the Ada language - the so-called templates, that is, procedures with parameters of undefined types. But still, the main advantages of Ada, which allow it to withstand the onslaught of more developed languages ​​today, were, in addition to powerful funding, built-in support for parallel execution of tasks and powerful means of coordinating their interaction. It should be noted that Ada’s main focus is not accounting automation systems in the US Department of Defense, but purely combat missions such as, for example, real-time microprocessor navigation of a homing missile, where it is necessary to simultaneously process information continuously received from a variety of different sensors . Previously, such tasks were written in assembler, which led to many errors and maintenance difficulties. For such tasks, Ada, of course, is perfectly suited.

However, Ada continues to position itself as good remedy for the development of large software systems. True, now the voices in support of this language sound quieter, something like this: “Ada, at least, is no worse than C.” The US Department of Defense, taking into account its main mistake - the lack of facilities, in accordance with modern requirements for program development technology, has developed new standard ISO/IEC 8652:1985(E) language. It describes the Ada95 (or Ada9X) version of the language. The most interesting thing is that this version is the world's first object-oriented programming system, for which an international standard was introduced, apparently by order (with C++ this does not yet work). In addition, the language has improved the system for coordinating data visibility in module specifications and added tools to improve the efficiency of parallel tasks.

The US Department of Defense is quite jealous of its expensive brainchild and even registered the word “Ada” as its trademark. However, later, instead of the trademark, the Moscow Region decided to use “Ada” as its internal certified mark. The US Department of Defense is not particularly happy about the emergence of commercial versions of this language. Of course, no one has the right to prohibit you from writing your own compiler, but in order for it to receive commercial recognition, it must meet a military standard, and testing is carried out only by the AJPO committee of the US Department of Defense, which very strictly checks the compiler's compliance with many requirements, including, obviously, and purely political.

Nevertheless, various versions of Ada can be obtained, as is usually the case with programming languages, for free, that is, for nothing, but not in a pirated way, but simply freeware versions, and, of course, for money.

Of the freely distributed versions, it is first necessary to highlight the GNAT compiler - GNU Ada95. It is available in source code from the GNU (free software) project. It can also work on a computer with one processor, it just needs to be operating system supported multitasking. This could be, for example, some version of UNIX or OS/2. As for MS DOS - guess for yourself. However, if you really want to run a hundred or two parallel processes on your personal computer under MS DOS 6.x, then you can try Ada/Ed - a compiler and interpreter for the 1987 version of the language, which, however, is completely incompatible with the standard and does not have a number of essential elements .

If you have money, then the situation, of course, becomes easier. Within the monthly salary of an average Russian programmer, you can purchase, for example, FirstAda and write a refrigerator control system. You can try to purchase more expensive systems for Windows, OS/2 or UNIX, certified by the US Department of Defense, directly from development companies, of which there are about a dozen.

Interestingly, not only the language itself was standardized, which made it possible to create easily portable programs, but also a set of developer tools - various input-output libraries and organizations GUI, preprocessors, verifiers, code generators, logical structure analyzers source code, programs for testing compilers, etc. Of course, there are large packages that include all the standardized development tools, but they seem to be very expensive.

It would be very interesting to know whether the USSR was working on languages ​​designed to solve similar military problems. Or did our specialists write only in Assembly?