Introduction to Ada

This course will teach you the basics of the Ada programming language and is intended for those who already have a basic understanding of programming techniques. You will learn how to apply those techniques to programming in Ada.

This document was written by Raphaël Amiard and Gustavo A. Hoffmann, with review from Richard Kenner.

Note

The code examples in this course use a 50-column limit, which greatly improves the readability of the code on devices with a small screen size. This constraint, however, leads to an unusual coding style. For instance, instead of calling Put_Line in a single line, we have this:

Put_Line
  (" is in the northeast quadrant");

or this:

Put_Line ("  (X => "
          & Integer'Image (P.X)
          & ")");

Note that typical Ada code uses a limit of at least 79 columns. Therefore, please don't take the coding style from this course as a reference!

Download PDF Download EPUB

Contents:

• Introduction
  • History
  • Ada today
  • Philosophy
  • SPARK
• Imperative Language
  • Hello world
  • Imperative language - If/Then/Else
  • Imperative language - Loops
    • For loops
    • Bare loops
    • While loops
  • Imperative language - Case statement
  • Imperative language - Declarative regions
  • Imperative language - conditional expressions
    • If expressions
    • Case expressions
• Subprograms
  • Subprograms
    • Subprogram calls
    • Nested subprograms
    • Function calls
  • Parameter modes
  • Subprogram calls
    • In parameters
    • In out parameters
    • Out parameters
    • Forward declaration of subprograms
  • Renaming
• Modular Programming
  • Packages
  • Using a package
  • Package body
  • Child packages
    • Child of a child package
    • Multiple children
    • Visibility
  • Renaming
• Strongly Typed Language
  • What is a type?
  • Integers
    • Operational semantics
  • Unsigned types
  • Enumerations
  • Floating-point types
    • Basic properties
    • Precision of floating-point types
    • Range of floating-point types
  • Strong typing
  • Derived types
  • Subtypes
    • Subtypes as type aliases
• Records
  • Record type declaration
  • Aggregates
  • Component selection
  • Renaming
• Arrays
  • Array type declaration
  • Indexing
  • Simpler array declarations
  • Range attribute
  • Unconstrained arrays
  • Predefined array type: String
  • Restrictions
  • Returning unconstrained arrays
  • Declaring arrays (2)
  • Array slices
  • Renaming
• More About Types
  • Aggregates: A primer
  • Overloading and qualified expressions
  • Character types
• Access Types
  • Overview
  • Allocation (by type)
  • Dereferencing
  • Other features
  • Mutually recursive types
• More About Records
  • Dynamically sized record types
  • Records with discriminant
  • Variant records
• Fixed-Point Types
  • Decimal fixed-point types
  • Ordinary fixed-point types
• Privacy
  • Basic encapsulation
  • Abstract data types
  • Limited types
  • Child packages & privacy
• Generics
  • Introduction
  • Formal type declaration
  • Formal object declaration
  • Generic body definition
  • Generic instantiation
  • Generic packages
  • Formal subprograms
  • Example: I/O instances
  • Example: ADTs
  • Example: Swap
  • Example: Reversing
  • Example: Test application
• Exceptions
  • Exception declaration
  • Raising an exception
  • Handling an exception
  • Predefined exceptions
• Tasking
  • Tasks
    • Simple task
    • Simple synchronization
    • Delay
    • Synchronization: rendezvous
    • Select loop
    • Cycling tasks
  • Protected objects
    • Simple object
    • Entries
  • Task and protected types
    • Task types
    • Protected types
• Design by contracts
  • Pre- and postconditions
  • Predicates
  • Type invariants
• Interfacing With C
  • Multi-language project
  • Type convention
  • Foreign subprograms
    • Calling C subprograms in Ada
    • Calling Ada subprograms in C
  • Foreign variables
    • Using C global variables in Ada
    • Using Ada variables in C
  • Generating bindings
    • Adapting bindings
• Object Oriented Programming
  • Derived types
  • Tagged types
  • Classwide types
  • Dispatching operations
  • Dot notation
  • Private & Limited
  • Classwide access types
• Standard Library: Containers
  • Vectors
    • Instantiation
    • Initialization
    • Appending and prepending elements
    • Accessing first and last elements
    • Iterating
    • Finding and changing elements
    • Inserting elements
    • Removing elements
    • Other Operations
  • Sets
    • Initialization and iteration
    • Operations on elements
    • Other Operations
  • Indefinite maps
    • Hashed maps
    • Ordered maps
    • Complexity
• Standard Library: Dates & Times
  • Date and time handling
    • Delaying using date
  • Real-time
    • Benchmarking
• Standard Library: Strings
  • String operations
  • Limitation of fixed-length strings
  • Bounded strings
  • Unbounded strings
• Standard Library: Files & Streams
  • Text I/O
  • Sequential I/O
  • Direct I/O
  • Stream I/O
• Standard Library: Numerics
  • Elementary Functions
  • Random Number Generation
  • Complex Types
  • Vector and Matrix Manipulation
• Appendices
  • Appendix A: Generic Formal Types
    • Indefinite version
  • Appendix B: Containers