Introduction to Ada
Upcoming SlideShare
Loading in...5
×
 

Introduction to Ada

on

  • 4,678 views

Presentation under the GPL license by Ludovic Brenta: "I originally wrote these slides for a 40-minute "introduction to Ada" ...

Presentation under the GPL license by Ludovic Brenta: "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."

Statistics

Views

Total Views
4,678
Views on SlideShare
4,672
Embed Views
6

Actions

Likes
2
Downloads
66
Comments
0

1 Embed 6

http://www.slideshare.net 6

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Introduction to Ada Introduction to Ada Presentation Transcript

    • 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 quot;introduction to Adaquot; 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 quot;+quot; (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 quot;+quot;    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