Ada 95 - Programming in the large

Franco Gasperoni
gasperon@act-europe.fr
http://libre.act-europe.fr

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

Copyright 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

2

3

What is the largest
software system
you have built ?

(in SLOC)

4

Small 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)

5

Medium/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
6

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

7

Separate Compilation
T
C
H O
D Compiler object
E E

L
C i
P O
D Compiler object n executable
k
R E
e
O r

B
L C
O
Compiler object
E D
E libraries
M 8

Problem with this approach
C C
O C
O O
D D
E D
C E E
O
D C
E O
D
E

• No structure

• To write your own code
– YOU MUST understand
everybody else’s code

9

Idea
SPECIFY
WHAT EACH
MODULE
SHOULD DO

10

SPECIFICATION

?
BODY Software module
11

• specification
• implementation
• specification rules in Ada

12

A Specification is a ...

Users/clients
Implementor of the
of the module
module
CONTRACT

• On the SERVICES provided by the module

13

• SPEC = list of services provided

• BODY = implementation of the services (hidden)

Service_1
Service_2
Service_3
Service_1
implementation

Service_2
implementation

Service_3
implementation
Software module 14

SPECIFICATION

?
BODY 15

Example

• 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

16

queue.ads
queue.ads
package Queue is
package Queue is
procedure Add (Element ::Integer);
procedure Add (Element Integer);

function First return Integer;
function Get return Integer;

function Empty return Boolean;
end Queue;
end Queue;

17

queue.ads
queue.ads
package Queue is
package Queue is
procedure Add (Element : :Integer);


end Queue;
end Queue;

?
BODY package Queue
18

Using package Queue
client.adb
with Queue;
procedure Client is
Queue_Error : exception;
X : Integer;
begin
Queue.Add (3);
Queue.Add (4);

if not Queue.Empty then
X := Queue.Get;
else
raise Queue_Error;
end if;
end Client;
19

Specifications Reduce Complexity
SPEC
SPEC
SPEC
SPEC SPEC
SPEC
SPEC
SPEC

• To write your own code
– only need to understand
specs for the services
you need

20

To write Client only need to look at
queue.ads
queue.ads
package Queue is
package Queue is
procedure Add (Element : :Integer);


end Queue;
end Queue;

? package Queue
21

Aside: use clause
with Queue; use Queue;
procedure Client is
Queue_Error : exception;
X : Integer;
begin
Queue. Add (3);
Queue. Add (4);

if not Queue. Empty then
X := Queue. Get;
else
raise Queue_Error;
end if;
end Client;
22

• specification
• implementation

23

ONE possible
implementation
of package
Queue

This implementation
raises Constraint_Error
if more than Max_Size
elements are put in the Queue.

24

Circular Buffer

Q

0 1
Max_Size - 1

Q_Last Q_First

25

queue.adb
package body Queue is
Max_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) is
begin
Q (Q_Last) := Element;
Q_Last := Q_Last + 1;
Size := Size + 1;
end Add;
... 26
end Queue;

package body Queue is queue.adb
...
function First return Integer is
begin
return Q (Q_First);
end First;
function Get return Integer is
begin
Q_First := Q_First + 1;
Size := Size - 1;
return Q (Q_First - 1);
end Get;

function Empty return Boolean is
begin
return Size = 0;
end Empty; 27
http://libre.act-europe.fr end Queue; under the GNU Free Documentation License
© ACT Europe

ANOTHER possible
implementation
of package
Queue

28

Linked List

Q_First Q_Last

Free 29

queue.adb
type Queue_Element;
type Element_Ptr is access Queue_Element;

type Queue_Element is record
Val : Integer;
Next : Element_Ptr;
end record;

Q_First : Element_Ptr;
Q_Last : Element_Ptr;

Free : Element_Ptr := new Queue_Element;
...
end Queue;
30

queue.adb
...
procedure Add (Element : Integer) is
begin
if Q_First = null then
Q_First := Free;
else
Q_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;
... 31
end Queue;

queue.adb
...
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;
32

queue.adb
...
function First return Integer is
begin
return Q_First;
end First;
function Empty return Boolean is
begin
return Q_First = null;
end Empty;
end Queue;
33

A Spec can have several
implementations
queue.ads
queue.ads
package Queue is
package Queue is (Element : Integer);
procedure Add
procedure Add (Element : Integer);
end Queue;
end Queue;

• Can change implementation
second
second
first
first implement.
implement.
implement.
implement. • WITHOUT having to change
ANY of the client’s code

34

• specification
• implementation

35

In Ada

