Ada

Ada is a structured, statically typed, imperative and object-oriented high-level programming language, designed from the outset for the construction of large, long-lived, and safety-critical software systems. It was created in the late 1970s on behalf of the United States Department of Defense (DoD) by an international design team led by the French computer scientist Jean Ichbiah of CII Honeywell Bull, and it was named in honor of Augusta Ada King, Countess of Lovelace (1815–1852), whose notes on Charles Babbage's Analytical Engine are widely regarded as containing the first published computer algorithm. Distinguished by exceptionally strong static typing, rigorous modularity, built-in support for concurrency and real-time programming, and—since 2012—native support for contract-based development, Ada has served for more than four decades as a principal language in aerospace, defense, air traffic control, railway signaling, and other mission- and safety-critical domains. It has been standardized by the American National Standards Institute (ANSI) and the International Organization for Standardization (ISO), with major revisions adopted in 1995, 2005 (published as a 2007 amendment), 2012, and 2022.

Background and Motivation

By the early 1970s, the United States Department of Defense was using several hundred different programming languages and dialects—among them FORTRAN, COBOL, JOVIAL, and various assembly and Algol-derived languages—for embedded computers in weapons systems, aircraft, ships, and command-and-control equipment. The proliferation of languages produced severe maintenance problems, high training costs, and poor software portability and reliability. In 1975 the DoD established the High Order Language Working Group (HOLWG), chaired by Colonel William A. Whitaker, to define requirements for a single common language suitable for embedded computer systems.

The group produced a series of successive requirement documents, informally named Strawman (1975), Woodenman (1975), Tinman (1976), Ironman (1977), and Steelman (1978). Each version refined the specification for a language intended to support modern software engineering practices, real-time control, and long-term maintainability. Existing languages were evaluated and found inadequate for these purposes, and the decision was made to design a new language, strongly influenced by the Algol and Pascal traditions.

Design Competition and Creation

In 1977 the DoD invited proposals, and in 1978 four contractor teams were selected to produce competing language designs, each identified only by a color to preserve neutrality: CII Honeywell Bull of France (green), Intermetrics of the United States (red), SofTech (blue), and SRI International (yellow). After successive evaluation phases, the green language—designed under the direction of Jean Ichbiah—was selected in 1979 as the winner.

The language was given the name "Ada" in honor of Ada Lovelace, and the first official reference manual was issued in 1980 as Military Standard MIL-STD-1815, the number deliberately chosen to commemorate her birth year of 1815. During the 1980s the DoD promoted the language aggressively: it sponsored compiler development and textbooks, and in 1987 Directive 3405.1 effectively required the use of Ada in all new DoD software, with exceptions granted only through formal waivers. The DoD also long maintained control over the "Ada" name, permitting it to be applied only to compilers that passed formal validation, a policy that was relaxed in the 1990s.

In 1996 the United States Congress removed the statutory requirement to use Ada in defense software, and by 1997 DoD policy allowed the use of commercial languages such as C++ and Java. Although this reduced the language's dominance in military procurement, Ada retained a firm position in high-integrity and safety-critical applications.

Standardization and Later Revisions

Ada became an ANSI standard in 1983 (MIL-STD-1815A) and an international standard in 1987 (ISO 8652:1987). The principal revisions since then are:

• Ada 95 (ISO/IEC 8652:1995). Designed under the leadership of S. Tucker Taft of Intermetrics, this revision introduced full object-oriented programming through tagged types and dynamic dispatching, hierarchical child libraries, protected objects for shared-data control, and improved interfacing facilities. It is often cited as the first internationally standardized object-oriented programming language. The GNU Ada compiler GNAT, originally developed at New York University, was integrated into the GNU Compiler Collection (GCC) in this era.
• Ada 2005 (formally ISO/IEC 8652:1995/Amd.1:2007). An amendment adding Java-style interfaces, improvements to access types, timing events, and a standard container library.
• Ada 2012 (ISO/IEC 8652:2012). A major revision that incorporated contract-based programming: subprogram preconditions and postconditions, type invariants, and subtype predicates, together with expression functions, quantified expressions, and other syntactic refinements.
• Ada 2022 (ISO/IEC 8652:2022). Published in 2023, this revision added lightweight parallelism (parallel blocks and parallel loops), reduction expressions, arbitrary-precision numeric libraries, and numerous smaller features.

The ISO standard is organized as a core language together with Specialized Needs Annexes addressing real-time systems, distributed systems, information systems, numerics, and safety and security, allowing the language to be tailored to particular application domains.

Language Design and Main Features

Ada's design emphasizes the early detection of errors, the clear expression of intent, and the construction of systems whose behavior is predictable and verifiable. Its principal features include:

• Strong, static typing. Every object and operation is typed at compile time; there are no implicit type conversions. Programmers may declare integer, real, enumeration, array, record, and access (pointer) types, and may attach range constraints to any scalar type so that out-of-range values are detected at run time—or proven impossible at compile time in suitable tools.
• Modularity and information hiding. Programs are organized into packages, each with a separately compilable specification and body (conventionally stored in .ads and .adb files). Private types and private parts allow implementation details to be hidden from clients.
• Generic units. Packages and subprograms may be parameterized by types and values, providing type-safe, compile-time genericity.
• Exception handling. Run-time errors and user-defined exceptional conditions are handled through a structured exception mechanism rather than ad hoc error codes; an exception that is not handled locally propagates in a well-defined manner.
• Concurrency. The language provides first-class task types with synchronous communication via entries and the rendezvous, select statements for nondeterministic waiting, and—since Ada 95—protected objects that encapsulate shared data with automatic mutual exclusion. The Ravenscar profile defines a small, deterministic subset of the tasking model for high-integrity real-time systems.
• Deterministic memory management. Ada requires no garbage collector; storage management is explicit and analyzable, an essential property for embedded and hard real-time systems.
• Low-level and hardware-related facilities. Representation clauses control the layout and alignment of data; machine addresses, interrupts, and direct interfaces to other languages (C, COBOL, Fortran) are supported, making the language suitable both for abstract system modeling and for code running directly on hardware.
• Rich numeric facilities. In addition to integer and floating-point types, Ada provides fixed-point and decimal types, valued in scientific, industrial, and financial computation.
• Contract-based programming. Since Ada 2012