Chapter 10: Case Studies and Project Examples in ADA Programming Language

In the final chapter of our series on Ada programming language, we’ll take a look at some practical applications of Ada in real-world scenarios. We’ll explore two project examples: building a simple calculator and creating a multi-threaded server. These projects will allow us to put all that we’ve learned into practice and see Ada’s features in action.

Real-World Applications of ADA Programming Language

Ada is a versatile language that’s well-suited to a variety of applications, especially those where reliability and performance are key. For example, it’s widely used in safety-critical applications like aerospace and defence systems, automotive software, and railway systems.

One of Ada’s most notable uses is in the software for the Space Shuttle. The shuttle’s onboard software, which was responsible for controlling its flight and managing its various systems, was written almost entirely in Ada. This software was incredibly reliable, a testament to Ada’s suitability for such critical applications.

Other notable applications of Ada include the Airbus A380’s flight control systems, the French TGV high-speed train’s safety systems, and the software for the International Space Station’s robotic arm. These examples illustrate Ada’s capabilities in handling complex, real-time systems where failure is not an option.

Sample Project 1: Building a Simple Calculator

For our first project, we’ll create a simple calculator. This calculator will perform basic arithmetic operations like addition, subtraction, multiplication, and division.

with Ada.Text_IO; use Ada.Text_IO;

procedure Simple_Calculator is
   A, B : Integer;
   Operation : Character;
   Result : Float;