• Spec always checked against implementation

• Must with the specs that you are going to
use (not in C)
• Packages provide multiple name spaces

36

Spec is checked against its body
package Queue is
package Queue is
procedure Add (Element ::Integer);
...
...
end Queue;
end Queue; Compilation
error
...
...
procedure Add (Element ::Integer; X ::Float) is
procedure Add (Element Integer; X Float) is
...
...
end Add;
end Add;
...
...
end Queue;
end Queue;
37

Must with Specs used

with Queue;
procedure Client is Compilation
... error
begin
Queue.Add (3);
...
end Client;

38

Multiple Name Spaces
package Queue is
package Queue is package Set is
package Set is
procedure Add (E ::Integer);
procedure Add (E Integer); procedure Add (E ::Integer);
procedure Add (E Integer);
...
... ...
...
end Queue;
end Queue; end Set;
end Set;

with Queue;
with Set;
procedure Client is
begin
Queue.Add (3);

Set.Add (99);
end Client; 39

Use Clause and Ambiguities
package Queue is
package Queue is package Set is
package Set is
procedure Add (E Integer); procedure Add (E ::Integer);
...
... ...
...
end Queue;
end Queue; end Set;
end Set;

with Set; use Set;
procedure Client is
begin Compilation
Add (123); error
end Client; ambiguity

40

But … Ada has overloading
package Queue is
package Queue is
procedure Add (E ::Float);
procedure Add (E Float);
...
...
end Queue;
end Queue;


procedure Client is
begin
Add (123);

Add (3.141);
end Client; 41

– privacy

42

Having Several Queues

package Queues is
package Queues is
type Queue is …;
type Queue is …;

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

43

!!! WARNING !!!

package Queues is
package Queues is

type Queue is …; Use Different names
type Queue is …;

end Queues;
end Queues;

44

Using Several Queues
with Queues; use Queues;
procedure Client is
Q1 : Queue;
Q2 : Queue;

begin
Add (Q1, 123);

Add (Q2, 3);

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

One possible implementation ...
type Q_Element;
type Q_Element;
type Element_Ptr is
type Element_Ptr is
access Queue_Element;
access Queue_Element;
Val ::Integer;
Val Integer;
Next ::Element_Ptr;
Next Element_Ptr;
end record;
end record;
package Queues is
type Queue is …; type Queue is record
type Queue is record
First ::Element_Ptr;
First Element_Ptr;
procedure Add (Q : Queue; Element : Integer); Last : Element_Ptr;
function First (Q : Queue) return Integer; Last : Element_Ptr;
end record;
function Get (Q : Queue) return Integer; end record;
function Empty (Q : Queue) return Boolean;
end Queues;

46

Client code allowed to depend
on the implementation !
procedure Client is
Q1 : Queue;
Q2 : Queue;

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

Q2.Last := null; OK

end Client;
47

Another implementation ...

Max_Size ::constant := 100;
Max_Size constant := 100;
type Q_array (Natural range <>)
type Q_array (Natural range <>)
of Integer;
of Integer;
Q ::Q_Array (0 .. Max_Size);
Q Q_Array (0 .. Max_Size);
package Queues is First ::Natural;
First Natural;
type Queue is …;
Last ::Natural;
Last Natural;
procedure Add (Q : Queue; Element : Integer);Size ::Natural;
Size Natural;
end record;
function First (Q : Queue) return Integer;end record;
function Get (Q : Queue) return Integer;
end Queues;

48

… breaks client code !

procedure Client is
Q1 : Queue;
Q2 : Queue;

begin
Add (Q1, 123);
Add (Q2, 3);
Compilation
error
Q2.Last := null;

end Client;
49

Even without changing
the implementation
there is a PROBLEM
procedure Client is
Q1 : Queue;
Q2 : Queue;

begin
Add (Q1, 123); Q2:
Q2 is in an 3
3
inconsistent
Add (Q2, 3);
First
state Last
Q2.Last := null;

end Client; null 50

You 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

51

Think BIG
what if
the Queues package
is used by 1000s of other
packages

52

• 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

53


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

54

Private types

package Queues is
package Queues is
type Queue is private;
private
private
type Queue is …;
type Queue is …;
end Queues;
end Queues;

55

In any implementation ...
package Queues is
procedure Add (Q : Queue; Element : Integer);
function First (Q : Queue) return Integer;
private
type Queue_Element;
Val : Integer;
Next : Element_Ptr;
end record;
First : Element_Ptr;
Last : Element_Ptr;
end record;
end Queues; 56

… private types are PRIVATE

