Introduction to Ada ­ slides suitable for a 40­minute presentation
Copyright (C) 2004 Ludovic Brenta <ludovic.brenta@insalien.org>
This presentation is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This presentation is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111­1307
USA
I originally wrote these slides for a 40­minute \"introduction to Ada\"
that I gave at the Libre Software Meeting in Bordeaux in 2004. I made
sure these slides were suitable for reuse.
Their purpose is not to teach Ada; this is impossible to do in just 40
minutes. Instead, they try to give an overview of the main features
of Ada and provide pointers to further information.

Prologue: Lady Ada Lovelace
Ada Augusta Byron, countess of
Lovelace (1815­1852)
Poet Lord Byron's daughter
A Mathematician
Worked with Charles Babbage on the
Difference Engine
First “computer scientist” in history
Invented the first program, and
programming language, for Babbage's
Difference Engine

Historique
Lisp (1958) was created by and for MIT professors
C (1973) was created by and for kernel hackers
Ada was created by and for industrial engineers
1980 : first military standard, MIL­STD­1815
All compilers must be validated against the standard
●
No dialects allowed
●
1983 : first civil US standard (ANSI)
1987 : first international standard, ISO 8652
1995 : Ada 95 is the first standard object­oriented language
2005 : Ada 2005 is in the works
Increased traffic on comp.lang.ada et al since 1995

Who uses Ada in 2004?
Space and aeronautics
Eurofighter: 2 million lines of Ada
code
Boeing (in progress: 7E7)
Airbus (in progress: A380,
A400M)
Ariane
Satellites
Eurocontrol (air traffic control)
Their subcontractors: Barco
Avionics, Thales, BAe Systems,
Smiths Aerospace, Raytheon, etc.

Qui utilise Ada en 2004?
Rail transport industry
French high­speed train (TGV)
Metro lines in New York, Paris (line 14), Delhi, Calcutta, etc.
Nuclear industry
Electricité de France (EDF): emergency reactor shutdown
Other
Financial: BNP (France), Paranor (Switzerland), PostFinance
Healthcare and medical : JEOL (USA), ReadySoft (France)
Automotive : BMW (Allemagne)
Communications : Canal+ (France)
And lots of free software!

Why Ada?
In industry
When human life is at stake
When software just has to work (no excuses accepted)
When you want to know why your software works (certification)
Free software
To develop twice as fast as in C
To produce 90% fewer bugs than in C
To be close to the application domain, and protected against machine
details (high­level programming)
For software to be portable
For software to be maintainable

Philosophy (1)
Cost of software development
Design
Implementation
Debugging
Hence the bright idea: bugs are the problem

Philosophy (2)
Effort required to correct a bug
1000
900
800
700
600
500
400
300
200
100
0
Implementati Compilation Testing After delivery
on
Hence the bright idea: find bugs as early as possible!

Obvious? Not at all!

Goals of the language
Reduce development and maintenance costs
Prevent writing bugs if possible
Detect bugs as early as possible, preferably during compilation
Encourage code reuse and team work
Packages with separate interface and implementation
●
Generics (a.k.a. templates)
●
Make maintenance easier
Legibility is paramount; language is “auto­documented”
●
Work well in all situations
In the small: embedded, limited resources, real time, no operating
system
In the large: millions of lines of code, networking, GUIs, etc.

The type system
Ada is powerfully and statically typed
Detects most bugs at compile time, before ever testing the program!
The main strength of the language
Programmers can define new types
To reflect the application domain
Number_Of_Apples, Number_Of_Oranges; not just Integer
●
To document the constraints of the problem
To not compare apples to oranges
●
The compiler enforces all constraints
●

Scalar types
package Apples_And_Oranges is
type Number_Of_Apples is range 1 .. 20; ­­ integer
type Number_Of_Oranges is range 1 .. 40; ­­ integer
type Mass is digits 4 range 0.0 .. 4000.0; ­­ real
type Colour is (Red, Green, Blue); ­­ enumeration
end Apples_And_Oranges;
Scalar types have attributes:
T'First, T'Last : constants
T'Range = T'First .. T'Last (range of permitted values)
T'Pred(X), T'Succ (X) : functions that return the previous or next
value
T'Image (X) : a string representation of X
etc.

Arrays
package Arrays is
type Colour is (Red, Green, Blue);
type Value is range 0 .. 255;
type Point is array (Colour) of Value;
­­ The index is an enumerated type
type Width is range 0 .. 640;
type Height is range 0 .. 480;
type Screen is array (Width, Height) of Point;
­­ The indexes are ranges
end Arrays;
with Arrays;
procedure Arrays_Trial is
My_Screen : Arrays.Screen;
begin
My_Screen (4, 5) := (Arrays.Red => 42,
Arrays.Green => 0,
Arrays.Blue => 35);
end Arrays_Trial;

