From Wikibooks, the open-content textbooks collection

---

Contents 1 Preface 1.1 About Ada 1.1.1 Programming in the large 1.1.2 Programming in the small 1.1.3 The Language Reference Manual 1.1.4 Ada Conformity Assessment Test Suite 1.2 Programming in Ada 1.2.1 Getting Started 1.2.2 Language Features 1.2.3 Computer Programming 1.2.4 Language Summary 1.2.5 Predefined Language Libraries 1.2.6 Other Language Libraries 1.3 External resources 1.4 Collections 1.4.1 Printable Versions 1.4.2 Source Code 1.5 References 1.6 See also 1.6.1 Resources 1.6.2 Manuals and guides 1.6.3 Associations 1.6.4 Free online books/courses 1.7 Authors and contributors 2 Basic Ada 2.1 "Hello, world!" programs 2.1.1 "Hello, world!" 2.1.2 "Hello, world!" with renames 2.1.3 "Hello, world!" with use 2.1.4 FAQ: Why is "Hello, world!" so big? 2.2 Things to look out for 2.2.1 Comb Format 2.2.2 Type and subtype 2.2.3 Constrained types and unconstrained types 2.2.4 Dynamic types 2.2.5 Separation of concerns 2.3 Notes 3 Installing 3.1 AdaMagic from SofCheck 3.2 AdaMULTI from Green Hills Software 3.3 DEC Ada from HP 3.4 GNAT, the GNU Ada Compiler from AdaCore and the Free Software Foundation 3.4.1 GNAT GPL Edition 3.4.2 GNAT Modified GPL releases 3.4.2.1 GNAT 3.15p 3.4.2.2 GNAT Pro 3.4.2.3 GCC 3.4.3 The GNU Ada Project 3.4.4 GNAT for AVR microcontrollers 3.4.5 Prebuilt packages as part of larger distributions 3.4.5.1 AIDE (for Microsoft Windows) 3.4.5.2 Blastwave (for Solaris on SPARC and x86) 3.4.5.3 Cygwin (for Microsoft Windows) 3.4.5.4 Debian (GNU/Linux and GNU/kFreeBSD) 3.4.5.5 DJGPP (for MS-DOS) 3.4.5.6 FreeBSD 3.4.5.7 Gentoo GNU/Linux 3.4.5.8 GNAT for Macintosh (for Mac OS 9 and X) 3.4.5.9 Mandriva Linux 3.4.5.10 MinGW (for Microsoft Windows) 3.4.5.11 SuSE Linux 3.5 ICC from Irvine Compiler Corporation 3.6 Janus/Ada 83 and 95 from RR Software 3.7 ObjectAda from Aonix 3.8 Power Ada from OC Systems 3.9 Rational Apex from IBM Rational 3.10 SCORE from DDC-I 3.11 XD Ada from SWEP-EDS 3.12 XGC Ada from XGC Software 4 Building 4.1 Building with various compilers 4.1.1 GNAT 4.1.1.1 GNAT command line 4.1.1.2 GNAT IDE 4.1.1.3 GNAT with Xcode 4.1.2 Rational APEX 4.1.3 ObjectAda 4.1.4 DEC Ada for VMS 4.1.4.1 DEC Ada IDE 4.1.5 To be completed 4.2 Compiling our Demo Source 4.2.1 GNAT 4.2.2 Rational APEX 4.2.3 ObjectAda 4.2.3.1 ObjectAda commandline 4.3 See also 5 Control Statements 5.1 Conditionals 5.1.1 if-else 5.1.2 Optimizing hints 5.1.3 case 5.2 Unconditionals 5.2.1 return 5.2.2 goto 5.2.2.1 Isn't goto evil? 5.3 Loops 5.3.1 Endless Loop 5.3.2 Loop with Condition at the Beginning 5.3.3 loop with condition at the end 5.3.4 loop with condition in the middle 5.3.5 for loop 5.3.5.1 for loop on arrays 5.3.5.2 Working Demo 5.4 See also 5.4.1 Wikibook 5.4.2 Ada Reference Manual 6 Type System 6.1 Predefined types 6.2 The Type Hierarchy 6.2.1 Classification of Types 6.3 Concurrency Types 6.4 Limited Types 6.5 Defining new types and subtypes 6.5.1 Creating subtypes 6.5.2 Derived types 6.6 Subtype categories 6.6.1 Anonymous subtype 6.6.2 Base type 6.6.3 Constrained subtype 6.6.4 Definite subtype 6.6.5 Indefinite subtype 6.6.6 Named subtype 6.6.7 Unconstrained subtype 6.7 Qualified expressions 6.8 Type conversions 6.8.1 Explicit type conversion 6.8.2 Change of Representation 6.8.3 Checked conversion for non-numeric types 6.8.4 View conversion, in object-oriented programming 6.8.4.1 View renaming 6.8.5 Address conversion 6.8.6 Unchecked conversion 6.8.7 Overlays 6.8.8 Export / Import 6.9 Elaborated Discussion of Types for Signed Integer Types 6.10 See also 6.10.1 Wikibook 6.10.2 Ada Reference Manual 7 Integer types 7.1 Working demo 7.2 See also 7.2.1 Wikibook 7.2.2 Ada Reference Manual 8 Unsigned integer types 8.1 Description 8.2 See also 8.2.1 Wikibook 8.2.2 Ada Reference Manual 9 Enumerations 9.1 Operators and attributes 9.2 Enumeration literals 9.2.1 Characters as enumeration literals 9.2.2 Booleans as enumeration literals 9.3 Enumeration subtypes 9.4 See also 9.4.1 Wikibook 9.4.2 Ada Reference Manual 10 Floating point types 10.1 Description 10.2 See also 10.2.1 Wikibook 10.2.2 Ada Reference Manual 11 Fixed point types 11.1 Description 11.2 Ordinary Fixed Point 11.3 Decimal Fixed Point 11.4 Differences between Ordinary and Decimal Fixed Point Types 11.5 See also 11.5.1 Wikibook 11.5.2 Ada 95 Reference Manual 11.5.3 Ada 2005 Reference Manual 12 Arrays 12.1 Declaring arrays 12.1.1 Basic syntax 12.1.2 With known subrange 12.1.3 With unknown subrange 12.1.4 With aliased elements 12.1.5 Arrays with more than one dimension 12.2 Using arrays 12.2.1 Assignment 12.2.2 Concatenate 12.2.3 Array Attributes 12.2.4 Empty or Null Arrays 12.3 See also 12.3.1 Wikibook 12.3.2 Ada 95 Reference Manual 12.3.3 Ada 2005 Reference Manual 12.3.4 Ada Quality and Style Guide 13 Records 13.1 Basic record 13.2 Null record 13.3 Record Values 13.4 Discriminated record 13.5 Variant record 13.5.1 Mutable and immutable variant records 13.6 Union 13.7 Tagged record 13.8 Abstract tagged record 13.9 With aliased elements 13.10 Limited Records 13.11 See also 13.11.1 Wikibook 13.11.2 Ada Reference Manual 13.11.2.1 Ada 95 13.11.2.2 Ada 2005 13.11.2.3 Ada Issues 14 Access types 14.1 Thin and Fat Access Types 14.1.1 Thin Pointers 14.1.2 Fat Pointers 14.1.3 Example 14.2 Declaring access types 14.2.1 Pool access 14.2.2 Access all 14.2.3 Access constant 14.2.4 Anonymous access 14.2.5 Not null access 14.2.6 Constant anonymous access 14.2.7 Access to subprogram 14.2.8 Anonymous access to subprogram 14.3 Using access types 14.3.1 Creating object in a storage pool 14.3.2 Deleting object from a storage pool 14.3.3 Implicit dereferencing 14.4 Access FAQ 14.4.1 Access vs. access all 14.4.2 Access performance 14.4.3 Access vs. System.Address 14.4.4 C compatible pointer 14.4.5 Where is void*? 14.5 See also 14.5.1 Wikibook 14.5.2 Ada Reference Manual 14.5.2.1 Ada 95 14.5.2.2 Ada 2005 14.5.3 Ada Quality and Style Guide 15 Limited types 15.1 Limited Types 15.2 Initialising Limited Types 15.3 See also 15.3.1 Ada 95 Reference Manual 15.3.2 Ada 2005 Reference Manual 15.3.3 Ada Quality and Style Guide 16 Strings 16.1 Fixed-length string handling 16.2 Bounded-length string handling 16.3 Unbounded-length string handling 16.4 See also 16.4.1 Wikibook 16.4.2 Ada 95 Reference Manual 16.4.3 Ada 2005 Reference Manual 17 Subprograms 17.1 Procedures 17.2 Functions 17.3 Named parameters 17.4 Default parameters 17.5 See also 17.5.1 Wikibook 17.5.2 Ada 95 Reference Manual 17.5.3 Ada 2005 Reference Manual 17.5.4 Ada Quality and Style Guide 18 Packages 18.1 Parts of a package 18.1.1 The package specification — the visible part 18.1.2 The private part 18.1.3 The package body 18.1.4 Two Flavors of Package 18.2 Using packages 18.2.1 Standard with 18.2.2 Private with 18.2.3 Limited with 18.2.4 Making operators visible 18.3 Package organisation 18.3.1 Nested packages 18.3.2 Child packages 18.3.3 Subunits 18.4 Notes 18.5 See also 18.5.1 Wikibook 18.5.2 Wikipedia 18.5.3 Ada 95 Reference Manual 18.5.4 Ada 2005 Reference Manual 19 Input Output 19.1 Text I/O 19.2 Direct I/O 19.3 Sequential I/O 19.4 Storage I/O 19.5 Stream I/O 19.6 See also 19.6.1 Wikibook 19.6.2 Ada 95 Reference Manual 19.6.3 Ada 2005 Reference Manual 19.6.4 Ada Quality and Style Guide 20 Exceptions 20.1 Robustness 20.2 Modules, preconditions and postconditions 20.3 Predefined exceptions 20.4 Input-output exceptions 20.5 Exception declarations 20.6 Raising exceptions 20.7 Exception handling and propagation 20.8 Information about an exception occurrence 20.9 See also 20.9.1 Wikibook 20.9.2 Ada 95 Reference Manual 20.9.3 Ada 2005 Reference Manual 20.9.4 Ada Quality and Style Guide 21 Generics 21.1 Parametric polymorphism (generic units) 21.2 Generic parameters 21.2.1 Generic formal objects 21.2.2 Generic formal types 21.2.3 Generic formal subprograms 21.2.4 Generic instances of other generic packages 21.3 Instantiating generics 21.4 Advanced generics 21.4.1 Generics and nesting 21.4.2 Generics and child units 21.5 See also 21.5.1 Wikibook 21.5.2 Wikipedia 21.5.3 Ada Reference Manual 22 Tasking 22.1 Tasks 22.1.1 Rendezvous 22.1.2 Selective Wait 22.1.3 Guards 22.2 Protected types 22.3 Entry families 22.4 Termination 22.5 Timeout 22.6 Conditional entry calls 22.7 Requeue statements 22.8 Scheduling 22.9 Interfaces 22.10 See also 22.10.1 Wikibook 22.10.2 Ada Reference Manual 22.10.2.1 Ada 95 22.10.2.2 Ada 2005 22.11 Ada Quality and Style Guide 23 Object Orientation 23.1 Object-orientation on Ada 23.1.1 The package 23.1.1.1 A little note for C++ programmers 23.1.2 The tagged record 23.1.2.1 Creating Objects 23.1.2.2 The class-wide type 23.1.3 Primitive operations 23.1.3.1 The class-wide type, again 23.1.4 Abstract types 23.1.5 Interfaces 23.2 Class names 23.2.1 Classes/Class 23.2.2 Class/Object 23.2.3 Class/Class_Type 23.3 See also 23.3.1 Wikibook 23.3.2 Wikipedia 23.3.3 Ada Reference Manual 23.3.3.1 Ada 95 23.3.3.2 Ada 2005 23.3.4 Ada Quality and Style Guide 24 New in Ada 2005 24.1 Language features 24.1.1 Character set 24.1.2 Interfaces 24.1.3 Union 24.1.4 With 24.1.5 Access types 24.1.5.1 Not null access 24.1.5.2 Anonymous access 24.2 Language library 24.2.1 Containers 24.2.2 Scan Filesystem Directories and Environment Variables 24.2.3 Numerics 24.3 Real-Time and High Integrity Systems 24.3.1 Ravenscar profile 24.3.2 New scheduling policies 24.3.3 Dynamic priorities for protected objects 24.4 Summary of what's new 24.4.1 New keywords 24.4.2 New pragmas 24.4.3 New attributes 24.4.4 New packages 24.5 See also 24.5.1 Wikibook 24.5.2 Pages in the category Ada 2005 24.6 External links 24.6.1 Papers and presentations 24.6.2 Rationale 24.6.3 Language Requirements 24.6.4 Ada Reference Manual 24.6.5 Ada Issues 25 Tips 25.1 Full declaration of a type can be deferred to the unit's body 25.2 Lambda calculus through generics 25.3 Compiler Messages 25.4 I/O 25.4.1 Text_IO Issues 25.5 Quirks 25.6 See also 25.6.1 Wikibook 25.6.2 Ada Reference Manual 26 Algorithms 26.1 Introduction 26.2 Chapter 1: Introduction 26.2.1 To Lower 26.2.2 Equal Ignore Case 26.3 Chapter 6: Dynamic Programming 26.3.1 Fibonacci numbers 26.3.1.1 Simple Implementation 26.3.1.2 Cached Implementation 26.3.1.3 Memory Optimized Implementation 26.3.1.4 No 64 bit integers 27 Function overloading 27.1 Description 27.2 Demonstration 27.2.1 calling the first function 27.2.2 calling the second function 27.3 Function overloading in Ada 27.4 See also 27.4.1 Wikibook 27.4.2 Ada 95 Reference Manual 27.4.3 Ada 2005 Reference Manual 28 Mathematical calculations 28.1 Simple calculations 28.1.1 Addition 28.1.2 Subtraction 28.1.3 Multiplication 28.1.4 Division 28.2 Exponential calculations 28.2.1 Power of 28.2.2 Root 28.2.3 Logarithm 28.2.4 Demonstration 28.3 Higher math 28.3.1 Trigonometric calculations 28.3.2 Hyperbolic calculations 28.3.3 Complex arithmethic 28.3.4 Vector and Matrix Arithmetic 28.4 See also 28.4.1 Wikibook 28.4.2 Ada 95 Reference Manual 28.4.3 Ada 2005 Reference Manual 29 Statements 30 Variables 30.1 Assignment statements 30.2 Uses 30.3 See also 30.3.1 Ada Reference Manual 31 Lexical elements 31.1 Character set 31.2 Lexical elements 31.2.1 Identifiers 31.2.2 Numbers 31.2.3 Character literals 31.2.4 String literals 31.2.5 Delimiters 31.2.6 Comments 31.2.7 Reserved words 31.3 See also 31.3.1 Wikibook 31.3.2 Ada Reference Manual 32 Keywords 32.1 Language summary keywords 32.2 List of keywords 32.3 See also 32.3.1 Wikibook 32.3.2 Ada 95 Reference Manual 32.3.3 Ada 2005 Reference Manual 32.3.4 Ada Quality and Style Guide 33 Delimiters 33.1 Single character delimiters 33.2 Compound character delimiters 33.3 Others 33.4 See also 33.4.1 Wikibook 33.4.2 Ada 95 Reference Manual 33.4.3 Ada 2005 Reference Manual 34 Operators 34.1 Standard operators 34.1.1 Logical operators 34.1.2 Relational operators 34.1.3 Binary adding operators 34.1.4 Unary adding operators 34.1.5 Multiplying operator 34.1.6 Highest precedence operator 34.2 Shortcut operators 34.3 Membership tests 34.4 See also 34.4.1 Wikibook 34.4.2 Ada 95 Reference Manual 34.4.3 Ada 2005 Reference Manual 34.4.4 Ada Quality and Style Guide 35 Attributes 35.1 Language summary attributes 35.2 List of language defined attributes 35.2.1 A – B 35.2.2 C 35.2.3 D – F 35.2.4 G – L 35.2.5 M 35.2.6 O – R 35.2.7 S 35.2.8 T – V 35.2.9 W – Z 35.3 List of implementation defined attributes 35.3.1 A – D 35.3.2 E – H 35.3.3 I – N 35.3.4 O – T 35.3.5 U – Z 35.4 See also 35.4.1 Wikibook 35.4.2 Ada 95 Reference Manual 35.4.3 Ada 2005 Reference Manual 36 Pragmas 36.1 Description 36.2 List of language defined pragmas 36.2.1 A – H 36.2.2 I – O 36.2.3 P – R 36.2.4 S – Z 36.3 List of implementation defined pragmas 36.3.1 A – C 36.3.2 D – H 36.3.3 I – L 36.3.4 M – S 36.3.5 T – Z 36.4 See also 36.4.1 Wikibook 36.4.2 Ada Reference Manual 36.4.2.1 Ada 95 36.4.2.2 Ada 2005 37 Libraries 37.1 Predefined Language Libraries 37.2 Other Language Libraries 37.3 See also 37.3.1 Wikibook 37.3.2 Ada Reference Manual 38 Libraries: Standard 38.1 Implementation 38.2 Portability 38.3 See also 38.3.1 Wikibook 38.3.2 Ada Reference Manual 38.3.3 Ada Quality and Style Guide 39 Libraries: Ada 39.1 List of language defined child units 39.1.1 A – C 39.1.2 D – F 39.1.3 G – R 39.1.4 R – S 39.1.5 T – U 39.1.6 W – Z 39.2 List of implementation defined child units 39.2.1 A – K 39.2.2 L – Q 39.2.3 R – Z 39.3 See also 39.3.1 Wikibook 39.3.2 Ada Reference Manual 40 Libraries: Interfaces 40.1 Child Packages 40.2 See also 40.2.1 Wikibook 40.2.2 Ada Reference Manual 40.2.2.1 Ada 95 40.2.2.2 Ada 2005 41 Libraries: System 42 Libraries: GNAT 42.1 Child packages 42.2 See also 42.2.1 External links 42.2.2 Wikibook 43 Libraries: Multi-Purpose 43.1 See also 43.1.1 Wikibook 43.1.2 Ada Reference Manual 44 Libraries: Container 44.1 See also 44.1.1 Wikibook 44.1.2 Ada Reference Manual 45 Libraries: GUI 45.1 See also 45.1.1 Wikibook 45.1.2 Ada Reference Manual 45.1.3 External Links 46 Libraries: Distributed Systems 46.1 See also 46.1.1 Wikibook 46.1.2 Ada Reference Manual 47 Libraries: Databases 47.1 See also 47.1.1 Wikibook 47.1.2 Ada Reference Manual 48 Libraries: Web 48.1 See also 48.1.1 Wikibook 48.1.2 Ada Reference Manual 49 Libraries: Input Output 49.1 See also 49.1.1 Wikibook 49.1.2 Ada Reference Manual 50 Platform Support 50.1 See also 50.1.1 Wikibook 50.1.2 Ada Reference Manual 50.1.3 Ada Quality and Style Guide 51 Platform: Linux 51.1 See also 51.1.1 Wikibook 51.1.2 Ada Reference Manual 51.1.3 External resources 52 Platform: Windows 52.1 See also 52.1.1 Wikibook 52.1.2 Ada Reference Manual 53 Platform: Virtual Machines 53.1 See also 53.1.1 Wikibook 53.1.2 Ada Reference Manual 54 Portals 54.1 See also 54.1.1 Wikibook 54.1.2 Ada Reference Manual 54.1.3 Ada Quality and Style Guide 55 Tutorials 56 GNU Free Documentation License 56.1 0. PREAMBLE 56.2 1. APPLICABILITY AND DEFINITIONS 56.3 2. VERBATIM COPYING 56.4 3. COPYING IN QUANTITY 56.5 4. MODIFICATIONS 56.6 5. COMBINING DOCUMENTS 56.7 6. COLLECTIONS OF DOCUMENTS 56.8 7. AGGREGATION WITH INDEPENDENT WORKS 56.9 8. TRANSLATION 56.10 9. TERMINATION 56.11 10. FUTURE REVISIONS OF THIS LICENSE

