Die Programmiersprache Ada

Wacker Art

Bild: "Der Traum" 56,4cm x 42cm
Inspiriert haben mich zu diesem Bild die Arbeiten von Emil Nolde
Stiftung Seebüll Ada und Emil Nolde

Prolog

Ada Lovelace

Augusta Ada Byron, Countess of Lovelace

Some programms are elegant, some are exquisite, some are sparkling. My claim is that it is possible to write grand programms, noble programms, truly magnificent ones!

Donald Knuth, 1974 Turing Award Lecture.

Die Programmiersprache Ada

Jean Ichbiah

Jean Ichbiah war ein französischer Informatiker, der die Programierspache Ada entwickelt hat.

Augusta Ada Byron

Die Programmiersprache Ada wurde benannt nach: Augusta Ada Byron, Countess of Lovelace.

Ada Lovelace war Mathematikerin und die Tochter des Dichters Lord Byron. Sie arbeitete für Charles Babbage an dessen "Analytical Engine" einer mechanischen Rechenmaschine und machte Vorschläge, zu deren Programmierung. Sie gilt deshalb als die erste Programmiererin.

Vorteile und Features der Programiersprache Ada

Die Verwendung der Programmiersprache Ada ist besonders zu empfehlen, bei der Erstellung von großen, langlebigen Softwareprojekten. Bei der Programmiersprache Ada stehen Robustheit der erstellten Programme und Lesbarkeit des Codes im Vordergrund.

Compiletime Checks
Extensive Checks während der Compilierung des programmierten Ada-Codes. Dies führt dazu, dass die normalen Flüchtigkeitsfehler die bei anderen Programmiersprachen zu extremem Testaufwand führen, bei Ada schon während der Compilierzeit entdeckt werden. Der daraus resultierende verringerte Aufwand bei Test und Integration ist einer der Hauptgründe für die Kostenreduktion bei der Verwendung von Ada in großen Projekten.
Runtime Checks
Während der Laufzeit eines Ada-Programmes werden definierte Checks durchgeführt. Bei der Verletzung dieser Regeln werden sofort Fehler ausgelöst. Durch die Verwendung von Exception Handlern, die Mann in jedem Block einbauen sollte, ist dann eine leichte Lokalisierung des Fehlers möglich.
Objektorientierung
Ada ist eine durch einen Internationalen Standard definierte objektorientierte Programmiersprache. Grady Booch einer der Gurus der Objektorientierten-Softwareentwicklung und der UML (Unified Modeling Language) ist mit dem Buch "Software Engineering with Ada" bekannt geworden. Ada gehört zu den Programmiersprachen über die Objektorientierung und andere moderne Software Engineering Methoden wie Datenkapselung und "Information Hiding" verbreitet wurden.
Multitasking Innerhalb eines Programmes können mehrere Tasks definiert werden, die als selbständige Threads laufen. Dadurch kann man elegant die Behandlung von asynchronen Ereignissen und Datenströmen programmieren. Bei anderen Programmiersprachen muß man in der Regel auf die Thread- oder Prozesstruktur des Betriebssystems zugreifen und wird dadurch abhängig vom verwendeten Betriebssystem.
Modularisierung Das Ada Package Konzept bietet die Möglichkeit, die größten Softwareprojekte zu gliedern und zu modularisieren. Die separate Compilierbarkeit von Ada-Units ist ein mächtiges Werkzeuge um ein Software Projekt von einem großen Team durchzuführen.
Generische Komponenten Generische Komponenten sind ein mächtiges Werkzeug, mit dem sich wiederverwendbare Komponenten erzeugen lassen, die mit verschiedenen Datentypen, Prozeduren und Paketen parametrisiert werden können.
Portabilität Die Programmiersprache wird durch den Ada Sprachstandard definiert. Eine Validierung eines Ada-Compilers gegen den Ada Sprachstandard ist möglich und wird von den meisten Compilerherstellern durchgeführt. Dies sichert die Portierbarkeit zwischen verschiedenen Compilerherstellern und Hardwareplattformen. Tipp: Man sollte nur validierte Ada Compiler verwenden.
Language Interfaces Die Programmiersprache Ada hat definierte Schnittstellen zu anderen Programmiersprachen. Dadurch werden auch diese Schnittstellen plattformunabhängig. Insbesondere lassen sich dadurch vorhandene C-Komponenten elegant in ein Programm einbinden.
Error Recovery Durch den Exception Handling Mechanismus in Ada können Fehler abgefangen werden und auf den Fehler abgestimmte Programmschritte definiert werden.
Tipp: Bauen Sie in jeden Block einen Exception Handler ein, der es ihnen ermöglicht einen währen der Laufzeit auftretenden Fehler zu lokalisieren und zu analysieren. Dies erleichtert Ihnen die Arbeit beim Testen und Integrieren.
Low-Level Features Mit Ada ist es möglich, jedes Bit einzeln zu manipulieren. Die hochentwickelten Ada Datenstrukturen lassen sich auf vordefinierte Bitmuster und Adressen abbilden.

