ada 95 - programming in the large

1http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License

Franco [email protected]://libre.act-europe.fr


Copyright NoticeCopyright Notice

• © ACT Europe under the GNU Free Documentation License

• Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; provided its original author is mentioned and the link to http://libre.act-europe.fr/ is kept at the bottom of every non-title slide. A copy of the license is available at:

• http://www.fsf.org/licenses/fdl.html


What is the largest What is the largest software systemsoftware systemyou have built ?you have built ?

(in SLOC)(in SLOC)


Small Software SystemsSmall Software Systems

• Understandable by 1 person

• Can throw away & replace it to– repair / extend– port to new platform

• Anything is OK for small systems (< 10 Ksloc)


Medium/Large SystemsMedium/Large Systems

• Team of people• No 1 person knows all its aspects• Long life-span (> 10 years)• CANNOT throw away & replace it to

– repair / extend– port to new platform

• Requires organization, discipline & right tools


• Programming in the Large– specification & implementation– privacy– abstract data types– hierarchical packages


Separate CompilationSeparate CompilationTHE

PROBLEM

Compiler objectCODE

Compiler objectCODE

Compiler objectCODE

Linker

executable

libraries


Problem with this approachProblem with this approach

CODE

CODE

CODE

• No structure

• To write your own code– YOU MUST understand

everybody else’s code

CODE

CODE


IdeaIdea

SPECIFY WHAT EACH

MODULESHOULD DO


SPECIFICATION

Software module

????

BODY


• Programming in the Large– specification & implementation

• specification• implementation• specification rules in Ada


A Specification is a ...A Specification is a ...

CONTRACTCONTRACTCONTRACTCONTRACTImplementorof themodule

Users/clientsof themodule

• On the SERVICES provided by the module


• SPEC = list of services provided

• BODY = implementation of the services (hidden)

Software module

Service_1Service_2Service_3

Service_1implementation




SPECIFICATION

????BODY


ExampleExample

• Create a Queue module that can– Add an Integer to the Queue– See the First integer in the Queue– Get the first integer in the Queue– Test whether the Queue is Empty


package Queue isprocedure Add (Element : Integer);

function First return Integer;function Get return Integer;

function Empty return Boolean;end Queue;




queue.adsqueue.ads


package Queue

????

BODY







queue.adsqueue.ads


Using package QueueUsing package Queue

with Queue;procedure Client is

Queue_Error : exception;X : Integer;

beginQueue.Add (3);Queue.Add (4);

if not Queue.Empty thenX := Queue.Get;

elseraise Queue_Error;

end if;end Client;

client.adb


Specifications Reduce ComplexitySpecifications Reduce Complexity

SPECSPEC

SPECSPEC

SPECSPECSPECSPEC

• To write your own code– only need to understand

specs for the services you need


package Queue????







queue.adsqueue.ads

To write Client only need to look atTo write Client only need to look at


Aside: use clauseAside: use clause

with Queue; use Queue;procedure Client is

Queue_Error : exception;X : Integer;

beginQueue. Add (3);Queue. Add (4);

if not Queue. Empty thenX := Queue. Get;

elseraise Queue_Error;

end if;end Client;


ONEONEONEONEONEONEONEONE possible possible implementationimplementation

of packageof packageQueueQueue

This implementationThis implementationraises Constraint_Errorraises Constraint_Errorif more than Max_Sizeif more than Max_Size

elements are put in the Queue.elements are put in the Queue.


Circular BufferCircular Buffer

Q

0 1 Max_Size - 1

Q_Last Q_First


package body Queue isMax_Size : constant := 100;

type Q_Index is mod Max_Size;Q : array (Q_Index range 0 .. Max_Size - 1) of Integer;

Q_First : Q_Index := Q ’ First;Q_Last : Q_Index := Q_First;Size : Natural range 0 .. Max_Size;

procedure Add (Element : Integer) isbegin

Q (Q_Last) := Element;Q_Last := Q_Last + 1;Size := Size + 1;

