AdaCoreGNAT,[2] Green Hills Software Optimising Ada 95 compiler, PTC ApexAda and ObjectAda,[3] MapuSoft Ada-C/C++ changer,[4] formerly known as "AdaMagic with C Intermediate",[5] DDC-I Score
Ada was originally designed forembedded andreal-time systems. The Ada 95 revision, designed by S. Tucker Taft ofIntermetrics between 1992 and 1995, improved support for systems, numerical, financial, andobject-oriented programming (OOP).
Thesyntax of Ada minimizes choices of ways to perform basic operations, and prefers English keywords (such asor else andand then) to symbols (such as|| and&&). Ada uses the basic arithmetical operators+,-,*, and/, but avoids using other symbols. Code blocks are delimited by words such as 'declare', 'begin', and 'end', where the 'end' (in most cases) is followed by the keyword of the block that it closes (e.g.,if ...end if,loop ...end loop). In the case of conditional blocks this avoids adangling else that could pair with the wrong nested 'if'-expression in other languages such as C or Java.
Ada is designed for developing very large software systems. Ada packages can be compiled separately. Ada package specifications (the package interface) can also be compiled separately without the implementation to check for consistency. This makes it possible to detect problems early during the design phase, before implementation starts.
A large number ofcompile-time checks are supported to help avoid bugs that would not be detectable until run time in some other languages or would require explicit checks to be added to the source code. For example, the syntax requires explicitly named closing of blocks to prevent errors due to mismatched end tokens. The adherence to strong typing allows detecting many common software errors (wrong parameters, range violations, invalid references, mismatched types, etc.) either during compile time, or otherwise during run time. As concurrency is part of the language specification, thecompiler can in some cases detect potentialdeadlocks.[14] Compilers also commonly check for misspelledidentifiers, visibility of packages, redundant declarations, etc. and can provide warnings and useful suggestions on how to fix the error.
Ada also supportsrun-time checks to protect against access to unallocated memory,buffer overflow errors, range violations,off-by-one errors, array access errors, and other detectable bugs. These checks can be disabled in the interest of runtime efficiency, but can often be compiled efficiently. It also includes facilities to helpprogram verification. For these reasons, Ada is sometimes used in critical systems, where anyanomaly might lead to very serious consequences, e.g., accidental death, injury or severe financial loss. Examples of systems where Ada is used includeavionics,air traffic control,railways, banking, military andspace technology.[15][16]
Ada's dynamicmemory management is high-level and type-safe. Ada has no generic or untypedpointers, nor does it implicitly declare any pointer type. Instead, all dynamic memory allocation and deallocation must occur via explicitly declaredaccess types. Each access type has an associatedstorage pool that handles the low-level details of memory management; the programmer can either use the default storage pool or define new ones (this is particularly relevant fornon-uniform memory access). It is even possible to declare several different access types that all designate the same type but use different storage pools. Also, the language provides foraccessibility checks, both at compile time and at run time, that ensures that anaccess value cannot outlive the type of the object it points to.[17]
Though the semantics of the language allow automaticgarbage collection of inaccessible objects, most implementations do not support it by default, as it would cause unpredictable behaviour in real-time systems. Ada supports a limited form ofregion-based memory management, and in Ada, destroying a storage pool also destroys all the objects in the pool.
A doubledash (--), resembling anem dash, denotes comment text. Comments stop at end of line; there is intentionally no way to make a comment span multiple lines, to prevent unclosed comments from accidentally voiding whole sections of source code. Disabling a whole block of code therefore requires the prefixing of each line (or column) individually with--. While this clearly denotes disabled code by creating a column of repeated '--' down the page, it also renders the experimental dis/re-enablement of large blocks a more drawn-out process in editors without block commenting support.
The semicolon (;) is astatement terminator, and the null or no-operation statement isnull;. A single; without a statement to terminate is not allowed.
Unlike mostISO standards, the Ada language definition (known as theAda Reference Manual orARM, or sometimes theLanguage Reference Manual orLRM) isfree content. Thus, it is a common reference for Ada programmers, not only programmers implementing Ada compilers. Apart from the reference manual, there is also an extensive rationale document which explains the language design and the use of various language constructs. This document is also widely used by programmers. When the language was revised, a new rationale document was written.
One notablefree software tool that is used by many Ada programmers to aid them in writing Ada source code is the GNAT Programming Studio, andGNAT which is part of theGNU Compiler Collection.
Alire is a package and toolchain management tool for Ada.[18]
In the 1970s theUS Department of Defense (DoD) became concerned by the number of different programming languages being used for its embedded computer system projects, many of which were obsolete or hardware-dependent, and none of which supported safe modular programming. In 1975, aworking group, theHigh Order Language Working Group (HOLWG), was formed with the intent to reduce this number by finding or creating a programming language generally suitable for the department's and theUK Ministry of Defence's requirements. After many iterations beginning with an originalstraw-man proposal[19] the eventual programming language was named Ada. The total number of high-level programming languages in use for such projects fell from over 450 in 1983 to 37 by 1996.
HOLWG crafted theSteelman language requirements, a series of documents stating the requirements they felt a programming language should satisfy. Many existing languages were formally reviewed, but the team concluded in 1977 that no existing language met the specifications. The requirements were created by theUnited States Department of Defense inThe Department of Defense Common High Order Language program in 1978. The predecessors of this document were called, in order, "Strawman", "Woodenman", "Tinman" and "Ironman".[20] The requirements focused on the needs ofembedded computer applications, and emphasised reliability, maintainability, and efficiency. Notably, they includedexception handling facilities,run-time checking, andparallel computing.
It was concluded that no existing language met these criteria to a sufficient extent,[21] so a contest was called to create a language that would be closer to fulfilling them. The design that won this contest became the Ada programming language. The resulting language followed the Steelman requirements closely, though not exactly.
Watercolour painting of Ada Lovelace
Requests for proposals for a new programming language were issued and four contractors were hired to develop their proposals under the names of Red (Intermetrics led by Benjamin Brosgol), Green (Honeywell, led byJean Ichbiah), Blue (SofTech, led by John Goodenough)[22] and Yellow (SRI International, led by Jay Spitzen). In April 1978, after public scrutiny, the Red and Green proposals passed to the next phase. In May 1979, the Green proposal, designed by Jean Ichbiah at Honeywell, was chosen and given the name Ada—after Augusta Ada King, Countess of Lovelace, usually known asAda Lovelace. This proposal was influenced by the languageLIS that Ichbiah and his group had developed in the 1970s. The preliminary Ada reference manual was published in ACM SIGPLAN Notices in June 1979. The Military Standard reference manual was approved on December 10, 1980 (Ada Lovelace's birthday), and given the number MIL-STD-1815 in honor of Ada Lovelace's birth year. In 1981,Tony Hoare took advantage of hisTuring Award speech to criticize Ada for being overly complex and hence unreliable,[23] but subsequently seemed to recant in the foreword he wrote for an Ada textbook.[24]
Passing the ACVC validation tests was an arduous task for Ada compiler vendors; here the certificate awarded by the Ada Joint Program Office and an award given by vendor management to its compiler staff
Ada attracted much attention from the programming community as a whole during its early days. Its backers and others predicted that it might become a dominant language for general purpose programming and not only defense-related work.[25] Ichbiah publicly stated that within ten years, only two programming languages would remain: Ada andLisp.[26] Early Ada compilers struggled to implement the large, complex language, and both compile-time and run-time performance tended to be slow and tools primitive.[25] Compiler vendors expended most of their efforts in passing the massive, language-conformance-testing, government-requiredAda Compiler Validation Capability (ACVC) validation suite that was required in another novel feature of the Ada language effort.[26]
In 1991, the US Department of Defense began to require the use of Ada (theAda mandate) for all software,[30] though exceptions to this rule were often granted.[25] The Department of Defense Ada mandate was effectively removed in 1997, as the DoD began to embracecommercial off-the-shelf (COTS) technology.[25] Similar requirements existed in otherNATO countries: Ada was required for NATO systems involvingcommand and control and other functions, and Ada was the mandated or preferred language for defense-related applications in countries such as Sweden, Germany, and Canada.[31]
By the late 1980s and early 1990s, Ada compilers had improved in performance, but there were still barriers to fully exploiting Ada's abilities, including a tasking model that was different from what most real-time programmers were used to.[26]
Because of Ada'ssafety-critical support features, it is now used not only for military applications, but also in commercial projects where a software bug can have severe consequences, e.g.,avionics andair traffic control, commercial rockets such as theAriane 4 and 5,satellites and other space systems, railway transport and banking.[16]For example, thePrimary Flight Control System, thefly-by-wire system software in theBoeing 777, was written in Ada, as were the fly-by-wire systems for the aerodynamically unstableEurofighter Typhoon,[32]Saab Gripen,[33]Lockheed Martin F-22 Raptor and the DFCS replacement flight control system for theGrumman F-14 Tomcat. The Canadian Automated Air Traffic System was written in 1 million lines of Ada (SLOC count). It featured advanceddistributed processing, a distributed Ada database, and object-oriented design. Ada is also used in other air traffic systems, e.g., the UK's next-generation Interim Future Area Control Tools Support (iFACTS) air traffic control system is designed and implemented usingSPARK Ada.[34]It is also used in theFrenchTVM in-cab signalling system on theTGV high-speed rail system, and the metro suburban trains in Paris, London, Hong Kong and New York City.[16][35]
The Ada 95 revision of the language went beyond the Steelman requirements, targeting general-purpose systems in addition to embedded ones, and adding features supportingobject-oriented programming.[36]
Preliminary Ada can be found in ACM Sigplan Notices Vol 14, No 6, June 1979[37]
Ada was first published in 1980 as anANSI standard ANSI/MIL-STD 1815. As this very first version held many errors and inconsistencies,[a] the revised edition was published in 1983 as ANSI/MIL-STD 1815A. Without any further changes, it became an ISO standard in 1987.[39] This version of the language is commonly known asAda 83, from the date of its adoption by ANSI, but is sometimes referred to also asAda 87, from the date of its adoption by ISO.[40] There is also a French translation; DIN translated it into German as DIN 66268 in 1988.
Ada 95, the joint ISO/IEC/ANSI standard ISO/IEC 8652:1995[41][42] was published in February 1995, making it the first ISO standard object-oriented programming language. To help with the standard revision and future acceptance, theUS Air Force funded the development of theGNATCompiler. Presently, the GNAT Compiler is part of theGNU Compiler Collection.
Work has continued on improving and updating the technical content of the Ada language. A Technical Corrigendum to Ada 95 was published in October 2001,[43][44] and a major Amendment, ISO/IEC 8652:1995/Amd 1:2007[45][46] was published on March 9, 2007, commonly known asAda 2005 because work on the new standard was finished that year.
The Ada-basedSPARK technology has been made possible by the enabling characteristics of the Ada language, including its separation of specification and implementation via packages, its support for user-defined scalar types, and its support for composite type usage without resorting to pointers. The Ada 2012 revision was especially important for SPARK, as its support forcontracts as a part of the language permitted SPARK to be redesigned from the beginning towards fulfilling its goal of co-developing programs alongside their proofs of correctness.[49]
On May 2, 2023, the Ada community saw the formal approval of publication of theAda 2022 edition of the programming language standard.[11]
Despite the names Ada 83, 95 etc., legally there is only one Ada standard, the last ISO/IEC standard: with the acceptance of a new standard version, the previous one becomes withdrawn. The other names are informal ones referencing a certain edition.
Other related standards includeISO/IEC 8651-3:1988Information processing systems—Computer graphics—Graphical Kernel System (GKS) language bindings—Part 3: Ada.
Ada is anALGOL-like programming language featuring control structures with reserved words such asif,then,else,while,for, and so on. However, Ada also has many data structuring facilities and other abstractions which were not included in the originalALGOL 60, such astype definitions,records,pointers, andenumerations. Such constructs were in part inherited from or inspired byPascal.
Ada's type system is not based on a set of predefinedprimitive types but allows users to declare their own types. This declaration in turn is not based on the internal representation of the type but on describing the goal which should be achieved. This allows the compiler to determine a suitable memory size for the type, and to check for violations of the type definition at compile time and run time (i.e., range violations, buffer overruns, type consistency, etc.). Ada supports numerical types defined by a 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 permitted.Special types provided by the language are task types and protected types.
subtypeWorking_HoursisHoursrange0..12;-- at most 12 Hours to work a daysubtypeWorking_DayisWeekdayrangeMonday..Friday;-- Days to workWork_Load:constantarray(Working_Day)ofWorking_Hours-- implicit type declaration:=(Friday=>6,Monday=>4,others=>10);-- lookup table for working hours with initialization
Types can have modifiers such aslimited, abstract, private etc. Private types do not show their inner structure; objects of limited types cannot be copied.[50] Ada 95 adds further features for object-oriented extension of types.
Ada is astructured programming language, meaning that the flow of control is structured into standard statements. All standard constructs and deep-level early exit are supported, so the use of the also supported "go to" commands is seldom needed.
-- while a is not equal to b, loop.whilea/=bloopAda.Text_IO.Put_Line("Waiting");endloop;ifa>bthenAda.Text_IO.Put_Line("Condition met");elseAda.Text_IO.Put_Line("Condition not met");endif;foriin1..10loopAda.Text_IO.Put("Iteration: ");Ada.Text_IO.Put(i);Ada.Text_IO.Put_Line;endloop;loopa:=a+1;exitwhena=10;endloop;caseiiswhen0=>Ada.Text_IO.Put("zero");when1=>Ada.Text_IO.Put("one");when2=>Ada.Text_IO.Put("two");-- case statements have to cover all possible cases:whenothers=>Ada.Text_IO.Put("none of the above");endcase;foraWeekdayinWeekday'Rangeloop-- loop over an enumerationPut_Line(Weekday'Image(aWeekday));-- output string representation of an enumerationifaWeekdayinWorking_Daythen-- check of a subtype of an enumerationPut_Line(" to work for "&Working_Hours'Image(Work_Load(aWeekday)));-- access into a lookup tableendif;endloop;
Among the parts of an Ada program are packages, procedures and functions.
Functions differ from procedures in that they must return a value. Function calls cannot be used "as a statement", and their result must be assigned to a variable. However, since Ada 2012, functions are not required to be pure and may mutate their suitably declared parameters or the global state.[51]
withAda.Text_IO;packagebodyExampleisi:Number:=Number'First;procedurePrint_and_Increment(j:inoutNumber)isfunctionNext(k:inNumber)returnNumberisbeginreturnk+1;endNext;beginAda.Text_IO.Put_Line("The total is: "&Number'Image(j));j:=Next(j);endPrint_and_Increment;-- package initialization executed when the package is elaboratedbeginwhilei<Number'LastloopPrint_and_Increment(i);endloop;endExample;
This program can be compiled, e.g., by using the freely available open-source compilerGNAT, by executing
gnatmake-zexample.adb
Packages, procedures and functions can nest to any depth, and each can also be the logical outermost block.
Each package, procedure or function can have its own declarations of constants, types, variables, and other procedures, functions and packages, which can be declared in any order.
A pragma is acompiler directive that conveys information to the compiler to allow specific manipulating of compiled output.[52] Certain pragmas are built into the language,[53] while others are implementation-specific.
Examples of common usage of compiler pragmas would be to disable certain features, such as run-time type checking or array subscript boundary checking, or to instruct the compiler to insert object code instead of a function call (as C/C++ does withinline functions).
Ada has had generics since it was first designed in 1977–1980. Thestandard library uses generics to provide many services. Ada 2005 adds a comprehensive generic container library to the standard library, which was inspired by C++'sStandard Template Library.[54][55]
Ageneric unit is a package or a subprogram that takes one or moregeneric formal parameters.[56]
Ageneric formal parameter is a value, a variable, a constant, a type, a subprogram, or even an instance of another, designated, generic unit. For generic formal types, the syntax distinguishes between discrete, floating-point, fixed-point, access (pointer) types, etc. Some formal parameters can have default values.[57]
Toinstantiate a generic unit, the programmer passesactual parameters for each formal. The generic instance then behaves just like any other unit. It is possible to instantiate generic units atrun-time, for example inside a loop.[57]
^Fuegi, J; Francis, J (2003). "Lovelace & Babbage and the creation of the 1843 'notes'".IEEE Annals of the History of Computing.25 (4):16–26.doi:10.1109/MAHC.2003.1253887.S2CID40077111.
^Dewar, Robert B. K.; Fisher, Gerald A. Jr.; Schonberg, Edmond; Froelich, Robert; Bryant, Stephen; Goss, Clinton F.; Burke, Michael (November 1980). "The NYU Ada translator and interpreter".Proceeding of the ACM-SIGPLAN symposium on Ada programming language – SIGPLAN '80. Vol. 15. pp. 194–201.doi:10.1145/948632.948659.ISBN0-89791-030-3.S2CID10586359.
^ab"Ada Validated Compilers List". Ada Information Clearinghouse. July 1, 1992. pp. 1–36.
^Chapman, Roderick; Dross, Claire; Matthews, Stuart; Moy, Yannick (March 2024). "Co-Developing Programs and Their Proof of Correctness".Communications of the ACM.67 (3):84–94.doi:10.1145/3624728.
Dale, Nell B.; Weems, Chip; McCormick, John (August 1996).Programming and Problem Solving with Ada 95. Jones & Bartlett Publishers.ISBN0-7637-0293-5.
Dale, Nell B.; McCormick, John (2007).Ada Plus Data Structures: An Object-Oriented Approach, 2nd edition. Jones & Bartlett Publishers.ISBN978-0-7637-3794-8.
Krell, Bruce C. (1992).Developing With Ada: Life-Cycle Methods. Bantam Dell Pub Group.ISBN0-553-09102-6.
Bishop, Judy (10 May 1990).Distributed Ada: Developments and Experiences. Cambridge University Press.ISBN0-521-39251-9.
Sanden, Bo (1994).Software Systems Construction With Examples in Ada. Prentice Hall.ISBN0-13-030834-X.
Hillam, Bruce (1994).Introduction to Abstract Data Types Using Ada. Prentice Hall.ISBN0-13-045949-6.
Rudd, David (1994).Introduction to Software Design and Development With Ada. Brooks Cole.ISBN0-314-02829-3.
Pyle, Ian C. (1991).Developing Safety Systems: A Guide Using Ada. Prentice Hall.ISBN0-13-204298-3.
Baker, Louis (1989).Artificial Intelligence With Ada. McGraw-Hill.ISBN0-07-003350-1.
Savitch, Walter; Peterson, Charles (1992).Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings Publishing Company.ISBN0-8053-7070-6.
Weiss, Mark Allen (1993).Data Structures and Algorithm Analysis in Ada. Benjamin-Cummings Publishing Company.ISBN0-8053-9055-3.
Ledgard, Henry (1983).Ada: An Introduction (second ed.). Springer-Verlag.ISBN0-387-90814-5.
Bjørner, Dines; Oest, Ole N., eds. (1980).Towards a Formal Description of Ada. London: Springer-Verlag.ISBN3-540-10283-3.
.jpg)