Resümee: Ada ist nicht nur eine Programmiersprache sondern ist ein Werkzeugkasten für die Implementierung moderner Software-Engineering Methoden. Nach dem ich über 25 Jahre Erfahrung mit der Entwicklung von Software habe und die verschiedensten Programmiersprachen ausprobiert habe, ist für mich Ada die Programmiersprache.

Compiler-Validierung und Compiler-Auswahl

Für Ada83 war es vorgeschrieben, daß jeder Compiler einmal im Jahr zu validiert ist. Dadurch wurde sichergestellt, daß ein einheitlicher Ada-Standard von jedem Compiler implementiert war.

Dies führte zu einer hohen Portierbarkeit von Ada-Sourcen auf andere Zielsystem. In der Regel reicht eine Neucompilierung der Sourcen aus um wieder ein funktionierendes System zu bekommen. Dieser Zwang zur Validierung des Ada-Compilers wurde für Ada95 aufgehoben. Meine Empfehlung ist nur validierte Ada-Compiler zu verwenden. Dadurch wird sichergestellt, daß der Compiler entsprechend des Ada-Standards implementiert ist. Bei nicht validierten Ada-Compilern soll es vorgekommen sein, daß diese nicht vollständig entsprechend des Ada-Standards implementiert sind. Ein Hinweis noch: Beim Ada95-Standard gibt es einen Kernstandard und "Special Need" Annexe, die in der Regel nicht alle implementiert sind. Vor der Auswahl eines Compilers sollte man sich deshalb überlegen, welche Annexe für das eigene Projekt implementiert sein müssen. Dies gilt insbesondere für die Portierung einer Ada-Application auf ein anderes Zielsystem. Für das saubere Arbeiten einer Multitasking Applikation empfehle ich z.b. die Implementierung des Realtime Annexes. Da dieser ein sauberes Task Scheduling erzwingt (Preemtive Scheduling). Wenn das Ada-Laufzeitsystem mit einem Betriebssystem zusammen arbeitet, so sind Implementierungen zu empfehlen, die Ada-Tasks auf Threats des Betriebssystems abbilden. Dies gilt insbesondere für Implementierungen auf Unix Systemen. Dies stellt sicher, daß nicht das gesamte Ada-Multitaskingsystem zum Stehen kommt, wenn aus einer Ada-Task heraus ein Betriebssystem Aufruf erfolgt.

Ada und sicherheitskritische Systeme

In mehreren internationalen Standards zur Entwicklung sicherheitsrelevanter Systeme (z.B. IEC 61508, EN 50128 und DO-178B) wird Ada explizit als "highly recommended" geführt! Ada wird deshalb häufig bei sicherheitskritischen Systemen eingesetzt. Ein Beispiel für den Einsatz von Ada in sicherheitskritischen Systemen ist die Software der Boeing 777 die zu 99,9% in Ada geschrieben wurde.

Bild: "Ferienland Waldeck"

Ada-Code Hallo World

Beispiel: Ein "Hello World" Programm in der Programmiersprache Ada

with Ada.Text_IO;

procedure Hello_World is
begin
   Ada.Text_IO.Put_Line ( "Hallo World!" );
end Hello_World;

Compile Hello World with the GNAT Ada-Compiler

Bild: "Ferienland Waldeck"

Ada-Code Beispiele

Beispiel 1: Ein- und Ausgabe von Aufzählungstypen

with Ada.Text_IO,
     Ada.Exceptions;

procedure Enumeration_IO_Example is

   use  Ada.Text_IO,
        Ada.Exceptions;

   type Days_Of_the_Week_Type is ( Monday,
                                   Tuesday,
                                   Wednesday,
                                   Thursday,
                                   Friday,
                                   Saturday,
                                   Sunday,
                                   End_of_Days );

   Day : Days_Of_the_Week_Type := Monday;

   -- define a package for the io of the enumeration type.
   package Day_Name_Io is new Enumeration_Io (Days_Of_the_Week_Type);
   use     Day_Name_Io;

