PDF de programación - Programación de sistemas grandes

ditdit

UPM

Programación de sistemas grandes

Juan Antonio de la Puente
DIT/UPM

Objetivos

u Repasaremos los elementos de los lenguajes de

programación que facilitan la realización de sistemas
grandes

u Veremos cómo usar módulos o paquetes para

descomponer un sistema y abstraer los detalles de
realización

u Veremos también cómo realizar componentes de

software que se puedan reutilizar en varios sistemas

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

1

Contenido

u Introducción
u Ocultamiento de información
u Tipos abstractos de datos
u Compilación separada
u Objetos
u Reutilización
u Programación en C

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

2

Descomposición y abstracción

u Descomposición

División de un sistema complejo en componentes más
sencillos, hasta conseguir que cada componente pueda ser
comprendido y realizado por una o varias personas

– diseño descendente

u Abstracción

Especificación de los aspectos esenciales de un componente,
dejando para más adelante su diseño detallado

– diseño ascendente

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

3

Módulos

u Un módulo es una colección de declaraciones de
tipos, objetos y operaciones relacionados entre sí

u Los módulos permiten encapsular partes del

sistema mediante interfaces bien definidas

u Los módulos permiten utilizar algunas técnicas que

facilitan el desarrollo de sistemas grandes:
– ocultamiento de información
– tipos abstractos de datos
– compilación separada

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

4

Contenido

u Introducción
u Ocultamiento de información
u Tipos abstractos de datos
u Compilación separada
u Objetos
u Reutilización
u Programación en C

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

5

Ocultamiento de información

u Los módulos permiten controlar la visibilidad de las

declaraciones

u Para ello se distingue entre
– interfaz visible (especificación)
– cuerpo invisible (implementación)

» contiene los detalles que no son visibles desde fuera

u Es deseable poder compilar la especificación sin

necesidad de escribir el cuerpo

u Ejemplos

– Ada: paquetes
– C: ficheros .h y .c

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

6

Paquetes en Ada

u Un paquete (package) tiene dos partes:

– especificación: contiene únicamente declaraciones

visibles desde otras partes del programa (la interfaz del
paquete)

– cuerpo: contiene los detalles invisibles desde fuera

u Todos los identificadores definidos en la

especificación son visibles a la vez

u Hay una relación formal entre la especificación y el

cuerpo

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

7

Ejemplo (1)

u Especificación de paquete (greetings.ads)

package Greetings is

-- procedimientos para saludar
procedure Hello;
procedure Goodbye;

end Greetings;

u Contiene la especificación de dos procedimientos
u Los cuerpos van en el cuerpo del paquete

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

8

Ejemplo (2)

u Cuerpo del paquete (greetings.adb)

with Ada.text_IO; use Ada.Text_IO;
package body Greetings is

procedure Hello is
begin