procedure Client is
Q1 : Queue;
Q2 : Queue;

begin
Add (Q1, 123);
Add (Q2, 3);
Compilation
Q2.Last := null; error

end Client;
57

Advantages of private types

• Enforces the contract of a specification

• No client code can corrupt your data structures

• Can change implementation without changing
client code

58

Why is the private part in the spec ?
package Queues is
private
type Queue_Element;
Val : Integer;
Next : Element_Ptr;
end record;
Last : Element_Ptr;
end record;
end Queues; © ACT Europe under the GNU Free Documentation License 59
http://libre.act-europe.fr

… because we still need to
compile the clients code

procedure Client is

Q1 : Queue;

begin
Add (Q1, 123);
end Client;

60

… but you can make a private type
quite private

package Queues is
private
type Queue_Info;
type Queue is access Queue_Info;
end Queues;

61

package body Queues is
type Queue_Element;

Val : Integer;
Next : Element_Ptr;
end record;
type Queue_Info is record
Last : Element_Ptr;
end record;
...
end Queues;
62


– privacy
• private types

63

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

private
type Q_array (Natural range <>) of Integer;

type Queue (Max_Size : Natural) is record
Q : Q_Array (0 .. Max_Size);
First : Natural;
Last : Natural;
Size : Natural;
end record;
end Queues; 64

procedure Client is

Q1 : Queue (100); Q1 can have up to 100 elmts

Q2 : Queue (250); Q2 can have up to 250 elmts

begin
Add (Q1, 123);

Add (Q2, 3);
end Client;

65


– privacy
• private types

66

procedure Client is
Q1 : Queue;
Q2 : Queue;

X : Integer;

begin
Add (Q1, 123);
Add (Q1, 3); Does this affect Q1 ?

Q2 := Q1;

X := Get (Q2);
end Client;

67

it depends on … the
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

68

with Queues; use Queues; Pointer
procedure Client is Pointer
Q1 : Queue; implementation
implementation
Q2 : Queue;
X : Integer;
begin
Q1: 123
123
Add (Q1, 123);

Add (Q1, 3); 123 3
Q1: 123 3

Q2 := Q1; Q2:

Q1: 123
123 3
3
X := Get (Q2);
end Client; Q2:
69

limited private types

• NO assignment :=

• NO equality comparison =
70

package Queues is
package Queues is
type Queue is limited private;
private
private
type Queue is …;
type Queue is …;
end Queues;
end Queues;

71

procedure Client is
Q1 : Queue;
Q2 : Queue;

X : Integer;

begin
Add (Q1, 123);
Add (Q1, 3); COMPILATION
ERROR
Q2 := Q1; := forbidden

end Client;
72

– privacy

73

Queue is an
Abstract Data Type
(ADT)

• Set of abstract values (data domain)
ADT =
• collection of abstract Operations
(routines that manipulate the values)

74

Queue is an ADT
values
package Queues is
package Queues is

private
private
type Queue is …;
type Queue is …; operations
end Queues;
end Queues; 75

Objects & 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

76

an object

My_Q : Queue;
Queue
object

name of the object

Memory
77

not all objects have a name

type Queue_Ptr is access Queue; Queue
object
Ptr : Queue_Ptr;

Ptr := new Queue;

object has no name
Ptr is just a pointer to the object Memory
78

CLASS = ADT
+ inheritance

79

operation invoke some
operation
in the SPEC
operation
to use ADT
services
operation

Private
data

ENCAPSULATION
80

The object model

81

The C model

GLOBAL DATA

C module C module C module 82

– privacy

83

To add functionality ...
function Last (Q : Queue) return Integer;

package Queues is

private
type Queue is …; Must add
end Queues; it to
Queues
Queue is a private type 84

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

85

Solution: use child units
queues.ads
package Queues is
private
type Queue is …;
Child end Queues;
subprogram

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

86

Child 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

87

Using a child unit

with Queues.Last;
procedure Client is
Q : Queue;
X : Integer;

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

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

queues.ads
package Queues is
private
type Queue is …;
end Queues;

Child
package
queues-new_functionality.ads
package Queues . New_Functionality is
end Queues . New_Functionality
89

with Queues.New_Functionality;
procedure Client is
Q : Queue;
X : Integer;

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

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

90

Ada 95 - Programming in the large

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (10)

Similar a Ada 95 - Programming in the large

Similar a Ada 95 - Programming in the large (20)

Más de Gneuromante canalada.org

Más de Gneuromante canalada.org (8)

Último

Último (20)

Ada 95 - Programming in the large