Arrays have attributes
For any array A:
A'Range is the range of the index
A1 : array (4 .. 8) of Integer;
●
A1'Range = 4 .. 8;
●
A2 : array (Colour) of Integer;
●
A2'Range = Red .. Blue;
●
A'Range (N) is the range of the Nth dimension
A'Length and A'Length (N) yield the number of elements
etc.

Records
with Ada.Calendar;
package Records is
type Gender is (Male, Female);
type Person (Sex : Gender) is record
First_Name, Last_Name : String (1 .. 100);
case Sex is
when Male => null;
when Frmale =>
Maiden_Name : String (1 .. 100);
end case;
end record;
end Records;
The record above has an optional discriminant

Pointers (access types)
Access types are incompatible with one another
Impossible to mix up different pointers (safety)
The compiler guarantees absence of dangling pointers
Pointers are used only when necessary
Dynamic data structures
OO programming and dynamic binding
with Records; use Records;
procedure Pointers is
type Pointer_To_Element;
type List_Element is record
P : Person;
Next : Pointer_To_Element;
end record;
type Pointer_To_Element is access List_Element;
List_Head : Pointer_To_Element := new List_Element;
begin
List_Head.Next := new List_Element;
end Pointers;

Object­oriented programming
with Ada.Calendar;
package Objects is
type Gender is (Male, Female);
type Person (Sex : Gender) is tagged record
First_Name, Last_Name : String (1 .. 100);
case Sex is
when Male => null;
when Female =>
Maiden_Name : String (1 .. 100);
end case;
end record;
type Diploma is record
Received : Ada.Calendar.Time;
Institution : String (1 .. 100);
Title : String (1 .. 200);
end record;
type Set_Of_Diplomas is array (Positive range <>) of Diplome;
type Educated_Person (Sex : Gender; Number_Of_Diplomas : Positive) is
new Person (Sex) with record
Diplomas : Set_Of_Diplomes (1 .. Nombre_Of_Diplomas);
end record;
end Objects;

Conclusion about types
Ada allows construction of very complex types
Types describe the “universe”: this is called modelling
High level of abstraction
Explicit constraints
Auto­documentation
Types and objects have attributes
Array dimensions are always known
Useful for loops and branches (if, case)
Pointers are much safer than in C or C++
The compiler enforces and checks all constraints
Statically whenever possible
At run time whenever necessary (using exceptions)

Subprograms
Procedures and functions as in Pascal, except:
Parameters are “in”, “out” et “in out”
The programmer says what he wants to do, not how to do it
The compiler chooses between by­reference and by­value
Possible to pass large objects (arrays, records) without explit pointers
Overloaded operators
Default parameter values like in C++
Functions
Also overloaded by their return value
Return value cannot be ignored (no ambiguity = safety)
All parameters are “in”

Subprograms : example
package Subprograms is
function A return Boolean;
function A return Integer;
procedure A;
type Private_Type is private; ­­ an abstract data type
Null_Object : constant Private_Type;
function \"+\" (Left, Right : in Private_Type) return Private_Type; ­­ operator
procedure A (T1 : in Private_Type := Null_Object; ­­ default parameter value
T2 : in out Private_Type);
procedure A (T : out Private_Type); ­­ constructor
private
type Private_Type is record
Value : Integer;
end record;
Null_Object : constant Private_Type := (Value => 0);
end Subprograms;