Put_Line ("Hello);

end Hello;

procedure Goodbye is
begin

Put_Line ("Goodbye");

end Goodbye;

end Greetings;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

9

Uso de los paquetes

u Los identificadores declarados en la especificación van

cualificados con el nombre del paquete

Greetings.Hello;

u Se puede evitar la cualificación con una cláusula use:

with Greetings; use Greetings;
procedure Greet is
begin

Hello;
Goodbye;
end Greet;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

10

Contenido

u Introducción
u Ocultamiento de información
u Tipos abstractos de datos
u Compilación separada
u Módulos genéricos
u Objetos
u Reutilización
u Programación en C

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

11

Tipos abstractos de datos

u Un TAD es un tipo de datos declarado conjuntamente con un

conjunto de operaciones primitivas

u Los detalles de representación del tipo se ocultan

– se dice que el tipo es privado

u Los detalles sobre la representación del tipo van en una parte

privada de la especificación del paquete
– la parte privada define la interfaz física del paquete y es invisible

desde fuera del mismo

– la utiliza el compilador para crear objetos del tipo abstracto

u Los tipos limitados no tienen operaciones predefinidas
u Los demás tipos privados tienen predefinida la asignación (“:=“)

y la igualdad (“=“)

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

12

Ejemplo: TAD cola (1)

package Queues is

-- tipo abstracto
type Queue is limited private;
-- operaciones primtivas
procedure Create (Q : in out Queue);
function
procedure Insert (Q : in out Queue; E : Element);
procedure Remove (Q : in out Queue; E : out Element);

Empty (Q : Queue) return Boolean;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

13

Ejemplo: TAD cola (2)

private

-- estas declaraciones no son visibles desde fuera
type Queue_Node;
type Queue_Node_Pointer is access Queue_Node;
type Queue_Node is

record

Contents : Element;
Next : Queue_Node_Pointer;

end record;

type Queue is limited

record

Front : Queue_Node_Pointer;
Back : Queue_Node_Pointer;

end record;

end Queues;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

14

Ejemplo: TAD cola (3)

package body Queues is

...

end Queues;

declare

use Queues;
Q1, Q2 : Queue;
E : Element;

begin

Create(Q1); Create(Q2);
if not Empty (Q1) then

Remove (Q1,E); Insert (Q2, E);

end if;

end;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

15

Contenido

u Introducción
u Ocultamiento de información
u Tipos abstractos de datos
u Compilación separada
u Módulos genéricos
u Objetos
u Reutilización
u Programación en C

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

16

Compilación separada

u Es interesante compilar por separado los módulos

de un programa grande

u Conviene distinguir

– Compilación independiente

» los módulos se compilan por separado, pero el compilador no

comprueba la interdependencias

» la resolución de las dependencias se hace al montar el

programa

» los errores aparecen al ejecutar el programa

– Compilación separada

» el compilador comprueba el uso de las definiciones de unos

módulos en otros

» se pueden detectar errores al compilar

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

17

Compilación separada en Ada
u Un programa grande se puede dividir en unidades de

compilación

u En Ada las unidades de compilación pueden ser:

– especificaciones de paquetes
– especificaciones de subprogramas
– los cuerpos de paquetes y subprogramas son unidades secundarias

u La dependencia entre unidades se indica con una cláusula with

with Greetings; use Greetings;
procedure Greet is
begin

Hello;
Goodbye;
end Greet;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

18

Compilación separada con GNAT
u Ahora hay tres ficheros:

greetings.ads
greetings.adb
greet.adb

(especificación de Greetings)
(cuerpo de Greetings)
(cuerpo del procedimiento Greet)

u Para compilar se hace:
$ gcc -c greet.adb
$ gcc -c greetings.adb
» ¡ no hace falta compilar greetings.ads !
» no importa el orden de compilación

u Montaje y enlace :

$ gnatbind greet.ali
$ gnatlink greet.ali

u Se puede hacer todo de una vez:

$ gnatmake greet

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

19

Biblioteca de compilación

u Las unidades que forman un programa se almacenan en una

biblioteca de compilación

u La cláusula with establece una relación de dependencia entre

unidades

u Se pueden escribir (y compilar) las especificaciones antes que

los cuerpos
– el compilador comprueba que las interfaces son consistentes
– esto es adecuado para implementar hacia arriba (bottom-up)
– es compatible con el diseño descendente (top-down)
– los cuerpos dependen de las especificaciones

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

20

Diagramas de módulos

u Permiten representar gráficamente las dependencias entre

unidades de compilación

especificación

cuerpo

Dispatcher

Queues

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

21

Paquetes sin cuerpo

u Los paquetes cuya especificación está completa no tienen

cuerpo

u Por ejemplo, si sólo se declaran tipos, constantes y variables
u Ejemplo:

package Elevation_Definitions is

type Elevation_Angle is digits 5 range -30.0 .. 90.0;

Maximum_Elevation : constant Elevation_Angle := 60.0;
Current_Elevation : Elevation_Angle;

end Elevation_Definitions;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

22

Unidades separadas

u La cláusula separate facilita la implementación hacia abajo
– se puede sustituir un cuerpo por un resguardo (stub) que se

compila más tarde

procedure Main is

type Reading is ...
type Control_Value is ...
procedure Convert (R : Reading; V : out Control_Value)

is separate;

begin -- Main

loop

end loop;

end Main;

Get (R); Convert (R,V); Put (V);

separate (Main)
procedure Convert (R : Reading; V : out Control_Value) is

-- cuerpo del procedimiento

end Convert;

Programación de sistemas grandes -

©1997-2000, Juan Antonio de la Puente

23

Biblioteca jerárquica

u Cuando un programa se hace muy grande, puede haber

conflictos de nombres entre unidades de programa

u Para evitar esto, Ada tiene una biblioteca jerárquica

– Un paquete P puede tener uno o más «hijos» P.Q
– La especificación de P.Q es una extensión de la especificación de

P

» E