end Add;...

end Queue;

queue.adb


package body Queue is...function First return Integer isbegin

return Q (Q_First);end First;

function Get return Integer isbegin

Q_First := Q_First + 1;Size := Size - 1;return Q (Q_First - 1);

end Get;

function Empty return Boolean isbegin

return Size = 0;end Empty;

end Queue;

queue.adb


ANOTHERANOTHERANOTHERANOTHERANOTHERANOTHERANOTHERANOTHER possible possible implementationimplementation

of packageof packageQueueQueue


Linked ListLinked List

Q_LastQ_First

Free


package body Queue istype Queue_Element;type Element_Ptr is access Queue_Element;

type Queue_Element is recordVal : Integer;Next : Element_Ptr;

end record;

Q_First : Element_Ptr;Q_Last : Element_Ptr;

Free : Element_Ptr := new Queue_Element;...

end Queue;

queue.adb


package body Queue is...procedure Add (Element : Integer) isbegin

if Q_First = null thenQ_First := Free;

elseQ_Last.Next := Free;

end if;Q_Last := Free;Free := Free.Next;Q_Last.all := (Element, null);if Free = null then

Free := new Queue_Element;end if;

end Add;...

end Queue;

queue.adb


package body Queue is...function Get return Integer is

Tmp : Element_Ptr := Q_First;begin

Q_First := Q_First.Next;if Q_First = null then

Q_Last := null;end if;Tmp.Next := Free;Free := Tmp;return Tmp.Val;

end Get;...

end Queue;

queue.adb


package body Queue is...function First return Integer isbegin

return Q_First;end First;

function Empty return Boolean isbegin

return Q_First = null;end Empty;

end Queue;

queue.adb


A Spec can have several A Spec can have several implementationsimplementations

• Can change implementation

• WITHOUT having to change ANY of the client’s code







queue.adsqueue.ads

firstimplement.

firstimplement.

secondimplement.second

implement.


In AdaIn Ada

• Spec always checked against implementation

• Must with the specs that you are going to use (not in C)

• Packages provide multiple name spaces


Spec is checked against its bodySpec is checked against its body

package Queue isprocedure Add (Element : Integer);...

end Queue;

package Queue isprocedure Add (Element : Integer);...

end Queue;

package body Queue is...procedure Add (Element : Integer; X : Float) is

...end Add;...

end Queue;

package body Queue is...procedure Add (Element : Integer; X : Float) is

...end Add;...

end Queue;

Compilationerror


Must with Specs usedMust with Specs used

with Queue;procedure Client is

...begin

Queue.Add (3);...

end Client;

Compilationerror


Multiple Name SpacesMultiple Name Spacespackage Queue is

procedure Add (E : Integer);...

end Queue;

package Queue isprocedure Add (E : Integer);...

end Queue;

package Set isprocedure Add (E : Integer);...

end Set;


end Set;

with Queue;with Set;procedure Client isbegin

Queue.Add (3);

Set.Add (99);end Client;


Use Clause and AmbiguitiesUse Clause and Ambiguitiespackage Queue is

procedure Add (E : Integer);...

end Queue;

package Queue isprocedure Add (E : Integer);...

end Queue;


end Set;


end Set;

with Queue; use Queue;with Set; use Set;procedure Client isbegin

Add (123);end Client;

Compilationerror

ambiguity


But … Ada has overloadingBut … Ada has overloadingpackage Queue is

procedure Add (E : Integer);procedure Add (E : Float);...

end Queue;

package Queue isprocedure Add (E : Integer);procedure Add (E : Float);...

end Queue;

with Queue; use Queue;

procedure Client isbegin

Add (123);

Add (3.141);end Client;


package Queues istype Queue is …;

procedure Add (Q : Queue; Element : Integer);function First (Q : Queue) return Integer;function Get (Q : Queue) return Integer;function Empty (Q : Queue) return Boolean;

end Queues;



end Queues;

Having Several QueuesHaving Several Queues


package Queues is