Preface

Welcome to the Ada Programming tutorial at Wikibooks. This is the first Ada tutorial covering the Ada 2005 standard. If you are a beginner you will learn the latest standard - if you are a seasoned Ada user you can see what's new.

Current Development Stage for Ada Programming is " (Jul 27, 2005)". At this date, there are more than 200 pages in this book, which makes Ada Programming the largest of the programming wikibooks^[1].

But still there is always room for improvement — do help us to expand Ada Programming. Even beginners will find areas to participate.

About Ada

Wikipedia has related information at Ada programming language.

Ada is a programming language named after Augusta Ada King, Countess of Lovelace, which is suitable for all development needs.

Ada has built-in features that directly support structured, object-oriented, generic, distributed and concurrent programming.

Ada is a good choice for Rapid Application Development, Extreme Programming (XP), and Free Software development.

Programming in the large

Ada puts unique emphasis on, and provides strong support for, good software engineering practices that scale well to very large software systems (millions of lines of code, and very large development teams). The following language features are particularly relevant in this respect:

• An extremely strong, static and safe type system, which allows the programmer to construct powerful abstractions that reflect the real world, and allows the compiler to detect many logic errors before they become bugs.

• Modularity, whereby the compiler directly manages the construction of very large software systems from sources.

• Information hiding; the language separates interfaces from implementation, and provides fine-grained control over visibility.

