Beginner's Guide to Ada

February 8, 2025 · 17 min read

Introduction to Ada #

Why Learn Ada? #

Ada is a powerful and expressive programming language prized for its reliability and safety. Unlike many languages that prioritize rapid development above all else, Ada emphasizes building robust and maintainable software, making it ideal for mission-critical applications where failures are unacceptable. Learning Ada equips you with skills highly valued in domains requiring high dependability, such as aerospace, defense, finance, and medical systems. Its strong typing system and compile-time checks help prevent common errors early in the development process, leading to fewer bugs and lower maintenance costs over the lifetime of a project. Ada’s features promote modularity and code reusability, which simplifies development and makes large projects more manageable. Although it might have a steeper learning curve than some more dynamically typed languages, the benefits in terms of software quality and long-term maintainability are significant.

Ada’s History and Applications #

Ada’s origins trace back to the 1970s, when the United States Department of Defense sought a single, modern programming language to replace the plethora of languages then in use. The resulting language, named after Ada Lovelace, was designed to be highly reliable and adaptable to various application domains. Its initial standardization (Ada 83) was followed by subsequent revisions (Ada 95, Ada 2005, Ada 2012, and Ada 2022), each incorporating advancements in programming language design and addressing evolving needs.

Ada’s strength lies in its applicability to safety- and security-critical systems. It’s found in numerous high-stakes environments:

Aerospace: Flight control systems, satellite navigation, and air traffic control.
Defense: Weapon systems, command and control systems, and simulation software.
Finance: High-frequency trading systems, banking applications, and risk management software.
Medical: Medical devices, patient monitoring systems, and hospital information systems.
Railways: Train control systems and signaling systems.

Beyond these critical domains, Ada’s features also make it suitable for general-purpose programming, though it is less prevalent in areas where rapid prototyping and quick iterations are prioritized over rigorous code correctness.

Setting up your Ada Development Environment #

Setting up your Ada development environment involves choosing a compiler, an editor or IDE (Integrated Development Environment), and potentially some supporting tools. The exact steps vary depending on your operating system (Windows, macOS, Linux), but the general process remains consistent:

Choose a Compiler: Select an Ada compiler suitable for your platform (see the next section for recommendations). Download and install the compiler according to the manufacturer’s instructions.
Select an Editor or IDE: You can use a simple text editor like Notepad++ (Windows), TextMate (macOS), or gedit (Linux) for basic editing. However, a dedicated IDE provides more advanced features like syntax highlighting, code completion, debugging, and project management. Popular choices include GPS (GNAT Programming Studio), which comes bundled with the GNAT compiler, and other specialized IDEs that support Ada.
Configure the Environment: You may need to set environment variables (e.g., PATH) to ensure your compiler and other tools are accessible from the command line or your IDE. The compiler documentation will usually provide detailed instructions on this step.
Test your Installation: Compile and run a simple “Hello, world!” program to verify that your compiler and development environment are correctly configured.

Choosing an Ada Compiler #

Several Ada compilers are available, both commercial and open-source. A popular and widely used choice is the GNAT compiler, part of the GNU Compiler Collection (GCC). GNAT is free and open-source, offering excellent support across various platforms. It often comes bundled with GPS (GNAT Programming Studio), a full-featured IDE.

Other compilers exist, some providing specialized features or targeting specific platforms. When choosing a compiler, consider factors such as:

Platform compatibility: Ensure the compiler supports your operating system.
Licensing: Determine whether the compiler is free/open-source or commercial.
Features: Consider whether any specialized features (e.g., specific Ada language extensions or integration with debugging tools) are important for your needs.
Community support: A compiler with a large and active community offers better support and troubleshooting resources.

It’s recommended to start with GNAT due to its widespread availability, robust features, and active community. The GNAT community provides ample resources and documentation to help beginners get started.

Basic Syntax and Structure #

Hello, World! Program #

The quintessential first program in any language demonstrates the basic syntax. Here’s the Ada equivalent:

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello is
begin
   Put_Line("Hello, World!");
end Hello;

Let’s break this down:

with Ada.Text_IO; use Ada.Text_IO;: These lines import the necessary library for input and output operations. with declares the dependency, and use makes the library’s functions directly accessible.
procedure Hello is: This declares a procedure named “Hello,” which is the main program unit. The is keyword separates the declaration from the implementation.
begin ... end Hello;: This block contains the executable part of the program. The begin keyword marks the start, and end Hello; marks the end, referencing the procedure’s name.
Put_Line("Hello, World!");: This statement prints “Hello, World!” to the console and adds a newline character.