type Queue is …;

end Queues;

package Queues is

type Queue is …;

end Queues;

!!! WARNING !!!!!! WARNING !!!

Use Different names


Using Several QueuesUsing Several Queues

with Queues; use Queues;procedure Client is

Q1 : Queue;Q2 : Queue;

beginAdd (Q1, 123);

Add (Q2, 3);

Add (Q2, Get (Q1));end Client;


One possible implementation ...One possible implementation ...



end Queues;

type Q_Element;type Element_Ptr is

access Queue_Element;


end record;

type Queue is recordFirst : Element_Ptr;Last : Element_Ptr;

end record;

type Q_Element;type Element_Ptr is

access Queue_Element;


end record;

type Queue is recordFirst : Element_Ptr;Last : Element_Ptr;

end record;


Client code allowed to depend Client code allowed to depend on the implementation !on the implementation !



beginAdd (Q1, 123);Add (Q2, 3);

Q2.Last := null;

end Client;

OK


Another implementation ...Another implementation ...



end Queues;

Max_Size : constant := 100;type Q_array (Natural range <>)

of Integer;

type Queue is recordQ : Q_Array (0 .. Max_Size);First : Natural;Last : Natural;Size : Natural;

end record;

Max_Size : constant := 100;type Q_array (Natural range <>)

of Integer;

type Queue is recordQ : Q_Array (0 .. Max_Size);First : Natural;Last : Natural;Size : Natural;

end record;


… breaks client code !… breaks client code !




Q2.Last := null;

end Client;

Compilationerror


Even without changing Even without changing the implementationthe implementationthere is a there is a PROBLEMPROBLEM




Q2.Last := null;

end Client;

Q2 is in aninconsistent

state

33FirstLast

null

Q2:


You need PRIVACYYou need PRIVACY

• Exposing your data structures is risky

– Client code may manipulate the structures directly without using your own services

– Client code is hard to change


ThinkThink BIGBIG

what if what if the the QueuesQueues package package

is is used byused by 1000s1000s of other of other packagespackages


• If there is a bug concerning a Queue, you may have to look at 1000s of packages to find the bug

• If you change the implementation you may have to update 1000s of packages


• Programming in the Large

– privacy• private types• private types & discriminants• limited private types


Private typesPrivate types

package Queues istype Queue is private;


privatetype Queue is …;

end Queues;

package Queues istype Queue is private;



end Queues;


In any implementation ...In any implementation ...package Queues is

type Queue is private;procedure Add (Q : Queue; Element : Integer);function First (Q : Queue) return Integer;function Get (Q : Queue) return Integer;function Empty (Q : Queue) return Boolean;

privatetype Queue_Element;type Element_Ptr is access Queue_Element;type Queue_Element is record

Val : Integer;Next : Element_Ptr;

end record;type Queue is record

First : Element_Ptr;Last : Element_Ptr;

end record;end Queues;


… private types are PRIVATE… private types are PRIVATE




Q2.Last := null;

end Client;

Compilationerror


Advantages of Advantages of privateprivate typestypes

• Enforces the contract of a specification

• No client code can corrupt your data structures

• Can change implementation without changing client code


Why is the private part in the spec ?Why is the private part in the spec ?package Queues is

type Queue is private;procedure Add (Q : Queue; Element : Integer);function First (Q : Queue) return Integer;function Get (Q : Queue) return Integer;function Empty (Q : Queue) return Boolean;

privatetype Queue_Element;type Element_Ptr is access Queue_Element;type Queue_Element is record

Val : Integer;Next : Element_Ptr;

end record;type Queue is record




… because we still need to … because we still need to compile the clients codecompile the clients code

with Queues; use Queues;

procedure Client is

Q1 : Queue;

beginAdd (Q1, 123);

end Client;


… but you can make a private type … but you can make a private type quite privatequite private

package Queues istype Queue is private;procedure Add (Q : Queue; Element : Integer);function First (Q : Queue) return Integer;function Get (Q : Queue) return Integer;function Empty (Q : Queue) return Boolean;