Subprograms in OOP
A method is a subprogram that:
accepts one or more parameters of a tagged type T, or access to T
is declared in the same package as T
procedure Foo (Object : in T); ­­ method of type T
No particular syntax; “this” parameter is explicit
Selection of methods (binding) may be:
static: decided at compile time
dynamic: decided at run time (as with C++ virtual methods)
For each tagged type T, there is a type T'Class that
encompasses T and its descendants
procedure Foo (Object : in T'Class); ­­ not a method
allows forcing static binding
Like “static methods” in C++

Calling subprograms
with Subprograms;
procedure Use_Subprograms is
Object1, Object2 : Subprograms.Private_Type;
B : Boolean := Subprograms.A;
I : Integer := Subprograms.A;
use Subprograms;
begin
A (Object1); ­­ constructor
Object2 := Object1 + Null_Object; ­­ operator \"+\"
A (T1 => Object1, T2 => Object2);
end Use_Subprograms;

Control structures
­­ Loops
­­ Branches
procedure Control_Structures is
separate (Control_Structures)
type Colour is (Red, Green, Blue);
function Foo (I : in Natural) return Colour is
I : Natural := 0;
Result : Colour;
begin
function Foo (I : in Natural)
if I in 1 .. 10 then
return Colour
Result := Red;
is separate;
elsif I in 11 .. 20 then
Result := Green;
Col : Colour := Foo (I);
elsif I in 21 .. 30 then
begin
Result := Blue;
for C in Colour loop
end if;
I := I + 1;
end loop;
case I is
when 1 .. 10 => Result := Red;
while I > 1 loop
when 11 .. 20 => Result := Green;
I := I ­ 1;
when 21 .. 30 => Result := Blue;
end loop;
when others => Result := Red;
­­ all cases must be processed
Named_Loop : loop
end case;
I := I + 1;
return Result;
exit Named_Loop when I = 1000;
end Foo;
I := I + 2;
end loop Named_Loop;
end Control_Structures;

Exceptions
with Ada.Text_IO; use Ada.Text_IO;
procedure Exceptions_Example (I : in Natural) is
Error : exception;
type Colour is (Red, Green, Blue);
Result : Colour;
begin
case I is
when 1 .. 10 => Result := Red;
when 11 .. 20 => Result := Green;
when 21 .. 30 => Result := Blue;
when others => raise Error;
end case;
exception
when Error =>
Put_Line (“Error : I does not represent a colour”);
end Exceptions_Example;

Générics (1)
More powerful than C++'s templates
A generic can be a procedure, a function or a package
Generic parameters can be
types
variables
procedures
functions
packages
Generics can impose constraints on accepted parameters

Générics (2)
generic
type Item_Type is private; ­­ Item_Type may be any nonlimited type
package JE.Stacks is
type Stack_Type is limited private;
procedure Push (Stack : in out Stack_Type;
Item : in Item_Type);
procedure Pop (Stack : in out Stack_Type;
Item : out Item_Type);
function Top (Stack : Stack_Type) return Item_Type;
function Size (Stack : Stack_Type) return Natural;
function Empty (Stack : Stack_Type) return Boolean;
Stack_Overflow, Stack_Underflow : exception;
private
­­ to be dealt with later
end JE.Stacks;

Tasking (1)
Part of the language; not in a library
Keywords task, protected, accept, entry, abort, etc.
with Ada.Text_IO; use Ada.Text_IO;
procedure Tasking_Example (Nombre_De_Taches : in Natural) is
task type Background_Task;
task body Background_Task is
begin
delay 1.0; ­­ 1 second
Put_Line (“I am in a background task”);
end Background_Task;
type Task_Index is range 1 .. 10;
The_Tasks : array (Task_Index) of Background_Task;
begin
Put_Line (“The main task is starting”);
Put_Line (“The main task is waiting for all background tasks to complete”);
end Tasking_Example;

Tasking (2) : protected objects
functions are reentrant: concurrent calls allowed
procedures and entries are not reentrant: a single call at a time
Entries have guards allowing to synchronise calls
protected type Shared_Stack_Type is
procedure Push (Item : in Integer);
entry Pop (Item : out Integer);
function Top return Integer;
function Size return Natural;
function Empty return Boolean;
private
package Int_Stacks is new JE.Stacks (Integer);
Stack : Int_Stacks.Stack_Type;
end Shared_Stack_Type;

Tasking (3): guards
protected body Shared_Stack_Type is
procedure Push (Item : in Integer) is
begin
Int_Stacks.Push (Stack,Item);
end Push;
entry Pop (Item : out Integer)
when not Int_Stacks.Empty (Stack) is
begin
Int_Stacks.Pop (Stack,Item);
end Pop;
function Top return Integer is
begin
return Int_Stacks.Top (Stack);
end Top;
function Size return Natural is
begin
return Int_Stacks.Size (Stack);
end Size;
function Empty return Boolean is
begin
return Int_Stacks.Empty (Stack);
end Empty;
end Shared_Stack_Type;

Other features
Representation clauses
Allow safe, low­level programming
Separate compilation is part of the language
The compiler guarantees consistency of the final executable
No need for a Makefile
Tasks can rendez­vous with each other
Standard interfaces with C, COBOL, FORTRAN
Allows using any C library out there (e.g. GTK+)
Controlled objects (Initialize, Adjust, Finalize)
ASIS (Ada Semantic Interface Specification)
high level API to the compiler
a program can inspect an Ada program parsed by the compiler
an ISO standard

Even more functionality
Specialised needs annexes in Ada 95
All of them are implemented by GNAT
Annex C : Systems programming (interrupts, machine code)
Annex D : Real­time systems
Annex E : Distributed systems (remote subprogram call)
Annex F : Information system (decimal number representations)
Annex G : Numerics (complex numbers, bounded performance)
Annex H : Safety and Security (aids to certification)

More information?
Web sites :
Ada Information Clearinghouse : http://www.adaic.com
ACT Europe Libre Software : http://libre.act­europe.fr
Ada France : http://www.ada­france.org
News groups
comp.lang.ada, fr.comp.lang.ada
Many free books and tutorials are on line
In English and other languages, including French
Thanks to John English for the tasking examples
Ada 95, The Craft of Object­Oriented Programming
http://www.it.bton.ac.uk/staff/je/adacraft