• Readability, which helps programmers review and verify code. Ada favours the reader of the program over the writer, because a program is written once but read many times. For example, the syntax bans all ambiguous constructs, so there are no surprises, in accordance with the Tao of Programming's Law of Least Astonishment. (Some Ada programmers are reluctant to talk about source code which is often cryptic; they prefer program text which is close to English prose.)

• Portability: the language definition allows compilers to differ only in a few controlled ways, and otherwise defines the semantics of programs very precisely; as a result, Ada source text is very portable across compilers and across target hardware platforms. Most often, the program can be recompiled without any changes^[2].

• Standardisation: standards have been a goal and a prominent feature ever since the design of the language in the late 1970's. The first standard was published in 1980, just 3 years after design commenced. Ada compilers all support the exact same language; there are no dialects.

Consequences of these qualities are superior reliability, reusability and maintainability. For example, compared to programs written in C, programs written in Ada 83 contain ten times fewer bugs, and cost half as much to develop in the first place^[3]. Ada shines even more in software maintenance, which often accounts for 80% of the total cost of development. With support for object-oriented programming, Ada95 brings even more cost benefits, although no serious study comparable to Zeigler's has been published.

Programming in the small

In addition to its support for good software engineering practices, which are applicable to general-purpose programming, Ada has powerful specialised features supporting low-level programming for real-time, safety-critical and embedded systems. Such features include, among others, machine code insertions, address arithmetic, low-level access to memory, control over bitwise representation of data, bit manipulations, and a well-defined, statically provable concurrent computing model called the Ravenscar Profile.