privatetype Queue_Info;type Queue is access Queue_Info;

end Queues;


package body Queues is type Queue_Element;type Element_Ptr is access Queue_Element;


end record;type Queue_Info is record


end record;...

end Queues;


package Queues istype Queue (Max_Size : Natural) is private;


privatetype Q_array (Natural range <>) of Integer;

type Queue (Max_Size : Natural) is recordQ : Q_Array (0 .. Max_Size);First : Natural;Last : Natural;Size : Natural;




Q1 : Queue (100);

Q2 : Queue (250);

beginAdd (Q1, 123);

Add (Q2, 3);end Client;

Q1 can have up to 100 elmts

Q2 can have up to 250 elmts




X : Integer;


Q2 := Q1;

X := Get (Q2);end Client;

Does this affect Q1 ?


it depends on … the it depends on … the implementation !implementation !

• If a Queue is implemented with

– a pointer then Get (Q2) MODIFIES Q1

– a record containing an array then Get (Q2) does NOT modify Q1



Q1 : Queue;Q2 : Queue;X : Integer;

beginAdd (Q1, 123);

Add (Q1, 3);

Q2 := Q1;

X := Get (Q2);X := Get (Q2);end Client;

123123Q1: 33

Q2:

123123Q1:

123123Q1: 33

Q2:

Pointer implementation

Pointer Pointer implementationimplementation


limited private typeslimited private types

• NO assignment :=

• NO equality comparison =


package Queues istype Queue is limited private;



end Queues;




end Queues;




X : Integer;


Q2 := Q1;

end Client;

COMPILATIONERROR

:= forbidden


QueueQueue is an is an Abstract Data TypeAbstract Data Type

(ADT)(ADT)

• Set of abstract values (data domain)

• collection of abstract Operations(routines that manipulate the values)

ADTADTADTADT ====


Queue Queue is an ADTis an ADT




end Queues;




end Queues;operations

values


Objects & VariablesObjects & Variables

• OBJECT = instance of an ADT– piece of memory containing values of the ADT

• VARIABLE = name of a specific object

• not all objects have a name


My_Q : Queue;

Memory

Queueobject

an object

name of the object


type Queue_Ptr is access Queue;

Ptr : Queue_Ptr;

Ptr := new Queue;

Memory

Queueobject

not all objects have a namenot all objects have a name

object has no namePtr is just a pointer to the object


CLASS = ADT+ inheritance


operation

PrivatePrivatePrivatePrivatedatadatadatadata

operation

operation

ENCAPSULATION

invoke some operationin the SPECto use ADTservices


The object modelThe object model


The C modelThe C model

C module C module C module

GLOBAL DATA


To add functionality ...To add functionality ...



end Queues;

function Last (Q : Queue) return Integer;

function Last (Q : Queue) return Integer;

Must add it to

QueuesQueue is a private type


But ...But ...

• Every time you change a spec you must recompile all its clients

• Every time you change a module you must RETEST the whole module


Solution: use child unitsSolution: use child units



end Queues;

queues.ads

function Queues . Last (Q : Queue) return Integer;queues-last.ads

Child subprogram


Child Units RulesChild Units Rules

• The body or private part of a child unit can see the private part of all of its parents

• The spec of a child unit does NOT


Using a child unitUsing a child unit

with Queues; use Queues;with Queues.Last;procedure Client is

Q : Queue;X : Integer;

beginAdd (Q, 123);Add (Q, 3);

X := Queues.Last (Q);end Client;




end Queues;

queues.ads

package Queues . New_Functionality isfunction Last (Q : Queue) return Integer;

end Queues . New_Functionality

queues-new_functionality.ads

Child package


with Queues; use Queues;with Queues.New_Functionality;procedure Client is

Q : Queue;X : Integer;

beginAdd (Q, 123);Add (Q, 3);

X := Queues.New_Functionality.Last (Q);end Client;

ada 95 - programming in the large

Technology