To compile and run this, save it as hello.ada (or a similar name with the .ada extension) and use your Ada compiler (e.g., gnatmake hello.ada).

Data Types (Integers, Floats, Booleans, Characters) #

Ada is a strongly-typed language, meaning you must explicitly declare the type of each variable. Some fundamental types include:

Integer: Represents whole numbers. Examples include Integer, Short_Integer, Long_Integer, etc., offering different ranges.
Float: Represents real numbers with decimal points. Examples include Float, Long_Float.
Boolean: Represents truth values, either True or False.
Character: Represents a single character, enclosed in single quotes (e.g., 'A', '%', ' ').

with Ada.Text_IO; use Ada.Text_IO;

procedure Data_Types is
   My_Integer : Integer := 10;
   My_Float   : Float   := 3.14159;
   My_Boolean : Boolean := True;
   My_Char    : Character := 'X';
begin
   Put_Line("Integer: " & Integer'Image(My_Integer));
   Put_Line("Float: " & Float'Image(My_Float));
   Put_Line("Boolean: " & Boolean'Image(My_Boolean));
   Put_Line("Character: " & My_Char);
end Data_Types;

Note the use of Integer'Image, Float'Image, and Boolean'Image to convert the values to strings for output.

Variables and Constants #

Variables hold values that can change during program execution, while constants hold values that remain fixed. Declarations use the := operator for initialization.

with Ada.Text_IO; use Ada.Text_IO;

procedure Variables_Constants is
   Variable_Number : Integer := 5;
   Constant_Number : constant Integer := 10;
begin
   Variable_Number := Variable_Number + 2; -- Modifying a variable
   Put_Line("Variable: " & Integer'Image(Variable_Number));
   -- Constant_Number := Constant_Number + 5; -- This would cause a compile-time error
   Put_Line("Constant: " & Integer'Image(Constant_Number));
end Variables_Constants;

Operators #

Ada supports standard arithmetic operators (+, -, *, /, mod, **), comparison operators (=, /=, <, <=, >, >=), logical operators (and, or, xor, not), and others.

Control Structures (if-then-else, loops) #

if-then-else: Conditional execution.

if Condition then
   -- Code to execute if Condition is True
else
   -- Code to execute if Condition is False
end if;

Loops: Ada offers several loop constructs:
- loop … end loop;: An infinite loop unless explicitly terminated with exit.
- for loop: Iterates a specified number of times.
```
for I in 1..10 loop
   -- Code to execute 10 times
end loop;
```
- while loop: Repeats as long as a condition is true.
```
while Condition loop
   -- Code to execute while Condition is True
end loop;
```

Input and Output #

The Ada.Text_IO package provides functions for basic input and output. Put_Line outputs a string to the console, and Get or Get_Line can be used for input.

with Ada.Text_IO; use Ada.Text_IO;

procedure Input_Output is
   Name : String(1..20);
begin
   Put("Enter your name: ");
   Get_Line(Name);
   Put_Line("Hello, " & Name & "!");
end Input_Output;

Remember to handle potential errors (e.g., user input exceeding the string length) in more robust applications.

Data Structures #

Arrays #

Arrays in Ada are collections of elements of the same type, accessed via an index. They are declared specifying the element type and the range of indices.

with Ada.Text_IO; use Ada.Text_IO;

procedure Arrays_Demo is
   Numbers : array (1..5) of Integer := (10, 20, 30, 40, 50);
   Chars   : array (1..10) of Character;
begin
   Put_Line("Numbers[3]: " & Integer'Image(Numbers(3)));  -- Accessing an element

   Chars(1) := 'A';
   Chars(10) := 'Z';

   for I in Chars'Range loop
       Put(Chars(I));
   end loop;
   New_Line;

end Arrays_Demo;

Note the use of Numbers'Range to iterate through the array’s indices. Ada also supports multi-dimensional arrays.

Records #

Records group elements of potentially different types under a single name.

with Ada.Text_IO; use Ada.Text_IO;

procedure Records_Demo is
   type Person is record
      Name : String(1..30);
      Age  : Integer;
   end record;

   My_Person : Person := ("Alice", 30);
begin
   Put_Line("Name: " & My_Person.Name);
   Put_Line("Age: " & Integer'Image(My_Person.Age));
end Records_Demo;

Elements within a record are accessed using the dot notation (e.g., My_Person.Name).

Access Types (Pointers) #

Access types in Ada are similar to pointers in other languages. They provide a way to dynamically allocate memory and refer to it indirectly.

with Ada.Text_IO; use Ada.Text_IO;

procedure Access_Types_Demo is
   type Int_Ptr is access Integer;
   My_Int : Int_Ptr;
begin
   My_Int := new Integer'(10); -- Allocate memory and assign the address to My_Int
   Put_Line("Value: " & Integer'Image(My_Int.all)); -- Access the value using .all
   My_Int.all := My_Int.all + 5; -- Modify the value
   Put_Line("New Value: " & Integer'Image(My_Int.all));
   My_Int := null; -- Set the pointer to null;  Remember to deallocate using `Deallocate` if needed for larger objects

end Access_Types_Demo;

The .all attribute is used to access the value pointed to by the access type. Remember that it’s crucial to manage memory allocated with new appropriately to prevent memory leaks, though Ada’s garbage collection will often handle this automatically for smaller objects.

Enumerated Types #

Enumerated types define a set of named values.

with Ada.Text_IO; use Ada.Text_IO;

procedure Enumerated_Types_Demo is
   type Day is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
   Today : Day := Mon;
begin
   case Today is
      when Mon => Put_Line("It's Monday!");
      when Tue => Put_Line("It's Tuesday!");
      when others => Put_Line("It's some other day!");
   end case;
end Enumerated_Types_Demo;

Enumerated types are often used to improve code readability and prevent errors by restricting values to a predefined set. The case statement provides a structured way to handle different enumerated values.

Subprograms and Modular Programming #

Procedures and Functions #

Subprograms are reusable blocks of code that perform specific tasks. Ada distinguishes between procedures and functions:

Procedures: Perform actions but don’t return a value.
Functions: Perform actions and return a single value.

with Ada.Text_IO; use Ada.Text_IO;

procedure Procedures_Functions is

   function Add(X, Y : Integer) return Integer is
   begin
      return X + Y;
   end Add;

   procedure Greet(Name : String) is
   begin
      Put_Line("Hello, " & Name & "!");
   end Greet;

begin
   Put_Line("Sum: " & Integer'Image(Add(5, 3)));
   Greet("Bob");
end Procedures_Functions;

Parameters and Arguments #

Parameters are variables declared in the subprogram’s declaration, while arguments are the actual values passed when the subprogram is called. Ada supports several parameter modes:

in: The parameter receives a value but cannot be modified. This is the default mode.
out: The parameter’s value is set by the subprogram and returned to the caller.
in out: The parameter’s value is passed in, modified by the subprogram, and the modified value is returned.

with Ada.Text_IO; use Ada.Text_IO;

procedure Parameters is
   procedure Modify(X : in out Integer) is
   begin
      X := X * 2;
   end Modify;

begin
   My_Number : Integer := 10;
   Modify(My_Number);
   Put_Line("Modified Number: " & Integer'Image(My_Number));
end Parameters;

Packages #

Packages are units that group related declarations (types, variables, subprograms) into a cohesive unit. They promote modularity, information hiding, and code reuse. A package consists of two parts:

Package specification: Declares the elements that are visible to other parts of the program.
Package body: Contains the implementation details of the elements declared in the specification.

-- my_math_package.ads (specification)
package My_Math is
   function Square(X : Integer) return Integer;
end My_Math;

-- my_math_package.adb (body)
package body My_Math is
   function Square(X : Integer) return Integer is
   begin
      return X * X;
   end Square;
end My_Math;

with Ada.Text_IO; use Ada.Text_IO;
with My_Math; use My_Math;

procedure Package_Demo is
begin
   Put_Line("Square of 5: " & Integer'Image(Square(5)));
end Package_Demo;

Separate Compilation #

Ada supports separate compilation, allowing you to compile different parts of a program independently. This improves development efficiency and maintainability. The compiler uses the package specifications to determine the interface between separately compiled units.

Generic Units #

Generic units are templates for subprograms or packages that can be instantiated with different types or parameters. This allows you to write reusable code that can work with various data types without modification.

generic
   type Item is private;
function Find_Max(A : array (Integer range <>) of Item) return Item;

procedure Generic_Demo is
   type My_Int is new Integer;
   Numbers : array (1..5) of My_Int := (1, 5, 2, 8, 3);
   Max_Number : My_Int;

   function Max_Int is new Find_Max(My_Int);
begin
   Max_Number := Max_Int(Numbers);
   Put_Line("Max Number: " & Integer'Image(Max_Number));
end Generic_Demo;

--implementation of Find_Max (in a separate file)
generic
   type Item is private;
function Find_Max(A : array (Integer range <>) of Item) return Item is
   Max_Item : Item := A(A'First);
begin
   for I in A'Range loop
      if A(I) > Max_Item then
         Max_Item := A(I);
      end if;
   end loop;
   return Max_Item;
end Find_Max;

The generic keyword defines the template. The is new clause instantiates the generic unit with the specified type. This example requires the Find_Max function’s implementation to be compiled separately.

Exception Handling #

Ada provides a robust mechanism for handling runtime errors using exceptions. This allows you to gracefully handle unexpected situations without causing program crashes.

Raising and Handling Exceptions #

Exceptions are raised (triggered) when a runtime error occurs. You can handle exceptions using a try-except block.

with Ada.Text_IO; use Ada.Text_IO;

procedure Exception_Handling is
   X, Y : Integer;
begin
   Put("Enter two numbers: ");
   Get(X); Get(Y);
   begin
      Put_Line("Result: " & Integer'Image(X / Y));
   exception
      when Constraint_Error => Put_Line("Division by zero!");
      when others => Put_Line("An error occurred.");
   end;
end Exception_Handling;

In this example, Constraint_Error is raised if Y is zero (division by zero). The exception block catches the exception and executes the corresponding handler. The others clause catches any other unhandled exceptions.

Exception Propagation #

If an exception is not handled within a try-except block, it propagates up the call stack to the next enclosing block. If no handler is found, the program terminates.

with Ada.Text_IO; use Ada.Text_IO;

procedure Exception_Propagation is
   procedure Subroutine is
   begin
      raise Constraint_Error;
   end Subroutine;
begin
   begin
      Subroutine;
   exception
      when Constraint_Error => Put_Line("Caught in main procedure!");
   end;
end Exception_Propagation;

Here, Constraint_Error is raised in Subroutine. Since it’s not handled there, it propagates to the main procedure where it is caught.

Defining Custom Exceptions #

You can define your own exceptions to represent specific error conditions within your application.

with Ada.Text_IO; use Ada.Text_IO;

procedure Custom_Exceptions is
   Invalid_Input : exception;

   procedure Read_Number(Num : out Integer) is
   begin
       Get(Num);
       if Num < 0 then
           raise Invalid_Input;
       end if;
   exception
       when Data_Error => Put_Line ("Data Error!");
   end Read_Number;

begin
   My_Number : Integer;
   begin
      Read_Number(My_Number);
      Put_Line("Number: " & Integer'Image(My_Number));
   exception
      when Invalid_Input => Put_Line("Invalid input: Number must be non-negative.");
      when others => Put_Line("An unexpected error occurred.");
   end;
end Custom_Exceptions;

Invalid_Input is a custom exception raised if the input number is negative. This improves code clarity and allows for more specific error handling. Note that the Data_Error exception in Read_Number is a standard exception and is handled within that procedure. If it were not handled, it would propagate upwards to the outer try-except block.

Object-Oriented Programming in Ada #

Introduction to OOP Concepts in Ada #

Ada supports object-oriented programming (OOP) features, although its approach differs somewhat from languages like Java or C++. Ada emphasizes strong typing and safety, which influences its OOP implementation. Key OOP concepts in Ada include:

Classes and Objects: A class is a template for creating objects. Objects are instances of a class. Classes are declared using the type ... is tagged ... construct. The tagged keyword indicates that the type supports inheritance and polymorphism.
Inheritance: Ada supports both single and multiple inheritance. A derived type inherits attributes and operations from a parent type.
Polymorphism: Ada achieves polymorphism through dispatching on tagged types. This means that the correct method is selected at runtime based on the object’s actual type.
Encapsulation: Ada enforces encapsulation through the use of private parts in packages and classes. This hides implementation details and protects data integrity.

Here’s a basic example of a class and object in Ada:

package My_Package is
   type Shape is tagged record
     X,Y : Float;
   end record;
   procedure Draw(S : in out Shape);
private
  -- internal details hidden here
end My_Package;

with Ada.Text_IO; use Ada.Text_IO;
package body My_Package is
   procedure Draw(S : in out Shape) is
   begin
      Put_Line("Drawing a generic shape at (" & Float'Image(S.X) & ", " & Float'Image(S.Y) & ")");
   end Draw;
end My_Package;

with My_Package; use My_Package;
with Ada.Text_IO; use Ada.Text_IO;

procedure OOP_Demo is
   My_Shape : Shape := (X => 1.0, Y => 2.0);
begin
   Draw(My_Shape);
end OOP_Demo;

Tasks and Concurrency #

Ada provides built-in support for concurrency through the use of tasks. Tasks are independent units of execution that can run concurrently. This allows for parallel processing and improved responsiveness in applications. Tasks are declared similarly to procedures or functions.

with Ada.Text_IO; use Ada.Text_IO;

procedure Concurrent_Demo is
   task Counter is
   end Counter;
   task body Counter is
   begin
      for I in 1..10 loop
         Put_Line("Counter: " & Integer'Image(I));
         delay 0.5; -- pause for 0.5 seconds
      end loop;
   end Counter;
begin
   Put_Line("Main task starting...");
   delay 2.0;
   Put_Line("Main task finishing.");
end Concurrent_Demo;

In this example, the Counter task runs concurrently with the main task. delay introduces a pause to allow both to execute noticeably.

Protected Objects #

Protected objects provide a way to safely share data among multiple tasks. They encapsulate data and provide controlled access using protected procedures and entries. This prevents race conditions and ensures data integrity in concurrent environments.

protected body Shared_Counter is
   entry Increment;
   procedure Decrement;
   Counter : Integer := 0;
begin
   entry Increment when Counter < 100 is
   begin
       Counter := Counter + 1;
   end Increment;
   procedure Decrement is
   begin
      Counter := Counter -1;
   end Decrement;
end Shared_Counter;

This uses a protected object to control access to a shared counter, allowing increment operations only when the counter is below 100.

Introduction to Ada’s Tasking Model #

Ada’s tasking model is a powerful feature that allows for the creation of robust and reliable concurrent programs. It uses a rendezvous mechanism for communication and synchronization between tasks. This ensures that tasks interact in a predictable and controlled way. Ada also offers features like protected objects and conditional entry calls to manage resource sharing and prevent deadlocks. The model is designed to handle situations where tasks need to coordinate their actions, preventing race conditions and ensuring data consistency. The Ada standard provides extensive support for debugging and analyzing concurrent programs to identify and resolve potential concurrency issues.

Advanced Topics #

Aspect-Oriented Programming in Ada #

While Ada doesn’t have dedicated aspect-oriented programming (AOP) keywords like some languages, you can achieve similar functionality through several techniques:

Pre- and Postconditions: Ada’s contracts, including pre- and postconditions, can be used to define aspects that must hold before and after a subprogram execution. These enforce constraints that act like aspects in AOP.
Exception Handlers: Centralized exception handling provides a mechanism to address cross-cutting concerns like logging or error recovery. The exception block acts as a way to ‘weave’ in additional code.
Aspect-like Packages: You can encapsulate common cross-cutting concerns (logging, security, etc.) into packages. Then you can call procedures from these packages from multiple parts of your code to modularly apply the aspects.

While not a full-fledged AOP language, Ada’s features offer ways to manage concerns and code in a modular fashion, achieving many benefits of AOP.

Interfacing with other languages #

Ada provides mechanisms for interfacing with other programming languages such as C and C++. This is essential when integrating Ada code with existing systems or libraries written in other languages. The key techniques include:

Foreign Language Interfaces: Ada’s Foreign Language Interface (FLI) allows you to declare and call functions written in other languages. This involves specifying the data types and calling conventions to match the external function’s signature. You would need to carefully consider data type mappings between Ada and the target language.
Foreign Language Procedures: Declaring functions and procedures with pragma Interface and pragma Import allows you to link and call routines from other languages directly.
Data type mapping: Careful consideration must be given to how different languages represent data structures; there might be a need for explicit conversion routines.
Calling Conventions: The way a function or procedure is called can vary between languages. The Ada FLI allows you to specify this to ensure compatibility.

Interfacing with other languages requires attention to detail and a thorough understanding of both Ada’s and the external language’s calling conventions and data representation. The process usually involves compiler-specific options and linking steps.

←

Beginner's Guide to Delphi

Beginner's Guide to Prolog

→