Other features include restrictions (it is possible to restrict which language features are accepted in a program) and features that help review and certify the object code generated by the compiler.

Several vendors provide Ada compilers accompanied by minimal run-time kernels suitable for use in certified, life-critical applications. It is also possible to write Ada programs which require no run-time kernel at all.

It should come as no surprise that Ada is heavily used in the aerospace, defense, medical, railroad, and nuclear industries.

The Language Reference Manual

Wikipedia has related information at ISO 8652.

The Ada Reference Manual (RM) is the official language definition. If you have a problem, if no one else can help, and you can find it, maybe you should read the RM (albeit often a bit cryptic for non-language-lawyers). For this reason, all complete (not draft) pages in Ada Programming contain links into the appropriate pages in the RM.

This tutorial covers Ada Reference Manual — ISO/IEC 8652:1995(E) with Technical Corrigendum 1:2001 and Amendment 1:2007 — Language and Standard Libraries, colloquially known as Ada 2005 or just Ada.

You can browse the complete Reference Manual at http://www.adaic.com/standards/05rm/html/RM-TTL.html

There are two companion documents:

• The Annotated Reference Manual, an extended version of the RM aimed at compiler writers or other persons who want to know the fine details of the language.
• The Rationale for Ada 2005, an explanation of the features of the language.