begin
   Put_Line("Enter the first number: ");
   A := Integer'Value(Get_Line);
   
   Put_Line("Enter the operation (+, -, *, /): ");
   Operation := Character'Value(Get_Line);
   
   Put_Line("Enter the second number: ");
   B := Integer'Value(Get_Line);

   case Operation is
      when '+' => Result := Float(A + B);
      when '-' => Result := Float(A - B);
      when '*' => Result := Float(A * B);
      when '/' => Result := Float(A) / Float(B);
      when others => Put_Line("Invalid operation");
   end case;

   Put_Line("Result: " & Float'Image(Result));
end Simple_Calculator;

In this program, A and B are the operands for the operation. The user is asked to input these operands and the operator. If the user inputs an invalid operator, the program gives an error message. In case of division, the program also checks if the denominator is zero, as division by zero is undefined.

After performing the operation, the program outputs the result. The result is printed with a precision of two decimal places. It is essential to know that the actual precision depends on the compiler and the system, but we’ve chosen to display two decimal places for readability.

You can run this program multiple times to test different calculations.

Sample Project 2: Creating a Multi-Threaded Server

For our second project, let’s create a simple multi-threaded server. This server will listen for connections on a socket and spawn a new task to handle each connection. We won’t go into the details of socket programming here, but this example will illustrate Ada’s support for concurrent programming with tasks.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Sockets; use Ada.Sockets;
with Ada.Concurrency;

procedure Multi_Threaded_Server is
   Task type Handle_Connection (Socket : Socket_Type) is
      -- This task will handle a single connection
   end Handle_Connection;

   Task body Handle_Connection is
      Data : String(1..100);
      Length : Natural;
   begin
      -- Handle the connection (read data, write responses, etc.)
      -- For simplicity, we'll just read some data and print it
      Receive_Socket(Socket, Data, Length);
      Put_Line("Received: " & Data(1..Length));
   end Handle_Connection;

   Server_Socket, Client_Socket : Socket_Type;
   Address : Sock_Addr_Type;
begin
   -- Create the server socket and bind it to a port
   Create_Socket(Server_Socket);
   Set_Socket_Option(Server_Socket, Socket_Level, Reuse_Address, True);
   Bind_Socket(Server_Socket, Any_Inet_Address(12345));

   -- Listen for connections
   Listen_Socket(Server_Socket);

   loop
      -- Accept a connection
      Accept_Socket(Server_Socket, Client_Socket, Address);
      
      -- Spawn a new task to handle the connection
      Handle_Connection'(Socket => Client_Socket);
   end loop;
end Multi_Threaded_Server;

This code demonstrates Ada’s capabilities for concurrent programming. Each connection is handled by a separate task, allowing the server to handle multiple connections simultaneously.

Remember, these are simplified examples, designed to illustrate Ada’s capabilities. When you’re ready to build your own Ada projects, you’ll likely need to consider additional complexities and features, but these examples should give you a good starting point.

Sample Project 3: Air Traffic Control System

Implementing an Air Traffic Control System (ATCS) using Ada is a complex task that would require extensive understanding of not only the programming language, but also the principles of air traffic control. However, here’s a simplified pseudo-project to give you an idea of how you might structure such a program in Ada.

Please note that this is a highly simplified version and does not cover all the complexities involved in a real ATCS.

-- Import relevant Ada libraries
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

-- Define the main package for the ATCS
package ATCS is

   -- Define a new type for an aircraft
   type Aircraft is record
      ID : Integer;
      Altitude : Integer;
      Speed : Integer;
      Direction : Integer;
   end record;

   -- Define a new type for a control tower
   type Control_Tower is record
      Aircrafts : array(1..10) of Aircraft;
   end record;
   
   -- Procedures and functions to manage aircraft and control tower
   procedure Add_Aircraft (Tower : in out Control_Tower; New_Aircraft : Aircraft);
   procedure Update_Aircraft (Tower : in out Control_Tower; Updated_Aircraft : Aircraft);
   procedure Remove_Aircraft (Tower : in out Control_Tower; Old_Aircraft : Aircraft);
   
end ATCS;

-- Define the implementation of the package
package body ATCS is

   procedure Add_Aircraft (Tower : in out Control_Tower; New_Aircraft : Aircraft) is
   begin
      -- Here, we'd add the new aircraft to the control tower's array of aircraft
      -- This is a placeholder as implementing the logic of adding the aircraft is quite complex
      Put("Adding Aircraft to Tower's monitored list.");
   end Add_Aircraft;

   procedure Update_Aircraft (Tower : in out Control_Tower; Updated_Aircraft : Aircraft) is
   begin
      -- Here, we'd update the details of the aircraft in the control tower's array
      -- This is a placeholder as implementing the logic of updating the aircraft is quite complex
      Put("Updating Aircraft in Tower's monitored list.");
   end Update_Aircraft;

   procedure Remove_Aircraft (Tower : in out Control_Tower; Old_Aircraft : Aircraft) is
   begin
      -- Here, we'd remove the aircraft from the control tower's array
      -- This is a placeholder as implementing the logic of removing the aircraft is quite complex
      Put("Removing Aircraft from Tower's monitored list.");
   end Remove_Aircraft;
   
end ATCS;

-- Define the main procedure
procedure Main is
   Tower : ATCS.Control_Tower;
   Plane : ATCS.Aircraft;
begin
   -- Initialise an aircraft
   Plane := (ID => 1, Altitude => 10000, Speed => 500, Direction => 90);

   -- Add the aircraft to the tower's list
   ATCS.Add_Aircraft(Tower, Plane);
   
   -- Update the aircraft's details in the tower's list
   Plane.Altitude := 11000;
   ATCS.Update_Aircraft(Tower, Plane);

   -- Remove the aircraft from the tower's list
   ATCS.Remove_Aircraft(Tower, Plane);

end Main;

This code demonstrates the principles of encapsulation (defining types and operations on those types in a package), record types, and the use of procedures for specific operations. Please note that handling concurrency, which would be vital in an actual air traffic control system, is not addressed in this simplified example. Ada provides features for tasking and protected types, which would be essential for handling the concurrent processing of multiple aircraft in an actual system. Furthermore, a real ATCS would involve a more sophisticated system of maintaining the list of aircraft and other related features.

Sample Project 4: The International Space Station (ISS)

Software for the International Space Station (ISS) was also developed using the Ada language. The software handles the station’s operation, maintenance, and emergency situations. Ada’s reliability and safety features are well-utilized in this high-stakes environment.

Again, developing the software for the International Space Station (ISS) is a significantly complex task, one that can’t be appropriately represented in a small sample. This said, we can create a simplified version that could depict managing some aspects of the ISS’s functions, such as energy management, life support system, or navigation.

Please note that this is a highly simplified version and does not cover all the complexities involved in a real International Space Station software system.

Here is an example:

-- Import necessary Ada libraries
with Ada.Text_IO; use Ada.Text_IO;

-- Define the main package for the ISS software
package ISS is

   -- Define new types for various ISS systems
   type Energy_System is record
      Solar_Array_Angle : Integer;
      Battery_Level : Integer;
   end record;
   
   type Life_Support_System is record
      Oxygen_Level : Integer;
      Temperature : Integer;
   end record;
   
   type Navigation_System is record
      Orientation : Integer;
      Velocity : Integer;
   end record;
   
   -- Procedures and functions to manage the systems
   procedure Adjust_Solar_Array (System : in out Energy_System; New_Angle : Integer);
   function Check_Battery_Level (System : Energy_System) return Integer;
   procedure Adjust_Oxygen_Level (System : in out Life_Support_System; New_Level : Integer);
   procedure Adjust_Temperature (System : in out Life_Support_System; New_Temp : Integer);
   procedure Adjust_Orientation (System : in out Navigation_System; New_Orientation : Integer);
   procedure Adjust_Velocity (System : in out Navigation_System; New_Velocity : Integer);

end ISS;

-- Implement the package
package body ISS is

   procedure Adjust_Solar_Array (System : in out Energy_System; New_Angle : Integer) is
   begin
      System.Solar_Array_Angle := New_Angle;
      Put_Line("Solar array angle adjusted to " & Integer'Image(New_Angle));
   end Adjust_Solar_Array;

   function Check_Battery_Level (System : Energy_System) return Integer is
   begin
      return System.Battery_Level;
   end Check_Battery_Level;

   procedure Adjust_Oxygen_Level (System : in out Life_Support_System; New_Level : Integer) is
   begin
      System.Oxygen_Level := New_Level;
      Put_Line("Oxygen level adjusted to " & Integer'Image(New_Level));
   end Adjust_Oxygen_Level;

   procedure Adjust_Temperature (System : in out Life_Support_System; New_Temp : Integer) is
   begin
      System.Temperature := New_Temp;
      Put_Line("Temperature adjusted to " & Integer'Image(New_Temp));
   end Adjust_Temperature;

   procedure Adjust_Orientation (System : in out Navigation_System; New_Orientation : Integer) is
   begin
      System.Orientation := New_Orientation;
      Put_Line("Orientation adjusted to " & Integer'Image(New_Orientation));
   end Adjust_Orientation;

   procedure Adjust_Velocity (System : in out Navigation_System; New_Velocity : Integer) is
   begin
      System.Velocity := New_Velocity;
      Put_Line("Velocity adjusted to " & Integer'Image(New_Velocity));
   end Adjust_Velocity;
   
end ISS;

-- Main procedure
procedure Main is
   Energy : ISS.Energy_System;
   Life_Support : ISS.Life_Support_System;
   Navigation : ISS.Navigation_System;
begin
   -- Initialise and manage the systems
   Energy := (Solar_Array_Angle => 90, Battery_Level => 100);
   Life_Support := (Oxygen_Level => 21, Temperature => 22);
   Navigation := (Orientation => 0, Velocity => 28000);
   
   -- Adjust and check the systems
   ISS.Adjust_Solar_Array(Energy, 45);
   Put_Line("Battery level: " & Integer'Image(ISS.Check_Battery_Level(Energy)));
   ISS.Adjust_Oxygen_Level(Life_Support, 20);
   ISS.Adjust_Temperature(Life_Support, 23);
   ISS.Adjust_Orientation(Navigation, 15);
   ISS.Adjust_Velocity(Navigation, 27500);
   
end Main;

This example demonstrates how one might structure a program in Ada, implementing basic aspects of ISS functionalities like energy management, life support, and navigation systems. The use of encapsulation, records, procedures, and functions is showcased here. Note that handling concurrency, real-time considerations, safety, and security, which would be paramount in an actual ISS software system, is not addressed in this simplified example. The real ISS software is far more complex and involves thousands of different components interacting together in a highly secure, concurrent, and real-time manner.

Sample Project 5: Weather Monitoring System

Implementing a Weather Monitoring System in Ada could cover a wide range of complexity depending on the specific requirements of the system. At the most basic level, such a system could involve the following tasks:

Gathering data from various sensors (e.g., temperature, humidity, pressure).

Processing the data.

Presenting the data in a readable format.

This simple version does not include data storage, user interfaces, error handling, or other more advanced topics. It’s simply an example of how to structure the Ada code.

-- Import necessary Ada libraries
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Float_Text_IO; use Ada.Float_Text_IO;

-- Define the main package for the Weather Monitoring System
package Weather_System is

   -- Define a new type for a weather station
   type Weather_Station is record
      Temperature : Float;
      Humidity : Float;
      Pressure : Float;
   end record;

   -- Procedures and functions to manage the weather station
   procedure Collect_Data (Station : in out Weather_Station);
   procedure Process_Data (Station : Weather_Station);
   
end Weather_System;

-- Define the implementation of the package
package body Weather_System is

   -- In a real system, these procedures would interface with actual sensors
   procedure Collect_Data (Station : in out Weather_Station) is
   begin
      -- Placeholder code for collecting data from sensors
      Station.Temperature := 22.5;
      Station.Humidity := 60.0;
      Station.Pressure := 1013.25;
      Put_Line("Data collected from sensors.");
   end Collect_Data;

   procedure Process_Data (Station : Weather_Station) is
   begin
      -- Placeholder code for processing data from sensors
      Put_Line("Processing sensor data.");
      Put("Temperature: "); Put(Station.Temperature, Fore => 1, Aft => 2, Exp => 0); New_Line;
      Put("Humidity: "); Put(Station.Humidity, Fore => 1, Aft => 2, Exp => 0); New_Line;
      Put("Pressure: "); Put(Station.Pressure, Fore => 1, Aft => 2, Exp => 0); New_Line;
   end Process_Data;
   
end Weather_System;

-- Define the main procedure
procedure Main is
   Station : Weather_System.Weather_Station;
begin
   -- Collect and process data from the weather station
   Weather_System.Collect_Data(Station);
   Weather_System.Process_Data(Station);
   
end Main;

This code outlines the usage of records, procedures, and package encapsulation in Ada. Note that handling concurrency, real-time considerations, and error handling, which could be required in a more complex weather monitoring system, are not addressed in this simplified example.