What Is Ada? History, Philosophy & Where It's Used
Understand what Ada is, why the US Department of Defense commissioned it, how it evolved from Ada 83 to Ada 2022, the design principles that make it different (readability, strong typing, safety, built-in concurrency and contracts), and the industries — aviation, rail, space, defence, medical, automotive — that rely on it today.
Ada is a general-purpose, compiled, statically and strongly typed programming language designed for building large, long-lived software that must not fail. It was created in the late 1970s and early 1980s for the United States Department of Defense, named after Ada Lovelace (often called the first computer programmer), and standardized by ANSI and ISO. What sets Ada apart is not any single feature but a philosophy: the compiler should catch as many mistakes as possible before the program runs, the language should be readable by the next engineer who maintains it decades later, and anything that can still go wrong at run time should be detected immediately instead of silently corrupting data. This lesson explains where Ada came from, how it has evolved, what makes it special, and where you will find it in the real world.
Why Ada Was Created
In the 1970s the US Department of Defense was paying for software written in more than 450 different programming languages and dialects. Every weapons system, aircraft and command system had its own language, its own compilers and its own maintainers, and the cost of keeping all of it working was enormous. The DoD ran a public competition (the 'Steelman' requirements) to design one language suitable for large, reliable, embedded and real-time systems. The winning design, led by Jean Ichbiah at CII Honeywell Bull, became Ada, standardized as ANSI/MIL-STD-1815A in 1983 — 1815 being the year Ada Lovelace was born.
The requirements shaped the language directly. Programs had to be reliable (so the language catches errors early), maintainable over decades (so it favours readability over brevity), efficient on small embedded computers (so it compiles to native code with no garbage collector required), able to express concurrency (so tasks and synchronization are part of the language itself, not a library), and portable across machines (so it is a strict international standard with a validation test suite).
• Ada was commissioned by the US DoD to replace hundreds of incompatible languages. • Designed by Jean Ichbiah's team; first standard: Ada 83 (MIL-STD-1815A, ISO 8652:1987). • Named after Ada Lovelace; 1815 in the standard's number is her birth year. • Core goals: reliability, maintainability, efficiency, concurrency, portability.
The Evolution: Ada 83 → 95 → 2005 → 2012 → 2022
Ada 83 introduced packages, generics, exceptions, strong typing and tasks. Ada 95 was the first internationally standardized object-oriented language: it added tagged types (inheritance and dynamic dispatch), child packages, protected objects for efficient synchronization, and a much larger standard library. Ada 2005 added interfaces (multiple inheritance of specifications), the Ravenscar real-time profile, the container library (vectors, maps, sets) and object.method dot notation.
Ada 2012 made contract-based programming a first-class feature: preconditions, postconditions, type invariants and subtype predicates, plus expression functions, conditional and quantified expressions and iterators. Ada 2022 (the current standard, ISO/IEC 8652:2023) added declare expressions, delta aggregates, container aggregates, the 'Image attribute on any object, parallel blocks and loops, the Jorvik real-time profile and improved generic and contract support. Each revision kept almost complete backward compatibility, which is why 40-year-old Ada code still compiles today.
• Ada 83: packages, generics, exceptions, tasks, strong typing. • Ada 95: OOP (tagged types), protected objects, child packages, bigger library. • Ada 2005: interfaces, containers, Ravenscar, dot notation. • Ada 2012: contracts (Pre/Post, predicates, invariants), expression functions, quantified expressions. • Ada 2022: declare expressions, delta/container aggregates, 'Image for all objects, parallel constructs, Jorvik.
Ada's Design Philosophy
Readability over writability: Ada code uses English keywords (begin, end, loop, is, then) instead of symbols, requires the name of a subprogram to be repeated after its final end, and discourages clever one-liners. Code is read far more often than it is written, especially in systems that live for 30+ years. Strong typing: you can declare distinct types such as Meters and Feet that the compiler refuses to mix, so unit-confusion bugs (the kind that destroyed NASA's Mars Climate Orbiter) become compile errors.
Safety by default: array indices, integer overflow, null pointer dereferences, range violations and division by zero are checked at run time and raise exceptions rather than causing undefined behaviour. Specification separated from implementation: every package has a specification (the contract other code relies on) and a body (the hidden implementation). Concurrency and real time built in: tasks, rendezvous, protected objects and precise timing are part of the language. And through SPARK, a formally analyzable subset, programs can be mathematically proven free of run-time errors.
• Readable, keyword-based syntax designed for maintenance. • Strong typing prevents mixing unrelated quantities. • Run-time checks turn silent corruption into immediate, catchable exceptions. • Packages separate interface (spec) from implementation (body). • Tasks, protected objects and timing are language features. • SPARK subset enables formal proof of correctness.
Where Ada Is Used Today
Ada remains a leading choice wherever software failure could kill people or cost billions: flight control and avionics (Airbus and Boeing aircraft systems, air-traffic management), railway signalling and metro control (including many European and Paris Métro systems), space (satellites, launchers, the ISS), defence systems, medical devices, nuclear power instrumentation, and increasingly automotive and security-critical software. Many projects certify their software to standards such as DO-178C (avionics), EN 50128 (rail) or ISO 26262 (automotive), and Ada plus SPARK make that certification cheaper.
It is also a superb teaching language for software engineering: the concepts it makes explicit — types as a design tool, contracts, information hiding, safe concurrency — transfer directly to every other language you will ever use. The main open-source compiler is GNAT, part of GCC, maintained by AdaCore, with the Alire package manager providing a modern project and library ecosystem.
• Domains: avionics, air-traffic control, rail signalling, space, defence, medical, nuclear, automotive, security. • Certification standards: DO-178C, EN 50128, ISO 26262, IEC 61508. • Compiler: GNAT (GCC-based); package manager: Alire. • Great for learning disciplined software engineering.
Code Examples
The smallest useful Ada program. 'with Ada.Text_IO;' makes the text input/output package available. 'procedure L1_Hello is ... begin ... end L1_Hello;' is the main subprogram — notice the name is repeated after 'end'. Output (real, compiled with GNAT 16.1): Hello, Ada! Named after Ada Lovelace, the first programmer.
A taste of Ada's safety: Percent can only hold 0 .. 100. Adding 5 to 90 is fine; adding 10 to 95 would produce 105, so Ada raises Constraint_Error instead of storing an invalid value, and the exception handler at the end of the procedure catches it. In C this would silently store 105. GNAT is so thorough that it even predicts this at compile time, warning: 'value not in range of type "Percent"' and 'Constraint_Error will be raised at run time'. Output: Battery: 90% Battery: 95% Caught Constraint_Error: 105 is not a valid Percent
with Ada.Text_IO;
procedure L1_Hello is
begin
Ada.Text_IO.Put_Line ("Hello, Ada!");
Ada.Text_IO.Put_Line ("Named after Ada Lovelace, the first programmer.");
end L1_Hello;with Ada.Text_IO; use Ada.Text_IO;
procedure L1_Safety is
type Percent is range 0 .. 100; -- only 0 .. 100 are legal values
Battery : Percent := 90;
begin
Put_Line ("Battery:" & Percent'Image (Battery) & "%");
Battery := Battery + 5;
Put_Line ("Battery:" & Percent'Image (Battery) & "%");
Battery := Battery + 10; -- 95 + 10 = 105: out of range!
Put_Line ("This line is never reached");
exception
when Constraint_Error =>
Put_Line ("Caught Constraint_Error: 105 is not a valid Percent");
end L1_Safety;Ada at a Glance
Ada combines high-level safety and abstraction with low-level control, which is why it suits embedded, real-time and safety-critical systems.
-- Thinking Ada is obsolete because it is old -- "Nobody uses Ada anymore" -- Ada 2022 is a current ISO standard (ISO/IEC 8652:2023) -- actively used in avionics, rail, space and defence
Ada is not a legacy curiosity: it receives regular standard revisions, has an actively maintained GCC-based compiler, and runs flight software being written today.
procedure Hello is begin Put_Line ("Hi"); end Hello;
with Ada.Text_IO; use Ada.Text_IO; procedure Hello is begin Put_Line ("Hi"); end Hello;
Nothing is visible by default: to call Put_Line you must 'with' the package Ada.Text_IO (and either 'use' it or write Ada.Text_IO.Put_Line).
Who commissioned the design of Ada? A. IBM B. The US Department of Defense C. Bell Labs D. Microsoft
B. The US Department of Defense — it wanted one reliable language to replace hundreds of incompatible ones in its systems.
Which Ada revision made Ada an object-oriented language with tagged types? A. Ada 83 B. Ada 95 C. Ada 2012 D. Ada 2022
B. Ada 95 — the first ISO-standardized object-oriented language, adding tagged types, protected objects and child packages.
What happens in Ada when a value goes outside its declared range at run time? A. It silently wraps around B. Undefined behaviour C. Constraint_Error is raised D. The value is clamped
C. Constraint_Error is raised — range checks turn invalid values into immediate, catchable exceptions.
Which feature was added in Ada 2012? A. Packages B. Tasks C. Preconditions and postconditions D. Generics
C. Preconditions and postconditions — Ada 2012 made contracts part of the language.
What does this program print? (It is the example above, compiled and run with GNAT.)
Real output: Battery: 90% Battery: 95% Caught Constraint_Error: 105 is not a valid Percent The third assignment would create 105, which is outside 0 .. 100, so Constraint_Error is raised before the unreachable Put_Line and handled by the exception section.
┌─────────────────────── Ada ───────────────────────┐
Safety │ strong types · range checks · no undefined behaviour│
Structure │ packages (spec + body) · child packages · generics │
Abstraction │ private types · tagged types · interfaces │
Correctness │ Pre/Post · predicates · invariants · SPARK proofs │
Concurrency │ tasks · rendezvous · protected objects · real time │
Low level │ representation clauses · C interfacing · no GC req'd │
└────────────────────────────────────────────────────┘with Ada.Text_IO; use Ada.Text_IO;
procedure L1_Safety is
type Percent is range 0 .. 100; -- only 0 .. 100 are legal values
Battery : Percent := 90;
begin
Put_Line ("Battery:" & Percent'Image (Battery) & "%");
Battery := Battery + 5;
Put_Line ("Battery:" & Percent'Image (Battery) & "%");
Battery := Battery + 10; -- 95 + 10 = 105: out of range!
Put_Line ("This line is never reached");
exception
when Constraint_Error =>
Put_Line ("Caught Constraint_Error: 105 is not a valid Percent");
end L1_Safety;