begin
   Put_Line ( "begin Enumeration_IO_Example" );
   Put_Line ( "      The Programm will run until you enter: End_of_Days!");
   New_Line;

   Put_Line ("Actual Day: " & Days_Of_the_Week_Type'image(Day) );
   New_Line;

   Main : loop
      -- display all the elements of the enumeration type
      for index in Days_Of_the_Week_Type'range loop
         Put ( index );
         New_Line;
      end loop;
      New_Line;

      Read_Block : declare
         Input_Text : String (1 .. 200) := ( others=> ' ' );
         Length     : Integer           := 0;
      begin
         Put ("Enter new day: ");
         -- read the terminal input as string
         Get_Line (Input_Text, Length);

         -- convert the string to the enumeration value
         -- raises exception Constraint_Error, when a conversion is not possible
         Day := Days_Of_the_Week_Type'Value ( Input_Text (1 .. Length) );

         -- display the actual enumeration value on screen
         Put_Line ( "Actual Day:    " & Days_Of_the_Week_Type'image(Day) );
         New_Line;

       exception
          when Constraint_Error => Put_Line ("Wrong Input!");
                                   New_Line;

          when others           => raise;
       end Read_Block;

       exit Main when Day = End_of_Days;

   end loop Main;

   Put_line ("end   Enumeration_IO_Example");

exception
    when Error: others =>
        Put_Line ( "Exception_Name:        " & Ada.Exceptions.Exception_Name        (Error) );
        Put_Line ( "Exception_Message:     " & Ada.Exceptions.Exception_Message     (Error) );
        Put_Line ( "Exception_Information: " & Ada.Exceptions.Exception_Information (Error) );

end Enumeration_IO_Example;

Das Programm erzeugt die folgenden Ausgaben:

$ ./enumeration_io_example.exe
begin Enumeration_IO_Example
      The Programm will run until you enter: End_of_Days!

Actual Day: MONDAY

MONDAY
TUESDAY
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY
SUNDAY
END_OF_DAYS

Enter new day: FRIDAY
Actual Day:    FRIDAY

MONDAY
TUESDAY
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY
SUNDAY
END_OF_DAYS

Enter new day: asdfdf
Wrong Input!

MONDAY
TUESDAY
WEDNESDAY
THURSDAY
FRIDAY
SATURDAY
SUNDAY
END_OF_DAYS

Enter new day: END_OF_DAYS
Actual Day:    END_OF_DAYS

end   Enumeration_IO_Example

Beispiel 2: Generisches Paket zur Zeilen orientierten Kommando Ein-/Ausgabe mit der Programmiersprache Ada

Package Specification

generic
   -- valid commands, that can be entered through the command line
   type Command_Type is (<>);

   -- a function that contains the control logic for the execution of the commands.
   with function Handle_Command ( Command : in Command_Type ) return boolean;
package Command_Line_Generic is
   procedure Get_Command;
end Command_Line_Generic;

Test Rahmen

with Command_Line_Generic;

procedure Test_Line_Command is

    type Command_Type is (Start, Stop);

    function Handle_Command (Command : in Command_Type) return boolean is
    begin
       case Command is
          when Start => return true;
          when Stop  => return false;
       end case;
    end;

    package Command_Line is new Command_Line_Generic ( Command_Type   => Command_Type,
                                                       Handle_Command => Handle_Command );

begin
   Command_Line.Get_Command;
end Test_Line_Command;

Package Body

with Ada.Text_io,
     Ada.Exceptions;

package body Command_Line_Generic is

  use Ada.Text_Io,
      Ada.Exceptions;

  package Command_Type_Io is new Enumeration_Io ( Command_Type );
  use     Command_Type_Io;


  procedure Get_Command is
     Command          : Command_Type := Command_Type'First;
     Continue_Reading : boolean      := true;
  begin
     Main : loop
        for index in Command_Type'range loop
           Put ( index );
           New_Line;
        end loop;
        New_Line;

        Read_Block : declare
           Input_Text : String (1 .. 200) := ( others=> ' ' );
           Length     : Integer           := 0;
        begin
           Put ( "Enter: " );
           Get_Line ( Input_Text, Length );
           Command := Command_Type'Value ( Input_Text (1 .. Length) );
           Continue_Reading := Handle_Command (Command);
        exception
           when Constraint_Error => Put_Line ("Wrong Input!");
                                    New_Line;

           when others           => raise;
        end Read_Block;

        exit Main when Continue_Reading = false;
     end loop Main;

  exception
     when Error: others =>
        Put_Line ("Exception_Name:        " & Ada.Exceptions.Exception_Name        ( Error ) );
        Put_Line ("Exception_Message:     " & Ada.Exceptions.Exception_Message     ( Error ) );
        Put_Line ("Exception_Information: " & Ada.Exceptions.Exception_Information ( Error ) );
  end Get_Command;

end Command_Line_Generic;

Test_Generic_Example

with Ada.Text_io,
     Ada.Exceptions,
     Command_LIne_Generic;

procedure Test_Generic_Example is

   use Ada.Text_Io,
       Ada.Exceptions;

   type Days_Of_the_Week_Type is ( Monday,
                                   Tuesday,
                                   Wednesday,
                                   Thursday,
                                   Friday,
                                   Saturday,
                                   Sunday,
                                   End_of_Days );

    function Day_Controller ( Day : Days_of_the_Week_Type ) return boolean is
    begin
       Put_Line ( "Day:   " &  Days_of_the_Week_Type'image (Day) );
       New_Line;

       case Day is
          when End_of_Days => return false;
          when others      => return true;
       end case;
    end Day_Controller;

    package Days_Of_The_Week_Handler is new Command_Line_Generic ( Command_Type   => Days_Of_the_Week_Type,
                                                                   Handle_Command => Day_Controller         );

begin
   Put_Line ( "begin Test_Generic_Example" );
   Days_of_the_Week_Handler.Get_Command;
   Put_Line ( "end   Test_Generic_Example" );
end Test_Generic_Example;