The Ada Information Clearinghouse also offers the older Ada 83 and Ada 95 standards and companion documents.

The RM is a collective work under the control of Ada users. If you think you've found a problem in the RM, please report it to the Ada Conformity Assessment Authority. On this site, you can also see the list of "Ada Issues" raised by other people.

Ada Conformity Assessment Test Suite

Wikipedia has related information at ISO 18009.

Unlike other programming languages, Ada compilers are officially tested, and only those which pass this test are accepted, for military and commercial work. This means that all Ada compilers behave (almost) the same, so you do not have to learn any dialects. But because the Ada standard allows the compiler writers to include some additions, you could learn a cool new feature only to find out that your favorite compiler does not support it....

Programming in Ada

Getting Started

Where to get a compiler, how to compile the source, all answered here:

• Basic Ada — (Sep 22, 2005), Read Me First!
• Finding and Installing Ada — (Sep 22, 2005)
• Building an Ada program — (Sep 22, 2005)

Language Features

These chapters look at the broader picture. They introduce you to the Ada features in a tutorial style.

• Control Structures — (Dec 14, 2005)
• Type system — (Jan 5, 2006)
• Strings — (Jan 5, 2006)
• Subprograms — (Jan 5, 2006)
• Packages — (Jan 5, 2006)
• Input Output — (Jan 5, 2006)
• Exceptions — (Jan 5, 2006)
• Generics — (Jan 5, 2006)
• Tasking — (Jan 5, 2006)
• Object Orientation — (Jan 5, 2006)
• Memory management — (Jan 5, 2006)
• New in Ada 2005 — (Jan 5, 2006)
• Containers — (Jan 5, 2006)
• Ada Programming Tips — (Jan 5, 2006)

Computer Programming

The following articles are Ada adaptations from articles of the Computer programming book. The texts of these articles are language neutral but the examples are all Ada.

• Algorithms
  • Chapter 1
  • Chapter 6
  • Knuth-Morris-Pratt pattern matcher
  • Binary search
• Error handling
• Function overloading
• Mathematical calculations
• Statements
  • Control
• Expressions
• Variables

Language Summary

Within the following chapters we look at foundations of Ada. These chapters may be used for reference of a particular keyword, delimiter, operator and so forth.

• Lexical elements —