Está en la página 1de 324

UNIVERSIDAD DE OVIEDO

Departamento de Informtica

TESIS DOCTORAL

SISTEMA COMPUTACIONAL DE PROGRAMACIN


FLEXIBLE DISEADO SOBRE UNA MQUINA
ABSTRACTA REFLECTIVA NO RESTRICTIVA

Presentada por
Francisco Ortn Soler
para obtencin del ttulo de Doctor por la Universidad de Oviedo

Dirigida por el
Profesor Doctor D. Juan Manuel Cueva Lovelle

Oviedo, Diciembre de 2001


R E S UME N

Esta tesis describe el modo en el que distintas tcnicas de reflectividad pueden ser
empleadas para el desarrollo de un sistema computacional de programacin extensible y
adaptable dinmicamente, sin sufrir dependencia alguna de un lenguaje de programacin
especfico, y empleando para ello una plataforma virtual heterognea.
Se disea una mquina abstracta, de tamao y complejidad semntica reducida, co-
mo la raz computacional del sistema, que otorga primitivas bsicas de reflectividad. Tanto
su tamao restringido como su capacidad introspectiva, la hacen susceptible de ser implan-
tada en entornos computacionales heterogneos, constituyendo adicionalmente un entorno
computacional independiente de la plataforma.
Haciendo uso de las facultades reflectivas ofrecidas por la mquina abstracta su ni-
vel de abstraccin computacional podr ser extendido dinmicamente, utilizando para ello
su propio lenguaje de programacin sin necesidad de modificar la implementacin reducida
de la mquina virtual, y, por tanto, sin perder portabilidad de su cdigo. El empleo de su
capacidad extensible se utilizar, a modo de ejemplo, en el diseo de abstracciones propias
de persistencia, distribucin, planificacin controlada de hilos y recoleccin de basura. To-
das las abstracciones ofrecidas mediante la extensin de la plataforma, utilizando su propio
lenguaje, son adaptables para cualquier aplicacin, en tiempo de ejecucin.
Se disea un sistema de procesamiento genrico de lenguajes disponiendo de las ca-
ractersticas reflectivas de la plataforma, dando lugar a una independencia global del lengua-
je de programacin seleccionado por el programador. Cualquier aplicacin podr interac-
tuar con otra bajo el modelo computacional de objetos ofrecido por la mquina abstracta,
independientemente del lenguaje en el que hayan sido creadas.
La flexibilidad dinmica del sistema creado es superior, tanto en expresividad como
en el espectro de facetas computacionales adaptables, a los actualmente existentes. La es-
tructura de las aplicaciones en ejecucin, y la especificacin lxica, sintctica y semntica del
lenguaje de programacin, son parmetros configurables dinmicamente, tanto por la pro-
pia aplicacin en cualquiera que sea su lenguaje de programacin, como por cualquier
otro programa. El sistema reflectivo ofrecido no posee restriccin alguna respecto a las
caractersticas computacionales a configurar, ni respecto al modo de expresar su adapta-
cin. Toda la flexibilidad ofrecida es dinmica, no siendo necesario finalizar la ejecucin de
una aplicacin para su configuracin, pudindose adaptar sta a requisitos surgidos dinmi-
camente, imprevisibles en tiempo de desarrollo.
PALABRAS CLAVE

Mquina abstracta, extensibilidad, adaptabilidad, introspeccin, reflectividad estruc-


tural, computacional y de lenguaje, modelo de objetos basado en prototipos, separacin de
aspectos e incumbencias, entorno de programacin, intrprete genrico.
ABSTRACT

This thesis describes the way in which different reflective technologies can be used
to develop a dynamically adaptable and extensible computational system, without any de-
pendency of a concrete programming language, built over a heterogeneous computing plat-
form.
An abstract machine with a reduced instruction set is built as the root computation
systems engine; it offers the programmer basic reflection computation primitives. Its re-
duced size and its introspective capabilities, make it easy to be deployed in heterogeneous
computational systems, becoming a platform-independent computational system.
By using the reflective features offered by the abstract machine, the programming
abstraction level can be extended. This would be programmed on its own language, with-
out needing to modify the virtual machines source code and, therefore, without loosing
code portability. As an example of its extensiveness, the programming environment is pro-
grammed (using the abstract machine programming language) achieving facilities such as
persistence, distribution, thread scheduling or garbage collection. All this new abstractions
are adaptable at runtime to any system application.
A generic processing language system is designed, making the whole system inde-
pendent of the language the programmer may select. Any application can interact with each
other, by using the abstract machines computational model, whatever the programming
language the application has been codified in.
The dynamic flexibility the system achieves is greater both in expressiveness and
in the adaptable computational-features set than any other existing one. At runtime, the
application structure and its programming language specification (lexical, syntactic and se-
mantic features) are completely customisable; it can be adapted by the own application as
well as by any other program no matter the language they have been programmed in. The
reflective system developed has no restriction at all: it can adapt any computational trait
without any expressiveness restriction it may use the whole abstract machine program-
ming language. This flexibility offered is dynamic: there is no need to stop the application
execution in order to adapt it to any runtime requirement, unexpected at design time.
KEYWORDS

Abstract machine, extensibility, adaptability, introspection, structural, computa-


tional and linguistic reflection, prototype-based object-oriented object model, separation of
concerns, aspect oriented programming, programming environment, generic interpreter.
TABLA DE CONTENIDOS

C
CAAPPTTU
ULLO
O 11 : INTRODUCCIN........................................................................................................... 1
1.1 INTRODUCCIN ............................................................................................................................. 1
1.2 OBJETIVOS .................................................................................................................................... 2
1.2.1 Independencia del Lenguaje de Programacin y Plataforma .............................................. 2
1.2.2 Interoperabilidad Directa .................................................................................................... 2
1.2.3 Extensibilidad....................................................................................................................... 3
1.2.4 Adaptabilidad no Restrictiva................................................................................................ 3
1.3 ORGANIZACIN DE LA TESIS ......................................................................................................... 4
1.3.1 Introduccin y Requisitos del Sistema.................................................................................. 4
1.3.2 Sistemas Existentes Estudiados ............................................................................................ 4
1.3.3 Diseo del Sistema ............................................................................................................... 5
1.3.4 Aplicaciones, Evaluacin, Conclusiones y Trabajo Futuro ................................................. 5
1.3.5 Apndices ............................................................................................................................. 5
C
CAAPPTTU
ULLO
O 22 : REQUISITOS DEL SISTEMA...................................................................................... 7
2.1 REQUISITOS DE LA PLATAFORMA DE COMPUTACIN .................................................................... 7
2.1.1 Sistema Computacional Multiplataforma............................................................................. 7
2.1.2 Independencia del Lenguaje de Programacin.................................................................... 8
2.1.3 Independencia del Problema................................................................................................ 8
2.1.4 Tamao y Semntica Computacional Reducida ................................................................... 8
2.1.5 Flexibilidad Computacional................................................................................................. 9
2.1.5.1 Semntica Operacional Abierta ........................................................................................ 9
2.1.5.2 Introspeccin y Acceso al Entorno................................................................................... 9
2.1.5.3 Semntica Computacional Abierta ................................................................................... 9
2.1.6 Interfaz de Acceso y Localizacin del Cdigo Nativo .......................................................... 9
2.1.7 Nivel de Abstraccin del Modelo de Computacin .............................................................. 9
2.2 REQUISITOS DEL ENTORNO DE PROGRAMACIN ......................................................................... 10
2.2.1 Desarrollo de Caractersticas de Computacin (Extensibilidad) ...................................... 10
2.2.2 Seleccin de Caractersticas de Computacin (Adaptabilidad)......................................... 10
2.2.3 Identificacin del Entorno de Programacin ..................................................................... 10
2.2.4 Autodocumentacin Real.................................................................................................... 11
2.3 REQUISITOS CONCERNIENTES AL GRADO DE FLEXIBILIDAD ....................................................... 11
2.3.1 Conocimiento Dinmico del Estado del Sistema................................................................ 11
2.3.2 Modificacin Estructural Dinmica................................................................................... 11
2.3.3 Modificacin Dinmica del Comportamiento .................................................................... 11
2.3.4 Modificacin Computacional sin Restricciones ................................................................. 11
2.3.5 Modificacin y Seleccin Dinmica del Lenguaje ............................................................. 12
2.3.6 Interoperabilidad Directa entre Aplicaciones.................................................................... 12
2.4 REQUISITOS GENERALES DE SISTEMA ......................................................................................... 12
2.4.1 Independencia del Hardware ............................................................................................. 12
2.4.2 Independencia del Sistema Operativo ................................................................................ 13
2.4.3 Interaccin con Sistemas Externos..................................................................................... 13

I
2.4.4 Interoperabilidad Uniforme................................................................................................13
2.4.5 Heterogeneidad ..................................................................................................................13
2.4.6 Sistema de Programacin nico ........................................................................................13
2.4.7 Independencia del Lenguaje ...............................................................................................14
2.4.8 Flexibilidad Dinmica No Restrictiva ................................................................................14
2.4.9 Interoperabilidad Directa...................................................................................................14
C
CAAPPTTU O 33 : MQUINAS ABSTRACTAS .......................................................................................15
ULLO
3.1 PROCESADORES COMPUTACIONALES ..........................................................................................15
3.1.1 Procesadores Implementados Fsicamente.........................................................................15
3.1.2 Procesadores Implementados Lgicamente .......................................................................16
3.2 PROCESADORES LGICOS Y MQUINAS ABSTRACTAS ................................................................17
3.2.1 Mquina Abstracta de Estados...........................................................................................17
3.3 UTILIZACIN DEL CONCEPTO DE MQUINA ABSTRACTA ............................................................18
3.3.1 Procesadores de Lenguajes ................................................................................................18
3.3.1.1 Entornos de Programacin Multilenguaje ......................................................................20
3.3.2 Portabilidad del Cdigo .....................................................................................................20
3.3.3 Sistemas Interactivos con Abstracciones Orientadas a Objetos.........................................21
3.3.4 Distribucin e Interoperabilidad de Aplicaciones..............................................................23
3.3.4.1 Distribucin de Aplicaciones..........................................................................................24
3.3.4.2 Interoperabilidad de Aplicaciones ..................................................................................24
3.3.5 Diseo y Coexistencia de Sistemas Operativos ..................................................................26
3.3.5.1 Diseo de Sistemas Operativos Distribuidos y Multiplataforma ....................................26
3.3.5.2 Coexistencia de Sistemas Operativos .............................................................................27
3.4 APORTACIN DE LA UTILIZACIN DE MQUINAS ABSTRACTAS..................................................28
C
CAAPPTTU
ULLO
O 44 : PANORMICA DE UTILIZACIN DE MQUINAS ABSTRACTAS .................29
4.1 PORTABILIDAD DE CDIGO .........................................................................................................29
4.1.1 Estudio de Sistemas Existentes ...........................................................................................29
Mquina-p ......................................................................................................................................29
OCODE ..........................................................................................................................................30
Portable Scheme Interpreter ...........................................................................................................30
Forth ...............................................................................................................................................31
Sequential Parlog Machine.............................................................................................................31
Code War........................................................................................................................................31
4.1.2 Aportaciones y Carencias de los Sistemas Estudiados.......................................................32
4.2 INTEROPERABILIDAD DE APLICACIONES......................................................................................33
4.2.1 Estudio de Sistemas Existentes ...........................................................................................33
Parallel Virtual Machine.................................................................................................................33
Coherent Virtual Machine ..............................................................................................................34
PerDiS ............................................................................................................................................35
4.2.2 Aportaciones y Carencias de los Sistemas Estudiados.......................................................36
4.3 PLATAFORMAS INDEPENDIENTES ................................................................................................36
4.3.1 Estudio de Sistemas Existentes ...........................................................................................36
Smalltalk-80 ...................................................................................................................................36
Self .................................................................................................................................................38
Java.................................................................................................................................................39
The IBM J9 Virtual Machine..........................................................................................................43
.NET ...............................................................................................................................................44
4.3.2 Aportaciones y Carencias de los Sistemas Estudiados.......................................................45
4.4 DESARROLLO DE SISTEMAS OPERATIVOS DISTRIBUIDOS Y MULTIPLATAFORMA ........................47
4.4.1 Estudio de Sistemas Existentes ...........................................................................................47
Merlin .............................................................................................................................................47
Inferno ............................................................................................................................................47
Oviedo3 ..........................................................................................................................................48
4.4.2 Aportaciones y Carencias de los Sistemas Estudiados.......................................................50
4.5 MQUINAS ABSTRACTAS NO MONOLTICAS ...............................................................................51
4.5.1 Estudio de Sistemas Existentes ...........................................................................................51
Virtual Virtual Machine..................................................................................................................51
Adaptive Virtual Machine ..............................................................................................................53

II
Extensible Virtual Machine............................................................................................................ 54
Distributed Virtual Machine........................................................................................................... 54
4.5.2 Aportaciones y Carencias de los Sistemas Estudiados....................................................... 55
4.6 CONCLUSIONES ........................................................................................................................... 56
C
CAAPPTTU
ULLO
O 55 : SISTEMAS FLEXIBLES NO REFLECTIVOS ......................................................... 59
5.1 IMPLEMENTACIONES ABIERTAS .................................................................................................. 59
5.1.1 Aportaciones y Carencias .................................................................................................. 61
5.2 FILTROS DE COMPOSICIN .......................................................................................................... 62
5.2.1 Aportaciones y Carencias .................................................................................................. 62
5.3 PROGRAMACIN ORIENTADA A ASPECTOS ................................................................................. 63
5.3.1 Aportaciones y Carencias .................................................................................................. 65
5.4 PROGRAMACIN ADAPTABLE ..................................................................................................... 65
5.4.1 Aportaciones y Carencias .................................................................................................. 66
5.5 SEPARACIN MULTIDIMENSIONAL DE INCUMBENCIAS ............................................................... 66
5.5.1 Aportaciones y Carencias .................................................................................................. 68
5.6 SISTEMAS OPERATIVOS BASADOS EN MICRONCLEO ................................................................. 68
Amoeba .......................................................................................................................................... 69
Mach............................................................................................................................................... 70
5.6.1 Aportaciones y Carencias .................................................................................................. 71
5.7 CONCLUSIONES ........................................................................................................................... 72
C
CAAPPTTU
ULLO
O 66 : REFLECTIVIDAD COMPUTACIONAL .................................................................. 73
6.1 CONCEPTOS DE REFLECTIVIDAD ................................................................................................. 73
6.1.1 Reflectividad....................................................................................................................... 73
6.1.2 Sistema Base....................................................................................................................... 74
6.1.3 Metasistema........................................................................................................................ 74
6.1.4 Cosificacin........................................................................................................................ 74
6.1.5 Conexin Causal ................................................................................................................ 75
6.1.6 Metaobjeto.......................................................................................................................... 75
6.1.7 Reflectividad Completa ...................................................................................................... 76
6.2 REFLECTIVIDAD COMO UNA TORRE DE INTRPRETES.................................................................. 76
6.3 CLASIFICACIONES DE REFLECTIVIDAD ........................................................................................ 78
6.3.1 Qu se refleja ..................................................................................................................... 78
6.3.1.1 Introspeccin .................................................................................................................. 78
6.3.1.2 Reflectividad Estructural ................................................................................................ 79
6.3.1.3 Reflectividad Computacional ......................................................................................... 79
6.3.1.4 Reflectividad Lingstica................................................................................................ 79
6.3.2 Cundo se produce el reflejo.............................................................................................. 80
6.3.2.1 Reflectividad en Tiempo de Compilacin ...................................................................... 80
6.3.2.2 Reflectividad en Tiempo de Ejecucin........................................................................... 80
6.3.3 Cmo se expresa el acceso al metasistema ........................................................................ 81
6.3.3.1 Reflectividad Procedural ................................................................................................ 81
6.3.3.2 Reflectividad Declarativa ............................................................................................... 81
6.3.4 Desde Dnde se puede modificar el sistema ...................................................................... 81
6.3.4.1 Reflectividad con Acceso Interno................................................................................... 81
6.3.4.2 Reflectividad con Acceso Externo ................................................................................. 81
6.3.5 Cmo se ejecuta el sistema................................................................................................. 82
6.3.5.1 Ejecucin Interpretada.................................................................................................... 82
6.3.5.2 Ejecucin Nativa ............................................................................................................ 82
6.4 HAMILTONIANS VERSUS JEFFERSONIANS .................................................................................... 82
6.5 FORMALIZACIN ......................................................................................................................... 83
C
CAAPPTTU
ULLO
O 77 : PANORMICA DE UTILIZACIN DE REFLECTIVIDAD ................................. 85
7.1 SISTEMAS DOTADOS DE INTROSPECCIN .................................................................................... 85
ANSI/ISO C++ RunTime Type Information (RTTI) ..................................................................... 85
Plataforma Java .............................................................................................................................. 86
CORBA .......................................................................................................................................... 88
COM............................................................................................................................................... 90
7.1.1 Aportaciones y Carencias de los Sistemas Estudiados....................................................... 91

III
7.2 SISTEMAS DOTADOS DE REFLECTIVIDAD ESTRUCTURAL ............................................................92
Smalltalk-80 ...................................................................................................................................92
Self, Proyecto Merlin......................................................................................................................94
ObjVlisp .........................................................................................................................................96
Linguistic Reflection in Java ..........................................................................................................98
Python.............................................................................................................................................99
7.2.1 Aportaciones y Carencias de los Sistemas Estudiados.....................................................100
7.3 REFLECTIVIDAD EN TIEMPO DE COMPILACIN ..........................................................................100
OpenC++ ......................................................................................................................................100
OpenJava ......................................................................................................................................101
Java Dynamic Proxy Classes ........................................................................................................102
7.3.1 Aportaciones y Carencias de los Sistemas Estudiados.....................................................103
7.4 REFLECTIVIDAD COMPUTACIONAL BASADA EN META-OBJECT PROTOCOLS .............................104
Closette.........................................................................................................................................104
MetaXa .........................................................................................................................................105
Iguana ...........................................................................................................................................107
Cognac..........................................................................................................................................108
Guanar ........................................................................................................................................110
Dalang ..........................................................................................................................................111
NeoClasstalk.................................................................................................................................112
Moostrap.......................................................................................................................................113
7.4.1 Aportaciones y Carencias de los Sistemas Estudiados.....................................................114
7.5 INTRPRETES METACIRCULARES...............................................................................................116
3-Lisp ...........................................................................................................................................116
ABCL/R2......................................................................................................................................117
MetaJ ............................................................................................................................................118
7.5.1 Aportaciones y Carencias de los Sistemas Estudiados.....................................................119
7.6 CONCLUSIONES .........................................................................................................................120
7.6.1 Momento en el que se Produce el Reflejo.........................................................................120
7.6.2 Informacin Reflejada ......................................................................................................120
7.6.3 Niveles Computacionales Reflectivos ...............................................................................121
C
CAAPPTTU
ULLO
O 88 : LENGUAJES ORIENTADOS A OBJETOS BASADOS EN PROTOTIPOS .......123
8.1 CLASES Y PROTOTIPOS ..............................................................................................................123
8.2 UTILIZACIN DE LENGUAJES ORIENTADOS A OBJETOS BASADOS EN PROTOTIPOS ...................125
8.2.1 Reduccin Semntica........................................................................................................125
8.2.2 Inexistencia de Prdida de Expresividad..........................................................................125
8.2.3 Traduccin Intuitiva de Modelos......................................................................................126
8.2.4 Coherencia en Entornos Reflectivos.................................................................................126
8.3 CONCLUSIONES .........................................................................................................................128
C
CAAPPTTU
ULLO
O 99 : ARQUITECTURA DEL SISTEMA ..........................................................................129
9.1 CAPAS DEL SISTEMA .................................................................................................................129
9.1.1 Mquina Abstracta ...........................................................................................................130
9.1.2 Entorno de Programacin ................................................................................................130
9.1.3 Sistema Reflectivo No Restrictivo .....................................................................................130
9.2 NICO MODELO COMPUTACIONAL DE OBJETOS .......................................................................131
9.3 MQUINA ABSTRACTA..............................................................................................................132
9.3.1 Conjunto Reducido de Primitivas .....................................................................................133
9.3.2 Mecanismo de Extensibilidad ...........................................................................................133
9.3.3 Seleccin del Modelo Computacional ..............................................................................134
9.3.4 Interaccin Directa entre Aplicaciones............................................................................134
9.3.5 Evaluacin Dinmica de Datos como Cdigo..................................................................135
9.4 ENTORNO DE PROGRAMACIN ..................................................................................................135
9.4.1 Portabilidad e Independencia del Lenguaje.....................................................................135
9.4.2 Adaptabilidad ...................................................................................................................135
9.4.3 Introspeccin ....................................................................................................................136
9.5 SISTEMA REFLECTIVO NO RESTRICTIVO ...................................................................................136
9.5.1 Caractersticas Adaptables...............................................................................................137
9.5.2 Independencia del Lenguaje .............................................................................................137

IV
9.5.3 Grado de Flexibilidad de la Semntica Computacional .................................................. 137
9.5.4 Adaptabilidad No Restrictiva ........................................................................................... 138
C
CAAPPTTU
ULLO
O 1100 : ARQUITECTURA DE LA MQUINA ABSTRACTA ........................................ 141
10.1 CARACTERSTICAS PRINCIPALES DE LA MQUINA ABSTRACTA ................................................ 141
10.1.1 Reduccin de Primitivas Computacionales...................................................................... 141
10.1.2 Extensibilidad................................................................................................................... 143
10.1.3 Definicin del Modelo Computacional............................................................................. 143
10.1.4 Adaptabilidad ................................................................................................................... 144
10.1.5 Interaccin Directa entre Aplicaciones............................................................................ 145
10.1.6 Manipulacin Dinmica del Comportamiento ................................................................. 145
10.2 TCNICAS DE DISEO SELECCIONADAS .................................................................................... 146
C
CAAPPTTU
ULLO
O 1111 : ARQUITECTURA DEL SISTEMA REFLECTIVO NO RESTRICTIVO ......... 147
11.1 ANLISIS DE TCNICAS DE OBTENCIN DE SISTEMAS FLEXIBLES ............................................ 147
11.1.1 Sistemas Flexibles No Reflectivos .................................................................................... 147
11.1.2 Sistemas Reflectivos ......................................................................................................... 148
11.1.2.1 Reflectividad Dinmica ............................................................................................ 148
11.2 SISTEMA COMPUTACIONAL REFLECTIVO SIN RESTRICCIONES .................................................. 150
11.2.1 Salto Computacional ........................................................................................................ 152
11.2.2 Representacin Estructural de Lenguajes y Aplicaciones................................................ 154
11.3 BENEFICIOS DEL SISTEMA PRESENTADO ................................................................................... 157
11.4 REQUISITOS IMPUESTOS A LA MQUINA ABSTRACTA ............................................................... 158
C
CAAPPTTU
ULLO
O 1122 : DISEO DE LA MQUINA ABSTRACTA.......................................................... 159
12.1 ESPECIFICACIN DE LA MQUINA ABSTRACTA ........................................................................ 159
12.1.1 Nocin de Objeto.............................................................................................................. 159
12.1.2 Entorno de Programacin................................................................................................ 160
12.1.3 Objetos Primitivos............................................................................................................ 160
Referencias ................................................................................................................................... 161
12.1.3.1 Objeto nil.................................................................................................................. 161
12.1.3.2 Objetos Cadenas de Caracteres................................................................................. 161
12.1.3.3 Objeto Extern .......................................................................................................... 163
12.1.3.4 Objeto System.......................................................................................................... 164
12.1.4 Posibles Evaluaciones...................................................................................................... 165
12.1.4.1 Creacin de Referencias ........................................................................................... 166
12.1.4.2 Asignacin de Referencias ....................................................................................... 166
12.1.4.3 Acceso a los Miembros ............................................................................................ 166
12.1.4.4 Evaluacin o Descosificacin de Objetos Miembro................................................. 167
12.1.4.5 Comentarios ............................................................................................................. 168
12.1.4.6 Evaluacin de Objetos Cadena de Caracteres .......................................................... 168
12.1.5 Delegacin o Herencia Dinmica .................................................................................... 168
12.1.6 Reflectividad Estructural y Computacional ..................................................................... 169
12.1.7 Objetos Miembro Primitivos ............................................................................................ 169
12.2 EXTENSIN DE LA MQUINA ABSTRACTA ................................................................................ 171
12.2.1 Creacin de Nuevas Abstracciones .................................................................................. 171
12.2.2 Evaluacin de Objetos...................................................................................................... 172
12.2.2.1 Evaluacin de Objetos Miembro .............................................................................. 173
12.2.2.2 Evaluacin de Objetos Cadena de Caracteres .......................................................... 174
12.2.3 Creacin de Objetos Evaluables ...................................................................................... 174
12.2.3.1 Creacin de Objetos con Identificador ..................................................................... 174
12.2.3.2 Igualdad de Objetos.................................................................................................. 174
12.2.3.3 Operaciones Lgicas ................................................................................................ 175
12.2.3.4 Iteraciones ................................................................................................................ 177
12.2.3.5 Recorrido de Miembros............................................................................................ 179
12.2.3.6 Bucles Infinitos......................................................................................................... 180
12.2.4 Aritmtica de la Plataforma ............................................................................................. 181
12.2.4.1 Miembros de Semntica Aritmtica ......................................................................... 182
12.2.5 Miembros Polimrficos de Comparacin......................................................................... 183
12.2.6 Miembros de Objetos Cadena de Caracteres................................................................... 185

V
12.2.7 Creacin de Abstracciones e Instancias...........................................................................186
12.2.7.1 Creacin de Abstracciones .......................................................................................186
12.2.7.2 Copia de Prototipos ..................................................................................................188
12.2.8 Implementaciones Externas Requeridas...........................................................................190
12.3 IMPLANTACIN Y ACCESO A LA PLATAFORMA..........................................................................191
C
CAAPPTTU
ULLO
O 1133 : DISEO DEL ENTORNO DE PROGRAMACIN..............................................195
13.1 RECOLECCIN DE BASURA ........................................................................................................195
13.1.1 Diseo General del Sistema..............................................................................................196
13.1.2 Recoleccin Genrica.......................................................................................................196
13.1.3 Algoritmos de Recoleccin ...............................................................................................197
13.1.4 Polticas de Activacin .....................................................................................................197
13.2 PLANIFICACIN DE HILOS .........................................................................................................198
13.2.1 Creacin de Mtodos........................................................................................................198
13.2.2 Introduccin de Cdigo Intruso de Sincronizacin ..........................................................199
13.2.3 MOP para la Evaluacin de Cdigo ................................................................................200
13.2.4 Creacin de Hilos.............................................................................................................201
13.2.5 Planificacin Genrica.....................................................................................................202
13.3 SISTEMA DE PERSISTENCIA........................................................................................................203
13.3.1 Diseo General del Sistema..............................................................................................203
13.3.2 Implantacin de un Flujo de Persistencia ........................................................................204
13.3.3 MOP para Acceso al Miembro .........................................................................................205
13.3.4 Objetos Delegados............................................................................................................206
13.3.5 Recuperacin de Objetos Persistentes..............................................................................208
13.4 SISTEMA DE DISTRIBUCIN .......................................................................................................209
13.4.1 Diseo General del Sistema..............................................................................................209
13.4.2 Primitivas del Sistema de Distribucin ............................................................................211
13.4.3 Objetos Delegados............................................................................................................212
13.4.4 Recolector de Basura Distribuido ....................................................................................213
13.5 CONCLUSIONES .........................................................................................................................215
C
CAAPPTTU
ULLO
O 1144 : DISEO DE UN PROTOTIPO DE COMPUTACIN REFLECTIVA SIN
RESTRICCIONES .................................................................................................................................217
14.1 SELECCIN DEL LENGUAJE DE PROGRAMACIN........................................................................217
Introspeccin ................................................................................................................................218
Reflectividad Estructural ..............................................................................................................218
Creacin, Manipulacin y Evaluacin Dinmica de Cdigo ........................................................219
Interaccin Directa entre Aplicaciones.........................................................................................219
14.2 DIAGRAMA DE SUBSISTEMAS ....................................................................................................220
14.2.1 Subsistema nitrO...............................................................................................................221
14.2.2 Subsistema objectBrowser ................................................................................................221
14.2.3 Subsistema langSpec.........................................................................................................221
14.2.4 Subsistema metaLang .......................................................................................................221
14.2.5 Subsistema appSpec..........................................................................................................222
14.2.6 Subsistema GI ...................................................................................................................222
14.3 SUBSISTEMA METALANG...........................................................................................................222
14.3.1 Diagrama de Clases .........................................................................................................222
14.4 SUBSISTEMA LANGSPEC ............................................................................................................223
14.4.1 Diagrama de Clases .........................................................................................................224
14.4.2 Especificacin de Lenguajes mediante Objetos................................................................225
14.5 SUBSISTEMA APPSPEC ...............................................................................................................227
14.5.1 Diagrama de Clases .........................................................................................................228
14.5.2 Creacin del rbol Sintctico ..........................................................................................229
14.6 SUBSISTEMA GI.........................................................................................................................230
14.6.1 Diagrama de Clases .........................................................................................................231
14.6.2 Evaluacin del rbol Sintctico .......................................................................................232
14.7 SUBSISTEMA NITRO...................................................................................................................233
14.7.1 Diagrama de Clases .........................................................................................................233
C
CAAPPTTU
ULLO
O 1155 : MBITOS DE APLICACIN DEL SISTEMA.....................................................235

VI
15.1 SISTEMAS DE PERSISTENCIA Y DISTRIBUCIN ........................................................................... 235
15.1.1 Adaptabilidad a los Cambios ........................................................................................... 236
15.1.2 Replicacin y Movilidad de Objetos Flexible................................................................... 237
15.1.3 Independencia del Aspecto y Seleccin Dinmica ........................................................... 237
15.1.4 Agentes Mviles Inteligentes y Autodescriptivos.............................................................. 238
15.1.5 Distribucin de Aplicaciones Independientemente de su Lenguaje ................................. 239
15.2 SISTEMAS DE COMPONENTES .................................................................................................... 239
15.3 PARADIGMA DE PROGRAMACIN DINMICAMENTE ADAPTABLE ............................................. 240
15.3.1 Polimorfismo Dinmico ................................................................................................... 240
15.3.2 Gestin de Informacin Desconocida en Fase de Desarrollo.......................................... 241
15.3.3 Patrones de Diseo Adaptables........................................................................................ 242
15.4 APLICACIONES TOLERANTES A FALLOS .................................................................................... 243
15.5 PROCESAMIENTO DE LENGUAJES .............................................................................................. 244
15.5.1 Depuracin y Programacin Continua ............................................................................ 244
15.5.2 Generacin de Cdigo...................................................................................................... 245
15.6 ADAPTACIN DE LENGUAJES DE PROGRAMACIN .................................................................... 246
15.6.1 Adaptacin al Problema................................................................................................... 246
15.6.2 Agregacin de Caractersticas al Lenguaje ..................................................................... 247
15.7 SISTEMAS OPERATIVOS ADAPTABLES ....................................................................................... 247
15.8 ADAPTACIN Y CONFIGURACIN DE SISTEMAS ........................................................................ 248
15.8.1 Gestin y Tratamiento del Conocimiento......................................................................... 248
15.8.2 Personalizacin de Aplicaciones...................................................................................... 248
C
CAAPPTTU
ULLO
O 1166 : EVALUACIN DEL SISTEMA ............................................................................. 251
16.1 COMPARATIVA DE SISTEMAS .................................................................................................... 251
16.2 CRITERIOS DE EVALUACIN ...................................................................................................... 252
16.3 EVALUACIN ............................................................................................................................ 253
16.4 JUSTIFICACIN DE LAS EVALUACIONES .................................................................................... 258
16.5 CONCLUSIONES ......................................................................................................................... 261
16.5.1 Evaluacin de las Plataformas......................................................................................... 261
16.5.2 Evaluacin de los Criterios para Construir un Entorno de Programacin ..................... 261
16.5.3 Evaluacin del Grado de Flexibilidad ............................................................................. 261
16.5.4 Evaluacin Global del Sistema ........................................................................................ 262
16.5.5 Evaluacin Absoluta......................................................................................................... 262
C
CAAPPTTU
ULLO
O 1177 : CONCLUSIONES..................................................................................................... 265
17.1 SISTEMA DISEADO .................................................................................................................. 266
17.1.1 Mquina Abstracta ........................................................................................................... 266
17.1.2 Entorno de Programacin................................................................................................ 266
17.1.3 Sistema Reflectivo No Restrictivo..................................................................................... 267
17.2 PRINCIPALES VENTAJAS APORTADAS ....................................................................................... 267
17.2.1 Heterogeneidad de la Plataforma .................................................................................... 267
17.2.2 Extensibilidad................................................................................................................... 268
17.2.3 Adaptabilidad ................................................................................................................... 268
17.2.4 Modelo Computacional nico e Independiente del Lenguaje.......................................... 269
17.2.5 Flexibilidad ...................................................................................................................... 269
17.3 FUTURAS LNEAS DE INVESTIGACIN Y TRABAJO ..................................................................... 270
17.3.1 Aplicacin a Sistemas Computacionales.......................................................................... 270
17.3.1.1 Sistema de Persistencia Implcita ............................................................................. 270
17.3.1.2 Entorno de Distribucin de Agentes......................................................................... 271
17.3.1.3 Semntica del Lenguaje Natural............................................................................... 271
17.3.2 Ampliacin y Modificacin de la Implementacin ........................................................... 272
17.3.2.1 nica Aplicacin ...................................................................................................... 272
17.3.2.2 Especificacin de Lenguajes .................................................................................... 272
17.3.2.3 Implantacin en Distintos Sistemas.......................................................................... 272
17.3.2.4 Ayuda al Desarrollo de Aplicaciones ....................................................................... 272
17.3.2.5 Eficiencia.................................................................................................................. 273
APPN
A NDDIIC
CEE A
A : DISEO DE UN PROTOTIPO DE MQUINA VIRTUAL.................................. 275
A.1 ACCESO A LA MQUINA VIRTUAL ............................................................................................ 275

VII
A.2 DIAGRAMA DE SUBSISTEMAS ....................................................................................................276
A.2.1 Subsistema LanguageProcessor .......................................................................................277
A.2.2 Subsistema Interpreter......................................................................................................277
A.2.3 Subsistema ObjectMemory ...............................................................................................277
A.3 SUBSISTEMA LANGUAGEPROCESSOR ........................................................................................277
A.4 SUBSISTEMA OBJECTMEMORY ..................................................................................................278
A.5 SUBSISTEMA INTERPRETER ........................................................................................................280
A
APPN
NDDIIC
CEE B
B : MANUAL DE USUARIO DEL PROTOTIPO DE COMPUTACIN
REFLECTIVA SIN RESTRICCIONES ..............................................................................................283
B.1 INSTALACIN Y CONFIGURACIN..............................................................................................283
B.2 METALENGUAJE DEL SISTEMA ..................................................................................................283
B.2.1 Gramtica del Metalenguaje ............................................................................................284
B.2.2 Descripcin Lxica ...........................................................................................................284
B.2.3 Descripcin Sintctica......................................................................................................285
B.2.4 Tokens de Escape y Reconocimiento Automtico.............................................................285
B.2.5 Especificacin Semntica .................................................................................................286
B.2.6 Instruccin Reify...............................................................................................................286
B.3 APLICACIONES DEL SISTEMA.....................................................................................................286
B.3.1 Gramtica de Aplicaciones...............................................................................................286
B.3.2 Aplicaciones Autosuficientes ............................................................................................287
B.3.3 Reflectividad No Restrictiva .............................................................................................287
B.3.4 Reflectividad de Lenguaje.................................................................................................288
B.4 INTERFAZ GRFICO ...................................................................................................................288
B.4.1 Intrprete de Comandos ...................................................................................................288
B.4.2 Archivos Empleados .........................................................................................................289
B.4.3 Introspeccin del Sistema .................................................................................................290
B.4.4 Ejecucin de Aplicaciones................................................................................................292
A
APPN
NDDIIC
CEE C
C : REFERENCIAS BIBLIOGRFICAS......................................................................295

VIII
CAPTULO 1:
INTRODUCCIN

A lo largo de este captulo se describen los principales objetivos buscados en el de-


sarrollo de esta tesis doctoral, estableciendo un marco de requisitos generales a cumplir en
la tesis enunciada en esta memoria y posteriormente demostrada mediante la creacin y
evaluacin de una serie de prototipos. Posteriormente se presenta la organizacin de la
memoria, estructurada tanto en secciones como en captulos.

1.1 Introduccin
El modo en el que un ordenador es programado queda determinado, principalmen-
te, por los requisitos que los futuros usuarios demandarn de dicha computadora. En el
caso del entorno de computacin de una oficina de ingeniera civil, se demandar la utiliza-
cin de aplicaciones relacionadas con el diseo asistido por computador. Sin embargo, en
el caso de entidades bancarias, el tratamiento de elevadas cantidades de informacin es el
proceso ms comn. La eleccin del lenguaje de programacin utilizado a la hora de im-
plementar una aplicacin, dentro de un amplio espectro de posibilidades, queda condicio-
nada por el tipo de aplicacin a desarrollar.
La semntica de un lenguaje de programacin, as como el propsito para el que s-
te haya sido diseado, restringe de algn modo la sencillez con la que pueda emplearse para
resolver un determinado tipo de problema. Los lenguajes de propsito especfico [Cue-
va98] estn enfocados a desarrollar una clase concreta de aplicaciones del modo ms senci-
llo posible, estando su semntica restringida al propsito para el que fueron creados. Por
otro lado, los denominados lenguajes de propsito general tienen como objetivo el poder
representar la solucin de cualquier tipo de problema computacional. Sin embargo, dentro
de esta clasificacin existen diferencias significativas. Lenguajes como Java [Gosling96] y
C++ [Stroustrup98], ambos de propsito general, orientados a objetos y de sintaxis anlo-
ga, pueden ser elegidos, por ejemplo, para desarrollar aplicaciones portables y distribuidas
en el primer caso, o bien para crear aqullas en las que prime su eficiencia en tiempo de
ejecucin el caso del lenguaje C++.
La semntica computacional de un lenguaje de programacin es algo fijo que se
mantiene constante en las aplicaciones codificadas sobre l. Una aplicacin carece de la
posibilidad de modificar la semntica del lenguaje con el que fue creada, para poder amol-
darse a nuevos requisitos que puedan surgir a lo largo de su existencia, sin necesidad de
modificar su cdigo existente su funcionalidad principal.

1
CAPTULO 1

Adems de limitar las posibilidades computacionales de una aplicacin a la hora de


elegir el lenguaje de programacin en el que sta vaya a ser desarrollado, la interaccin entre
aplicaciones desarrolladas sobre distintos lenguajes se lleva a cabo comnmente mediante la
utilizacin de mecanismos adicionales. El uso de modelos binarios de componentes (como
por ejemplo COM [Microsoft95]) o de arquitecturas de objetos distribuidos y middlewares
(CORBA [OMG95]), son necesarios para permitir la interaccin entre aplicaciones desarro-
lladas en distintos lenguajes de programacin y, en ocasiones, sobre distintas plataformas.
Justificamos as la necesidad de estudiar las alternativas en la creacin de un entor-
no computacional de programacin, independiente del lenguaje y plataforma seleccionados,
que permita desarrollar aplicaciones en cualquier lenguaje de programacin, y que stas
puedan interactuar entre s sin necesidad de utilizar ningn mecanismo intermedio. Del
mismo modo, la semntica de un lenguaje de programacin no deber ser algo fijo e inva-
riable a lo largo del ciclo de vida de las aplicaciones codificadas sobre l; su significado (se-
mntica) podr adaptarse a futuros contextos imprevisibles en tiempo de desarrollo.
A lo largo de esta tesis estudiaremos las distintas alternativas, y enunciaremos otras,
para crear un entorno computacional de programacin flexible, en el que se satisfagan to-
dos los objetivos enunciados someramente en el prrafo anterior.

1.2 Objetivos
Enunciaremos los distintos objetivos generales propuestos en la creacin del entor-
no de programacin previamente mencionado, posponiendo hasta el siguiente captulo la
especificacin formal del conjunto integral de requisitos impuestos a nuestro sistema.

1.2.1 Independencia del Lenguaje de Programacin y Plataforma


El sistema computacional podr ser programado mediante cualquier lenguaje y sus
aplicaciones podrn ser ejecutadas sobre cualquier plataforma. La dependencia actualmente
existente en determinados sistemas computacionales, en el que el lenguaje de programacin
de aplicaciones y la plataforma de desarrollo imponen una determinada plataforma en su
implantacin, deber ser suprimida. La eleccin del lenguaje de programacin a utilizar
estar nicamente determinada por el modo en el que su expresividad modela el problema,
y por las preferencias del programador.
En nuestro sistema, una aplicacin podr desarrollarse utilizando mltiples lengua-
jes de programacin, sin necesidad de utilizar una capa de intercomunicacin entre sus dis-
tintos mdulos. La programacin del sistema no tiene por qu llevarse a cabo mediante un
lenguaje conocido; en su cdigo fuente podr especificarse el lenguaje de codificacin utili-
zado, capacitando al sistema para la ejecucin de la aplicacin sin conocimiento previo del
lenguaje a emplear.

1.2.2 Interoperabilidad Directa


Actualmente, la utilizacin de una capa software intermedia es la solucin ms ex-
tendida para conseguir interoperabilidad entre aplicaciones desarrolladas en distintos len-
guajes de programacin o distintas plataformas fsicas. La traduccin entre modelos de
componentes, middlewares de distribucin o arquitecturas de objetos distribuidos, otorga la
posibilidad de intercomunicar aplicaciones desarrolladas en distintos lenguajes de progra-
macin, sistemas operativos y plataformas. Sin embargo, la utilizacin de estas capas adi-
cionales conlleva determinados inconvenientes: una mayor complejidad a la hora de des-

2
Introduccin

arrollar aplicaciones, mltiples traducciones entre distintos modelos computacionales, de-


pendencia de los mecanismos utilizados (acoplamiento), y reduccin de la mantenibilidad
ante futuros cambios.
Para nuestro sistema, la interoperabilidad entre las distintas capas de una aplicacin,
as como entre distintas aplicaciones dentro del sistema, ha de llevarse a cabo sin necesidad
de utilizar de un software intermedio de intercomunicacin, de forma independiente al
lenguaje de programacin y plataforma utilizados.
El sistema ha de ofrecer un conocimiento dinmico del estado del mismo, ofre-
ciendo los servicios de cualquier aplicacin que est ejecutndose.

1.2.3 Extensibilidad
Los sistemas computacionales comunes amplan su nivel de abstraccin de diversas
maneras; ejemplos son la ampliacin del lenguaje de programacin, la implementacin de
libreras o APIs, o el desarrollo de componentes software.
La modificacin del lenguaje de programacin supone nuevas versiones de los pro-
cesadores del lenguaje asociado, generando una prdida de la portabilidad del cdigo des-
arrollado para versiones anteriores. La utilizacin de componentes, APIs o libreras, no
ofrece un conocimiento dinmico de los servicios ofrecidos y carece de un sistema genrico
de ampliacin de su funcionalidad para el resto del sistema en ocasiones, existe una de-
pendencia adicional de una plataforma o lenguaje de programacin.
Nuestro sistema deber soportar un mecanismo para poder extenderse: conocer di-
nmicamente los servicios existentes para poder ampliar stos, si as es requerido, obte-
niendo un mayor nivel de abstraccin para el conjunto del entorno de programacin, de un
modo independiente del lenguaje y plataforma.
Una aplicacin podr hacer uso de los servicios desarrollados que extiendan el nivel
de abstraccin global del sistema cualquiera que sea su lenguaje de programacin y plata-
forma.

1.2.4 Adaptabilidad no Restrictiva


La adaptabilidad de un sistema computacional es la capacidad para poder amoldarse
a requisitos surgidos dinmicamente, desconocidos en fase de desarrollo. La mayora de los
sistemas existentes ofrecen mecanismos muy limitados para poder desarrollar aplicaciones
dinmicamente adaptables.
Las aplicaciones desarrolladas en nuestro entorno de programacin debern poder
adaptarse a contextos surgidos dinmicamente, sin haber predicho stos en fase de desarro-
llo. En tiempo de ejecucin, una aplicacin podr detectar nuevos requisitos y adaptarse a
stos sin necesidad de detener su ejecucin, modificar su cdigo fuente, y reanudarla.
Tanto la estructura de la aplicacin en ejecucin, como la semntica del lenguaje de
programacin sobre el que haya sido codificada, debern poder adaptarse sin restriccin
alguna. Como estudiaremos en el captulo 5 y en el captulo 7, determinados sistemas slo
permiten adaptar dinmicamente una parte de la estructura de sus aplicaciones, o de su
lenguaje de programacin.
Bajo nuestro sistema computacional, una aplicacin, cualquiera que sea su lenguaje
de programacin, podr ser desarrollada separando su cdigo funcional de determinados
aspectos independientes de su funcionalidad y, por tanto, reutilizables (depuracin, persis-

3
CAPTULO 1

tencia, sincronizacin, distribucin o monitorizacin). Dinmicamente, los distintos aspec-


tos del programa podrn ser examinados y modificados, sin necesidad de finalizar su ejecu-
cin.
A lo largo de esta memoria, utilizaremos el concepto de flexibilidad como la unin
de las caractersticas de extensibilidad y adaptabilidad, propias de un sistema computacio-
nal.
Cabe mencionar, como profundizaremos en el captulo 6, que el objetivo principal
del sistema buscado es la flexibilidad del mismo, siendo sta comnmente contraria a su
eficiencia; cuanto ms flexible es un entorno computacional, menor es su eficiencia. Queda
por tanto fuera de nuestros principales objetivos el buscar un sistema de computacin ms
eficiente que los estudiados pero s ms flexible. Diversas tcnicas para obtener una mejo-
ra de rendimientos de ejecucin, podrn ser aplicadas al sistema presentado.

1.3 Organizacin de la Tesis


A continuacin estructuramos la tesis, agrupando los captulos en secciones con un
contenido acorde.

1.3.1 Introduccin y Requisitos del Sistema


En este captulo narraremos la introduccin, objetivos y organizacin de esta tesis.
En el captulo siguiente estableceremos el conjunto de requisitos impuestos a nuestro sis-
tema, que sern utilizados principalmente:
Para evaluar las aportaciones y carencias de los sistemas estudiados en la prxi-
ma seccin.
Para fijar la arquitectura global de nuestro sistema, as como la arquitectura de
cada una de las capas que ste posee.
Para evaluar los resultados del sistema propuesto, comparndolos con otros sis-
temas existentes estudiados captulo 16.

1.3.2 Sistemas Existentes Estudiados


En esta seccin se lleva a cabo un estudio del estado del arte de los sistemas simila-
res al buscado. En el captulo 3 se introduce el concepto de mquina abstracta, as como las
ventajas generales de su utilizacin. Un estudio y evaluacin de distintos tipos de mquinas
abstractas existentes es llevado a cabo en el captulo 4.
En el captulo 5, se detalla el anlisis de cmo determinados sistemas ofrecen flexi-
bilidad computacional sin utilizar tcnicas de reflectividad. Esta tcnica, sus conceptos
principales y distintas clasificaciones, son introducidos en el captulo 6. La evaluacin de
mltiples sistemas reflectivos, sus aportaciones y limitaciones frente a los requisitos im-
puestos, son presentados en el captulo 7.
Finalmente, en el captulo 8, se presentan y estudian los modelos computacionales
orientados a objetos que, careciendo del concepto de clase, estn basados en prototipos.

4
Introduccin

1.3.3 Diseo del Sistema


En esta seccin se introduce el sistema propuesto basndose en los requisitos im-
puestos y los sistemas estudiados. La arquitectura global del sistema y su descomposicin
en capas es presentada en el captulo 9; la arquitectura de la primera capa, mquina abstrac-
ta, en el captulo 10; el sistema reflectivo sin restricciones e independiente del lenguaje es
presentado en el captulo 11.
Detallamos los captulos anteriores presentando el diseo de la mquina abstracta
en el captulo 12. Sobre ella, desarrollamos un entorno de programacin (captulo 13) que
amplia el nivel de abstraccin del sistema sin necesidad de modificar la implementacin de
la mquina. En el captulo 14 se disea de la tercera capa del sistema que otorga la flexibili-
dad mxima, de un modo independiente del lenguaje de programacin seleccionado.

1.3.4 Aplicaciones, Evaluacin, Conclusiones y Trabajo Futuro


Un conjunto de posibles aplicaciones prcticas de nuestro sistema se presenta en el
captulo 15, encontrndonos actualmente en fase de desarrollo de parte de ellas haciendo
uso de los prototipos existentes.
La evaluacin del sistema presentado en esta tesis, comparndolo con otros existen-
tes, es llevada a cabo en el captulo 16 bajo los requisitos establecidos al comienzo de sta.
Finalmente, en el captulo 17, se muestran las conclusiones globales de la tesis, las principa-
les aportaciones realizadas frente a los sistemas estudiados, y las futuras lneas de investiga-
cin y trabajo a realizar.

1.3.5 Apndices
Como apndices de esta memoria se presentan:
En el apndice A se presenta un diseo de un prototipo, intrprete de la m-
quina abstracta diseada en el captulo 12.
Manual de usuario del sistema reflectivo no restrictivo (apndice B), cuyo dise-
o fue detallado en el captulo 14.
El apndice C constituye el conjunto de referencias bibliogrficas utilizadas en
este documento.

5
CAPTULO 2:
REQUISITOS DEL SISTEMA

En este captulo especificaremos los requisitos del sistema buscado en esta tesis. Se
identificarn los distintos requisitos y se describirn brevemente, englobando stos dentro
de distintas categoras funcionales. Los grupos de requisitos sern los propios de la plata-
forma bsica de computacin buscada ( 2.1), los necesarios para disear un entorno de
programacin con las caractersticas perseguidas ( 2.2), y los distintos niveles de flexibili-
dad requeridos para obtener los objetivos fijados ( 2.3). Finalmente, identificaremos el
conjunto de requisitos generales de nuestro sistema desde un punto de vista global ( 2.4).
La especificacin de los requisitos del sistema llevada a cabo en este captulo, tiene
por objetivo la validacin del sistema diseado as como el estudio de los distintos sistemas
existentes similares al buscado. Los requisitos del sistema nos permiten reconocer los pun-
tos positivos de sistemas reales para su futura adopcin o estudio as como cuantificar
sus carencias y justificar determinadas modificaciones y/o ampliaciones.
La especificacin de los requisitos nos ayudar a establecer los objetivos buscados
en el diseo de nuestro sistema, as como a validar la consecucin de dichos objetivos una
vez que ste haya sido desarrollado.

2.1 Requisitos de la Plataforma de Computacin


Para desarrollar un sistema computacional flexible y adaptable, que se pueda ejecu-
tar en cualquier plataforma de forma independiente al lenguaje y que sus aplicaciones sean
distribuibles e interoperables, la capa base de ejecucin la plataforma virtual ha de satis-
facer un elevado nmero de requisitos. La seleccin e implantacin de stos ser una tarea
crtica, puesto que todo el sistema ser desarrollado sobre esta plataforma; si sta no ofrece
la suficiente flexibilidad, el entorno de programacin no podr ser completamente adapta-
ble.
Identificaremos brevemente los requisitos que deber cumplir la plataforma virtual
de nuestro sistema para satisfacer los objetivos descritos en 1.2.

2.1.1 Sistema Computacional Multiplataforma


La plataforma base de computacin para nuestro sistema deber poder ser implan-
tada en cualquier sistema existente. Deber ser totalmente independiente de caractersticas

7
CAPTULO 2

propias de un microprocesador, sistema operativo o cualquier particularidad propia de un


determinado sistema.
La implantacin de nuestra plataforma base de computacin deber poderse inte-
grar en cualquier sistema computacional con unos requisitos mnimos de procesamiento1.

2.1.2 Independencia del Lenguaje de Programacin


La utilizacin de una plataforma virtual mediante la descripcin de una mquina
abstracta captulo 3 es comn en entornos distribuidos y portables. Sin embargo, la defi-
nicin de estas plataformas suele ir ligada a un determinado lenguaje de programacin.
La base computacional de nuestro sistema deber ser independiente de los lengua-
jes de programacin utilizados para acceder a ella. Mediante un proceso de compilacin
deber ser factible una traduccin desde diversos lenguajes de programacin al cdigo nati-
vo de la plataforma.

2.1.3 Independencia del Problema


La descripcin de la plataforma no deber estar enfocada a la resolucin de un tipo
de problema. Existen implementaciones que describen una plataforma para abordar pro-
blemas como la persistencia de sistemas orientados a objetos o la intercomunicacin de
aplicaciones distribuidas. Este tipo de plataforma es descrito de una forma especfica para
la resolucin del problema planteado.
Nuestra plataforma computacional deber ser descrita con flexibilidad frente a los
problemas tratados. No se trata de que se implemente una solucin para la mayora de los
problemas existentes, sino que permita adaptar de una forma genrica su semntica y mo-
delo computacional para la resolucin de cualquier problema que surgiere.

2.1.4 Tamao y Semntica Computacional Reducida


El primer requisito identificado, Sistema Computacional Multiplataforma, obliga-
ba a la plataforma a ser independiente del sistema en el que se implante. Identificbamos
adems la necesidad de que sta se pudiese ejecutar sobre sistemas con capacidad computa-
cional reducida. Para que este requisito se pueda llevar a cabo, la plataforma base deber
implementarse buscando un tamao reducido.
La semntica computacional bsica de la plataforma primitivas de computacin
deber ser lo ms sencilla posible. Esta semntica es la descripcin del funcionamiento
propio de la mquina abstracta. Sin embargo, las primitivas operacionales, o funcionalida-
des propias del lenguaje de la mquina, debern ser externas, accesibles y ampliables, de
forma concreta a cada implementacin2.
Dividiendo la semntica operacional y computacional de la plataforma, consegui-
mos reducir al mximo la plataforma raz para que pueda ser implantada en cualquier en-
torno. Si el sistema posee capacidad computacional suficiente, podr ampliar su nmero de
operaciones computacionales. Esta divisin impulsa los dos siguientes requisitos.

1
Veremos cmo estos mnimos sern restringidos en el requisito 2.1.4.
2
Esta diferenciacin en la semntica de la plataforma queda patente en el captulo 12, donde se especifica
la plataforma computacional bsica de nuestro sistema.

8
Requisitos del Sistema

2.1.5 Flexibilidad Computacional


Como definamos en el requisito Independencia del Problema, la plataforma de-
ber ser lo suficientemente flexible para adaptarse a la resolucin de cualquier problema.
No ser trata de prever todos las necesidades de un sistema y resolverlas, sino de disear una
plataforma flexible que permita adaptarse a cualquier problema.
Para ello hemos dividido este requisito de adaptabilidad en tres partes:

2.1.5.1 Semntica Operacional Abierta


Las operaciones primitivas del lenguaje de la plataforma debern ser modificables
para cada implantacin. En cada mquina abstracta podremos aumentar el nmero de pri-
mitivas sobre las existentes para aadir un mayor nivel de abstraccin al entorno. Lo con-
seguido es una flexibilidad en la semntica operacional del lenguaje.

2.1.5.2 Introspeccin y Acceso al Entorno


Una aplicacin portable deber ser capaz de conocer las funcionalidades existentes
en el entorno en el que se est ejecutando. Mediante introspeccin, una aplicacin podr
saber si las operaciones que demanda han sido desarrolladas y obrar en consecuencia. De
esta forma, con una nica plataforma, ofrecemos diversos niveles de abstraccin y la capa-
cidad de conocer en cul nos encontramos.

2.1.5.3 Semntica Computacional Abierta


El mayor grado de flexibilidad de la plataforma se obtendr gracias un mecanismo
de modificacin de su semntica computacional, mediante el propio lenguaje de la mquina
abstracta. Permitir modificar el funcionamiento propio de la mquina, facilitar al progra-
mador modificar la interpretacin de un programa sin modificar una lnea de cdigo. Ade-
ms, la implementacin de la mquina nunca es alterada: se modifica su funcionamiento
mediante su propio lenguaje.

2.1.6 Interfaz de Acceso y Localizacin del Cdigo Nativo


Cumpliendo la especificacin de requisitos descritos, la base de nuestro sistema de-
ber ser multiplataforma y autoprogramado aumenta su nivel de abstraccin desde un
modelo bsico, programndose sobre su propio lenguaje. Todo el cdigo desarrollado so-
bre la propia plataforma es portable, sin embargo, la implementacin del intrprete de la
mquina abstracta tendr cdigo nativo dependiente de la plataforma fsica en la que se
ejecuta las operaciones primitivas.
La reducida3 parte del sistema que sea dependiente de la plataforma deber identifi-
carse de forma separada al resto del cdigo y tendr una interfaz de acceso bien definida.
La migracin del sistema a una plataforma fsica distinta, se conseguir nicamente median-
te la implementacin de esta parte en la nueva plataforma y la recompilacin de la mquina
virtual.

2.1.7 Nivel de Abstraccin del Modelo de Computacin


El nivel de abstraccin proporcionado por la plataforma virtual ser el modelo utili-
zado para interconectar las distintas aplicaciones del sistema. La seleccin del correcto nivel

3
Cuanto ms reducido sea el tamao de cdigo implementado dependiente de la plataforma, ms sencilla
ser la implementacin del sistema en una plataforma distinta.

9
CAPTULO 2

de abstraccin que ofrezca el modelo de computacin es una tarea difcil: Un bajo nivel de
abstraccin hace ms compleja la interoperabilidad de aplicaciones, mientras que un eleva-
do nivel de abstraccin puede generar una plataforma dependiente del lenguaje
incumpliendo as el requisito 2.1.2.
Una mala eleccin del modelo de computacin de la plataforma puede dificultar la
obtencin de muchos de los requisitos expuestos en este captulo.

2.2 Requisitos del Entorno de Programacin


El diseo de la plataforma de computacin se centra en el desarrollo de una mqui-
na abstracta (captulo 12) flexible ( 2.1.5), que posea un tamao y semntica operacional
reducidos ( 2.1.4).
Para aumentar su semntica computacional y ofrecer un mayor nivel de abstraccin
al programador de aplicaciones, desarrollaremos un entorno de programacin con servicios
propios de un sistema operativo distribuido (sin que cobre carcter de sistema operativo4).
Para validar su condicin de flexibilidad, el entorno de programacin implementar
las distintas funcionalidades de un modo adaptable, de forma que puedan ser seleccionadas
y modificadas dinmicamente.

2.2.1 Desarrollo de Caractersticas de Computacin (Extensibilidad)


La plataforma de computacin deber ser lo suficientemente extensible como para
poder desarrollar sobre ella otras caractersticas computacionales. Dadas las primitivas de la
plataforma (por ejemplo, paso de mensajes, creacin de objetos o evaluacin de mtodos)
el entorno de programacin deber ser capaz de construir sobre estas funcionalidades otras
de mayor nivel de abstraccin o substitutivas de las existentes.

2.2.2 Seleccin de Caractersticas de Computacin (Adaptabilidad)


Las nuevas caractersticas de computacin desarrolladas en el entorno de progra-
macin debern ser reemplazables de forma dinmica, pudiendo modificar o elegir stas en
funcin de las necesidades del programador. Si, por ejemplo, el paso de mensajes ha sido
modificado para ser distribuido, deber poder seleccionarse dinmicamente el protocolo de
comunicaciones utilizado.

2.2.3 Identificacin del Entorno de Programacin


La nica condicin para formar parte de la plataforma distribuida es estar ejecutan-
do una mquina virtual. Como hemos mencionado, el tamao de sta y el conjunto de sus
primitivas es reducido, y por ello ampliamos estos con el entorno de programacin.
Si un sistema fsico posee poca memoria o capacidad de procesamiento, tendr una
parte mnima del entorno de programacin. Por esta razn, en un sistema heterogneo de
computacin, es necesario tener un mecanismo para conocer o identificar el conjunto de
servicios que en el entorno de programacin hayan sido instalados.

4
El entorno de programacin desarrollado busca facilitar al programador la interaccin con la plataforma
base. En ningn momento se trata de desarrollar un sistema operativo sobre la plataforma creada [lva-
rez96].

10
Requisitos del Sistema

2.2.4 Autodocumentacin Real


En el requisito anterior sealbamos la posibilidad de que existiesen infinitas ver-
siones del entorno de programacin cada una en funcin de los intereses y limitaciones de
la unidad de procesamiento. Para conocer exactamente el entorno existente es necesario un
sistema de autodocumentacin.
La plataforma deber facilitar la informacin de todos los objetos, mtodos y atri-
butos reales existentes de forma real y directa. Si se modifica uno de stos, el sistema debe-
r ser capaz de modificar dicha documentacin automticamente; sta nunca podr quedar
desfasada respecto a lo que en el sistema realmente exista.

2.3 Requisitos Concernientes al Grado de Flexibilidad


El principal objetivo del sistema buscado en esta tesis, es obtener sistema con un
elevado grado de flexibilidad que permita constituirse como una plataforma de ejecucin
universal, sin necesidad de modificar la implementacin de la mquina abstracta.
Desde el punto de vista de la seguridad del sistema computacional, el acceso y mo-
dificacin de las distintas aplicaciones representa una tcnica a restringir mediante un me-
canismo de seguridad. En el desarrollo de esta tesis nos centraremos en disear un sistema
con el grado de flexibilidad fijado en este captulo, dejando los aspectos de seguridad como
una capa adicional que restrinja el acceso a estas funcionalidades.

2.3.1 Conocimiento Dinmico del Estado del Sistema


Cualquier aplicacin deber ser capaz de conocer el estado del sistema o de otra
aplicacin en tiempo de ejecucin. Gracias a esta caracterstica podremos desarrollar aplica-
ciones dinmicamente adaptables a contextos, puesto que podrn analizarse stos en tiem-
po de ejecucin.

2.3.2 Modificacin Estructural Dinmica


La estructura de un objeto, aplicacin o de todo el entorno de programacin, podr
ser modificada dinmicamente por cualquier aplicacin ejecutada sobre la plataforma. El
hecho de poder modificar la estructura de cualquier entidad en tiempo de ejecucin, permi-
te construir sistemas extensibles dinmicamente.

2.3.3 Modificacin Dinmica del Comportamiento


La modificacin dinmica del comportamiento o semntica de una aplicacin, im-
plica la variacin de su comportamiento sin necesidad de modificar su estructura ni su c-
digo fuente. Un programa se ejecutar sobre un entorno variable o adaptable de forma di-
nmica, sin modificar la aplicacin.
En este punto, el grado de adaptabilidad del sistema es mximo: toda su semntica
puede variar sin necesidad de modificar la aplicacin adaptada.

2.3.4 Modificacin Computacional sin Restricciones


El requisito anterior justifica la necesidad de tener un mecanismo de modificacin
del comportamiento del sistema. Muchos sistemas poseen esta capacidad pero con un con-

11
CAPTULO 2

junto de restricciones. En ellos, la modificacin de funciones del comportamiento se lleva a


cabo mediante un protocolo que restringe el conjunto de caractersticas que podrn ser
modificadas en un futuro: si un protocolo no acoge la posibilidad de modificar una fun-
cin, sta no podr ser substituida en tiempo de ejecucin.
Nuestro sistema deber implantar un sistema de flexibilidad computacional en el
que cualquier funcionalidad pueda ser modificada dinmicamente, sin necesidad de especi-
ficarlo a priori. La modificacin de la mquina abstracta no deber ser contemplada para
modificar el entorno en el que se ejecute una aplicacin.

2.3.5 Modificacin y Seleccin Dinmica del Lenguaje


Nuestra plataforma computacional deber ser independiente del lenguaje de pro-
gramacin seleccionado, de forma que no slo se deber poder seleccionar cualquier len-
guaje, sino que se permitir modificar la semntica de ste dinmicamente. Cualquier aspec-
to del lenguaje de programacin podr ser modificado, y nuevas caractersticas podrn ser
aadidas.
Distintas aplicaciones en distintos lenguajes podrn interactuar entre s, adems de
permitir desarrollar una aplicacin en distintos lenguajes. De forma adicional, una aplica-
cin podr especificar dentro de su cdigo el lenguaje de programacin utilizado antes de
su ejecucin, permitindose as su computacin sin necesidad de que la especificacin del
lenguaje tenga que existir previamente en el sistema.

2.3.6 Interoperabilidad Directa entre Aplicaciones


La flexibilidad ofrecida por nuestro sistema debe ser totalmente dinmica, de forma
que la adaptabilidad y extensibilidad pueda producirse en tiempo de ejecucin. Si una apli-
cacin est ejecutndose, y queremos personalizarla sin detenerla, la interoperabilidad entre
aplicaciones cobra una especial importancia.
Desde una aplicacin que se ejecute sobre la misma mquina abstracta, se deber
tener un acceso directo sin ningn artificio o middleware a todas las aplicaciones que estn
corriendo sobre dicha plataforma. De esta forma, el acceso y modificacin dinmicos desde
una aplicacin a otra es directo, y no ser necesario construir una aplicacin de un modo
especial para que pueda ser accesible desde otros procesos.

2.4 Requisitos Generales de Sistema


En este punto definiremos brevemente todos los requisitos que debe cumplir nues-
tro sistema desde un punto de vista global, y que no hayan sido contemplados en los pun-
tos anteriores ( 2.1, 2.2 y 2.3).

2.4.1 Independencia del Hardware


La interfaz de acceso a la plataforma no deber ser dependiente del hardware en el
que haya sino implantado. La plataforma, y en conjunto todo el sistema, deber poder ins-
talarse sobre distintos sistemas hardware.

12
Requisitos del Sistema

2.4.2 Independencia del Sistema Operativo


El sistema deber poder implantarse en cualquier sistema operativo, y por lo tanto
no deber ser diseado con caractersticas particulares de algn sistema concreto.

2.4.3 Interaccin con Sistemas Externos


Las aplicaciones desarrolladas sobre el sistema debern poder interactuar con apli-
caciones nativas existentes en el sistema operativo utilizado. El acceso a la plataforma debe-
r tener una interfaz similar para cada una de los operativos utilizados, siguiendo en cada
caso un mtodo estndar documentado de interaccin entre aplicaciones.
Mediante el mecanismo estndar seleccionado, cualquier aplicacin existente en un
sistema podr interactuar con la plataforma diseada, y el cdigo portable de nuestra plata-
forma podr acceder a los recursos propios del sistema real en ejecucin.

2.4.4 Interoperabilidad Uniforme


Los distintos elementos de computacin distribuidos que formen el sistema interac-
tuarn entre s de un modo uniforme, indiferentemente del hardware, sistema operativo o
lenguaje utilizado. Esta uniformidad implica utilizar un nico modelo de objetos y repre-
sentacin de los datos en entornos heterogneos.

2.4.5 Heterogeneidad
El sistema deber poder implantarse en entornos heterogneos. Para cumplir esta
faceta, la base de la plataforma deber ser de un tamao reducido para poder implantarla
en sistemas computacionales poco avanzados, el sistema deber ser extensible para po-
der elevar el nivel de abstraccin e introspectivo para conocer el entorno del sistema
computacional.
Cualquier elemento de computacin, indiferentemente de cul sea su poder compu-
tacional, deber poder formar parte de la plataforma diseada, aportando en cada caso un
distinto nmero de recursos.

2.4.6 Sistema de Programacin nico


En la mayora de sistemas distribuidos existentes, el arquitecto o ingeniero software
debe dividir una aplicacin en elementos ubicados en distintos nodos computacionales. De
alguna forma se debe identificar dnde se va a ejecutar cada parte de la aplicacin antes de
que sta sea implantada.
En el sistema computacional buscado, el programador tendr la posibilidad de ac-
ceder a cualquier elemento de computacin de forma dinmica, y la aplicacin o una parte
de ella podr desplazarse en funcin de una serie de condiciones. Para el programador, el
sistema computacional es una nica entidad con distintos nodos computacionales, todos
ellos accesibles en cualquier momento de la ejecucin de la aplicacin.

13
CAPTULO 2

2.4.7 Independencia del Lenguaje


La programacin de aplicaciones en el sistema deber poder realizarse mediante
cualquier lenguaje de programacin; por lo tanto, su diseo no se debe enfocar a determi-
nadas peculiaridades propias de un lenguaje de programacin.
La eleccin del nivel de abstraccin del modelo computacional es una tarea difcil:
debe ser lo suficientemente genrica (bajo nivel de abstraccin) para la mayora de lengua-
jes, pero ofreciendo una semntica comprensible (mayor nivel de abstraccin) para facilitar
la interaccin entre aplicaciones.

2.4.8 Flexibilidad Dinmica No Restrictiva


El sistema debe aportar una flexibilidad dinmica en tiempo de ejecucin total: se
deber poder acceder y modificar una aplicacin en todas sus caractersticas, as como su
entorno de ejecucin (el sistema). El mecanismo utilizado para obtener esta flexibilidad no
debe imponer ningn tipo de restriccin previa.
Sobre el sistema debern poder desarrollarse aplicaciones mediante separacin de
incumbencias; se define el aspecto funcional de sta y, una vez finalizada (e incluso en
tiempo de ejecucin), se aadirn otros aspectos adicionales referentes a su distribucin
fsica, persistencia o planificacin de procesos. Esta separacin de incumbencias o aspectos
deber poder efectuarse sin necesidad de modificar la aplicacin en su nivel funcional.

2.4.9 Interoperabilidad Directa


Cada aplicacin deber poder acceder directamente a cualquier otro programa u ob-
jeto, sin necesidad de establecer un mecanismo especfico de interconexin. El sistema
deber verse como un conjunto nico computacional ( 2.4.6) con distintos procesos, to-
dos ellos interactuando entre s. El acceso, modificacin y reutilizacin de aplicaciones se-
rn tareas indiferentes del proceso en el que fueron creadas.

14
CAPTULO 3:
MQUINAS ABSTRACTAS

En este captulo se define el concepto de mquina abstracta y mquina virtual que


estarn presentes a lo largo de toda la memoria. Analizaremos la evolucin histrica que
han tenido as como el objetivo principal buscado en cada una de las etapas.
Aquellos sistemas que utilicen este concepto para obtener objetivos distintos a los
expuestos en 1.2 y 2.1, sern descritos de forma superficial. En caso contrario, se expli-
car la funcionalidad general y el beneficio obtenido mediante la utilizacin de mquinas
abstractas, sin detallar los casos reales existentes.
Al finalizar el captulo se comentar, a modo de conclusin, qu ventajas aporta el
concepto de mquina abstracta a esta tesis y se establecer una clasificacin funcional para
el estudio de los sistemas existentes que se llevar a cabo en el captulo 4.

3.1 Procesadores Computacionales


Un programa es un conjunto ordenado de instrucciones que se dan al ordenador
indicndole las operaciones o tareas que se desea que realice [Cueva94]. Estos programas
van a ser ejecutados, animados o interpretados por un procesador computacional.
Un procesador computacional ejecuta las instrucciones propias de un programa que
accedern, examinando o modificando, a los datos pertenecientes a dicho programa. La
implementacin de un procesador computacional puede ser fsica (hardware) o lgica (softwa-
re) mediante el desarrollo de otro programa.

3.1.1 Procesadores Implementados Fsicamente


Un procesador fsico es un intrprete de programas que ha sido desarrollado de
forma fsica (comnmente como un circuito integrado). Los procesadores ms extendidos
son los procesadores digitales sncronos. Estn formados por una unidad de control, una
memoria y una unidad aritmtico lgica, todas ellas interconectadas entre s [Mandado73].
Un computador es un procesador digital sncrono cuya unidad de control es un sis-
tema secuencial sncrono que recibe desde el exterior (el programador) una secuencia de
instrucciones que le indican las microoperaciones que debe realizar [Mandado73]. La se-
cuencia de ejecucin de estas operaciones es definida en la memoria describiendo un pro-

15
CAPTULO 3

grama, pero la semntica de cada instruccin y el conjunto global existente para el procesa-
dor es invariable.
La ventaja de este tipo de procesadores frente a los lgicos es su velocidad al haber
sido desarrollados fsicamente. Su principal inconveniente, como decamos en el prrafo
anterior, es su inflexibilidad.

3.1.2 Procesadores Implementados Lgicamente


Un procesador software es un programa que interpreta a su vez programas de otro
procesador [Cueva98]. Es aquel programa capaz de interpretar o emular el funcionamiento
de un determinado procesador.
La modificacin de un programa que emule a un procesador es mucho ms sencilla
que la modificacin fsica de un procesador hardware. Esto hace que los emuladores softwa-
re se utilicen, entre otras cosas, como herramientas de simulacin encaminadas a la imple-
mentacin fsica del procesador que emulan.
La principal desventaja de este tipo de procesadores frente a los procesadores hard-
ware o fsicos es la velocidad de ejecucin. Puesto que los procesadores lgicos establecen
un nivel ms de computacin (son ejecutados o interpretados por otro procesador), es in-
evitable que requieran un mayor nmero de computaciones para interpretar un programa
que su versin hardware. Esta sobrecarga computacional se aprecia grficamente en la
Figura 3.1:
Memoria de A

Datos
Lectura/Escritura programa en A
de Datos Programa en A
Instrucciones
programa en A

Instruccin en Ejecucin

Procesador Hw A

Memoria de B

Datos
Programa en A Programa en A
Instruccin en Ejecucin y Datos Programa en B
de A ejecutada por el Instrucciones
Procesador de A en B Programa en A

Lectura/Escritura
de Datos

Instruccin en Procesador Software


Ejecucin de B de A en B

Procesador Hw B

Figura 3.1: Ejecucin de un procesador lgico frente a un procesador fsico.

16
Mquinas Abstractas

En la parte superior de la figura se muestra cmo el procesador fsico A va interpre-


tando las distintas instrucciones mquina. La interpretacin de las instrucciones implica la
lectura y/o escritura de los datos.
En el caso de interpretar a nivel software el programa, el procesador es a su vez un
programa en otro procesador fsico (procesador B en la Figura 3.1). Vemos cmo existe
una nueva capa de computacin frente al ejemplo anterior. Esto hace que se requieran ms
computaciones5 o clculos que en el primer caso.
En el segundo caso el procesador A es ms flexible que en el primero. La modifica-
cin, eliminacin o adicin de una instruccin de dicho procesador, se consigue con la mo-
dificacin del programa emulador. Sin embargo, el mismo proceso en el primer ejemplo,
requiere la modificacin del procesador a nivel fsico.

3.2 Procesadores Lgicos y Mquinas Abstractas


Una mquina abstracta es el diseo de un procesador computacional sin intencin
de que ste sea desarrollado de forma fsica [Howe99]. Apoyndose en dicho diseo del
procesador computacional, se especifica formalmente la semntica del juego de instruccio-
nes de dicha mquina en funcin de la modificacin del estado de la mquina abstracta.
Un procesador computacional desarrollado fsicamente es tambin una mquina
abstracta con una determinada implementacin [lvarez98]. Existen multitud de ejemplos
de emuladores de microprocesadores fsicos desarrollados como programas sobre otro
procesador. Sin embargo, el nombre de mquina abstracta es empleado mayoritariamente
para aquellos procesadores que no tienen una implementacin fsica.
Un intrprete es un programa que ejecuta las instrucciones de un lenguaje que en-
cuentra en una archivo fuente [Cueva98]. Su objetivo principal es animar la secuencia de
operaciones que un programador ha especificado, en funcin de la descripcin semntica
de las instrucciones del lenguaje utilizado. Un procesador computacional implementado
fsica o lgicamente es un intrprete del lenguaje que procese.
Se define mquina virtual como un intrprete de una mquina abstracta6 [Howe99].
Una mquina virtual es por tanto un intrprete definido sobre una mquina abstracta. De
esta forma, la mquina abstracta es utilizada en la descripcin semntica de las instruccio-
nes de dicho intrprete.

3.2.1 Mquina Abstracta de Estados


En teora de lenguajes formales y autmatas, una mquina abstracta es un procedi-
miento para ejecutar un conjunto de instrucciones de un lenguaje formal [Howe99]. Una
mquina abstracta define una estructura sobre la cul es posible representar la semntica
computacional del lenguaje formal asociado. Esta acepcin es similar a la anterior, pero est
ms enfocada a estudios de computabilidad que a aplicaciones prcticas.
Ejemplos de mquinas abstractas son la mquina de Turing, autmatas lineales aco-
tados, autmatas de pila y autmatas finitos, que soportan la computacin de lenguajes de
tipo 0, 1, 2 y 3 (lenguajes regulares) respectivamente [Cueva91].

5
Mayor nmero de computaciones no implica siempre mayor tiempo de ejecucin. Esta propiedad se
cumplira si la velocidad de procesamiento del computador B fuese igual a la del computador A.
6
Aunque el concepto de mquina abstracta y mquina virtual no son exactamente idnticos, son comn-
mente intercambiados.

17
CAPTULO 3

Las mquinas abstractas de estados (abstract state machines) proporcionan el nexo en-
tre los mtodos formales de especificacin y los modelos de computacin [Huggins96].
stas amplan la tesis de Turing [Turing36] especificando mquinas ms verstiles, capaces
de simular cualquier algoritmo en su nivel de abstraccin natural (no a bajo nivel) y de for-
ma independiente al lenguaje de codificacin utilizado. A partir de estos conceptos, los
miembros de la comunidad ASM (Abstract State Machine Community) han desarrollado una
metodologa para describir mquinas abstractas de estados que modelen cualquier tipo de
algoritmo [Huggins99].
Esta lnea de investigacin, que utiliza el concepto de mquina abstracta para espe-
cificar formalmente algoritmos computacionales en su nivel de abstraccin natural, est
fuera del estudio realizado en esta memoria. Utilizaremos el concepto de mquina abstracta
para disear un sistema portable y flexible y no para profundizar en el campo de lenguajes
formales.

3.3 Utilizacin del Concepto de Mquina Abstracta


En este punto realizaremos un estudio de las distintas aplicaciones prcticas encon-
tradas al concepto de mquina abstracta excluyendo la descrita en 3.2.1. Especificaremos
una clasificacin por funcionalidades y una descripcin colectiva de lo conseguido con cada
utilizacin. En el siguiente captulo (Panormica de Utilizacin de Mquinas Abstractas)
analizaremos cada caso particular, destacando sus aportaciones y carencias en funcin de
los requisitos establecidos en el captulo 2.

3.3.1 Procesadores de Lenguajes


En la implementacin de compiladores ha utilizado el concepto de mquina abs-
tracta para simplificar su diseo [Cueva94]. El proceso de compilacin toma un lenguaje de
alto nivel y genera un cdigo intermedio. Este cdigo intermedio es propio de una mquina
abstracta.
Se disea una mquina abstracta lo ms general posible, de forma que se pueda tra-
ducir de sta a cualquier mquina real existente. Para generar el cdigo binario de una m-
quina real, tan slo hay que traducir el cdigo de la mquina abstracta a la mquina fsica
elegida, independientemente del lenguaje de alto nivel que haya sido compilado previamen-
te.
Cdigo Fuente Origen

Fortran Pascal ... Cobol n Lenguajes

Compilacin Directa a n*m Traducciones


las Plataformas Existentes

i80x86 Motorola ... Sun m Plataformas


68000 sparc

Cdigo Binario de una Plataforma Especfica

Figura 3.2: Compilacin directa de n lenguajes a m plataformas.

18
Mquinas Abstractas

Cdigo Fuente Origen

Fortran Pascal ... Cobol n Lenguajes

Compilacin a una Mquina Abstracta

Cdigo
Intermedio n+m Traducciones

Traduccin de Mquina Abstracta a Mquina Real

Motorola Sun
i80x86 ... m Plataformas
68000 sparc

Cdigo Binario de una Plataforma Especfica

Figura 3.3: Compilacin de lenguajes pasando por la generacin de cdigo intermedio.

En la Figura 3.2 y en la Figura 3.3 se observa cmo el nmero de traducciones y


compilaciones se reduce cuando tenemos varios lenguajes fuente y varias mquinas destino
existentes7.
El proyecto UNCOL (Universal Computer Oriented Language) propona un lenguaje in-
termedio universal para el diseo de compiladores [Steel60]. El objetivo de este proyecto
era especificar una mquina abstracta universal para que los compiladores generasen cdigo
intermedio a una plataforma abierta.
ANDF (Architecture Neutral Distribution Format) [Macrakis93] tuvo como objetivo un
hbrido entre la simplificacin de compiladores y la portabilidad del cdigo (punto siguien-
te). Un compilador podra generar cdigo para la especificacin de la mquina ANDF sien-
do este cdigo portable a distintas plataformas.
Este cdigo ANDF no era interpretado por un procesador software sino que era
traducido (o instalado) a cdigo binario de una plataforma especfica. De esta forma se
consegua lo propuesto con UNCOL: la distribucin de un cdigo de una plataforma inde-
pendiente.
Esta prctica tambin ha sido adoptada por varias compaas que desarrollan diver-
sos tipos de compiladores. Un ejemplo la utilizacin de esta prctica son los productos de
Borland/Inprise [Borland91]. Inicialmente esta compaa seleccion un mismo back end
para todos sus compiladores. Se especifica un formato binario para una mquina comparti-
da por todas sus herramientas (archivos de extensin obj). Mdulos de aplicaciones des-
arrolladas en distintos lenguajes como C++ y Delphi pueden enlazarse para generar una
aplicacin, siempre que hayan sido compiladas a una misma plataforma [Trados96].
El siguiente paso fue la especificacin de una plataforma o mquina abstracta inde-
pendiente del sistema operativo que permita desarrollar aplicaciones en distintos lenguajes y
sistemas operativos. Este proyecto bautizado como Proyecto Kylix especifica un modelo
de componentes CLX (Component Library Cross-Platform) que permite desarrollar aplicaciones
en C++ Builder y Delphi para los sistemas operativos Win32 y Linux [Kozak2000].

7
En concreto, para n lenguajes y m plataformas, se reduce el nmero de traducciones para n y m mayores
que dos.

19
CAPTULO 3

3.3.1.1 Entornos de Programacin Multilenguaje


Apoyndose de forma directa en los conceptos de mquinas abstractas y mquinas
virtuales, se han desarrollado entornos integrados de desarrollo de aplicaciones
multilenguaje.
POPLOG es un entorno de programacin multilenguaje enfocado al desarrollo de
aplicaciones de inteligencia artificial [Smith92]. Utiliza compiladores incrementales de
Common Lisp, Pop-11, Prolog y Standard ML. La capacidad de interaccin entre los len-
guajes reside en la traduccin a una mquina abstracta de alto nivel (PVM, Poplog Virtual
Machine) y la independencia de la plataforma fsica utilizada se obtiene gracias a la compila-
cin a una mquina de bajo nivel (PIM, Poplog Implementation Machine) y su posterior conver-
sin a una plataforma fsica como veamos en la Figura 3.3.

3.3.2 Portabilidad del Cdigo


Aunque todos los procesadores hardware son realmente implementaciones fsicas de
una mquina abstracta, es comn utilizar el concepto de mquina abstracta para designar la
especificacin de una plataforma cuyo objetivo final no es su implementacin en silicio.
Probablemente la caracterstica ms explotada en la utilizacin de mquinas abstrac-
tas proviene de su ausencia de implementacin fsica. El hecho de que sea un procesador
software el que interpreta las instrucciones de la mquina, da lugar a una independencia de la
plataforma fsica real utilizada. Una vez codificado un programa para una mquina abstrac-
ta, su ejecucin podr realizarse en cualquier plataforma8 que posea un procesador lgico
capaz de interpretar sus instrucciones, como se muestra en la siguiente figura:

Programa codificado
en Mquina Abstracta

Procesador Procesador Procesador


Mquina Abstracta Mquina Abstracta Mquina Abstracta
en Windows NT en Solaris en System8

Figura 3.4: Ejecucin de un programa portable sobre varias plataformas.

Al igual que un compilador de un lenguaje de alto nivel genera cdigo para una m-
quina especfica, la compilacin a una mquina abstracta hace que ese programa generado
sea independiente de la plataforma que lo ejecute. Dicho programa podr ser ejecutado por
cualquier procesador ya sea hardware o software que implemente la especificacin com-
putacional de un procesador de la mquina abstracta.

8
Entendiendo por plataforma la combinacin de microprocesador y sistema operativo.

20
Mquinas Abstractas

Cada procesador computacional de la mquina abstracta podr estar implementado


acorde a las necesidades y caractersticas del sistema real. En la Figura 3.5 se identifican
distintos grados de implementacin del procesador de la mquina. En el primer ejemplo se
implementa la mquina fsicamente obteniendo velocidad de ejecucin del programa al
tener un nico nivel de interpretacin.
Si se implementa un procesador lgico sobre una plataforma distinta, obtenemos la
portabilidad mencionada en este punto perdiendo velocidad de ejecucin frente al caso
anterior. Cada plataforma fsica que emule la mquina abstracta, implementar de forma
distinta este procesador en funcin de sus recursos. En el ejemplo mostrado en la Figura
3.4, el procesador implementado sobre el PC con Windows NT podr haber sido desarro-
llado de forma distinta a la implementacin sobre el Macintosh con System8.
En la Figura 3.5 se muestra otro ejemplo en el que el emulador de la mquina abs-
tracta es desarrollado sobre otro procesador lgico. Seguimos teniendo portabilidad del
cdigo y obtenemos una flexibilidad en el propio emulador de la mquina abstracta. Se
puede ver este caso como un procesador (de A sobre B) de un procesador de la mquina
abstracta (sobre A). Volvemos a ganar en flexibilidad a costa de aumentar en nmero de
computaciones necesarias en la ejecucin de un programa de la mquina abstracta9.
Memoria
Procesador B

Programa
en la Mquina
Memoria Abstracta
Procesador A Ejecucin

Programa Procesador
Memoria en la Software A
Mquina de la
Procesador Hw Ejecucin Abstracta Mquina
Abstracta
Ejecucin
Programa Procesador
en la Software
Mquina A de la Procesador
Abstracta Mquina Software B
Abstracta del Procesador A

Procesador Hardware
Procesador A
de la Mquina Abstracta Procesador Hardware B

Figura 3.5: Distintos niveles de implementacin de un procesador.

Existen multitud de casos prcticos que utilizan el concepto de mquina abstracta


para conseguir programas portables a distintas plataformas. En el captulo 4 estudiaremos
un conjunto de stos.

3.3.3 Sistemas Interactivos con Abstracciones Orientadas a Objetos


Con la utilizacin de los lenguajes orientados a objetos en la dcada de los 80, el ni-
vel de abstraccin en la programacin de aplicaciones se elev considerablemente
[Booch94]. Sin embargo, los microprocesadores existentes se seguan basando en la ejecu-
cin de cdigo no estructurado y los intentos de desarrollarlos con este nuevo paradigma
finalizaban en fracaso por la falta de eficiencia obtenida causada por la complejidad de la
implementacin [Colwel88]. Posteriormente se llevaron a cabo estudios que concluyen que,
haciendo uso de optimizaciones de compilacin e interpretacin se obtienen buenos ren-
9
Esta estructura de procesamiento de procesamiento se utilizar posteriormente en el captulo 11.

21
CAPTULO 3

dimientos y, por tanto, no es rentable el desarrollo de plataformas fsicas orientadas a obje-


tos [Hlzle95].
Para desarrollar entornos de programacin y sistemas que aportasen directamente la
abstraccin de orientacin a objetos, y que fuesen totalmente interactivos, se utiliz el con-
cepto de mquina abstracta orientada a objetos. Los sistemas, al igual los lenguajes de
programacin, ofrecan la posibilidad de crear y manipular una serie de objetos. Estos obje-
tos residan en la memoria de una mquina abstracta. Las diferencias de trabajar con una
mquina abstracta en lugar de compilar a la plataforma nativa son las propias de la dualidad
compilador/intrprete:
Compilador Intrprete

Tiempo de Ejecucin - +
Tiempo de Compilacin + -
Portabilidad de Cdigo - +
Interaccin entre Aplicaciones - +
Flexibilidad - +
Como vimos en los dos puntos anteriores, el utilizar un procesador lgico genera
un mayor nmero de computaciones en su interpretacin perdiendo tiempo de ejecucin y
ganando en portabilidad cdigo. Si la plataforma que interpretamos es de un nivel ms cer-
cano al lenguaje (es orientada a objetos), los tiempos de compilacin se reducirn al no
producirse cambio de paradigma.
Como se muestra en Figura 3.6, el procesamiento lgico de los programas hace que
todos ellos compartan una zona de memoria asociada a un proceso el intrprete. La inter-
accin entre aplicaciones es homognea por tanto ms sencilla de implementar que en el
caso de que se cree un proceso distinto para la ejecucin de cada aplicacin.
Memoria

Memoria

Representaciones Programa 1
en memoria
Proceso Representacin Proceso
Ejecucin 1 en memoria Ejecucin
Programa 2 Procesador
Mquina
Proceso
Ejecucin 2
Programa 3

Proceso
Ejecucin 3

Programa 1 Programa 2 Programa 3

Interpreta
Procesador
Programa 1 Programa 2 Programa 3 Mquina

Ejecuta Ejecuta

Sistema Operativo Sistema Operativo

Ejecucin Programas Nativos Ejecucin Programas Interpretados

Figura 3.6: Diferencia entre la ejecucin de programas nativos frente interpretados.

22
Mquinas Abstractas

El hecho de que las aplicaciones puedan interactuar fcilmente y que se pueda ac-
ceder y modificar los distintos objetos existentes, aumenta la flexibilidad global del sistema
pudiendo representar sus funcionalidades mediante objetos y mtodos modificables.
Los sistemas desarrollados sobre una mquina abstracta orientada a objetos facilitan
al usuario:
Utilizacin del sistema con una abstraccin ms natural a la forma de pensar del
ser humano [Booch94].
Autodocumentacin del sistema y de las aplicaciones. El acceso a cualquier ob-
jeto permite conocer la estructura y comportamiento de ste en cualquier mo-
mento.
Programacin interactiva y continua. Una vez que el usuario entra en el sistema,
accede a un mundo interactivo de objetos [Smith95]. Puede hacer uso de cual-
quier objeto existente. Si necesita desarrollar una nueva funcionalidad va crean-
do nuevos objetos, definiendo su estructura y comportamiento, comprobando
su correcta funcionalidad y utilizando cualquier otro objeto existente de una
forma totalmente interactiva. A partir de ese momento el sistema posee una
nueva funcionalidad y un mayor nmero de objetos.
Dentro de este tipo de sistemas se pueden nombrar a los clsicos Smalltalk [Me-
vel87] y Self [Ungar87] que sern tratados con mayor profundidad en el punto 4.3.1.

3.3.4 Distribucin e Interoperabilidad de Aplicaciones


Esta ventaja en la utilizacin de una plataforma abstracta es una ampliacin de la
caracterstica de portabilidad de cdigo comentada previamente en 3.3.2. El hecho de
tener una aplicacin codificada sobre una mquina abstracta implica que sta podr ejecu-
tarse en cualquier plataforma que implemente esta mquina virtual. Adems de esta porta-
bilidad de cdigo, la independencia de la plataforma fsica puede ofrecer dos ventajas adi-
cionales:
Una aplicacin (su cdigo) podr ser distribuida a lo largo de una red de com-
putadores. Los distintos mdulos codificados para la mquina abstracta pueden
descargarse y ejecutarse en cualquier plataforma fsica que implemente la m-
quina virtual.
Las aplicaciones pueden interoperar entre s (con envo y recepcin de datos) de
forma independiente a la plataforma fsica sobre la que estn ejecutndose. La
representacin de la informacin nativa de la mquina abstracta ser interpreta-
da por la mquina virtual de cada plataforma.
Aunque estos beneficios en la utilizacin de una mquina abstracta ya estaban pre-
sentes en Smalltalk [Goldberg83] y Self [Smith95], su mayor auge tuvo lugar con la apari-
cin de la plataforma virtual de Java [Kramer96] que estudiaremos en mayor profundidad
en el 4.3.1. Esta plataforma impuls el desarrollo de aplicaciones distribuidas, especial-
mente a travs de Internet.

23
CAPTULO 3

3.3.4.1 Distribucin de Aplicaciones


Servidor de la Aplicacin

Aplicacin
sobre
Mquina
Abstracta

Distribucin de una
aplicacin portable

Ejecucin
Aplicacin

Red de Ordenadores
Implementacin fsica de la
Mquina Abstracta

Ejecucin Ejecucin
Aplicacin Aplicacin

Implementacin Implementacin
en B de la en A de la
Mquina Mquina
Abstracta Abstracta

Plataforma B Plataforma A

Figura 3.7: Distribucin de aplicaciones portables.

En la Figura 3.7 se muestra un escenario de distribucin de una aplicacin desarro-


llada sobre una mquina abstracta. Un ordenador servidor de la aplicacin, conectado me-
diante una red de ordenadores a un conjunto de clientes, posee el cdigo del programa a
distribuir. Mediante un determinado protocolo de comunicaciones, cada cliente demanda la
aplicacin del servidor, la obtiene en su ubicacin y la ejecuta gracias su implementacin de
la mquina virtual. Esta ejecucin ser computacionalmente similar en todos los clientes,
con el aspecto propio de la plataforma fsica en la que es interpretada como mostrbamos
en la Figura 3.4 de la pgina 20.
Un caso de uso tpico del escenario mostrado es una descarga applets en Internet. El
servidor de aplicaciones es un servidor Web. El cdigo de la aplicacin es cdigo Java res-
tringido denominado applet [Kramer96]. El cliente, mediante su navegador Web, se conecta
al servidor utilizando el protocolo HTTP [Beners96] o HTTPS [Freier96] y descarga el
cdigo Java en su navegador. La aplicacin es interpretada por la mquina virtual de Java
[Sun95] implementada en el navegador de forma independiente a la plataforma y navegador
que utilizados por el cliente.

3.3.4.2 Interoperabilidad de Aplicaciones


Uno de los mayores problemas en la intercomunicacin de aplicaciones dis-
tribuidas fsicamente es la representacin de la informacin enviada. Si desarrollamos
dos aplicaciones nativas sobre dos plataformas distintas y hacemos que intercambien
informacin, deberemos establecer previamente la representacin de la informacin
utilizada. Por ejemplo, una variable entera en el lenguaje de programacin C [Rit-
chie78] puede tener una longitud y representacin binaria distinta en cada una de las
plataformas.

24
Mquinas Abstractas

A la complejidad de definir la representacin de la informacin y traducir sta


a su representacin nativa, se le une la tarea de definir el protocolo de comunicacin:
el modo en el que las aplicaciones deben dialogar para intercambiar dicha informa-
cin.
Existen especificaciones estndar definidas para interconectar aplicaciones
nativas sobre distintas plataformas. Un ejemplo es el complejo protocolo GIOP (Ge-
neral Inter-ORB Protocol) [OMG95] definido en CORBA [Baker97]. Establece el proto-
colo y representacin de informacin necesarios para interconectar cualquier aplica-
cin nativa a travs de la arquitectura de objetos distribuidos CORBA. Este tipo de
middleware proporciona un elevado nivel de abstraccin, facilitando el desarrollo de
aplicaciones distribuidas, pero conlleva una serie de inconvenientes:
Requiere una elevada cantidad de cdigo adicional para implementar el protoco-
lo y la traduccin de la informacin enviada por la red. Este cdigo recibe el
nombre de ORB (Object Request Broker).
Aumenta el volumen de informacin enviada a travs de la red de ordenadores
al implementar un protocolo de propsito general que proporcione un mayor
nivel de abstraccin.
Si las aplicaciones se desarrollan sobre una misma mquina abstracta, el envo de la
informacin se puede realizar directamente en el formato nativo de sta puesto que existe
una mquina virtual en toda plataforma. La traduccin de la informacin de la mquina a la
plataforma fsica la lleva a cabo en el intrprete de la mquina virtual. El resultado es poder
interconectar aplicaciones codificadas en una mquina abstracta y ejecutadas en plataforma,
y por lo tanto dispositivos, totalmente dispares.

Aplicacin A
Aplicacin A
Mquina
Abstracta Mquina
Abstracta

Aplicacin A Aplicacin A
Mquina Mquina
Abstracta Lectura y escritura Abstracta
de informacin nativa
de la mquina abstracta

Figura 3.8: Interoperabilidad nativa de aplicaciones sobre distintas plataformas.

En el lenguaje de programacin Java [Gosling96], podemos enviar los datos en su


representacin nativa. No estamos restringidos al envo y recepcin de tipos simples de
datos sino que es posible tambin enviar objetos, convirtindolos a una secuencia de bytes
(serialization) [Campione99].

25
CAPTULO 3

Mediante el paquete de clases ofrecidas en java.net, es posible implementar un


protocolo propio de un tipo de aplicaciones sobre TCP/IP o UDP/IP [Raman98]. Si de-
seamos obtener un mayor nivel de abstraccin para el desarrollo de aplicaciones distribui-
das, al igual que tenamos con CORBA, podemos utilizar RMI (Remote Method Invocation) sin
sobrecargar tanto la red de comunicaciones [Sun97e]. RMI desarrolla un protocolo de in-
terconexin de aplicaciones Java JRMP, Java Remote Method Protocol que permite, entre
otras cosas, invocar a mtodos de objetos ubicados en otras mquinas virtuales.
La potencia de las aplicaciones distribuidas desarrolladas sobre la plataforma Java
cobra significado cuando unimos las dos caractersticas comentadas en este punto: aplica-
ciones cuyo cdigo es distribuido a travs de la red, capaces de interoperar entre s sin lle-
var a cabo una conversin de datos, de forma independiente a la plataforma fsica en la que
se estn ejecutando.

3.3.5 Diseo y Coexistencia de Sistemas Operativos


La utilizacin del concepto de mquina abstracta ha estado presente tambin en el
desarrollo de sistemas operativos. Podemos clasificar su utilizacin en funcin del objetivo
buscado, de la siguiente forma:
Desarrollo de sistemas operativos distribuidos y multiplataforma.
Ejecucin de aplicaciones desarrolladas sobre cualquier sistema operativo.
Existen sistemas operativos, como el VM/ESA de IBM [IBM2000], que utilizan la
conjuncin de ambas funcionalidades en la utilizacin de una mquina abstracta.

3.3.5.1 Diseo de Sistemas Operativos Distribuidos y Multiplataforma


Estos sistemas operativos aprovechan todas las ventajas de la utilizacin de mqui-
nas abstractas comentadas en los puntos anteriores, para desarrollar un sistema operativo
distribuido y multiplataforma. Sobre la descripcin de una mquina abstracta, se implemen-
ta un intrprete de la mquina virtual en toda aquella plataforma en la que vaya a desarro-
llarse el sistema operativo. En el cdigo de la mquina, se desarrollan servicios propios del
sistema operativo que permitan interactuar con el sistema y elevar el nivel de abstraccin; lo
conseguido finalmente es:
Una aplicacin para este sistema operativo es portable a cualquier plataforma.
Las aplicaciones no se limitan a utilizar los servicios de la mquina, sino que
podrn codificarse en un mayor nivel de abstraccin: el ofrecido por los servi-
cios sistema operativo.
El propio sistema operativo es portable, puesto que ha sido desarrollado sobre
la mquina abstracta. No es necesario pues, codificar cada servicio para cada
plataforma.
La interoperabilidad de las aplicaciones es uniforme, al estar utilizando nica-
mente el modelo de computacin de la mquina abstracta. En otros sistemas
operativos es necesario especificar la interfaz exacta de acceso a sus servicios.
Las aplicaciones desarrolladas sobre este sistema operativo pueden ser distri-
buidas fsicamente por el sistema operativo, ya que todas sern ejecutadas por
un intrprete de la misma mquina abstracta.

26
Mquinas Abstractas

En la comunicacin de aplicaciones ejecutndose en computadores distribuidos


fsicamente, no es necesario establecer traducciones de datos. La interaccin es
directa, al ejecutarse todas las aplicaciones sobre la misma mquina abstracta
en distintas mquinas virtuales o intrpretes.
Existen distintos sistemas operativos desarrollados sobre una mquina abstracta ya
sean comerciales, de investigacin o didcticos. En el captulo 4 analizaremos los sistemas
existentes y lo que pueden aportar a esta tesis.

3.3.5.2 Coexistencia de Sistemas Operativos


En este apartado veremos la utilizacin del concepto de mquina virtual desde un
punto de vista distinto. Este concepto puede definirse como un acceso uniforme a los re-
cursos de una plataforma fsica (de una mquina real). Es una interfaz de interaccin con
una plataforma fsica que puede ser dividida en un conjunto de mquinas virtuales.
La particin de los recursos fsicos de una plataforma, mediante un acceso inde-
pendiente, permite la ejecucin de distintos sistemas operativos inmersos en el operativo
que se encuentre en ejecucin. Dentro de un sistema operativo, se desarrollan tantas m-
quinas virtuales como sistemas inmersos deseemos tener. La ejecucin de una aplicacin
desarrollada para un sistema operativo distinto al activo, se producir sobre la mquina
virtual implementada para el sistema operativo husped. Esta ejecucin utilizar los re-
cursos asignados a su mquina virtual.
La ventaja obtenida se resume en la posibilidad de ejecutar aplicaciones desarrolla-
das sobre cualquier sistema operativo sin tener que reiniciar el sistema, es decir, sin necesi-
dad de cambiar el sistema operativo existente en memoria.
El principal inconveniente frente a los sistemas descritos en el punto anterior,
Diseo de Sistemas Operativos Distribuidos y Multiplataforma, es la carencia de interac-
cin entre las aplicaciones ejecutadas sobre distintos sistemas operativos: no es posible
comunicar las aplicaciones husped entre s, ni con las aplicaciones del propio operativo.
Por este motivo, desecharemos la utilizacin de mquinas virtuales en este sentido.
El primer sistema operativo que utiliz de esta forma una mquina virtual fue el
producto OS/2 de IBM. Se declar como el sucesor de IBM del sistema operativo DOS,
desarrollado para microprocesadores intel 80286. Este sistema era capaz de ejecutar en un
microprocesador intel 80386 varias aplicaciones MS-DOS, Windows y propia aplicaciones
grficas nativas, haciendo uso de la implementacin de distintas mquinas virtuales.
IBM abandon el proyecto iniciado con su sistema operativo OS/2. Sin embargo,
parte de sus caractersticas fueron adoptadas en el desarrollo de su operativo VM/ESA
desarrollado para servidores IBM S/390 [IBM2000]. Este sistema permite ejecutar aplica-
ciones desarrolladas para otros sistemas operativos, utilizando una mquina virtual como
modo de acceso a los recursos fsicos. El empleo de una mquina virtual es aprovechado
adems para la portabilidad e interoperabilidad del cdigo: cualquier grupo de aplicaciones
desarrolladas sobre esta mquina abstracta puede interoperar entre s, de forma indepen-
diente al tipo de servidor sobre el que se estn ejecutando.
Otro producto que utiliza el concepto de mquina virtual para multiplexar el acceso
a una plataforma fsica es VMware Virtual Platform [Jones99]. Ejecutndose en Windows
NT o en Linux permite lanzar aplicaciones codificadas para Windows 3.1, MS-DOS, Win-
dows NT, Linux, FreeBDS y Solaris 7 para intel.

27
CAPTULO 3

3.4 Aportacin de la Utilizacin de Mquinas Abstractas


A lo largo de este captulo hemos estudiado concepto de mquina abstracta y las
ventajas que aporta la utilizacin de las mismas. De todas ellas podemos indicar que las
aportaciones a nuestro sistema buscado, descrito en el captulo 1, son:
1. Independencia del lenguaje de programacin ( 3.1.1).
2. Portabilidad de su cdigo ( 3.3.2).
3. Independencia de la plataforma ( 3.3.2).
4. Eleccin del nivel de abstraccin base para el sistema global ( 3.3.3).
5. Interaccin nica entre aplicaciones, utilizando un nico modelo de computa-
cin ( 3.3.3).
6. Programacin interactiva y continua ( 3.3.3).
7. Distribucin de aplicaciones ( 3.3.4.1).
8. Interoperabilidad nativa de aplicaciones distribuidas ( 3.3.4.2).
9. Desarrollo de servicios operativos mediante cdigo nico, portable y distribui-
ble ( 3.3.5.1).
Los sistemas existentes, que haciendo uso de mquinas abstractas consigan estos
beneficios, sern estudiados en el prximo captulo.

28
CAPTULO 4:
PANORMICA DE UTILIZACIN DE MQUINAS
ABSTRACTAS

En el captulo anterior introdujimos los conceptos de mquina abstracta y mquina


virtual as como las distintas posibilidades prcticas que podan aportar a un sistema infor-
mtico. Del abanico global de ventajas que ofrece su utilizacin, subrayamos un conjunto
de ellas como adoptables al sistema propuesto en el captulo 1.
En funcin de una clasificacin prctica de sistemas existentes, estudiaremos las
distintas implementaciones realizadas, siguiendo los requisitos establecidos en el captulo 2,
destacando los requisitos logrados y las carencias existentes.
Una vez descritos y analizados los distintos sistemas, identificaremos qu requisitos
han sido cumplidos por los casos prcticos existentes y cmo adaptarlos a nuestros objeti-
vos, as como sus insuficiencias y las necesidades surgidas para superarlas.

4.1 Portabilidad de Cdigo


Como comentbamos en 3.3.2, una de las ventajas ms explotada en la utilizacin
de mquinas abstractas es la portabilidad de su cdigo. La ausencia de necesidad de una
implementacin fsica de su procesador computacional implica que el cdigo desarrollado
para esta plataforma puede ser ejecutado en cualquier sistema que implemente dicho proce-
sador.
A continuacin estudiaremos un conjunto de casos prcticos en los que se utiliza-
ron mquinas abstractas para obtener, principalmente, portabilidad de un cdigo generado.

4.1.1 Estudio de Sistemas Existentes

Mquina-p
El cdigo-p era el lenguaje intermedio propio de la mquina abstracta mquina-p
[Nori76] utilizada inicialmente en el desarrollo de un compilador del lenguaje Pascal [Jen-
sen91].
La Universidad de California en San Diego (UCSD) desarroll un procesador que
ejecutaba cdigo binario de la mquina-p (cdigo-p). Adopt la especificacin de la mqui-

29
CAPTULO 4

na abstracta para desarrollar as un proyecto de Pascal portable. Se lleg a disponer de so-


porte para multitarea y se desarroll el p-System: un sistema operativo portable, codificado
en Pascal y traducido a cdigo-p [Campbell83]. La nica parte del sistema que haba que
implementar en una plataforma concreta era el emulador de la mquina-p. El sistema se
lleg a implantar en diversos microprocesadores como DEC LSI-11, Zilog Z80, Motorola
68000 e intel 8088 [Irvine99].
Al igual que los lenguajes C y Algol, el Pascal es un lenguaje orientado a bloques
(orientado a marcos de pila10, desde el punto de vista de implementacin) [Jensen91] y esto
hizo que el criterio fundamental en la especificacin de la mquina-p fuese orientarla a una
estructura de pila.
El p-System implementado tenia la siguiente distribucin de memoria, desde las di-
recciones superiores a las inferiores:
El cdigo (p-cdigo) propio del sistema operativo (p-System).
La pila del sistema (creciendo en sentido descendente).
La memoria heap (creciendo en sentido ascendente).
El conjunto de las pilas propias de hilos segn se iban demandando en tiempo
de ejecucin.
Los segmentos globales de datos (de constantes y variables).
El intrprete o simulador de la mquina abstracta.
La mquina abstracta lleg a tener un procesador hardware. Western Digital imple-
ment en 1980 la mquina-p en el WD9000 Pascal Microengine. ste estaba basado en el
microprocesador programable WD MCP-1600.

OCODE
OCODE [Richards71] fue el nombre asignado al lenguaje ensamblador de una m-
quina abstracta diseada como una mquina de pila. Se utilizaba como cdigo intermedio
de un compilador de BCPL [Richards79], obteniendo portabilidad del cdigo generado
entre distintos sistemas.
BCPL (Basic CPL) es un lenguaje de sistemas desarrollado en 1969. Es un descen-
diente del lenguaje CPL (Combined Programming Language); se programa en un bajo nivel de
abstraccin, carece de tipos, est orientado a bloques y proporciona vectores de una di-
mensin y punteros. Es un lenguaje estructurado y posee procedimientos con paso por
valor.
La ejecucin de aplicaciones permite comunicarse mediante memoria compartida,
donde se almacenan variables del sistema y de usuario. BCPL fue utilizado para desarrollar
el sistema operativo TRIPOS, posteriormente renombrado a AmigaDOS.

Portable Scheme Interpreter


Es una implementacin de un compilador del lenguaje Scheme [Abelson2000] una
mquina virtual PSI (Portable Scheme Interpreter). La compilacin del cdigo Scheme a la m-
quina virtual permite ejecutar la aplicacin en cualquier sistema que posea este intrprete.

10
Stack Frame Oriented: Por cada bloque se apila un marco o contexto propio de la ejecucin de ese
bloque.

30
Panormica de Utilizacin de Mquinas Abstractas

El sistema permite aadir primitivas, depurar una aplicacin sobre la mquina vir-
tual (mediante el Portable Scheme Debugger) y la interpretacin del cdigo se considera acep-
table en trminos de eficiencia.

Forth
Otro ejemplo de especificacin de una mquina abstracta para conseguir portabili-
dad de cdigo es la mquina virtual de Forth [Brodie87]. Este lenguaje fue desarrollado en
la dcada de los 70 por Charles Moore para el control de telescopios. Es un lenguaje senci-
llo, rpido y ampliable que es interpretado en una mquina virtual, consiguiendo ser porta-
ble a distintas plataformas y til para empotrarlo en sistemas.
El simulador de la mquina virtual de Forth posee dos pilas. La primera es la pila de
datos: los parmetros de una operacin son tomados del tope de la pila y el resultado es
posteriormente apilado. La segunda pila es la pila de valores de retorno: se apilan los valo-
res del contador de programa antes de una invocacin a una subrutina, para poder retornar
al punto de ejecucin original una vez finalizada sta.

Sequential Parlog Machine


En este caso, adems de la portabilidad del cdigo, el concepto de mquina abstrac-
ta se utiliz para desarrollar un lenguaje multitarea. SPM (Sequential Parlog Machine) [Grego-
ry87] es una mquina virtual del lenguaje de programacin lgica Parlog [Clark83].
En 3.3.3, estudibamos cmo la interpretacin del lenguaje para una plataforma
virtual, facilita la intercomunicacin de las aplicaciones en ejecucin. En este caso, la m-
quina abstracta SPM permite implementar el lenguaje Parlog definido como Parallel-Prolog
[Clark83].

Code War
La utilizacin de una mquina abstracta para que su cdigo sea portable a distintas
plataformas, cobra, en este caso, un carcter de originalidad respecto a los sistemas anterio-
res: La portabilidad del cdigo es utilizada para crear programas que luchen entre s, tra-
tndose de eliminarse los unos a los otros.
Code War es un juego entre dos o ms programas no usuarios o jugadores des-
arrollados en un lenguaje ensamblador denominado Redcode: cdigo nativo de una mqui-
na abstracta denominada MARS (Memory Array Redcode Simulator) [Dewdney88]. El objetivo
del juego es desarrollar un programa que sea capaz de eliminar todos los procesos de los
programas contrarios que estuvieren ejecutndose en la mquina virtual, quedando tan solo
l en la memoria de la mquina.
Gracias a la utilizacin de una mquina virtual es posible desarrollar programas y
jugar en Code War en multitud de plataformas: UNIX, IBM PC compatible, Macintosh y
Amiga. Para tener una plataforma estndar de ejecucin, se creo ICWS (International Core
War Society), responsable de la creacin y mantenimiento del estndar de la plataforma de
Code War, as de cmo la organizacin de campeonatos siendo King of the Hill uno de
los ms conocidos, accesible mediante Internet.

31
CAPTULO 4

Batalla disputada entre los distintos programas

Programa 1 Programa 2 Programa 3

MARS

Plataforma Ejecucin Juego

Codificacin y prueba
Programa 1 de ejecucin de distintos Programa 3
MARS programas en distintas MARS
sobre A plataformas sobre C
Plataforma A Plataforma C
Programa 2
MARS
sobre B
Plataforma B

Figura 4.1: Desarrollo y ejecucin de programas para Code War.

El sistema en el que los programas son ejecutados es realmente simple. El ncleo


del sistema es su memoria: un vector de instrucciones inicialmente vaci. El cdigo de cada
programa es interpretado de forma circular, de manera que cuando finaliza su ltima ins-
truccin, se vuelve a ejecutar la primera.
La mquina virtual de MARS ejecuta una instruccin de cada programa en cada
turno. Una vez evaluada la instruccin de un programa, toma otro cdigo y ejecuta una
instruccin de ste. La interpretacin de cada instruccin lleva siempre el mismo tiempo,
un ciclo de la mquina virtual, sea cual fuere su semntica. De esta forma, el tiempo de
procesamiento es distribuido equitativamente a lo largo de todos los programas que estu-
vieren en memoria [Dewdney90].
Cada programa podr tener un conjunto de procesos en ejecucin. Estos procesos
son almacenados por la mquina virtual en una pila de tareas. Cuando se produce el turno
de ejecucin de un programa, un proceso de ste ser desapilado, y su siguiente instruccin
ser ejecutada. Los procesos que no sean destruidos durante la evaluacin de su instruccin
sern introducidos nuevamente en la pila de tareas.

4.1.2 Aportaciones y Carencias de los Sistemas Estudiados


Todos los sistemas estudiados en 4.1.1 estn basados principalmente en la porta-
bilidad del cdigo escrito para una plataforma virtual: requisito 2.1.1. En la mayora de los
casos, los distintos lenguajes de programacin son compilados a una plataforma intermedia,
y sta es interpretada en distintas plataformas, dando lugar a la portabilidad del cdigo ge-
nerado. En el caso de Code War, esta caracterstica supone la posibilidad de jugar con un
programa desarrollado y probado en cualquier entorno.
En la totalidad de los sistemas estudiados, se produce una dependencia del lenguaje
de programacin que se desea que sea portable. La mquina abstracta se disea en funcin
de un lenguaje de programacin de alto nivel, restringiendo as la traduccin a ella desde
otros lenguajes de programacin (requisito 2.1.2).

32
Panormica de Utilizacin de Mquinas Abstractas

Las plataformas son diseadas para resolver nicamente el problema de hacer que
el cdigo de un lenguaje sea portable. En el caso de Code War, la plataforma es desarrolla-
da para permitir establecer batallas entre programas. Esto rompe con el requisito 2.1.3,
que impone el diseo de una plataforma de forma independiente a la resolucin de un ni-
co problema.
El resto de requisitos propios de la plataforma buscada, identificados en 2.1, no
han sido tenidos en cuenta en los sistemas estudiados.

4.2 Interoperabilidad de Aplicaciones


En este punto estudiaremos distintos casos prcticos en los que se establecen espe-
cificaciones computacionales, para permitir que distintas aplicaciones puedan interoperar
entre s. Si bien el concepto de mquina abstracta no es utilizado como una plataforma
completa de computacin, veremos cmo puede describirse como un pequeo middleware
para interconectar distintas aplicaciones.

4.2.1 Estudio de Sistemas Existentes

Parallel Virtual Machine


Parallel Virtual Machine (PVM) es un sistema software, que permite la interaccin
de un conjunto heterogneo de computadores UNIX, interconectados entre s, pudindose
abstraer el conjunto como un programa en una mquina multiprocesador [Geist94].
PVM fue diseado para interconectar los recursos de distintos computadores, pro-
porcionando al usuario una plataforma multiprocesador, capaz de ejecutar sus aplicaciones
de forma independiente al nmero y ubicacin de ordenadores utilizados.
El proyecto PVM comenz en el verano de 1989, en el Oak Ridge National Labo-
ratory, donde se construy el primer prototipo; ste fue interno al laboratorio y no se dis-
tribuy pblicamente. La segunda versin se implement en la Universidad de Tennessee,
finalizndose en marzo de 1991. A partir de esta versin, PVM comenz a utilizarse en
multitud de aplicaciones cientficas. La versin 3 se desarroll en febrero de 1993 y fue
distribuida pblica y gratuitamente por Internet.
PVM es un conjunto integrado de herramientas y libreras software, que emulan un
entorno de programacin de propsito general, flexible, homogneo y concurrente, des-
arrollado sobre un conjunto heterogneo de computadores interconectados. Los principios
sobre los que se ha desarrollado, son:
Acceso a mltiples computadores: Las tareas computacionales de una aplicacin
son ejecutadas en un conjunto de ordenadores. Este grupo de computadores es
seleccionado por el usuario, de forma previa a la ejecucin de un programa.
Independencia del hardware: Los programas sern ejecutados sobre un entorno
de procesamiento virtual. Si el usuario desea ejecutar una computacin sobre
una plataforma concreta, podr asociar sta a una mquina en particular.
Independencia del lenguaje: Los servicios de PVM han sido desarrollados como
libreras estticas para diversos lenguajes como C [Ritchie78], C++ [Strous-
trup98] o Fortran [Koelbel94].

33
CAPTULO 4

Computacin basada en tareas: La unidad de paralelismo en PVM es una tarea:


un hilo de ejecucin secuencial e independiente. No existe una traduccin dire-
cta de tarea a procesador: un procesador puede ejecutar diversas tareas.
Modelo de paso de mensajes explcitos: Las distintas tareas en ejecucin reali-
zan una parte del trabajo global, y todas ellas se comunican entre s mediante el
envo explcito de mensajes.
Entorno de computacin heterogneo: PVM soporta heterogeneidad respecto
al hardware, redes de comunicacin y aplicaciones.
Soporte multiprocesador: Las plataformas multiprocesador puede desarrollar su
propia implementacin de la interfaz PVM, obteniendo mayor eficiencia de un
modo estndar.
La arquitectura de PVM se muestra en la siguiente figura:

Parallel Virtual Machine


pvmd pvmd
Ordenador A pvmd pvmd Ordenador B
Estndar
Interfaz

Estndar
Interfaz
Fragmento A Librera Librera Fragmento B
Aplicacin Esttica Esttica Aplicacin
PVM PVM PVM PVM

SOUNIX
UNIX SOUNIX
UNIX
SO SO

Hardware A Hardware B

Figura 4.2: Arquitectura de PVM.

Cada plataforma UNIX que desee utilizar PVM deber ejecutar el proceso demonio
(daemon) de la mquina virtual. Eligiendo un lenguaje de programacin, el acceso al sistema
heterogneo y distribuido se realiza mediante una interfaz de invocacin a una librera est-
tica. Esta librera ofrece un conjunto de rutinas, necesarias para la intercomunicacin de las
distintas tareas de una aplicacin. La implementacin de dichas rutinas se apoya en el pro-
ceso residente que intercomunica las distintas mquinas virtuales: pvmd (Parallel Virtual
Machine Daemon).

Coherent Virtual Machine


Coherent Virtual Machine (CVM) es una librera de programacin en C que permite
al usuario acceder a un sistema de memoria compartida, para desarrollar aplicaciones distri-
buidas entre distintos procesadores [Keleher96]. La librera se ha desarrollado para sistemas
UNIX y est enfocada principalmente para la intercomunicacin de workstations.
CVM se ha implementado en C++ y consiste en un conjunto de clases que estable-
cen una interfaz bsica e invariable de funcionamiento; definen un protocolo de comparti-
cin de memoria flexible, un sistema sencillo de gestin de hilos y una comunicacin entre
aplicaciones distribuidas, desarrollado sobre UDP [Raman98].

34
Panormica de Utilizacin de Mquinas Abstractas

Es posible implementar cualquier protocolo de sincronizacin de memoria compar-


tida, derivando la implementacin de las clases Page y Protocol. Todo funcionamiento
que deseemos modificar respecto al comportamiento base, se especificar en los mtodos
derivados derogando su comportamiento [Booch94].

PerDiS
PerDis es un middleware que ofrece un entorno de programacin de aplicaciones
orientadas a objetos, distribuidas, persistentes y transaccionales, desarrolladas de una forma
transparente, escalable y eficiente [Kloosterman98].
La creacin de la plataforma PerDiS surge por la necesidad de desarrollar aplicacio-
nes cooperativas de ingeniera en empresas virtuales: un conjunto de compaas o depar-
tamentos que trabajan conjuntamente en la implementacin de un proyecto. Las distintas
partes de la empresa virtual cooperan y coordinan su trabajo mediante la comparticin de
datos a travs de su red de ordenadores.
PerDiS ofrece un entorno distribuido de persistencia, combinando caractersticas de
modelos de memoria compartida, sistemas de archivos distribuidos y bases de datos orien-
tadas a objetos. PerDiS permite, al igual que en los entornos de programacin de memoria
compartida [Li89], desarrollar aplicaciones que accedan a objetos en memoria indistinta-
mente de su ubicacin. Los objetos son enviados a la memoria local de un modo transpa-
rente cuando son requeridos, haciendo que la programacin distribuida sea menos explcita
en cuanto a la ubicacin de los objetos.
Al igual que un sistema de archivos distribuido, PerDiS almacena en el disco blo-
ques de datos denominados clusters, almacenando en el cliente una cach de los mismos. Un
cluster es un grupo de objetos que define una unidad de almacenamiento, nombrado, pro-
teccin y comparticin, del mismo modo que sucede en los sistemas de archivos [Sun89].
PerDiS facilita adems un conjunto bsico de funcionalidades propias de bases de
datos orientadas a objetos [Bancilhon92] como el almacenamiento nativo y manipulacin
de objetos desde lenguajes orientados a objetos como C++, diferentes modelos de transac-
ciones y tolerancia a fallos.

Aplicacin PerDiS Aplicacin PerDiS Aplicacin PerDiS


en Lenguaje A en Lenguaje B en Lenguaje A

API en A API en B API en A

Librera de Acceso Librera de Acceso Librera de Acceso

PerDiS Daemon PerDiS Daemon PerDiS Daemon

Mquina 1 Mquina 2 Mquina 3

Figura 4.3: Arquitectura de la plataforma PerDiS.

La plataforma PerDiS se basa en una arquitectura cliente/servidor simtrica: cada


nodo ordenador del sistema se comporta al mismo tiempo como cliente y servidor. La
Figura 4.3 muestra los componentes propios de la arquitectura del sistema:

35
CAPTULO 4

Aplicacin desarrollada sobre la plataforma virtual, en un lenguaje de progra-


macin.
API (Application Programming Interface) de acceso a la plataforma, dependiente del
lenguaje de programacin.
Una nica librera, independiente del lenguaje, que sirve como nexo entre la pla-
taforma virtual y el API utilizado para una determinada aplicacin.
El proceso demonio, PerDiS Daemon, encargado de interconectar todos los
ordenadores de la plataforma de forma independiente al lenguaje de programa-
cin, y gestor del sistema de persistencia distribuido.
Como se muestra en la Figura 4.3, el sistema es independiente del lenguaje, y en ca-
da nodo existe parte del almacenamiento global del sistema aunque no exista ninguna
aplicacin en ejecucin.

4.2.2 Aportaciones y Carencias de los Sistemas Estudiados


Los tres sistemas estudiados en el punto anterior son ejemplos de sistemas que tra-
tan de ofrecer una plataforma de computacin virtual. Para ello, no definen una mquina
abstracta con todos los requisitos identificados en 2.1, sino que establecen una interfaz de
acceso a cada mquina concreta.
La unin de todos los accesos desde las distintas plataformas existentes consigue la
abstraccin de una nica plataforma virtual, susceptible de ser utilizada como una sola enti-
dad para la resolucin de un problema. Este requisito es definido como global del sistema
final en 2.4.6; si bien busca una nica entidad de programacin, carece de determinadas
caractersticas necesarias en ese tipo de sistema.
El principal inconveniente de los sistemas estudiados reside en que su diseo ha es-
tado enfocado a la resolucin de un determinado problema. No se trata de construir una
plataforma flexible, requisito 2.1.5, diseada para la resolucin de mltiples problemas,
sino que su diseo se ha llevado a cabo bajo el establecimiento previo del problema a re-
solver. Van, por tanto, en contra del requisito 2.1.3.

4.3 Plataformas Independientes


Dentro de esta clasificacin, analizaremos casos prcticos de la utilizacin de m-
quinas abstractas como instrumento para conseguir plataformas independientes del lengua-
je, sistema operativo y microprocesador. Los sistemas estudiados identifican una mquina
abstracta como base computacional y, sobre sta, desarrollan el conjunto de su plataforma,
de modo independiente al entorno computacional real existente.

4.3.1 Estudio de Sistemas Existentes

Smalltalk-80
El sistema Smalltalk-80 tiene sus races en el centro de investigacin de Xerox, Palo
Alto. Empez en la dcada de los setenta, pasando por la implementacin de tres sistemas
principales: Smalltalk 72, 76 y 80; el nmero corresponde al ao en el que fueron diseados
[Krasner83].

36
Panormica de Utilizacin de Mquinas Abstractas

Los esfuerzos del grupo investigador estaban orientados a la obtencin de un sis-


tema que fuese manejable por personas no informticas. Para llegar a esto, se apost por
un sistema basado en grficos, interfaces interactivas y visuales, y una mejora en la abstrac-
cin y flexibilidad a la hora de programar. La abstraccin utilizada, ms cercana al humano,
era la orientacin a objetos, y, respecto a la flexibilidad, se poda acceder cmodamente y
en tiempo de ejecucin a las clases y objetos que existan en el sistema [Mevel87].
El sistema Smalltalk-80 est dividido bsicamente en dos grandes componentes
[Goldberg83]:
1. La imagen virtual: Coleccin de objetos, instancias de clases, que proporcionan
estructuras bsicas de datos y control, primitivas de texto y grficos, compilado-
res y manejo bsico de la interfaz de usuario.
2. La mquina virtual: Intrprete de la imagen virtual y de cualquier aplicacin del
usuario. Dividida en:
El gestor de memoria: Se encarga de gestionar los distintos objetos en me-
moria, sus relaciones y su ciclo de vida. Para ello implementa un recolector
de basura de objetos.
El intrprete de instrucciones: Analiza y ejecuta las instrucciones en tiempo
de ejecucin. Las operaciones que se utilizan son un conjunto de primitivas
que operan directamente sobre el sistema.
Aunque exista una especificacin formal de la mquina abstracta [Goldberg83], con
la existencia de sta no se busc directamente una plataforma independiente, sino aprove-
char determinadas caractersticas propias de un lenguaje interpretado11: flexibilidad del sis-
tema y un nivel de abstraccin base adecuado orientacin a objetos.
Todas las aplicaciones constituyentes del sistema de Smalltalk-80 estn escritas en el
propio lenguaje Smalltalk y, al ser ste interpretado, se puede acceder dinmicamente a to-
dos los objetos existentes en tiempo de ejecucin (como sealbamos en 3.3.3). El mejor
ejemplo es el Browser del sistema [Mevel87], mostrado en la Figura 4.4: aplicacin que reco-
rre todas las clases (los objetos derivados de Class) del sistema (del diccionario
Smalltalk) y nos visualiza la informacin de sta:

Categora a la que pertenece la clase.


Un texto que describe la funcionalidad de sta.
Sus mtodos.
Sus atributos.
Cdigo que define el comportamiento de cada mtodo.
Esta informacin es modificable en todo momento; adems tenemos la documen-
tacin real, puesto que se genera dinmicamente, de todas las clases, objetos, mtodos y
atributos existentes en el sistema.

11
Smalltalk no es interpretado directamente. Pasa primero por una fase de compilacin a un cdigo bina-
rio en la que se detecta una serie de errores. Este cdigo binario ser posteriormente interpretado por el
simulador o procesador software de la mquina abstracta.

37
CAPTULO 4

Figura 4.4: Acceso al mtodo inspect del grupo user interface, propio del objeto Object per-
teneciente al grupo Kernel-Objects.

El aplicar estos criterios con todos los programas del sistema hace que la programa-
cin, depuracin y anlisis de estos sea muy sencilla. La consecucin de dichos objetivos es
obtenida gracias a la figura de una mquina abstracta, encargada de ejecutar el sistema.
Smalltalk-80 es pues, un sistema de computacin que consigue, mediante una m-
quina virtual, una integracin entre todas sus aplicaciones, una independencia de la plata-
forma utilizada y un nivel de abstraccin orientado a objetos para su modelo de computa-
cin base.

Self
Tomando originalmente la plataforma y lenguaje de Smalltalk-80, se cre el proyec-
to Self [Ungar87]. Se especific una mquina abstracta que reduca la representacin en
memoria del modelo de objetos utilizado por Smalltalk. El criterio principal de diseo fue
representar el sistema slo con objetos, eliminado el concepto de clase; este tipo de modelo
de objetos se define como basado en prototipos [Evins94] lo estudiaremos con mayor
detenimiento en el captulo 8.
La simplicidad y la pureza en los conceptos de esta mquina, hicieron que se reali-
zasen mltiples optimizaciones en la compilacin llegando a resultados interesantes como
la obtencin tiempos de ejecucin 50% superiores a cdigo C compilado de forma optimi-
zada en velocidad [Chambers91].
En la bsqueda de optimizacin de mquinas virtuales, se descubrieron nuevos m-
todos de compilacin e interpretacin como la compilacin continua unida a la optimiza-
cin adaptable [Hlze94]. Estas tcnicas de compilacin y optimizacin avanzadas han sido
utilizadas en la mejora de mquinas abstractas comerciales como la de Java (The Java
HotSpot Virtual Machine) [Sun98].
El modo de programar en Self vara respecto a los entornos clsicos. Self se basa en
un sistema grfico que permite crear aplicaciones de forma continua e interactiva. Posee un

38
Panormica de Utilizacin de Mquinas Abstractas

conjunto de objetos grficos denominados morphs, que facilitan la creacin de interfaces,


inspeccionndolos, modificndolos y volcndolos a disco. La programacin se lleva a cabo
accediendo, en tiempo de ejecucin, a cualquier objeto existente en memoria posea o no,
representacin grfica; esta facilidad es definida como live editing. Los objetos existentes
en el sistema son compartidos por todos los usuarios y aplicaciones.
Su implementacin se llev a cabo nicamente plataformas Solaris, y su utilizacin
prctica se limit a la investigacin y anlisis para la creacin de otros sistemas ms comer-
ciales, como Java.
Uno de los proyectos para los que se utiliz fue el proyecto Merlin: un sistema que
trataba de acercar los ordenadores a la forma de pensar de los humanos, pudiendo ser stos
fcilmente utilizables por cualquier persona [Assumpcao93]. Self fue ampliado para obtener
un grado de flexibilidad mayor, ofrecido por la capacidad de modificar parte de su compor-
tamiento mediante reflectividad computacional [Assumpcao95] definiremos y estudiare-
mos este concepto en el captulo 6. La plataforma Self modificada pas de ser un sistema
con un modelo muy bsico, a ganar en flexibilidad y complejidad utilizando conceptos co-
mo mappings y reflectors.

Java
En 1991, un grupo de ingenieros trabajaba en el proyecto Green: un sistema para
interconectar cualquier aparato electrnico. Se buscaba poder programar cualquier aparato
mediante un lenguaje sencillo, un intrprete reducido, y que el cdigo fuese totalmente por-
table. Especificaron una mquina abstracta con un cdigo binario en bytes y, como lengua-
je de programacin de sta, intentaron utilizar C++ [Stroustrup98]. Se dieron cuenta de su
complejidad y dependencia de la plataforma de ejecucin y lo redujeron al lenguaje Oak,
renombrndolo posteriormente a Java [Gosling96].
Ninguna empresa de electrodomsticos se interes en el producto y en 1994 el pro-
yecto haba fracasado. En 1995, con el extensivo uso de Internet, desarrollaron en Java un
navegador HTTP [Beners96] capaz de ejecutar aplicaciones Java en el cliente, descargadas
previamente del servidor denominndose ste HotJava [Kramer96]. A raz de esta imple-
mentacin, Netscape introdujo en su Navigator el emulador de la mquina abstracta permi-
tiendo aadir computacin, mediante applets, a las pginas estticas HTML utilizadas en
Internet [Beners93]; Java result mundialmente conocido.
Un programa en el lenguaje Java se compila para ser ejecutado sobre una platafor-
ma independiente [Kramer96]. Esta plataforma de ejecucin independiente est formada
bsicamente por:
La mquina virtual de Java (Java Virtual Machine) [Sun95].
La interfaz de programacin de aplicaciones en Java o core API (Application Pro-
gramming Interface).
Esta dualidad, que consigue la independencia de una plataforma y el mayor nivel de
abstraccin en la programacin de aplicaciones, es igual que la que hemos identificado en
Smalltalk-80: imagen y mquina virtual. El API es un conjunto de clases que estn compi-
ladas en el formato de cdigo binario de la mquina abstracta [Sun95]. Estas clases son
utilizadas por el programador para realizar aplicaciones de una forma ms sencilla.
La mquina virtual de Java es el procesador del cdigo binario de esta plataforma.
El soporte a la orientacin a objetos est definido en su cdigo binario aunque no se define

39
CAPTULO 4

su arquitectura12. Por lo tanto, la implementacin del intrprete y la representacin de los


objetos en memoria queda a disposicin del diseador del simulador, que podr utilizar las
ventajas propias de la plataforma real.
La creacin de la plataforma de Java se debe a la necesidad existente de abrir el es-
pacio computacional de una aplicacin. Las redes de computadores interconectan distintos
tipos de ordenadores y dispositivos entre s. Se han creado mltiples aplicaciones, protoco-
los, middlewares y arquitecturas cliente servidor para resolver el problema de lo que se cono-
ce como programacin distribuida [Orfali96].
Una red de ordenadores tiene interconectados distintos tipos de dispositivos y or-
denadores, con distintas arquitecturas hardware y sistemas operativos. Java define una m-
quina abstracta para conseguir implementar aplicaciones distribuidas que se ejecuten en
todas las plataformas existentes en la red (plataforma independiente). De esta forma, cual-
quier elemento conectado a la red, que posea un procesador de la mquina virtual y el API
correspondiente, ser capaz de procesar una aplicacin o una parte de sta implementada
en Java (caracterstica estudiada previamente en 3.3.4).
Para conseguir una este tipo de programacin distribuida, la especificacin de la
mquina abstracta de Java se ha realizado siguiendo fundamentalmente tres criterios [Ven-
ners98]:
1. Bsqueda de una plataforma independiente.
2. Movilidad del cdigo a lo largo de la red.
3. Especificacin de un mecanismo de seguridad robusto.
La caracterstica de definir una plataforma independiente est implcita en la especi-
ficacin de una mquina abstracta. Sin embargo, para conseguir la movilidad del cdigo a
travs de las redes de computadores, es necesario tener en cuenta otra cuestin: la especifi-
cacin de la mquina ha de permitir obtener cdigo de una aplicacin a partir de una m-
quina remota ( 3.3.4.1).
La distribucin del cdigo de una aplicacin Java es directamente soportada por la
funcionalidad de los class loaders [Gosling96]; se permite definir la forma en la que se ob-
tiene el software en este caso las clases, pudiendo ste estar localizado en mquinas re-
motas. De esta forma la distribucin de software es automtica, puesto que se puede cen-
tralizar todo el cdigo en una sola mquina y ser cargado desde los propios clientes al prin-
cipio de cada ejecucin.
Adicionalmente, cabe mencionar la importancia que se le ha dado a la seguridad y
robustez de la plataforma. Las redes representan un instrumento para aquellos programa-
dores que deseen destruir informacin, escamotear recursos o simplemente molestar. Un
ejemplo de este tipo de aplicaciones puede ser un virus distribuido, que se ejecute en nues-
tra mquina una vez demandado por la red.
El primer mdulo en la definicin de la plataforma enfocado hacia su robustez, es
el code verifier [Sun95]. Una vez que el cdigo ha sido cargado, entra en fase de verifica-
cin: la mquina se asegura de que la clase est correctamente codificada y de que no viole
la integridad de la mquina abstracta [Venners98].
El sistema de seguridad en la ejecucin de cdigo, proporcionado por la mquina
virtual, es ofrecido por el security manager; una aplicacin cliente puede definir un security
manager de forma que se limite, por la propia mquina virtual, el acceso a todos los recursos

12
Si bien no define exactamente su arquitectura, supone la existencia de determinados elementos de sta
como una pila [Sun95].

40
Panormica de Utilizacin de Mquinas Abstractas

que se estime oportuno13. Se pueden definir as los lmites del software obtenido; verbigra-
cia: la ejecucin de un applet descargado de un servidor Web, no se le permitir borrar ar-
chivos del disco duro.
Servidor
Aplicacin Java

Compilador
Java

Cliente
A.class B.class D.class C.class E.class

Java API

Implementacin
Red de Ordenadores D.class fsica JVM

Cliente
Cliente A.class
A.class E.class

JVM para
JVM para Plataforma 2
Plataforma 1

Java API
Java API Plataforma 2
Plataforma 1

Figura 4.5: Ejemplo de entorno de programacin distribuida en Java.

En la Figura 4.5 se aprecia cmo se enlazan los distintos conceptos mencionados.


En un determinado equipo servidor, se disea una aplicacin y se compila al cdigo especi-
ficado como binario de la mquina abstracta. Este cdigo es independiente de la plataforma
en la que fue compilado (caracterstica de la utilizacin de mquinas abstractas, estudiada en
3.3.2), pudindose interpretar en cualquier arquitectura que posea dicha mquina virtual.
Parte de esta aplicacin es demandada por una mquina remota. La porcin del
software solicitado es obtenida a travs de la red de comunicaciones, y es interpretado por
la implementacin del procesador en el entorno cliente. La forma en la que la aplicacin
cliente solicita el cdigo a la mquina remota es definida en su class loader (un ejemplo tpico
es un applet que se ejecuta en el intrprete de un Web browser, demandando el cdigo del
servidor HTTP).
El cdigo obtenido puede ser controlado por un security manager definido en la
aplicacin cliente. De esta forma la mquina virtual comprueba los accesos a recursos no
permitidos, lanzando una excepcin en tiempo de ejecucin si se produjese alguno [Gos-
ling96]. El resultado es una plataforma independiente, capaz de distribuir de forma sencilla
sus aplicaciones en una red de computadores y con un mecanismo de control de cdigo
correcto y seguro.

13
Este concepto ha sido definido como caja de arena o sandbox. Debido lo estricto que resultaba para el
desarrollo de applets, en Java2 se ha hecho ms flexible mediante la utilizacin de archivos de polticas
en el Java Runtime Environment del cliente [Dageforde2000].

41
CAPTULO 4

Aunque en la especificacin de la mquina virtual de Java [Sun95] no se identifica


una implementacin, el comportamiento de sta se describe en trminos de subsistemas,
zonas de memoria, tipos de datos e instrucciones. En la Figura 4.6 se muestran los subsis-
temas y zonas de memoria nombrados en la especificacin.

Ficheros Ficheros
Compilados Compilados
(.class) Cargador de (.class) Aplicacin
Clases en Disco

Red de Ordenadores

Thread 1

Thread 1

Thread 2

Thread 2 Thread 2
Zona de Zona Thread 3
Mtodos Heap
Pilas
Registros Thread 3 Mtodos
Cont. Prog. Pilas Java Nativos
Zonas de Memoria Existentes en Tiempo de Ejecucin

Motor de Ejecucin

Figura 4.6: Arquitectura interna de la mquina virtual de Java.

La mquina virtual tiene un subsistema de carga de clases (class loader): mecanismo


utilizado para cargar en memoria tipos clases e interfaces [Gosling96]. La mquina tambin
tiene un motor de ejecucin (execution engine): mecanismo encargado de ejecutar las instruc-
ciones existentes en los mtodos de las clases cargadas [Venners98].
La mquina virtual identifica bsicamente dos zonas de memoria necesarias para
ejecutar un programa:
1. Las inherentes a la ejecucin de la mquina virtual: una zona por cada ejecucin
de la mquina.
2. Las inherentes a los hilos (threads) de ejecucin dentro de una mquina: una zo-
na por cada hilo existente en la mquina.
En el primer grupo tenemos el rea de mtodos y el rea heap. En la zona de mto-
dos se introduce bsicamente la informacin y los datos propios de las clases de la aplica-
cin. En la zona heap se representan los distintos objetos existentes en tiempo de ejecucin.
Por cada hilo en ejecucin, se crea una zona de pila, un registro contador de pro-
grama y una pila de mtodos nativos mtodos codificados en la plataforma real mediante
el uso de una interfaz de invocaciones: JNI (Java Native Interface) [Sun97c]. En cada hilo se
va incrementando el contador de programa por cada ejecucin, se van apilando y desapi-

42
Panormica de Utilizacin de Mquinas Abstractas

lando contextos o marcos en su pila, y se crea una pila de mtodo nativo si se ejecuta un
mtodo de este tipo.
Con respecto a la implementacin de la mquina virtual, comentaremos que Java-
soft y Sun Microelectronics han desarrollado la familia de procesadores JavaChip
[Kramer96]: picoJava, microJava y ultraJava [Sun97]. Estos microprocesadores son
implementaciones fsicas de intrpretes de la mquina abstracta de Java, optimizados para
las demandas de esta plataforma como son la multitarea y la recoleccin de basura.

The IBM J9 Virtual Machine


Como una implementacin comercial de la mquina abstracta de Java, la mquina
virtual J9 de IBM est enfocada al desarrollo de software empotrado [IBM2000b]. Median-
te la utilizacin de esta mquina abstracta y el entorno de desarrollo VisualAge Micro Edi-
tion, se puede implementar software estndar que sea independiente de las siguientes va-
riables [IBM2000c]:
El dispositivo hardware destino (microprocesador).
El sistema operativo destino.
Las herramientas utilizadas en el desarrollo de la aplicacin.
VisualAge Micro Edition ofrece un amplio abanico de libreras de clases para ser
implantadas: desde libreras de tamao reducido para los dispositivos de capacidades redu-
cidas, hasta amplias APIs para los entornos ms potentes.
El desarrollo de una aplicacin en este entorno de IBM se lleva a cabo siguiendo la
arquitectura mostrada en la Figura 4.7:

Aplicacin

Mquina Virtual / JNI

SO Tiempo Real / Controladores

Microprocesador / Dispositivos

Figura 4.7: Arquitectura de aplicaciones en VisualAge Micro Edition.

Con esta arquitectura, el cdigo de la aplicacin est aislado de las peculiaridades


existentes en la plataforma fsica destino. Mediante el Java Native Interface (JNI)
[Sun97c], se podr acceder directamente a los controladores de los dispositivos y a funcio-
nalidades propias de sistemas operativos en tiempo real. ste es el modo de asilar el cdigo
nativo del portable.
Este sistema de IBM es un ejemplo prctico de la portabilidad de cdigo para la
plataforma Java. Define un sistema estndar para la creacin, ejecucin y embebido de apli-
caciones empotradas en hardware [IBM2000d].

43
CAPTULO 4

.NET
.NET es la unin de una estrategia comercial de Microsoft y el diseo de una plata-
forma, ambos enfocados a introducir la computacin de cualquier ordenador en Internet
[Microsoft2000]. El objetivo principal es proporcionar una plataforma, en la que los usua-
rios individuales y las empresas, posean un entorno de interoperabilidad sin fisuras a travs
de Internet. Se podrn desarrollar y distribuir aplicaciones fcilmente mediante la red, de
forma independiente a la plataforma fsica utilizada.
La versin final de .NET est anunciada para el ao 2002. Una primera publicacin
de la herramienta de desarrollo Visual Studio .NET est disponible en el portal para des-
arrolladores de Microsoft, desde Julio de 2000. Toda la informacin relativa al desarrollo de
esta plataforma es publicada en la pgina principal de .NET [Microsoft2000].
Con la plataforma .NET, Microsoft pasar de ser un proveedor de software a ser
un proveedor de servicios [Johnston2000]; desarrollar funciones que los usuarios obten-
drn mediante su conexin a Internet. Los consumidores de los servicios no seguirn el
ciclo: compra, instalacin y mantenimiento de cada aplicacin; con .NET, comprarn una
licencia de un servicio y ste se instalar y actualizar de forma automtica en su mquina
cliente.
Los tres servicios principales que la compaa ha identificado son: almacenamiento,
autenticacin y notificacin. Con stos, .NET proporcionar [Microsoft2000]:
La facilidad de interconectar y hacer que se comuniquen entre s distintos sis-
temas de computacin, haciendo que la informacin de usuario sea actualizada
y sincronizada de forma automtica.
Un mayor nivel de interaccin para las aplicaciones Web, habilitando el uso de
informacin en XML (Extensible Markup Language) [W3C98].
Un servicio de suscripcin en lnea que permita acceder y obtener, de forma
personalizada, productos y servicios del ordenador servidor.
Un almacenamiento de datos centralizado, que aumentar la eficiencia y facili-
dad de acceso a la informacin, al mismo tiempo que los datos estarn sincroni-
zados entre los distintos usuarios y dispositivos.
La posibilidad de interconexin de equipos mediante distintos medios, como
correo electrnico, faxes y telfonos.
Para los desarrolladores de software, la posibilidad de crear mdulos reutiliza-
bles e independientes de la plataforma, que aumenten la productividad.
En la base de la arquitectura de la plataforma .NET (Figura 4.8), se encuentra una
mquina virtual denominada Common Language Runtime que proporciona un motor de
ejecucin de cdigo independiente del sistema en el que fue desarrollado, y compilado des-
de cualquier lenguaje de programacin.
Sobre la raz de la plataforma (Common Runtime Language), se ofrecer un marco de
trabajo base: cdigo base, vlido para cualquier plataforma, que puede ser utilizado desde
cualquier lenguaje de programacin.
El entorno de programacin est basado en XML [W3C98]. A ste se podr acce-
der desde una aplicacin web con un navegador de Internet o bien desde una interfaz
grfica. La comunicacin entre cualquier aplicacin se llevar a cabo mediante mensajes
codificados en XML, siendo as independiente del programa y sistema operativo emisor.

44
Panormica de Utilizacin de Mquinas Abstractas

Servicios Interfaz
Web de Usuario

Datos y XML

Marco de Trabajo Base

Common Language Runtime

Figura 4.8: Arquitectura de la plataforma .NET.

Las ventajas propias de desarrollar aplicaciones en .NET, haciendo uso de la arqui-


tectura mostrada en la Figura 4.8, son [Johnston2000]:
Utilizacin del mismo cdigo base en .NET, puesto que su codificacin es in-
dependiente de la mquina hardware.
La depuracin de aplicaciones se realizar de forma indiferente al lenguaje de
implementacin utilizado. Se podrn depurar aplicaciones, incluso si estn codi-
ficadas en distintos lenguajes de programacin.
Los desarrolladores podrn reutilizar cualquier clase, mediante herencia o com-
posicin, indistintamente del lenguaje empleado.
Unificacin de tipos de datos y manejo de errores (excepciones).
La mquina virtual ejecutar cdigo con un sistema propio de seguridad.
Se puede examinar cualquier cdigo con una clase, obtener sus mtodos, mirar
si el cdigo est firmado, e incluso conocer su rbol de jerarqua14.

4.3.2 Aportaciones y Carencias de los Sistemas Estudiados


En todos los sistemas estudiados, se ha obtenido un sistema de computacin multi-
plataforma (requisito 2.1.1). Si bien en Smalltalk no era el objetivo principal, la indepen-
dencia del sistema operativo y procesador hardware ha sido buscada en el diseo de todas
ellas.
Las mquinas abstractas de Smalltalk, Self y Java fueron desarrolladas para dar un
soporte portable a un lenguaje de programacin. Su arquitectura est pensada especialmen-
te para trabajar con un determinado lenguaje. Sin embargo, aunque .NET est en fase de
desarrollo, parece que su arquitectura no va a ser dependiente de un determinado lenguaje
de programacin; no obstante, parece que C# fue especificado especialmente para esta

14
Estas facilidades se obtienen al tener una mquina abstracta dotada de introspeccin; estudiaremos este
concepto en 6.3.1.

45
CAPTULO 4

plataforma [Microsoft2000b]. De esta forma, .NET es la nica plataforma pensada de


acuerdo con el requisito 2.1.2.
Si bien, cuando se disearon las plataformas estudiadas, se trataba de obtener una
serie de resultados con su utilizacin, ninguna se desarroll para solucionar un tipo espec-
fico de problema. Al contrario de lo que ocurra en 4.2, las mquinas virtuales no resuel-
ven un problema ad hoc.
El tamao de todas las plataformas estudiadas es realmente elevado si lo evaluamos
con el requisito 2.1.4. A modo de ejemplo, la mquina virtual ms sencilla de las estudia-
das, Self, posee ms de 100.000 lneas de cdigo C++ y 3.000 lneas de cdigo ensamblador
[Wolczko96]. Implementar una mquina virtual sobre una nueva plataforma, o en un siste-
ma empotrado es costoso; una ratificacin de esto es la distribucin de la mquina virtual
de Java por javasoft mediante un plug-in: las diversas modificaciones de la JVM y su
complejidad hace que se ralentice la implementacin de sta en los navegadores de
Internet, y por ello se distribuye con el sistema un plug-in [Javasoft99].
En cuanto a los grados de flexibilidad demandados en el requisito 2.1.5, todas las
mquinas gozan de introspeccin: se puede analizar cualquier objeto en tiempo de ejecu-
cin. Ninguna posee acceso al medio. Slo en Smalltalk se pueden aadir primitivas, pero
para ello hay que modificar la implementacin de la mquina virtual. El mayor grado de
flexibilidad lo consigue la modificacin de la mquina Self, llevada a cabo en el proyecto
Merlin [Assumpcao93]; mediante reflectividad computacional se pueden modificar partes
del funcionamiento de la mquina ( 2.1.5.3).
Otro de los requisitos necesarios en la bsqueda de una plataforma virtual era la
identificacin y existencia de un interfaz de invocaciones a codificacin nativa ( 2.1.6). La
nica mquina abstracta que lleva a cabo este requerimiento es Java, con su interfaz de in-
vocaciones nativas JNI [Sun97c]. Como demostracin de sus posibilidades, hemos estudia-
do en 4.3 la plataforma J9 de IBM enfocada a implementar software empotrado. La inter-
faz empleada es un sistema de enlazado (link) con una librera de cdigo C. Un inconve-
niente es que no se localizan los mtodos de forma agrupada, sino que hay que analizar si
poseen la palabra reservada native en su declaracin.
Respecto al nivel de abstraccin de su modelo de computacin, exceptuando Self,
todas poseen un modelo demasiado orientado al lenguaje de programacin. Esto hace que
la traduccin desde otros sistemas sea compleja, si stos poseen un modelo de computa-
cin diferente. Self se basa en un modelo basado en prototipos muy simple, uniforme y
puede representar a multitud de lenguajes orientados a objetos [Wolczko96]15.
Finalmente, a modo de conclusin, comentar que la investigacin en la creacin de
la plataforma .NET por Microsoft, indica, de alguna forma, que es necesario en el mundo
de la computacin, una solucin global para el desarrollo de aplicaciones distribuidas, por-
tables e interoperables. Actualmente existen diversas alternativas para crear este tipo de
aplicaciones, pero no existe una solucin global. Los objetivos buscados por Microsoft con
.NET y los objetivos buscados en esta tesis, convergen en la necesidad desarrollar una nue-
va plataforma de computacin virtual.

15
Estudiaremos en profundidad este tipo de modelo de computacin y sus posibilidades en el captulo 8.

46
Panormica de Utilizacin de Mquinas Abstractas

4.4 Desarrollo de Sistemas Operativos Distribuidos y


Multiplataforma
La portabilidad del cdigo generado para una mquina abstracta ( 3.3.2) y la distri-
bucin e interoperabilidad de sus aplicaciones ( 3.3.4) han sido los motivos principales
para desarrollar sistemas operativos sobre mquinas abstractas. Las aplicaciones para este
tipo de sistemas operativos adoptan todas las ventajas indicadas en 3.4, y el cdigo de las
rutinas propias del sistema operativo es distribuible a lo largo de un entorno de computa-
cin heterogneo e independientes de la plataforma.
En este apartado, estudiaremos un conjunto de sistemas operativos que hacen uso
de mquinas abstractas. Nos centraremos en el diseo de las mquinas, sin entrar en pro-
fundidad en el desarrollo de los sistemas operativos. Finalmente, indicaremos las aporta-
ciones y limitaciones de las distintas mquinas virtuales.

4.4.1 Estudio de Sistemas Existentes

Merlin
El proyecto Merlin buscaba un sistema en el que se acercase el modelo de compu-
tacin de los ordenadores a la forma de pensar de los humanos, pudiendo ser stos fcil-
mente utilizados por cualquier persona [Assumpcao93].
El proyecto Merlin se inici con la utilizacin de una simplificacin de la mquina
abstracta de Self [Ungar87] denominada tinySelf (las caractersticas de esta mquina vir-
tual han sido descritas en 4.3). Ante las limitaciones de la arquitectura monoltica propia
de Self, desarrollaron un intrprete de este lenguaje sobre tinySelf aadindole reflectivi-
dad16 [Assumpcao99]; el resultado fue el lenguaje Self/R que heredaba las ventajas de Self
sumndole un grado de flexibilidad para obtener una semntica computacional abierta: es
posible modificar parte de la semntica del lenguaje.
La flexibilidad obtenida para el sistema hace que esta mquina, al no ser monoltica,
pueda clasificarse tanto en este apartado como en el 4.5, Mquinas Abstractas No Mo-
nolticas.

Inferno
El sistema operativo Inferno ha sido diseado para ser implantado en elementos
de computacin heterogneos as como en los sistemas computaciones tradicionales. Las
ventajas que ofrece este sistema operativo son [Dorward97]:
Portabilidad a distintos procesadores. Existen versiones para Intel, SPARC,
MIPS, ARM, HP-PA, Power PC y AMD 29K.
Portabilidad a distintos entornos. Puede ejecutarse tanto como un sistema ope-
rativo nico para una mquina, como coexistir con otro sistema operativo co-
mo Windows NT, Windows 95, Irix, Solaris, Linux, AIX, HP/UX y NetBSD.
Diseo distribuido. El mismo sistema es implantado tanto en la terminal del
cliente como en el servidor, pudindose acceder siempre desde uno a los recur-
sos del otro.

16
Especificaremos este concepto en el captulo 6.

47
CAPTULO 4

Requerimientos hardware reducidos. Inferno se ejecuta en mquinas con tan


solo 1Mb de memoria y sin necesidad de que se implemente un sistema de tra-
duccin de direcciones de memoria en hardware.
Aplicaciones portables. Las aplicaciones en Inferno se codifican en un lenguaje
denominado Limbo [Dorward97b], cuya representacin binaria es indepen-
diente de la plataforma.
Adaptabilidad dinmica. En funcin del hardware existente, las aplicaciones
podrn cargar un determinado mdulo u otro. Se permite conocer las caracte-
rsticas de la plataforma real existente.
Todas las caractersticas que aporta Inferno se consiguen estableciendo una mqui-
na abstracta como motor de ejecucin: Dis, the Inferno Virtual Machine [Winterbottom97].
El diseo de esta mquina abstracta, al estar enfocado al desarrollo de un sistema operativo
multiplataforma, se basa principalmente en dos pilares:
1. La eficiencia es un aspecto crtico para el posterior desarrollo del sistema opera-
tivo. El hecho de utilizar una mquina abstracta, ralentiza la ejecucin de las ru-
tinas del operativo; el diseo de la mquina ha de estar orientado a reducir los
tiempos de ejecucin al mnimo.
2. Su arquitectura debe cubrir las caractersticas generales de todas las plataformas
fsicas en las que va a ser implantado. Su definicin no se ha llevado a cabo co-
mo un intrprete, sino como la raz de todas las arquitecturas de los procesado-
res modernos.
La arquitectura de Dis no es una mquina de pila, sino que sus instrucciones son
siempre de transferencia de memoria [Aho90]. La sintaxis de una instruccin para Dis es:

OP src1, src2, dst

Donde OP es el cdigo de la operacin, src1 y src2 son operandos en memoria,


y dst es el destino, tambin en memoria.
La memoria es un factor crtico al tratar de hacer el sistema lo ms sencillo posible.
La mquina virtual utiliza un sistema de recoleccin de basura mediante un simple contador
de referencias [Cueva92]. Las referencias cclicas son eliminadas con un algoritmo adicio-
nal. El resultado es un sistema de gestin de memoria sencillo y eficiente, lo suficientemen-
te reducido como para poder implantarse en pequeos sistemas de computacin.

Oviedo3
Oviedo317 [Cueva96] es un proyecto de investigacin desarrollado por un grupo de
investigacin en Tecnologas Orientadas a Objetos de la Universidad de Oviedo. El objeti-
vo del proyecto es construir un sistema computacional integral orientado a objetos. Las
caractersticas que soporta son las propias de un sistema orientado a objetos [Booch94]:
Abstraccin e identidad de objetos.
Encapsulamiento.
Herencia.
Polimorfismo.
17
Oviedo Orientado a Objetos.

48
Panormica de Utilizacin de Mquinas Abstractas

Sistema de comprobacin de tipos en tiempo de ejecucin.


Concurrencia.
Persistencia.
Distribucin.
El motor computacional de todo el sistema es una mquina abstracta orientada a
objetos denominada Carbayonia [Izquierdo96]. sta constituye el ncleo del sistema esta-
bleciendo el paradigma de la orientacin a objetos desde la raz del sistema.
El concepto bsico en Oviedo3 es el objeto. Para manejar los objetos y alcanzar los
requisitos inherentes al sistema, surgen otros conceptos como el paso de mensajes, la defi-
nicin de mtodos, la existencia de hilos, etc.
Sobre la plataforma virtual se desarrollan las distintas capas del sistema orientado a
objetos (Figura 4.9). La primera capa es un conjunto de objetos que desarrollan las funcio-
nes propias de un sistema operativo: SO418 [lvarez96, lvarez97]; gestiona las tareas bsi-
cas del sistema, dando un soporte de nivel de abstraccin mayor al resto de los mdulos
[Alvarez98].
Sobre sta, se desarrollan compiladores y bases de datos orientadas a objetos estos
ltimos se apoyan directamente en el sistema de persistencia ofrecido por la mquina vir-
tual [Ortn97, Ortn97b] y en la nocin de objeto persistente frente a tabla, cambiando la
identificacin de la informacin propia de las bases de datos relacionales [Martnez98].

Aplicaciones de Usuario
Compiladores
Bases de Datos OO
Sistema Operativo OO

Mquina Abstracta
Orientada a Objetos

Independencia del Hardware

Figura 4.9: Capas del Sistema Integral Orienta a Objetos Oviedo3.

El diseo de aplicaciones en esta plataforma utiliza de forma ntegra el paradigma


de la orientacin a objetos, reutilizando los objetos existentes en tiempo de ejecucin ya
sean propios del sistema o creados por el programador.
La mquina abstracta Carbayonia est compuesta fundamentalmente por cuatro
reas mostradas en la Figura 4.10. En Carbayonia no se trabaja nunca con direcciones fsi-
cas de memoria, sino que cada rea se puede considerar a su vez como un objeto: se encar-
ga de la gestin de sus objetos, y se le envan mensajes para crearlos, obtenerlos y liberarlos.
El direccionamiento de un objeto se realiza a travs de una referencia.

18
Sistema Operativo de Oviedo3.

49
CAPTULO 4

rea de Referencias
Clases del Sistema

this rr exc

rea de rea de
Instancias Threads

Figura 4.10: reas de la mquina abstracta Carbayonia.

rea de Clases. En este rea se guarda la descripcin de cada clase. Esta infor-
macin est compuesta por los mtodos que tiene, las variables miembro que la
componen y de quin deriva.
rea de Instancias. Los objetos son ubicados en este rea. Cuando se crea un
objeto se deposita aqu, y cuando ste se destruye es eliminado. Se relaciona con
el rea de clases de manera que cada objeto puede acceder a la informacin de
la clase a la que pertenece, conocindose as su tipo en tiempo de ejecucin.
La nica forma en la que se puede acceder a una instancia es mediante la utiliza-
cin de una referencia. Mediante la referencia, podremos pasarle al objeto los
mensajes pertinentes para que ste los interprete.
Referencias del Sistema. Son una serie de referencias que posee la mquina vir-
tual y tienen funciones especficas dentro el sistema:
this: dentro de un mtodo, apunta al objeto implcito de la invocacin.

exc: cuando se lanza una excepcin, apunta al objeto que identifica la


excepcin lanzada.
rr (return reference): referencia donde los mtodos asignan el valor de re-
torno.
rea de hilos (threads). En la ejecucin de una aplicacin se crea un hilo (thread)
principal con un mtodo inicial en la ejecucin. En la ejecucin de la aplicacin
se podrn crear ms threads, coordinarlos y finalizarlos. Cada hilo posee una pila
de contextos. El conjunto de threads existentes en una ejecucin se almacena en
este rea.

4.4.2 Aportaciones y Carencias de los Sistemas Estudiados


Las plataformas estudiadas, orientadas a crear un sistema operativo, se construyen
sobre una mquina abstracta multiplataforma (requisito 2.1.1) y no dependen de un pro-
blema determinado a resolver (requisito 2.1.3) el diseo de un sistema operativo no est
enfocado a la resolucin de un tipo de problema, sino que ofrece unos servicios para que el
sistema pueda ser fcilmente accesible. Exceptuando el caso de Self/R, los sistemas son
tambin independientes del lenguaje: se puede acceder a sus servicios desde distintos len-
guajes de programacin, mediante una compilacin previa.
En lo referente al tamao y semntica de la mquina virtual (requisito 2.1.4), la
mquina virtual de Inferno es la nica que posee un tamao que permita implantarse en

50
Panormica de Utilizacin de Mquinas Abstractas

pequeos sistemas de computacin. El tamao de las mquinas de Self y Oviedo3 hace,


adems, muy difcil su migracin a distintas plataformas fsicas. Ninguna separa la semnti-
ca computacional de la operacional.
Las mquinas virtuales Carbayonia, Dis y Self son monolticas: definen un modelo
esttico de computacin, careciendo de flexibilidad computacional (requisito 2.1.5). No
permiten modificar sus primitivas operacionales ( 2.1.5.1) ni computacionales ( 2.1.5.3).
Dis facilita un modo de acceso al entorno ( 2.1.5.2) y Self posee introspeccin para cono-
cer el aspecto de sus objetos en tiempo de ejecucin ( 2.1.5.2.). Sin embargo, las carencias
en flexibilidad de Self son eliminadas con la interpretacin de este lenguaje por l mismo,
consiguiendo un grado de reflectividad (ahondaremos en este concepto en el captulo 6).
La separacin del cdigo dependiente de la plataforma, y la definicin de una inter-
faz de acceso a ste (requisito 2.1.6), no son definidas para ninguna mquina abstracta. A
modo de ejemplo, Self/R entremezcla cdigo Self y cdigo ensamblador del microprocesa-
dor utilizado.
En Dis, el nivel de abstraccin utilizado (requisito 2.1.7) es muy bajo puesto que
no define un modelo computacional base (es otro tipo de cdigo ensamblador). Carbayonia
define un modelo basado en la orientacin a objetos, pero aumenta demasiado la abstrac-
cin de la mquina con caractersticas como distribucin, seguridad o persistencia: la de-
manda de una modificacin en estas funcionalidades implica la modificacin de la mquina
virtual. Como hemos sealado en 4.3.2, y como ampliaremos en el captulo 8, el modelo
computacional de Self, basado en prototipos, define una raz computacional correcta en su
abstraccin, y es independiente del lenguaje.

4.5 Mquinas Abstractas No Monolticas


Las diferentes mquinas abstractas estudiadas poseen una arquitectura monoltica:
definen un sistema computacional invariable con una poltica y una semntica. El modo en
el que llevan a cabo la computacin de las aplicaciones y sus diferentes caractersticas son
constantes y en ningn momento pueden modificarse. Este aspecto monoltico de las m-
quinas abstractas, limita la obtencin del grado de flexibilidad computacional buscado (re-
quisito 2.1.5).
La mquina virtual de Java [Sun95], permite modificar slo un conjunto limitado de
sus caractersticas: el modo que carga las clases, mediante un ClassLoader, y el modo en
el que restringe la ejecucin de un cdigo por motivos de seguridad, mediante un
SecurityManager [Eckel2000]. sta es una solucin de compromiso para determina-
dos casos prcticos, pero no define una arquitectura flexible.
Para implementar el proyecto Merlin, se ampli la mquina virtual de Self para aa-
dirle reflectividad [Assumpcao95]. Mediante la utilizacin de reflectividad podemos conse-
guir plataformas flexibles (como veremos en el captulo 6). Sin embargo, en este punto
estudiaremos las plataformas no monolticas existentes sin que hagan uso de arquitecturas
reflectivas.

4.5.1 Estudio de Sistemas Existentes

Virtual Virtual Machine


Actualmente existen aplicaciones con multitud de funcionalidades que llegan a im-
plementar servicios propios de un sistema operativo; sin embargo, carecen de interoperabi-

51
CAPTULO 4

lidad con otras aplicaciones. Un entorno computacional ms orientado hacia la reutiliza-


cin, debera dar soporte a un sistema que promueva la interaccin entre aplicaciones (in-
teroperabilidad interna) y que sea accesible desde cualquier lenguaje, cdigo o representa-
cin de datos (interoperabilidad externa) [Folliot98]. stos fueron los objetivos buscados
en el diseo de virtual virtual machine (VVM) [Folliot97], una plataforma multilenguaje, inde-
pendiente del hardware y sistema operativo, y que es extensible y adaptable, de forma di-
nmica, a cualquier tipo de aplicacin.
Una aplicacin que se vaya a ejecutar sobre la VVM, tendr asociado un tipo el
lenguaje en el que ha sido codificada. Cada tipo o lenguaje de programacin tiene asocia-
da una descripcin para la mquina virtual denominada VMlet. Esta descripcin contiene
un conjunto de reglas que describen cmo traducir la aplicacin, codificada en su propio
lenguaje, a la representacin interna del modelo de computacin de la VVM. La interope-
rabilidad interna del sistema (reutilizacin de cdigo, independientemente del lenguaje en el
que fue desarrollado) se consigue gracias a la traduccin a un nico modelo de computa-
cin. La arquitectura propuesta se muestra en la Figura 4.11:

Aplicacin 1 Aplicacin 2 Aplicacin 3


(Java) (Java+Smalltalk) (Smalltalk)

Reglas Reglas Java VMlet Reglas Smalltalk


Globales Java Smalltalk VMlet
Herramientas de Lenguajes

Mdulo
Seguridad Procesador Virtual

Ejecucin Consola Administracin


Optimizacin Administracin de la VVM
Validacin
... Sistema Operativo Virtual
Sistema Operativo Real

Figura 4.11: Arquitectura de Virtual Virtual Machine.

El procesador virtual es la raz bsica del modelo de computacin del sistema. Eje-
cuta un lenguaje interno, al cul se traduce cualquier lenguaje de programacin utilizado
para acceder a la plataforma. Sobre este procesador virtual se construye el sistema operati-
vo virtual: implementa las rutinas propias de un sistema operativo, siendo ste independien-
te de la plataforma y del lenguaje.
Las herramientas de lenguajes son un conjunto de libreras de programacin que
proporcionan funcionalidades propias de un conjunto de lenguajes. Su representacin tam-
bin es independiente de la plataforma y lenguaje, al haber sido desarrolladas sobre el pro-
cesador virtual.
Las interoperabilidad interna se apoya en un mdulo de seguridad, crtico para ase-
gurar la integridad del sistema. Las reglas que definen la seguridad del sistema estn dentro
de este mdulo. Las reglas propias de cada lenguaje, se encuentran en su VMlet.
Las aplicaciones codificadas para VVM son traducidas dinmicamente, utilizando
su VMlet, a la representacin interna de computacin. Esto permite que aplicaciones des-
arrolladas en distintos lenguajes interacten entre s, y que una aplicacin pueda desarrollar-
se en distintos lenguajes de programacin.

52
Panormica de Utilizacin de Mquinas Abstractas

VVM posee una consola para poder administrar y acceder a la plataforma virtual
desde el sistema operativo real utilizado.

Adaptive Virtual Machine


El diseo de Adative Virtual Machine (AVM) est enfocado a encontrar una plata-
forma de ejecucin dotada de movilidad, adaptabilidad, extensibilidad y dinamicidad. Sobre
ella, las aplicaciones podrn distribuirse de forma portable, segura e interoperable. Las apli-
caciones se podrn adaptar a cualquier plataforma fsica, y se podr extender su funcionali-
dad de un modo sencillo. Adems, el entorno de ejecucin de una aplicacin podr ser
modificado de forma dinmica [Baillarguet98].
Se identifica el desarrollo de una mquina abstracta como mecanismo para lograr
los objetivos mencionados, puesto que stas ofrecen una separacin entre las aplicaciones
ejecutables y el hardware sobre las que se ejecutan [Baillarguet98]. Se disea pues una m-
quina abstracta adaptable (AVM) sobre la que se ofrece un entorno virtual de ejecucin
Virtual Execution Environment (VEE). En la Figura 4.12 se muestra la arquitectura del entor-
no virtual de ejecucin.
VMspec
jd
jdfsfa
sa
aa
kk
sf
sk
js
jf
safa
ddjdjd
fk safj
safk
jk
Plataforma Fsica Real
sdsdaajjfa fadd
ssjafd
ja sj
fdsj
sa
sajjaa sdff
sdff
aafsfd
sdkkaasj
sj
Interfaz del Sistema Operativo

Primitivas Objetos Ejecucin


Compilador
de VMspec Aplicacin
en Aplicacin
Intrprete
Ejecucin

Optimizador
de Cdigo Mquina Virtual Generada
Generador
de VMlet Cargador de
aplicaciones
VMlet
0001010
0001010
1111010
1111010 Cargador
0101010
0101010 de VMlet
1010101
1010101
Adaptable Virtual Machine

Figura 4.12: Arquitectura de la Adaptable Virtual Machine.

La AVM separa la parte esttica que representa el motor de ejecucin o intrprete,


de la parte dinmica que define las caractersticas propias del entorno de computacin en la
interpretacin por ejemplo, el planificador de hilos. La unin de ambas partes supone el
entorno virtual de computacin (VEE): un sistema de computacin adaptable.
La parte dinmica son especificaciones de mquina virtual (VMspec): constituyen
especificaciones de alto nivel de componentes de la mquina virtual, como sistemas de per-
sistencia o planificacin de hilos. Cada VMspec incluye las definiciones de ejecucin y un
modelo de objetos, as como un conjunto de primitivas para acceder al sistema operativo.
El compilador y optimizador de cdigo transforman las VMspecs en una representacin
binaria denominada VMlet.
El cargador de VMlets carga en memoria la especificacin de la mquina virtual de-
finida, y el generador de la mquina virtual la introduce en el sistema de interpretacin
adaptable (AVM). Una vez concluido este proceso, la mquina virtual se comporta con
unas determinadas caractersticas hasta que sean modificadas con la carga de una nueva
especificacin.

53
CAPTULO 4

El intrprete de la mquina abstracta ha sido desarrollado como un framework orien-


tado a objetos que produce un entorno de computacin adaptable.

Extensible Virtual Machine


El hecho de implementar un motor mnimo de ejecucin dotado de unas interfaces
de acceso a bajo nivel, permite disear una plataforma de ejecucin de un amplio espectro
de aplicaciones, adaptable a cualquier tipo de problema. Esta es la idea bsica sobre la que
se disea Extensible Virtual Machine (XVM) [Harris99].
La mayora de las mquinas abstractas existentes siguen un esquema monoltico, en
el que la arquitectura de stas poseen un esquema fijo de abstracciones, funcionalidades y
polticas de funcionamiento en la ejecucin de sus aplicaciones. De forma contraria, un
sistema extensible debera permitir a los programadores de aplicaciones, modificar el en-
torno de ejecucin en funcin de las necesidades demandadas por del tipo de aplicacin
que se est desarrollando. Podemos poner la gestin de memoria heap como ejemplo: De-
terminados tipos de aplicaciones hacen un uso extenso de un tamao concreto de objetos y
establecen una determinada dependencia entre stos. Para este tipo de aplicaciones, un
modo especfico de creacin y ubicacin de objetos en la memoria heap implica una reduc-
cin significativa en los tiempos de ejecucin [Vo96].
Sceptre es el primer prototipo desarrollado para obtener la XVM. Su diseo, orienta-
do a la extensibilidad, utiliza una fina granularidad de operaciones primitivas, mediante las
cuales se desarrollarn las aplicaciones. Su arquitectura se basa en la utilizacin de compo-
nentes; cada componente implementa un conjunto de operaciones. Una mquina virtual
concreta se crea como composicin de un conjunto de componentes. Al ms bajo nivel, los
componentes se implementan sobre la core-machine (motor base de ejecucin), que pro-
porciona acceso a la memoria y a la pila. Los servicios que ofrece un componente se especi-
fican mediante una determinada interfaz denominada port.

Distributed Virtual Machine


Distributed Virtual Machine (DVM) establece una arquitectura de servicios distribui-
dos que permite administrar y establecer un sistema global de seguridad, para un conjunto
heterogneo de sistemas de computacin sobre una misma mquina virtual [Sirer99]. Con
DVM, caractersticas como verificacin del cdigo, seguridad, compilacin y optimizacin,
son extradas de los clientes (mquinas virtuales) y centralizadas en potentes servidores.
En las mquinas virtuales monolticas, como Java [Sun95], no es posible establecer
un sistema de seguridad y una administracin para el conjunto de todas las mquinas
virtuales en ejecucin. DVM ha sido diseada e implementada partiendo de Java,
descentralizando todas aquellas partes de su arquitectura monoltica que deban estar
distribuidas para un control global, al nivel de sistema.
La funcionalidad centralizada de DVM se realiza mediante un procesamiento estti-
co (tiempo de compilacin), y un anlisis y gestin dinmica (en tiempo de ejecucin). Este
esquema es mostrado en la Figura 4.13.

54
Panormica de Utilizacin de Mquinas Abstractas

Servicios Estticos

Servicios Seguridad Servicios Ejecucin


Servicios
Verificador Administracin Compilador

Cdigo Control Administrador Optimizador Cdigo


Fuente Seguridad del Cliente Binario
Compilacin
Auditor Perfilador
Ejecucin Llamadas a
servicios
dinmicos

Administracin

Control
Seguridad

Acceso a
Libreras
Administracin
Centralizada
Servicios Dinmicos

Figura 4.13: Fases en la compilacin y ejecucin de una aplicacin sobre DVM.

Los servicios estticos son el verificador, compilador, auditor, perfilador y optimi-


zador. Analizan la aplicacin antes de su ejecucin y aseguran que cumplan todas las res-
tricciones del sistema. Los servicios dinmicos complementan la funcionalidad de los servi-
cios estticos, proporcionando servicios en tiempo de ejecucin dependientes del contexto
del cliente.
El enlace entre los servicios estticos y dinmicos, se produce gracias a un cdigo
adicional que se inyecta en los archivos binarios, en la fase de procesamiento esttico.
Cuando, en el anlisis esttico, se encuentran operaciones que no pueden ser comprobadas
en tiempo de compilacin, se inserta en el cdigo llamadas al correspondiente servicio di-
nmico.
Mientras que los problemas propios de una arquitectura monoltica son resueltos
con DVM de una forma distribuida, sta distribucin puede llevar a costes de eficiencia en
tiempo de ejecucin; la transmisin de la informacin a travs de la red, puede llegar a ser
el cuello de botella de las aplicaciones en DVM. La resolucin de este problema se puede
conseguir mediante servidores que utilicen replicacin de su informacin.

4.5.2 Aportaciones y Carencias de los Sistemas Estudiados


Las distintas plataformas estudiadas son multiplataforma (requisito 2.1.1) y no de-
penden de forma directa de un lenguaje de programacin (requisito 2.1.2). Todas estn
enfocadas a desarrollar una plataforma computacional de forma independiente a un pro-
blema preestablecido (requisito 2.1.3), aunque DVM est principalmente enfocado a la
administracin de una plataforma distribuida.
La flexibilidad y extensibilidad (requisito 2.1.5) es la caracterstica comn que las
agrupa. Rompen con las arquitecturas monolticas tpicas, y establecen mecanismos para
modificar caractersticas del entorno de computacin. Excepto XVM, todas ofrecen un
mecanismo de extensibilidad basado en una arquitectura modular; se identifican las funcio-
nalidades susceptibles de ser modificadas, y se establece una interfaz para extender stas.
XVM ofrece una expresividad de su flexibilidad basada en un lenguaje de acceso a su core-

55
CAPTULO 4

machine; no se ofrece un conjunto de mdulos variables, sino que el programador define


una mquina virtual concreta, apoyndose la expresividad de un lenguaje.
El mismo diseo modular identificado en el prrafo anterior, es el culpable de los
tamaos de las distintas plataformas (requisito 2.1.4). VVM, AVM y DVM establecen un
framework de desarrollo y ejecucin flexible respecto a un conjunto de mdulos. La flexibili-
dad modular hace que el tamao del framework sea elevado, dificultando la implantacin y
migracin de la plataforma a distintos sistemas. En XVM, el tamao de la plataforma est
en funcin de su nivel de abstraccin, y la mayora de su cdigo se desarrolla sobre la m-
quina abstracta siendo as totalmente portable.
En VVM y ADM existe una interfaz nica de acceso al sistema operativo utilizado
(requisito 2.1.6).

4.6 Conclusiones
Hemos visto cmo inicialmente la utilizacin de una plataforma virtual, basada en
una mquina abstracta, buscaba la portabilidad de su cdigo binario. Los sistemas desarro-
llados conseguan este objetivo para un determinado lenguaje ( 4.1.1); otras plataformas
ms modernas, que gozan de xito comercial, tambin han sido desarrolladas para dar so-
porte principalmente a un lenguaje de programacin (como es el caso de Java Virtual Machi-
ne). Uno de los objetivos a alcanzar en el diseo de una plataforma de computacin flexible
es que la construccin de sta, no est asociada a un determinado lenguaje de programacin
de alto nivel (requisito 2.1.2).
La portabilidad del cdigo ofrecida por una mquina virtual, es explotada en entor-
nos distribuidos de computacin. Si el cdigo de una plataforma puede ser ejecutado en
cualquier sistema, ste puede ser fcilmente distribuido a travs de una red de ordenadores.
Adems, al existir un nico modelo de computacin y representacin de datos, las aplica-
ciones distribuidas en un entorno heterogneo de computacin pueden intercambiar datos
de forma nativa sin necesidad de utilizar una interfaz de representacin comn.
Como hemos sealado en 4.2.1, la creacin de distintas mquinas abstractas ha si-
do utilizada para resolver problemas concretos. Sin embargo, el objetivo de esta tesis es
encontrar una plataforma de computacin independiente de un determinado problema
(requisito 2.1.3).
Plataformas de diseo ms avanzadas, con las ventajas ya mencionadas, han sido es-
tudiadas en 4.3. Estos sistemas ofrecen programacin portable, distribucin de cdigo,
interaccin de aplicaciones distribuidas y un modelo de computacin nico, basado en el
paradigma de la programacin orientada a objetos. La implementacin de aplicaciones es
ms homognea y sencilla, para entornos heterogneos distribuidos. Cabe destacar el pro-
yecto .NET de Microsoft ( 4.3.1), actualmente en fase de desarrollo, que unifica sus
sistemas operativos en una nica plataforma basada en una mquina abstracta.
En los sistemas analizados en el punto anterior, las distintas mquinas abstractas se
han diseado para obtener entornos de programacin. Sin embargo, las caractersticas ofre-
cidas tambin se han utilizado para desarrollar sistemas operativos ( 4.4.1). La nica dife-
rencia entre unos y otros se centra en la semntica de los servicios implementados.
El principal inconveniente de todos los sistemas mencionados es su arquitectura
monoltica: se ofrece un modelo esttico de computacin, careciendo de flexibilidad com-
putacional; las caractersticas computacionales de la plataforma no pueden modificarse. Un
objetivo primordial en esta tesis es la obtencin de flexibilidad del entorno computacional
(requisito 2.1.5). Las arquitecturas monolticas no pueden ofrecer esta caracterstica.

56
Panormica de Utilizacin de Mquinas Abstractas

El desarrollo de plataformas no monolticas se centra en la descomposicin modu-


lar de sus caractersticas ( 4.5). Mediante la seleccin dinmica de estas funcionalidades se
pueden obtener distintas mquinas virtuales, especficas para un determinado tipo de pro-
blema. Sus limitaciones principales son el tamao de los sistemas y el establecimiento a
priori de las caractersticas modificables ( 4.5.2) algo no identificado en el diseo no se
podr modificar posteriormente.
A modo de conclusin, sealaremos la mquina virtual de Self como una platafor-
ma con muchas caractersticas positivas: Representa un nivel de abstraccin adecuado (ba-
sado nicamente en objetos), es independiente del lenguaje (en [Wolczko96] se utiliz a
travs distintos lenguajes, como Java y Smalltalk) y Self/R otorga una flexibilidad basada en
reflectividad (desarrollada para el proyecto Merlin). Sin embargo, su desarrollo es complejo
(ms de 100.000 lneas de C++ y 3.000 de ensamblador), limitando su portabilidad; entrela-
za cdigo independiente de la plataforma con cdigo ensamblador, dificultando su imple-
mentacin en nuevas plataformas; finalmente, el sistema de reflectividad de Self/R es com-
plejo y poco flexible.

57
CAPTULO 5:
SISTEMAS FLEXIBLES NO REFLECTIVOS

Buscando entornos computacionales de programacin flexible, en este captulo es-


tudiaremos los trabajos relacionados existentes exceptuando una tcnica: la reflectividad
computacional sta ser estudiada con detenimiento en el captulo 6.
La mayora de los sistemas estudiados se fundamentan en un paradigma de diseo y
programacin denominado separacin de incumbencias (separation of concerns) [Hrsch95],
que se centra en separar la funcionalidad bsica de una aplicacin de otros aspectos
especiales, como pueden ser la persistencia o distribucin.
Cuando se desarrolla un sistema, comnmente se entremezclan en su codificacin
caractersticas tan dispares como su funcionalidad (aspecto principal) y aspectos adicionales
como los relativos a su almacenamiento de datos, sincronizacin de procesos, distribucin,
restricciones de tiempo real, persistencia o tolerancia a fallos. El hecho de unir todas estas
incumbencias en la propia aplicacin conlleva:
1. Elevada complejidad en el diseo y codificacin de la aplicacin.
2. El programa, al unir todos sus aspectos en una dimensin, es difcil de mante-
ner. Los cambios en una incumbencia implican el cambio global del sistema.
3. El cdigo de la aplicacin es poco legible; al combinar todos los aspectos, la
funcionalidad central de la aplicacin no sobresale en un plano superior de abs-
traccin.
Los sistemas a estudiar en este captulo separan las distintas incumbencias o aspec-
tos de una aplicacin y, mediante distintos mecanismos de implementacin, forman el sis-
tema global a partir de las especificaciones realizadas. El objetivo final es siempre separar la
funcionalidad de una aplicacin de sus distintas incumbencias, haciendo stas variables y
consiguiendo as la adaptabilidad global del sistema.
En cada caso estableceremos una descripcin y estudio del sistema, para posterior-
mente analizar sus puntos positivos aportados y sus carencias, en funcin de los requisitos
definidos en el captulo 3.

5.1 Implementaciones Abiertas


La construccin de software se ha apoyado tradicionalmente en el concepto de
mdulo o caja negra que expone su funcionalidad ocultando su implementacin. Este prin-

59
CAPTULO 5

cipio de caja negra ha facilitado la divisin de problemas reduciendo su complejidad, y ha


fomentado la portabilidad y reutilizacin de cdigo. Sin embargo, el hecho de ocultar la
implementacin de las funcionalidades expuestas puede llevar a carencias de eficiencia en la
reutilizacin del mdulo.
La aproximacin denominada implementacin abierta (open implementation) trata de
construir software reutilizable al mismo tiempo que eficiente [Kiczales96]. Esta tcnica
permite al cliente del mdulo seleccionar distintas estrategias de implementacin en fun-
cin de sus necesidades de eficiencia. La implementacin sigue estando separada de la in-
terfaz del mdulo, pero es posible parametrizarla en funcin de los contextos de utiliza-
cin.
A modo de ejemplo, podemos pensar en la implementacin de un mdulo que
ofrece la computacin propia de un conjunto. Su interfaz poseer operaciones como in-
sertar, eliminar, buscar o recorrer sus elementos. Una vez implementado este m-
dulo, lo reutilizamos en distintas aplicaciones bajo diferentes contextos, variando significa-
tivamente aspectos como:
El nmero de elementos que contiene.
La frecuencia con que se van a insertar dichos elementos.
El nmero de elementos y frecuencia con que van a ser eliminados en tiempo
de ejecucin.
La implementacin del contenedor se puede efectuar mediante distintas estructuras
de datos como tablas hash, listas enlazadas o rboles. En funcin del contexto de utiliza-
cin, la seleccin de una u otra estructura de datos producir cambios en la eficiencia del
sistema. De esta forma, las implementaciones abiertas describen una funcionalidad median-
te una interfaz y la posibilidad de seleccionar una determinada estrategia de implementacin
(ISC code) [Kiczales96b]. Se puede expresar una implementacin abierta como la funcin:
f :C S
Siendo C el conjunto de posibles perfiles de usuario, y S el conjunto de estrategias
de implementacin ofrecidas por el mdulo. A lo largo del tiempo, el conjunto de contex-
tos del cliente (C) podr variar y, por lo tanto, deber poder variar el abanico de estrategias
de implementacin (S). En una implementacin abierta, deberemos permitir la modifica-
cin y ampliacin de perfiles de usuario (C), implementaciones (S) y asociacin entre
stas (f). Un mdulo abierto deber pues proporcionar cuatro interfaces distintas:

60
Sistemas Flexibles No Reflectivos

Interfaz de
Caja Negra

Perfiles de Interfaz de
Cliente C Especificacin de
Perfil de Usuario

Interfaz de
Seleccin de
f Seleccin de
Estrategia
Estrategia

Interfaz de
Estrategias de S Estrategia de
Implementacin Implementacin

Mdulo Abierto

Figura 5.1: Distintas interfaces ofrecidos en una implementacin abierta.

1. Interfaz de caja negra: ofrece la funcionalidad del mdulo para una estrategia de
implementacin por defecto.
2. Interfaz de especificacin de perfil de usuario: permite definir contextos de uti-
lizacin futuros por parte del cliente.
3. Interfaz de estrategia de implementacin: facilita la adicin de nuevas imple-
mentaciones para conseguir los servicios ofrecidos por la interfaz de caja negra.
4. Interfaz de seleccin de estrategia: ofrece al cliente la posibilidad de elegir l
mismo la estrategia de implementacin oportuna eliminando as la seleccin
automtica conseguida por f.
Sobre esta teora se ha descrito un mtodo para determinar el aspecto de las interfa-
ces ofrecidas al usuario del mdulo, a partir de la especificacin de un problema. Este m-
todo ha sido bautizado con el nombre de anlisis y diseo de implementaciones abiertas
(Open Implementation Analysis/Design) [Maeda97].

5.1.1 Aportaciones y Carencias


Esta primera aproximacin para la generacin de software flexible, consigue ofrecer
las ventajas de separar la implementacin de la interfaz de un mdulo, sin perder eficiencia
en la reutilizacin de cdigo. Es una instancia de la teora de separacin de incumbencias
[Hrsch95]: se separa una funcionalidad de sus distintas implementaciones.
Este mecanismo ofrece una mera solucin al problema de la eficiencia de un siste-
ma construido a travs de mdulos reutilizables, sin ofrecer ninguno de los grados de flexi-
bilidad indicados en los requisitos 2.3. Como ejemplo, podemos indicar que el usuario
podra conocer las distintas estrategias de implementacin existentes en un mdulo, si el
sistema hubiese sido dotado de introspeccin ( 2.3.1).
Este sistema fue la base para crear otros ms avanzados como la programacin
orientada a aspectos ( 5.3) o la programacin adaptable ( 5.4), que estudiaremos poste-
riormente en este captulo.

61
CAPTULO 5

5.2 Filtros de Composicin


Los filtros de composicin fueron diseados para aumentar la adaptabilidad del pa-
radigma de la orientacin a objetos, aadiendo a ste extensiones modulares y ortogonales
[Bergmans94]:
La modularidad de las extensiones implica que los filtros de composicin pue-
den ser aadidos a cada objeto, sin necesidad de modificar la definicin de ste.
La ortogonalidad de los filtros requiere que stos tengan funcionalidades inde-
pendientes entre s.
Un ejemplo comparativo de adaptabilidad de objetos mediante filtros de composi-
cin puede ser la modificacin del funcionamiento de una cmara de fotos. Si las condicio-
nes de luz son pobres y el cuerpo a fotografiar se encuentra alejado, podremos modificar el
funcionamiento de la cmara (objeto) aadindole filtros de color y lentes de aumento (fil-
tros de composicin); estas dos extensiones son modulares porque no es necesario modifi-
car el funcionamiento de la cmara para acoplarlas, y son ortogonales porque sus funciona-
lidades son independientes entre s.
Los filtros de composicin son objetos instanciados de una clase filtro. Su propsi-
to es acceder y modificar la forma en la que se envan y reciben los mensajes, especificando
condiciones para aceptarlo o rechazarlo, y determinando la accin a desencadenar en cada
caso. El sistema se asegura que un mensaje sea procesado por los filtros especificados antes
de que el mtodo sea ejecutado (filtro de entrada) y antes de que un mensaje sea pasado
(filtro de salida). Se identifican as dos niveles de abstraccin distintos: los mtodos de
mayor nivel de abstraccin y los filtros de composicin adaptables y dependientes del
contexto, y por lo tanto de menor nivel de abstraccin.
Las acciones a llevar a cabo en la recepcin o envo de un mensaje dependen de la
clase de la que el filtro es instancia. Existen filtros Dispatch (para implementar herencia
dinmica o delegacin), RealTime (restricciones de tiempo real), Meta (coordinacin de
comportamientos), Error (incorreccin en el manejo de un mensaje) y Wait (sincroniza-
cin de procesos).
Los filtros de composicin se han aplicado para adaptar la orientacin a objetos a
determinadas necesidades como delegacin [Aksit88], transacciones atmicas [Aksit91],
integracin de acceso a bases de datos en un lenguaje de programacin [Aksit92], coordina-
cin de comportamiento entre objetos [Aksit93], restricciones de tiempo real [Aksit94] y
especificaciones flexibles y reutilizables de sincronizacin de procesos [Bergmans94].
El primer lenguaje de programacin de filtros de composicin fue Sina [Koop-
mans95]. Posteriormente, los lenguajes de programacin Smalltalk y C++ fueron extendi-
dos para poder aadir filtros de composicin a sus objetos sin necesidad de modificar stos
[Dijk95, Glandrup95].

5.2.1 Aportaciones y Carencias


Los filtros de composicin permiten modificar el mecanismo computacional base
en la orientacin a objetos: el paso de mensajes. Con esta tcnica se permite modificar el
comportamiento de un grupo de objetos (los instanciados de una determinada clase). El
paso de mensajes es el nico comportamiento susceptible de modificacin, sin poder recti-
ficar cualquier otro aspecto computacional del sistema ( 2.3.3).

62
Sistemas Flexibles No Reflectivos

La flexibilidad de las aplicaciones se consigue especificando su funcionalidad bsica


mediante un lenguaje orientado a objetos, y posteriormente ampliando sta mediante la
programacin de filtros de composicin. Para que un objeto pueda utilizar un filtro de
composicin, deber especificarlo a priori (en tiempo de compilacin) en la interfaz de su
clase; esto limita la flexibilidad dinmica del sistema ( 2.3.4).
El sistema final alcanza un compromiso flexibilidad-eficiencia: simplifica la adapta-
bilidad de una aplicacin a la modificacin del paso de mensajes, para conseguir desarrollar
aplicaciones suficientemente eficientes en tiempo de ejecucin.

5.3 Programacin Orientada a Aspectos


Existen situaciones en las que los lenguajes orientados a objetos no permiten mode-
lar de forma suficientemente clara las decisiones de diseo tomadas previamente a la im-
plementacin. El sistema final se codifica entremezclando el cdigo propio de la especifica-
cin funcional del diseo, con llamadas a rutinas de diversas libreras encargadas de obtener
una funcionalidad adicional (por ejemplo, distribucin, persistencia o multitarea). El resul-
tado es un cdigo fuente excesivamente difcil de desarrollar, entender, y por lo tanto man-
tener [Kiczales97].
Cuando desarrollamos una aplicacin, podemos hacerlo de dos forma bien distin-
tas: la primera, siguiendo una estructura computacional clara y organizada; la segunda, pri-
mando la eficiencia de la aplicacin, generalmente con un cdigo fuente menos legible. La
programacin orientada a aspectos permite separar la funcionalidad de la aplicacin de la
gestin de memoria y eficiencia de los algoritmos utilizados, y compone el sistema final a
partir del conjunto de aspectos identificados por el programador. En la programacin
orientada a aspectos se definen dos trminos distintos [Kiczales97]:
Un componente es aquel mdulo software que puede ser encapsulado en un
procedimiento (un objeto, mtodo, procedimiento o API). Los componentes
sern unidades funcionales en las que se descompone el sistema.
Un aspecto es aquel mdulo software que no puede ser encapsulado en un pro-
cedimiento. No son unidades funcionales en las que se pueda dividir un siste-
ma, sino propiedades que afectan la ejecucin o semntica de los componentes.
Ejemplos de aspectos son la gestin de la memoria o la sincronizacin de hilos.
Una aplicacin desarrollada mediante programacin orientada a aspectos est com-
puesta por la programacin de sus componentes funcionales en un determinado lenguaje, y
por la programacin de un conjunto de aspectos que especifican caractersticas adicionales
del sistema. El tejedor de aspectos (aspect weaver) acepta la programacin de aspectos y
componentes, y genera la aplicacin final en un determinado lenguaje de programacin.
Como se muestra en la Figura 5.2, la generacin de la aplicacin final se produce en
tres fases:

63
CAPTULO 5

Tejedor de Aspectos

Grafo del flujo Modificacin del


de ejecucin de los grafo de ejecucin
componentes por los distintos
aspectos
1
Programacin 2
de
Componentes

Aplicacin
Programacin Final
de
Aspectos

Figura 5.2: Fases en la generacin de una aplicacin orientada a aspectos.

1. En la primera fase, el tejedor construye un grafo del flujo de ejecucin del


programa de componentes.
2. El segundo paso consiste en ejecutar la programacin de cada uno de los aspec-
tos. stos actan sobre el grafo que define la funcionalidad del sistema (punto
anterior) realizando las modificaciones o aadiduras oportunas.
3. La ltima fase consiste en recorrer el grafo modificado y generar el cdigo final
de la aplicacin; sta cumple con la funcionalidad descrita por sus componentes
y ofrece los aspectos definidos por el programador.
Se han implementado distintos sistemas de programacin orientada a aspectos,
siendo uno de los ms avanzados el denominado AspectJ [Kiczales2001]; una extensin de
la plataforma de Java. Una aplicacin en AspectJ consta de:
Puntos de unin (join points): Describen puntos de ejecucin de una aplicacin.
AspectJ proporciona un elevado grupo de puntos de unin, siendo un ejemplo
de stos la invocacin de mtodos.
Designacin de puntos de ruptura (pointcut designators): Identifican colecciones de
puntos de unin en el flujo de ejecucin de un programa, para posteriormente
poder modificar su semntica.
Consejo (advice): Acciones que se ejecutan previamente, en el momento, o pos-
teriormente a que se alcance la ejecucin de una designacin de puntos de rup-
tura.
Aspecto (aspect): Mdulo de implementacin, definido como una clase, que
agrupa acciones en puntos de unin.
Utilizando este entorno de programacin se han desarrollado sistemas de trazabili-
dad de software, auditora de invocacin a mtodos (logging), adicin de precondiciones y
poscondiciones, as como utilizacin de programacin por contratos [Meyer97] en fase de
desarrollo y su posterior eliminacin sin necesidad de modificar el cdigo fuente. Tambin
se ha conseguido desarrollar aspectos reutilizables como por ejemplo determinadas polti-
cas de sincronizacin de hilos [Kiczales2001].

64
Sistemas Flexibles No Reflectivos

5.3.1 Aportaciones y Carencias


La programacin orientada a aspectos permite separar la parte funcional de una
aplicacin de otros aspectos propios de su implantacin o despliegue. Esta facilidad otorga
al sistema cierta flexibilidad con ciertas limitaciones.
El proceso de especificacin de aspectos para modificar la semntica de una aplica-
cin es un proceso esttico ( 2.3.3); una aplicacin no puede modificar sus distintos aspec-
tos en tiempo de ejecucin.
El modo en el que se crea, y posteriormente se trata, el grafo que define el flujo de
la ejecucin de la aplicacin, supone una elevada complejidad para el programador, e impli-
ca la definicin de un lenguaje distinto para la descripcin de aspectos. La implementacin
de AspectJ ha sido ms sencilla, al hacer uso de la caracterstica introspectiva de la plata-
forma Java [Sun97d] ( 2.3.1). De la misma forma, podra facilitarse el tratamiento del grafo
aadiendo un sistema de modificacin estructural dinmica del sistema ( 2.3.2).
Otra limitacin en la flexibilidad de la programacin orienta a aspectos es la restric-
cin a priori impuesta por la definicin de puntos de unin (join points): si una caracterstica
del lenguaje de programacin de componentes no se identifica como un punto de unin,
no podr ser modificada posteriormente ( 2.3.4). Todos los sistemas desarrollados son
tambin dependientes del lenguaje utilizado ( 2.3.5).

5.4 Programacin Adaptable


La programacin adaptable es una extensin de la programacin orientada a obje-
tos, en la que se flexibiliza las relaciones entre la computacin y los datos; el software se
puede adaptar para manejar cambios en los requerimientos del sistema. La programacin
adaptable permite expresar la intencin general de un programa sin necesidad de especificar
todos los detalles de las estructuras de los objetos [Lieberherr96].
El software adaptable toma el paradigma de la orientacin a objetos y lo ampla pa-
ra que ste soporte un desarrollo evolutivo de aplicaciones. La naturaleza progresiva de la
mayor parte de los sistemas informticos, hace que stos sufran un nmero elevado de
cambios a lo largo de su ciclo de vida. La adaptabilidad de un sistema gua la creacin de
ste a una tcnica que minimice el impacto producido por los cambios. Software adaptable
es aqul que se amolda automticamente a los cambios contextuales (por ejemplo, la im-
plementacin de un mtodo, la estructura de una clase, la sincronizacin de procesos o la
migracin de objetos).
Un caso prctico de programacin adaptable es el mtodo Demeter (Demeter Met-
hod) [Lieberherr96]. En este mtodo se identifican inicialmente clases y su comportamiento
bsico sin necesidad de definir su estructura. Las relaciones entre stas y sus restricciones se
establecen mediante patrones de propagacin (propagation patterns). En este nivel de progra-
macin se especifica la intencin general del programa sin llegar a realizar una especifica-
cin formal.
Cada patrn de propagacin de divide en las siguientes partes:
Signatura de la operacin o prototipo de la computacin a implementar.
Especificacin de un camino; indicando la direccin en el grafo de relaciones
entre clases que va a seguir el clculo de la operacin.

65
CAPTULO 5

Fragmento de cdigo; especificando algn tipo de restriccin, o la realizacin


de la operacin desde un elevado nivel de abstraccin.
Una vez especificado el grafo de clases y los patrones de propagacin, tenemos una
aplicacin de mayor nivel de abstraccin que una programada convencionalmente sobre un
lenguaje orientado a objetos. Esta aplicacin podr ser formalizada en distintas aplicaciones
finales mediante distintas personalizaciones (customizations). En cada personalizacin se es-
pecifica la estructura y comportamiento exacto de cada clase en un lenguaje de programa-
cin en el caso de Demeter, en C++ [Stroustrup98].
Finalmente, una vez especificado el programa adaptable y su personalizacin, el
compilador Demeter genera la aplicacin final en C++. La adaptabilidad del sistema final
se centra en la modificacin de las personalizaciones a lo largo del ciclo de vida de la apli-
cacin; distintas personalizaciones de un mismo programa adaptable dan lugar a diferentes
aplicaciones finales, sin variar la semntica del nivel de abstraccin ms elevado.

5.4.1 Aportaciones y Carencias


La flexibilidad conseguida en este tipo de sistemas es similar a la otorgada por la
programacin orientada a aspectos: es posible separar la funcionalidad central de la aplica-
cin de otras incumbencias no funcionales. Sin embargo, la principal diferencia entre am-
bos es que los aspectos son una tcnica de implementacin, y la programacin adaptable
est ms enfocada a la ingeniera del software. Los programas adaptables tratan de repre-
sentar de algn modo la funcionalidad captada en tiempo de anlisis y diseo.
La programacin adaptable, ms que buscar entornos de computacin flexible (co-
mo los requeridos para esta tesis), est enfocada a minimizar el impacto en los cambios
producidos en entornos de desarrollo evolutivos. Es por esta razn, por la que este tipo de
sistemas no cumple los requisitos impuestos de flexibilidad ( 2.3).

5.5 Separacin Multidimensional de Incumbencias


En la introduccin de este captulo Sistemas Flexibles No Reflectivos, identific-
bamos la separacin de incumbencias como un nuevo paradigma de diseo y programa-
cin, basado en identificar, encapsular y manipular las partes de un sistema relevantes a sus
distintas competencias. La separacin de estas competencias o incumbencias, evita la mis-
celnea de cdigo concerniente a la obtencin de distintos objetivos, facilitando el desarro-
llo de software y su mantenimiento.
El conjunto de incumbencias relevantes en un sistema vara a lo largo del ciclo de
vida de ste, aadiendo mayor complejidad a la separacin de las competencias. El caso
ms general es aqul en el que cualquier criterio para la descomposicin de incumbencias
pueda ser aplicado. A modo de ejemplo, podemos identificar un sistema en el que se reco-
nozcan tres dimensiones de competencias (mostrado en la Figura 5.3): primero, el estado y
comportamiento de cada objeto, ubicados en su clase modificar sta implica modificar la
funcionalidad y estructura de sus instancias; segundo, las caractersticas de cada objeto
capacidad de visualizacin, impresin, persistencia, etc.; tercero, reutilizacin de artefactos
software middleware (COM [Brown98], CORBA [OMG95], etc.), acceso a bases de datos,
sistemas de seguridad, etc.

66
Sistemas Flexibles No Reflectivos

Artefacto Software
(middleware, bases de
datos, seguridad, etc.)

Comportamiento
y estructura del
objeto (clase)

Caractersticas
(impresin, visualizacin,
persistencia, etc.)

Figura 5.3: Ejemplo de sistema con tres dimensiones de incumbencias.

El trmino separacin multidimensional de incumbencias (Multi-Dimensional Sepa-


ration of Concerns) se ha utilizado para designar a los sistemas capaces de proporcionar la
separacin incremental, modularizacin e integracin de artefactos software, basados en
cualquier nmero de incumbencias [IBM2000e]. Los principales objetivos de estos sistemas
son:
1. Permitir encapsular todos los tipos de incumbencias de un sistema, de forma
simultnea: El usuario podr elegir y especificar cualquier dimensin de incum-
bencias del sistema, sin estar restringido a un nmero determinado ni a un tipo
de competencias preestablecidas.
2. Utilizacin de incumbencias solapadas e interactivas: En los sistemas estudiados
previamente en este captulo, las incumbencias separables de un sistema deban
ser independientes y ortogonales en la prctica esto no ocurre. La separacin
multidimensional de incumbencias permite que stas se solapen y que la inter-
accin entre ellas sea posible.
3. Remodularizacin de incumbencias: El cambio o aumento de requisitos de un
sistema puede implicar nuevas apariciones de incumbencias o modificaciones
de las existentes. La creacin o modificacin de los mdulos existentes deber
ser factible sin necesidad de modificar los mdulos no implicados.
Las distintas ventajas de la utilizacin de este paradigma son:
Promueve la reutilizacin de cdigo; no slo aspectos funcionales de computa-
cin, sino competencias adicionales (persistencia, distribucin, etc.).
Al separarse los distintos aspectos del sistema, se mejora la comprensin del
cdigo fuente.
Reduccin de los impactos en el cambio de requisitos del sistema.
Facilita el mantenimiento de los sistemas gracias al encapsulamiento individual
de las incumbencias identificadas.
Mejora la trazabilidad de una aplicacin centrndonos en aquel aspecto que de-
seemos controlar.

67
CAPTULO 5

Existen diversos sistemas de investigacin construidos basndose en este paradigma


[OOPSLA99, ICSE2000]. Un ejemplo es Hyperspaces [Ossher99], un sistema de separacin
multidimensional de incumbencias independiente del lenguaje, creado por IBM, as como la
herramienta Hyper/J [IBM2000f] que da soporte a Hyperspaces en el lenguaje de programa-
cin Java [Gosling96].

5.5.1 Aportaciones y Carencias


La principal aportacin de los sistemas basados en separacin multidimensional de
incumbencias, en comparacin con los estudiados en este captulo, es el grado de flexibili-
dad otorgado: mientras que el resto de sistemas identifican un conjunto limitado de aspec-
tos a describir, en este caso no existen lmites.
Por otro lado, si bien el grado de flexibilidad aumenta al aumentar la posibilidad de
identificar ms incumbencias, el mecanismo para obtener dicha flexibilidad no se modifica.
Dicho mecanismo sigue los pasos de descripcin de competencias y procesamiento de s-
tas para generar el sistema final. Aunque se llega a un compromiso de flexibilidad para ob-
tener eficiencia de la aplicacin final, ste est lejos de ser el mecanismo flexible dinmico
(accesible en tiempo de ejecucin) descrito en los requisitos de 2.3.

5.6 Sistemas Operativos Basados en Microncleo


A la hora de disear sistemas operativos distribuidos, existen dos grandes tipos de
arquitecturas distintas [Tanenbaum95]:
Una se basa en que cada mquina debe ejecutar un ncleo tradicional (ncleo
monoltico) que proporcione la mayora de los servicios.
Otra disea el ncleo del sistema operativo de forma que sea lo ms reducido
posible (microncleo), y el grueso de los servicios del sistema operativo se ob-
tiene a partir de los servidores al nivel de usuario.
El objetivo de los sistemas no monolticos es mantener lo ms reducido posible la
funcionalidad del microncleo. En trminos bsicos, suelen proporcionar primitivas de
comunicacin entre procesos, administracin de memoria y entrada/salida a bajo nivel. Los
servicios se construyen sobre estas primitivas, establecindose previamente una interfaz
bien definida de acceso al microncleo.
El carcter modular de estos sistemas facilita la implantacin, eliminacin y modifi-
cacin de los distintos servidores, obteniendo as mayor flexibilidad que los operativos mo-
nolticos. Adems, los usuarios que necesiten un determinado servicio especfico, podrn
codificarlo e implantarlo en el sistema ellos mismos.

68
Sistemas Flexibles No Reflectivos

Aplicaciones

SO Monoltico
Aplicaciones
SO basado en Microncleo
Interfaz de Acceso

Archivos Acceso Usuario Sistema Archivos A Sistema Archivos B


Procesos
Pipes
Microncleo Microncleo Microncleo

Buffers Administrador

Dispositivo Gestin Memoria


Hardware Hardware Hardware

Red Computadores
Hardware

Figura 5.4: Comparacin de acceso a sistemas de archivos de sistemas operativos monolticos y


basados en microncleo.

En la figura anterior se muestra un ejemplo de utilizacin de un sistema basado en


microncleo en la que se implementan distintos sistemas de archivos. Se puede desarrollar
un servidor de archivos DOS, otro UNIX y un tercero propietario implementado por el
usuario. Los distintos programas desarrollados sobre este operativo, podrn seleccionar
cualquiera de los tres sistemas de archivos a utilizar, e incluso utilizar los tres simultnea-
mente.
La mayor desventaja de estos sistemas respecto a los monolticos es el rendimiento.
El hecho de centralizar las operaciones sobre las primitivas del microncleo, supone un
mayor acoplamiento, y por lo tanto una prdida de rendimiento. Sin embargo, mediante
distintas tcnicas de implementacin, se han realizado estudios en los que el rendimiento
no baja substancialmente y es aceptable gracias a la flexibilidad obtenida [Liedtke95].
La arquitectura de sistemas operativos basados en microncleo ha sido motivo de
investigacin en los ltimos aos, existiendo multitud de ellos: Amoeba [Mullender87],
CHORUS [Rozier88], MOS [Barak85], Topaz [McJones88], V-System [Cheriton88] o Mach
[Rashid86]. Como caso prctico, estudiaremos brevemente dos de ellos.

Amoeba
Ameba es un sistema operativo distribuido que permite agrupar CPUs y equipos de
entrada/salida, haciendo que todo el conjunto se comporte como una nica computadora
[Mullender90]. Facilita tambin elementos de programacin paralela.
Se origin en Vrije Universiteit (Amsterdam) en 1981, como un proyecto de inves-
tigacin en el cmputo distribuido y paralelo [Tanenbaum95]. Fue diseado por Andrew
Tanenbaum y tres de sus estudiantes de doctorado. En el ao 1983, Amoeba 1.0 tena un
primer nivel operacional. El sistema evolucion durante algunos aos, adquiriendo caracte-
rsticas como emulacin parcial de UNIX, comunicacin en grupo y un nuevo protocolo
de bajo nivel.
Una de las mayores diferencias entre Amoeba y el resto de sistemas operativos dis-
tribuidos es que Amoeba carece del concepto de mquina origen. Cuando un usuario
entra en el sistema, entra a ste como un todo y no a una mquina especfica. Las mquinas

69
CAPTULO 5

no tienen propietarios. El shell ofrecido al usuario busca de manera automtica la mquina


con la menor carga, para ejecutar cada en ella comando solicitado.
Amoeba consta de dos partes fundamentales: el microncleo que se ejecuta en cada
procesador, y una coleccin de servidores que proporcionan la mayor parte de la funciona-
lidad global de un sistema operativo tradicional. La estructura general se muestra en la si-
guiente figura:
Sistema Operativo Amoeba
Servidores

Aplicacin Cliente Sistema Archivos


Aplicacin
Cliente

Servicios Sistema Servicios Planificador Servicios


Archivos Procesos

Microncleo Microncleo Microncleo

Procesador A Procesador B Procesador C


Hilos

Red Computadores

Figura 5.5: Estructura de aplicaciones sobre el sistema operativo Amoeba.

El microncleo se ejecuta en todas las mquinas del sistema. ste tiene cuatro fun-
ciones bsicas:
1. Manejo de procesos e hilos.
2. Soporte del manejo de memoria a bajo nivel.
3. Soporte de la comunicacin.
4. Manejo de entrada/salida mediante primitivas de bajo nivel.
Mediante esta arquitectura se consiguen dos grandes objetivos: distribuir los servi-
cios a lo largo de una red heterognea de computadores, y separar la interfaz e implementa-
cin de un servicio para que ste pueda adaptarse a las distintas necesidades.

Mach
El principal objetivo del sistema operativo Mach era demostrar que se podan es-
tructurar los sistemas operativos de manera modular, como una coleccin de procesos que
se comuniquen entre s mediante la transferencia de mensajes, incluso a travs de una red
[Babao89].
La primera versin de Mach apareci en 1986 para un VAX 11/784, un multipro-
cesador con cuatro CPUs. Poco despus se instituy la Open Software Foundation, un conso-
cio de vendedores de computadores, con el fin de arrebatarle el control del UNIX a su
creador AT&T. OSF eligi a Mach 2.5 como la base para su primer sistema operativo.
En 1988, el ncleo de Mach era grande y monoltico, debido a la presencia de una
gran parte del cdigo UNIX de Berkeley. En 1989, se elimin dicho cdigo del ncleo y se
ubic en el espacio de usuario, constituyendo Mach 3.0 como un sistema basado en micro-
ncleo [Tanenbaum95]. ste manejaba cinco abstracciones principales:
1. Procesos.

70
Sistemas Flexibles No Reflectivos

2. Hilos.
3. Objetos de memoria.
4. Puertos.
5. Mensajes.
El microncleo de Mach se dise como una base para emular cualquier tipo de sis-
tema operativo. La emulacin se lleva a cabo mediante una capa software ejecutada fuera
del ncleo, en el espacio de usuario como se muestra en la Figura 5.6. Con este sistema, es
posible ejecutar aplicaciones sobre distintos sistemas operativos, al mismo tiempo y sobre
una misma mquina.
Sistema Operativo Mach

Procesos Usuario

Espacio
de
Usuario

Emulacin
Sistema
Emulacin Operativo
Sistema B Emulacin
Operativo Sistema
A Operativo
C

Espacio
Microncleo del
Microncleo

Figura 5.6: Ejecucin de aplicaciones sobre distintos sistemas operativos emulados en Mach.

La idea subyacente en el ncleo de Mach es proporcionar los mecanismos necesa-


rios para que el sistema funcione, dejando las distintas polticas para los procesos de usua-
rio. El sistema de microncleo no slo permite flexibilizar los distintos servicios del opera-
tivo como veamos en el caso de Amoeba, sino que puede utilizarse para flexibilizar el
propio sistema operativo, implementando simultneamente distintas emulaciones.

5.6.1 Aportaciones y Carencias


La idea principal de los sistemas operativos basados en microncleo se centra en
codificar la parte computacional mnima de forma monoltica, para identificar posterior-
mente los servicios de un mayor nivel de abstraccin como unidades modulares reempla-
zables. Este tipo de sistemas aporta un modo sencillo de disear un primer mecanismo de
flexibilidad para una plataforma de computacin ( 2.1.4) sistemas estructuralmente re-
flectivos, como la mquina abstracta de Smalltalk [Goldberg83], utilizan esta tcnica para
poder adaptar y extender su ncleo computacional [Krasner83].
Las primitivas ofrecidas por el microncleo pueden ser ampliadas a un mayor nivel
de abstraccin implementndolas como servicios, y flexibilizando as los elementos bsicos
del sistema computacional ( 2.2.1). El usuario puede modificar, elegir y ampliar cualquier
caracterstica del sistema ( 2.2.2), siempre que haya sido desarrollada como un servicio.
Otra de las aportaciones positivas derivadas de la reduccin del ncleo computa-
cional es la posibilidad de implantar ste en entornos heterogneos ( 2.4.5). Al haberse

71
CAPTULO 5

especificado previamente una interfaz de acceso, la seleccin de los distintos servicios que
se desarrollan sobre el micro ncleo puede ser llevada a cabo de forma dinmica ( 2.2.2).
Una de sus mayores carencias para convertirse en entornos computacionales flexi-
bles es la falta de un sistema introspectivo que permita conocer ( 2.2.3) y autodocumentar
( 2.2.4) dinmicamente todas las caractersticas de los servicios implantados en el sistema.

5.7 Conclusiones
En este captulo hemos visto cmo la programacin adaptable puede ser utilizada
en distintos campos, y cmo se han desarrollado distintas tcnicas para conseguirla. Los
sistemas estudiados han sido desarrollados buscando un entorno en el que la parte funcio-
nal de la aplicacin se pudiese separar del resto de incumbencias. Estos trabajos de investi-
gacin identifican, de algn modo, la necesidad de desarrollar entornos de programacin
flexibles.
La principal diferencia entre los distintos sistemas estudiados reside en el punto de
vista que adoptan para conseguir la separacin de incumbencias: desarrollo de componen-
tes ( 5.1), modificacin de parte de la semntica de un lenguaje de programacin ( 5.2),
separacin de funcionalidades ( 5.3), ciclo de vida de un sistema informtico ( 5.4) y
computaciones susceptibles de ser reemplazadas ( 5.6).
A excepcin de los sistemas operativos basados en microncleo, las herramientas
analizadas otorgan un reducido nivel de flexibilidad para resolver un problema concreto,
sin incurrir en elevadas carencias de eficiencia computacional.
En lo referente a los sistemas operativos basados en microncleo, el criterio de di-
seo centrado en separar la computacin primitiva de los servicios supone un mecanismo
para desarrollar un sistema con un elevado grado de flexibilidad: todo lo desarrollado como
un servicio es reemplazable.
La simplificacin del microncleo facilita su implantacin en entornos heterog-
neos y simplifica la recodificacin de sus primitivas como servicios para su posterior mo-
dificacin.
Sus principales carencias son acarreadas por la ausencia de un mecanismo de acceso
dinmico19.
No es posible conocer de forma exacta y en tiempo de ejecucin los servicios
existentes en el sistema.
La seleccin dinmica de distintos servicios no est permitida.
No es posible modificar un servicio de forma dinmica, sin necesidad de finali-
zar su ejecucin.
La utilizacin de un servicio por una aplicacin es explcita, y por lo tanto es
necesario modificar la aplicacin si queremos modificar algn aspecto de los
servicios que utiliza.

19
Veremos en el captulo 10 cmo estos problemas se pueden solventar con la incorporacin de caracte-
rsticas reflectivas al sistema computacional base.

72
CAPTULO 6:
REFLECTIVIDAD COMPUTACIONAL

Previamente a este captulo, hemos estudiado un conjunto de sistemas que dotaban


a distintos entornos computacionales de un cierto grado de flexibilidad. Cada uno de di-
chos sistemas utilizaba distintas tcnicas para conseguir adaptarse a las distintas necesidades
del usuario, as como para poder ampliar o extender sus caractersticas.
A lo largo de este captulo, introduciremos los conceptos propios de una tcnica
utilizada para conseguir un elevado grado de flexibilidad en determinados sistemas: la re-
flectividad20 computacional. Haremos un estudio genrico de las posibilidades de los siste-
mas reflectivos y estableceremos distintas clasificaciones en funcin de distintos criterios.
En el siguiente captulo, todos los trminos definidos y estudiados aqu sern utili-
zados para analizar los distintos sistemas dotados de reflectividad, as como para, poste-
riormente, poder especificar y disear nuestro propio entorno computacional reflectivo.

6.1 Conceptos de Reflectividad

6.1.1 Reflectividad
Reflectividad o reflexin (reflection) es la propiedad de un sistema computacional que
le permite razonar y actuar sobre l mismo, as como ajustar su comportamiento en funcin
de ciertas condiciones [Maes87].
El dominio computacional de un sistema reflectivo el conjunto de informacin
que computa aade al dominio de un sistema convencional la estructura y comportamien-
to de s mismo. Se trata pues de un sistema capaz de acceder, analizar y modificarse a s
mismo, como si de una serie de estructuras de datos propias de un programa de usuario se
tratase.

20
Traduccin de reflection. Muchos autores la han traducido tambin como reflexin. Nosotros utilizare-
mos el trmino reflectividad a lo largo de esta memoria.

73
CAPTULO 6

6.1.2 Sistema Base


Aqul sistema de computacin que es dominio de otro sistema computacional dis-
tinto, denominado metasistema [Golm97]. El sistema base es el motor de computacin
(intrprete, software o hardware) de un programa de usuario.

6.1.3 Metasistema
Aqul sistema computacional que posee por dominio de computacin a otro siste-
ma computacional denominado sistema base. Un metasistema es por lo tanto un intrprete
de otro intrprete.

6.1.4 Cosificacin
Cosificacin o concretizacin (reification) es la capacidad de un sistema para acceder
al estado de computacin de una aplicacin, como si se tratase de un conjunto de datos
propios de una aplicacin de usuario [Smith82].
La cosificacin es la posibilidad de acceso desde un sistema base a su metasistema,
en el que se puede manipular el sistema base como si de datos se tratase; es el salto del en-
torno de computacin de usuario al entorno de computacin del intrprete de la aplicacin
de usuario.
Si podemos cosificar21 un sistema, podremos acceder y modificar su estructura y
comportamiento y, por lo tanto, podremos aadir a su dominio computacional su propia
semntica; estaremos trabajando pues, con un sistema reflectivo.

21
Cosificar o concretizar: transformar una representacin, idea o pensamiento en cosa.

74
Reflectividad Computacional

Programa
Usuario

Interpreta

Sistema Base

Objeto en
sistema Base
Meta-Objeto

Cosificacin Reflectividad Objeto computado


Interpreta (conexin causal) en el Sistema Base
Objeto computado
Meta-Sistema en el Meta-Sistema

Interpreta

Intrprete
Software o
Hardware

Figura 6.1: Entorno de computacin reflectivo.

6.1.5 Conexin Causal


Un sistema es causalmente conexo si su dominio computacional alberga el entorno
computacional de otro sistema (permite la cosificacin del sistema base) y, al modificar la
representacin de ste, los cambios realizados causan un efecto en su propia computacin
(la del sistema base) [Maes87b].
Un sistema reflectivo es aqul capaz de ofrecer cosificacin completa de su sistema
base, e implementa un mecanismo de conexin causal. La forma en la que los distintos
sistemas reflectivos desarrollan esta conexin vara significativamente.

6.1.6 Metaobjeto
Identificando la orientacin a objetos como paradigma del sistema reflectivo, puede
definirse un metaobjeto como un objeto del metasistema que contiene informacin y com-
portamiento propia del sistema base [Kiczales91]. La abstraccin del metaobjeto no es ne-
cesariamente la de un objeto propio del sistema base, sino que puede representar cualquier
elemento que forme parte de ste por ejemplo, el mecanismo del paso de mensajes.

75
CAPTULO 6

6.1.7 Reflectividad Completa


La conexin causal no es suficiente para un sistema reflectivo ntegro. Cuando la
cosificacin de un sistema es total, desde el metasistema se puede acceder a cualquier ele-
mento del sistema base y la conexin causal se produce para cualquier elemento modifica-
do, entonces ese sistema posee reflectividad completa (completeness) [Blair97]. En este caso,
el metasistema debe ofrecer una representacin ntegra del sistema base (todo podr ser
modificado).
Como veremos en el estudio de sistemas reales (captulo 7), la mayora de los siste-
mas existentes limitan a priori el conjunto de caractersticas del sistema base que pueden ser
modificados mediante el mecanismo de reflectividad implementado.

6.2 Reflectividad como una Torre de Intrpretes


Para explicar el concepto de reflectividad computacional, as como para posterior-
mente implementar prototipos de demostracin de su utilidad, Smith identific el concepto
de reflectividad computacional como una torre de intrpretes [Smith82].
Dise un entorno de trabajo en el que todo intrprete de un lenguaje era a su vez
interpretado por otro intrprete, estableciendo una torre de interpretaciones. El programa
de usuario se ejecuta en un nivel de interpretacin 0; cobra vida gracias a un intrprete que
lo anima desde el nivel computacional 1. En tiempo de ejecucin el sistema podr cosifi-
carse, pasando el intrprete del nivel 1 a ser computado por otro intrprete la reflectividad
computacional implica una computacin de la computacin. En este caso (Figura 6.2.b) un
nuevo intrprete, desde el nivel 2, pasa a computar el intrprete inicial. El dominio compu-
tacional del intrprete mostrado en la Figura 6.2 por un doble recuadro estar formado
por la aplicacin de usuario (nivel 0) y la interpretacin directa de ste (nivel 1). En esta
situacin se podr acceder tanto a la aplicacin de usuario (por ejemplo, para modificar sus
objetos) como a la forma en la que ste es interpretado (por ejemplo, para modificar la se-
mntica del paso de mensajes). El reflejo de dichos cambios en el nivel 1 es lo que se de-
nomina reflectividad o reflexin.
Intrprete
Nivel 3

Interpreta

Intrprete Intrprete
Nivel 2

Interpreta Interpreta

Intrprete Intrprete Intrprete Nivel 1


Cosificacin Cosificacin
Interpreta Interpreta Interpreta

Programa de Programa de Programa de


Usuario Usuario Usuario Nivel 0

a) c)
b)

Dominios Computacionales

Figura 6.2: Torre de intrpretes definida por Smith.

La operacin de cosificacin se puede aplicar tantas veces como deseemos. Si el in-


trprete procesa al intrprete del nivel 1, podemos cosificar este contexto para obtener un

76
Reflectividad Computacional

nuevo nivel de computacin? S; se creara un nuevo intrprete que procesare los niveles
0, 1 y 2, ubicndose ste en el nivel computacional 3. En este caso reflejaramos la forma en
la que se refleja la aplicacin de usuario (tendramos una meta-meta-computacin).
Un ejemplo clsico es la depuracin de un sistema (debug). Si estamos ejecutando un
sistema y deseamos depurar mediante una traza todo su conjunto, podremos cosificar ste,
para generar informacin relativa a su ejecucin desde su intrprete. Todos los pasos de su
interpretacin podrn ser trazados. Si deseamos depurar el intrprete de la aplicacin en
lugar de la propia aplicacin, podremos establecer una nueva cosificacin aplicando el
mismo sistema [Douence99].
Este entorno de trabajo fue definido por Smith como una torre de intrpretes
[Smith82]. Defini el concepto de reflectividad, y propuso la semntica de sta para los
lenguajes de programacin, sin llevar a cabo una implementacin. La primera implementa-
cin de este sistema fue realizada mediante la modificacin del lenguaje Lisp [Steele90],
denominndolo 3-Lisp [Rivires84].
La torre infinita de intrpretes siempre tiene un nivel mximo de computacin.
Siempre existir un intrprete que no sea interpretado a su vez por otro procesador: un
intrprete hardware o microprocesador. Un microprocesador es un intrprete de un lenguaje
de bajo nivel, implementado fsicamente.
En la Figura 6.3 mostramos un ejemplo real de una torre de intrpretes. Se trata de
la implementacin de un intrprete de un lenguaje de alto nivel, en el lenguaje de progra-
macin Java [Gosling96].

Nivel 0 Programa
de usuario Aplicaciones

Cdigo Alto Nivel

Ejecuta

Intrprete
Nivel 1 Intrprete
del Lenguaje
del Lenguaje
alto nivel Compilador
Cdigo binario JVM alto nivel
de Java Cdigo Java

Ejecuta

Lenguajes Programacin
Java
Nivel 2 Java
Virtual
Virtual
Machine
Compilador Machine
Binario 80x86
de C a 80x86 Cdigo C

Ejecuta

Nivel 3
80x86

Figura 6.3: Ejemplo de torre de intrpretes en la implementacin de un intrprete en Java.

Java es un lenguaje que se compila a un cdigo binario de una mquina abstracta


denominada Java Virtual Machine [Lindholm96]. Para interpretar este cdigo
previamente compilado podemos utilizar un emulador de la mquina virtual programado
en C y compilado, por ejemplo, para un i80X86. Finalmente el cdigo binario de este mi-

77
CAPTULO 6

croprocesador es interpretado una implementacin fsica de ste. En el ejemplo expuesto


tenemos un total de cuatro niveles computacionales en la torre de intrpretes.
Si pensamos en el comportamiento o la semntica de un programa como una fun-
cin de nivel n, sta podr ser vista realmente como una estructura de datos desde el nivel
n+1. En el ejemplo, el intrprete del lenguaje de alto nivel define la semntica de dicho
lenguaje, y la mquina virtual de Java define la semntica del intrprete del lenguaje de alto
nivel. Por lo tanto, el intrprete de Java podr modificar la semntica computacional del
lenguaje de alto nivel, obteniendo as reflectividad computacional.
Cada vez que en la torre de intrpretes nos movamos en un sentido de niveles as-
cendente, podemos identificar esta operacin como cosificacin22 (reification). Un movi-
miento en el sentido contrario se identificar como reflexin (reflection) [Smith82].

6.3 Clasificaciones de Reflectividad


Pueden establecerse distintas clasificaciones en el tipo de reflectividad desarrollado
por un sistema, en funcin de diversos criterios. En este punto identificaremos dichos cri-
terios, clasificaremos los sistemas reflectivos basndonos en el criterio seleccionado, y des-
cribiremos cada uno de los tipos.
Para cada clasificacin de sistemas reflectivos identificado, mencionaremos algn
ejemplo existente para facilitar la comprensin de dicha divisin. Sin embargo, el estudio
detallado de los distintos entornos reflectivos existentes se llevar a cabo en el captulo 7.

6.3.1 Qu se refleja
Hemos definido reflectividad en 6.1 como la propiedad de un sistema computa-
cional que le permite razonar y actuar sobre l mismo. El grado de informacin que un
sistema posee acerca de s mismo aquello susceptible de ser cosificado y reflejado esta-
blece la siguiente clasificacin.

6.3.1.1 Introspeccin
Capacidad de un sistema para poder inspeccionar u observar, pero no modificar, los
objetos de un sistema [Foote92]. En este tipo de reflectividad, se facilita al programador
acceder al estado del sistema en tiempo de ejecucin: el sistema ofrece la capacidad de co-
nocerse a s mismo.
Esta caracterstica se ha utilizado de forma pragmtica en numerosos sistemas. A
modo de ejemplo, la plataforma Java [Kramer96] ofrece introspeccin mediante su paquete
java.reflect [Sun97d]. Gracias a esta capacidad, en Java es posible almacenar un obje-
to en disco sin necesidad de implementar un solo mtodo: el sistema accede de forma in-
trospectiva al objeto, analiza sus atributos y los convierte en una secuencia de bytes para su
posterior envo a un flujo23 [Eckel2000]. Sobre este mismo mecanismo Java implementa
adems su sistema de componentes JavaBeans [Sun96]: dado un objeto, en tiempo de eje-
cucin, se determinar su conjunto de propiedades y operaciones.
Otro ejemplo de introspeccin, en este caso para cdigo nativo compilado, es la
adicin de informacin en tiempo de ejecucin al estndar ISO/ANSI C++ (RTTI, Run-
Time Type Information) [Kalev98]. Este mecanismo introspectivo permite conocer la clase de

22
Ciertamente hacemos datos (o cosa) un comportamiento.
23
Este proceso se conoce como serializacin (serialization).

78
Reflectividad Computacional

la que es instancia un objeto, para poder ahormar ste de forma segura respecto al tipo
[Cardelli97].

6.3.1.2 Reflectividad Estructural


Se refleja el estado estructural del sistema en tiempo de ejecucin elementos tales
como las clases, el rbol de herencia, la estructura de los objetos y los tipos del lenguaje
permitiendo tanto su observacin como su manipulacin [Ferber88].
Mediante reflectividad estructural, se puede acceder al estado de la ejecucin de una
aplicacin desde el sistema base. Podr conocerse su estado, acceder las distintas partes del
mismo, y modificarlo si se estima oportuno. De esta manera, una vez reanudada la ejecu-
cin del sistema base (despus de producirse la reflexin), los resultados pueden ser distin-
tos a los que se hubieren obtenido si la modificacin de su estado no se hubiera llevado a
cabo.
Ejemplos de sistemas de naturaleza estructuralmente reflectiva son Smalltalk-80
[Goldberg83] y Self [Ungar87]. La programacin sobre estas plataformas se centra en ir
creando los objetos mediante sucesivas modificaciones de su estructura. No existe diferen-
cia entre tiempo de diseo y tiempo de ejecucin; al poder acceder a toda la estructura del
sistema, el programador se encuentra siempre en tiempo de ejecucin modificando dicha
estructura ( 4.3).

6.3.1.3 Reflectividad Computacional


Tambin denominada reflectividad de comportamiento (behavioural reflection). Se re-
fleja el comportamiento exhibido por un sistema computacional, de forma que ste pueda
computarse a s mismo mediante un mecanismo de conexin causal ( 6.1) [Maes87]. Un
sistema dotado de reflectividad computacional puede modificar su propia semntica; el
propio comportamiento del sistema podr cosificarse para su posterior manipulacin.
Un ejemplo de abstraccin de reflectividad computacional es la adicin de las
Proxy Classes [Sun99] a la plataforma Java2. Apoyndose en el paquete de introspeccin
(java.reflect), se ofrece un mecanismo para modificar el paso de mensajes: puede
manipularse dinmicamente la forma en la que un objeto interpreta la recepcin de un
mensaje24. De esta forma la semntica del paso de mensajes puede ser modificada.
Otros ejemplos reducidos de reflectividad computacional en la plataforma Java son
la posibilidad de sustituir el modo en el que las clases se cargan en memoria y el grado de
seguridad de ejecucin de la mquina abstracta. Gracias a las clases
java.lang.ClassLoader y java.lang.SecurityManager [Gosling96], se puede
modificar en el sistema la semntica obtencin del cdigo fuente (de este modo se consigue
cargar un applet de un servidor web) y el modo en el que una aplicacin puede acceder a su
sistema nativo (el sistema de seguridad frente a virus, en la ejecucin de applets, conocido
como sandbox [Orfali98]).

6.3.1.4 Reflectividad Lingstica


Un lenguaje de programacin posee unas especificaciones lxicas [Cueva93], sintc-
ticas [Cueva95] y semnticas [Cueva95b]. Un programa correcto es aqul que cumple las
tres especificaciones descritas. La semntica del lenguaje de programacin identifica el sig-
nificado de cualquier programa codificado en dicho lenguaje, es decir cul ser su compor-
tamiento al ejecutarse.

24
Estudiaremos este mecanismo, en mayor profundidad, en el siguiente captulo.

79
CAPTULO 6

La reflectividad computacional de un sistema nos permite cosificar y reflejar su se-


mntica; la reflectividad lingstica [Ortn2001] nos permite modificar cualquier aspecto del
lenguaje de programacin utilizado: mediante el lenguaje del sistema base se podr modifi-
car el propio lenguaje (por ejemplo, aadir operadores, construcciones sintcticas o nuevas
instrucciones).
Un ejemplo de sistema dotado de reflectividad lingstica es OpenJava [Chiba98].
Ampliando el lenguaje de acceso al sistema, Java, se aade una sintaxis y semntica para
aplicar patrones de diseo [GOF94], de forma directa, por el lenguaje de programacin
amolda el lenguaje a los patrones Adapter y Visitor [Tatsubori98].

6.3.2 Cundo se produce el reflejo


En funcin de la clasificacin anterior, un sistema determina lo que puede ser cosi-
ficado para su posterior manipulacin. En este punto clasificaremos los sistemas reflectivos
en funcin del momento en el que se puede llevar a cabo dicha cosificacin.

6.3.2.1 Reflectividad en Tiempo de Compilacin


El acceso desde el sistema base al metasistema se realiza en el momento en el que el
cdigo fuente est siendo compilado, modificndose el proceso de compilacin y por lo
tanto las caractersticas del lenguaje procesado [Golm97].
Tomando Java como lenguaje de programacin, OpenJava es una modificacin de
ste que le otorga capacidad de reflejarse en tiempo de compilacin [Chiba98]. En lugar de
modificar la mquina virtual de la plataforma para que sta posea mayor flexibilidad, se
rectifica el compilador del lenguaje con una tcnica de macros que expande las construc-
ciones del lenguaje. De esta forma, la eficiencia perdida por la flexibilidad del sistema queda
latente en tiempo de compilacin y no en tiempo de ejecucin.
Lo que pueda ser modificado en el sistema est en funcin de la clasificacin
6.3.1. En el ejemplo de OpenJava se pueden modificar todos los elementos; verbigracia, la
invocacin de mtodos, el acceso a los atributos, operadores del lenguaje o sus tipos. El
hecho de que el acceso al metasistema se produzca en tiempo de compilacin implica que
una aplicacin tiene que prever su flexibilidad antes de ser ejecutada; una vez que est co-
rriendo, no podr accederse a su metasistema de una forma no contemplada en su cdigo
fuente.

6.3.2.2 Reflectividad en Tiempo de Ejecucin


En este tipo de sistemas, el acceso del metasistema desde el sistema base, su mani-
pulacin y el reflejo producido por un mecanismo de conexin causal, se lleva a cabo en
tiempo de ejecucin [Golm97]. En este caso, una aplicacin tendr la capacidad de ser
flexible de forma dinmica, es decir, podr adaptarse a eventos no previstos25 cuando est
ejecutndose.
El sistema MetaXa, previamente denominado MetaJava, modifica la mquina virtual
de la plataforma Java para poder ofrecer reflectividad en tiempo de ejecucin [Klein-
der96]. A las diferentes primitivas semnticas de la mquina virtual se pueden asociar me-
taobjetos que deroguen el funcionamiento de dichas primitivas: el metaobjeto define la
nueva semntica. Ejemplos clsicos de utilizacin de esta flexibilidad son la modificacin
del paso de mensajes para implementar un sistema de depuracin, auditora o restricciones
de sistemas en tiempo real [Golm97b].

25
No previstos en tiempo de compilacin cuando la aplicacin se est siendo implementada.

80
Reflectividad Computacional

6.3.3 Cmo se expresa el acceso al metasistema


En funcin del modo en el que se exprese el metasistema desde el sistema base,
podremos establecer la siguiente clasificacin.

6.3.3.1 Reflectividad Procedural


La representacin del metasistema se ofrece de forma directa por el programa que
implementa el metasistema [Maes87]. En este tipo de reflectividad, el metasistema y el sis-
tema base utilizan el mismo modelo computacional; si nos encontramos en un modelo de
programacin orientado a objetos, el acceso al metasistema se facilitar utilizando este pa-
radigma.
El hecho de acceder de forma directa a la implementacin del sistema ofrece dos
ventajas frente a la reflectividad declarativa:
1. La totalidad del sistema es accesible y por lo tanto cualquier parte de ste podr
ser manipulada. No existen restricciones en el acceso.
2. La conexin causal es automtica [Blair97]. Al acceder directamente a la imple-
mentacin del sistema base, no es necesario desarrollar un mecanismo de actua-
lizacin o reflexin.

6.3.3.2 Reflectividad Declarativa


En la reflectividad declarativa, la representacin del sistema en su cosificacin es
ofrecida mediante un conjunto de sentencias representativas del comportamiento de ste
[Maes87]. Haciendo uso de estas sentencias, el sistema podr ser adaptado.
La ventaja principal que ofrece esta clasificacin es la posibilidad de elevar el nivel
de abstraccin, a la hora de representar el metasistema. Las dos ventajas de la reflectividad
procedural comentadas previamente, se convierten en inconvenientes para este tipo de
sistemas.
La mayor parte de los sistemas existentes ofrecen un mecanismo de reflectividad
declarativa. En el caso de MetaXa [Kleinder96], se ofrece una representacin de acceso a
las primitivas de la mquina abstracta modificables.

6.3.4 Desde Dnde se puede modificar el sistema


El acceso reflectivo a un sistema se puede llevar a cabo desde distintos procesos. La
siguiente clasificacin no es excluyente: un sistema puede estar incluido en de ambas clasi-
ficaciones.

6.3.4.1 Reflectividad con Acceso Interno


Los sistemas con acceso interno (inward) a su metasistema permiten modificar una
aplicacin desde la definicin de ste (su codificacin) [Foote92]. Esta caracterstica define
aquellos sistemas que permiten modificar una aplicacin desde s misma.
La mayora de los sistemas ofrecen esta posibilidad. En MetaXa [Kleinder96], slo
la propia aplicacin puede modificar su comportamiento.

6.3.4.2 Reflectividad con Acceso Externo


El acceso externo de un sistema (outward) permite la modificacin de una aplicacin
mediante otro proceso distinto al que ser modificado [Foote92]. En un sistema con esta
caracterstica, cualquier proceso puede modificar al resto. La ventaja es la flexibilidad obte-

81
CAPTULO 6

nida; el principal inconveniente, la necesidad de establecer un mecanismo de seguridad en


el acceso entre procesos ( 6.4).
El sistema Smalltalk-80 ofrece un mecanismo de reflectividad estructural con acce-
so externo [Mevel87]: el programador puede acceder, y modificar en su estructura, cual-
quier aplicacin o proceso del sistema.

6.3.5 Cmo se ejecuta el sistema


La ejecucin del sistema reflectivo puede darse de dos formas: mediante cdigo na-
tivo o mediante la interpretacin de un cdigo intermedio.

6.3.5.1 Ejecucin Interpretada


Si el sistema se ejecuta mediante una interpretacin software, las caractersticas de re-
flectividad dinmica se pueden ofrecer de una forma ms sencilla. Ejemplos de este tipo de
sistemas son Self [Smith95], Smalltalk-80 [Krasner83] o Java [Kramer96]. Estas plataformas
de interpretacin ofrecen caractersticas reflectivas de un modo sencillo, al encontrase el
intrprete y el programa ejecutado en el mismo espacio de direcciones ( 3.3.3).
Su principal inconveniente es la prdida de eficiencia por la inclusin del proceso de
interpretacin.

6.3.5.2 Ejecucin Nativa


Se produce cuando se compila cdigo nativo, capaz de ofrecer cualquier grado de
reflectividad indicado en 6.3.1. Un primer ejemplo es el mecanismo RTTI del ANSI/ISO
C++, que ofrece introspeccin en tiempo de ejecucin para un sistema nativo [Kalev98].
Esta clasificacin es distinta a la indicada en 6.3.2. Puede producirse el reflejo del
sistema en tiempo de ejecucin, tanto para sistemas compilados (nativos) como interpreta-
dos. Un ejemplo de ello es el sistema Iguana [Gowing96]. Este sistema implementa un
compilador de C++ que ofrece reflectividad computacional en tiempo de ejecucin. El
cdigo generado es una ampliacin del estndar RTTI.
La principal ventaja de este tipo de sistemas es su eficiencia; sin embargo, su im-
plementacin es ms costosa que la de un intrprete, puesto que debemos generar cdigo
capaz de ser modificado dinmicamente.

6.4 Hamiltonians versus Jeffersonians


Durante el desarrollo del sistema democrtico americano, existan dos escuelas de
pensamiento distintas: los Hamiltonians y los Jeffersonians. Los Jeffersonians pensaban que cual-
quier persona debera tener poder para llevar a cabo decisiones como la eleccin del presi-
dente de los Estados Unidos. Por el contrario, los Hamiltonians eran de la opinin de que
slo una elite educada para ello, y no todo el pueblo, debera influir en tales decisiones.
Esta diferencia de pensamiento ha sido utilizada para implementar distintas polticas en
sistemas computacionales reflectivos [Foote92].
La vertiente Jeffersoniana otorga al programador de un sistema reflectivo la posibi-
lidad de poder modificar cualquier elemento de ste. No restringe el abanico de posibilida-
des en el acceso al metasistema. El hecho de permitir modificar cualquier caracterstica del
sistema, en cualquier momento y por cualquier usuario, puede desembocar en una semnti-
ca del sistema prcticamente incomprensible. Un ejemplo de esto, es un programa escrito

82
Reflectividad Computacional

en C++ con uso intensivo de sobrecarga de operadores (reflectividad del lenguaje): el resul-
tado puede ser un cdigo fuente prcticamente ininteligible.
Muchos autores abogan por el establecimiento de un mecanismo de seguridad que
restrinja el modo en el una aplicacin pueda modificar el sistema [Foote90]. Un ejemplo
clsico es establecer una lista de control de acceso en el que slo los administradores del
sistema puedan cambiar la semntica global. Por el contrario, el resto de usuarios podrn
modificar nicamente la semntica de sus aplicaciones.
Como mencionamos en el captulo 1, esta tesis trata de buscar un entorno compu-
tacional con un elevado grado de flexibilidad. No es nuestro objetivo la implementacin de
un sistema de seguridad encargado de controlar el nivel de reflexin permitido esto for-
mara parte del desarrollo de una plataforma comercial. Por esta razn, nos centraremos en
la vertiente Jeffersoniana, teniendo siempre en cuenta los riesgos que sta puede llegar a
suponer.

6.5 Formalizacin
Las bases de la computacin han sido formalizadas mediante matemticas, basn-
dose principalmente en -calculus [Barendregt81] y extensiones de ste. Un ejemplo es la
formalizacin realizada por Mendhekar en la que define una pequea lgica para lenguajes
funcionales reflectivos [Mendhekar96].
Mendhekar propone un clculo reducido de computacin, denominado
v calculus , y define sobre l una lgica ecuacional. Se aprecia cmo es realmente difcil
formalizar un sistema reflectivo y las limitadas ventajas que proporciona. La investigacin
acerca de reflectividad computacional, tiene una rama relativa a su formalizacin y estudio
matemtico, pero su complejidad hace que vaya por detrs de las implementaciones y
estudios de prototipos computacionales.
En esta tesis, el estudio y diseo de las distintas tcnicas para obtener reflectividad
computacional sern abordadas desde el punto de vista pragmtico y emprico; no formal.

83
CAPTULO 7:
PANORMICA DE UTILIZACIN DE REFLECTIVIDAD

En el captulo anterior clasificbamos la reflectividad en funcin de distintos crite-


rios. Utilizando dicha clasificacin y los conceptos definidos en el mencionado captulo,
estableceremos un estudio de un conjunto de sistemas existentes que utilizan de algn mo-
do reflectividad.
Agruparemos los sistemas en funcin de ciertas caractersticas comunes, especifica-
remos brevemente su funcionamiento, y, en el mbito de grupo, detallaremos los beneficios
aportados y carencias existentes de los sistemas estudiados. A modo de conclusin y apo-
yndonos en los requisitos definidos en el captulo 2, analizaremos las principales carencias
del conjunto total de sistemas existentes.

7.1 Sistemas Dotados de Introspeccin


En el captulo anterior, definamos introspeccin como la capacidad de acceder a la
representacin de un sistema en tiempo de ejecucin. Mediante introspeccin nicamente
se puede conocer el sistema, sin permitir la modificacin de ste y sin producirse, por lo
tanto, su reflejo mediante un sistema de conexin causal. Por esto determinados autores
definen introspeccin como reflectividad estructural de slo lectura [Foote90].
La introspeccin es probablemente el tipo de reflectividad ms utilizado actualmen-
te en los sistemas comerciales. Se ha desarrollado en reas como la especificacin de com-
ponentes, arquitecturas de objetos distribuidos y programacin orientada a objetos.

ANSI/ISO C++ RunTime Type Information (RTTI)


El lenguaje de programacin C++ es un lenguaje compilado que genera cdigo na-
tivo para cualquier tipo de plataforma [Cueva98]. En la fase de ejecucin de dicho cdigo
nativo, existe una carencia del conocimiento de los tipos de los objetos en tiempo de ejecu-
cin. El estndar ANSI/ISO de este lenguaje ampli su especificacin aadiendo cierta
informacin respecto al tipo (RTTI) en tiempo de ejecucin, para poder dar seguridad res-
pecto al tipo al programador de aplicaciones [Kalev98].
El caso tpico en la utilizacin de este mecanismo es el ahormado descendente
(downcast) en una jerarqua de herencia [Eckel2000b]. Un puntero o referencia a una clase
base se utiliza genricamente para englobar cualquier objeto de esa clase o derivado (Figura
7.1). Si tenemos un puntero a dicha clase, qu mensajes le podemos pasar? Slo aqullos

85
CAPTULO 7

definidos en la clase base; por lo tanto, en el caso de un objeto instancia de una clase deri-
vada, se pierde su tipo no se puede invocar a los mtodos propios de la clase derivada.

ClaseBase
mtodo1()
mtodo2()
mtodo3()

DerivadaA DerivadaB
medodoDerivadaA() metodoDerivadaB()

Figura 7.1: Punteros o referencias Base permiten la utilizacin genrica de objetos derivados.

La resolucin de este problema se lleva a cabo aadiendo a los objetos informacin


dinmica relativa a su tipo (introspeccin). Mediante el estndar RTTI podemos preguntar-
le a un objeto cul es su tipo y recuperar ste si lo hubisemos perdido [Stroustrup98]. El
siguiente fragmento de cdigo referente a la jerarqua de clases mostrada en la Figura 7.1,
recupera el tipo del objeto gracias al operador dynamic_cast que forma parte del estn-
dar RTTI.

Base *ptrBase;
DerivadaA *ptrDerivadaA=new DerivadaA;
// * Tratamiento genrico mediante herencia
ptrBase=ptrDerivadaA;
// * SLO se pueden pasar mensajes de la clase Base
ptrBase->metodoBase();
// * Solicitamos informacin del tipo del objeto
ptrDerivadaA=dynamic_cast<DerivadaA*>(ptrBase);
// * Es de tipo DerivadaA?
if (ptrDerivadaA)
// * Recuperamos el tipo; se pueden pasar mensajes de Derivada
ptrDerivadaA->mentodoDerivadaA();

Al acceder al objeto derivado mediante el puntero base, se pierde el tipo de ste no


pudiendo invocar a los mensajes derivados. Gracias a la utilizacin de RTTI, el programa-
dor puede recuperar el tipo de un objeto, e invocar a sus propios mensajes.

Plataforma Java
Java define para su plataforma [Kramer96] una interfaz de desarrollo de aplicacio-
nes (API, Application Programming Interface) que proporciona introspeccin, denominada The
Java Reflection API [Sun97d]. Este API permite acceder en tiempo de ejecucin a la repre-
sentacin de las clases, interfaces y objetos existentes en la mquina virtual. Las posibilida-
des que ofrece al programador son:
Determinar la clase de la que un objeto es instancia.
Obtener informacin sobre los modificadores de una clase [Gosling96], sus m-
todos, campos, constructores y clases base.
Encontrar las declaraciones de mtodos y constantes pertenecientes a un interfa-
ce.

86
Panormica de Utilizacin de Reflectividad

Crear una instancia de una clase totalmente desconocida en tiempo de compila-


cin.
Obtener y asignar el valor de un atributo de un objeto en tiempo de ejecucin,
sin necesidad de conocer ste en tiempo de compilacin.
Invocar un mtodo de un objeto en tiempo de ejecucin, aun siendo ste des-
conocido en tiempo de compilacin.
Crear dinmicamente un array26 y modificar los valores de sus elementos.
La restriccin de utilizar slo este tipo de operaciones pasa por la imposibilidad de
modificar el cdigo de un mtodo en tiempo de ejecucin. La nica tarea que se puede
realizar con respecto a los mtodos es su invocacin dinmica. La insercin, modificacin y
borrado de miembros (mtodos y atributos) no es posible en la plataforma Java.
Sobre este API de introspeccin se define el paquete java.beans, que ofrece un
conjunto de clases e interfaces para desarrollar la especificacin de componentes software de
la plataforma Java: los JavaBeans [Sun96].
Cabe preguntarse por qu es necesaria la introspeccin para el desarrollo de un sis-
tema de componentes. Un componente est constituido por mtodos, propiedades y even-
tos. Sin embargo, una aplicacin que vaya a utilizar un conjunto de componentes no puede
saber a priori la estructura que stos van a tener. Para conocer el conjunto de estas tres
caractersticas, de forma dinmica, se utiliza la introspeccin: permite acceder a los mtodos
de instancia pblicos y conocer su signatura.

- Obtener Mtodos Propiedades


Bean
- Buscar Mtodo Conocimiento Operaciones Aplicacin
Reflection - Comprobar Parmetros Clases para Eventos
API - Invocar al Mtodo Introspeccin

Figura 7.2: Utilizacin de introspeccin en el desarrollo de un sistema de componentes.

El paquete de introspeccin identifica una forma segura de acceder al API de


reflectividad, y facilita el conocimiento y acceso de mtodos, propiedades y eventos de un
componente en tiempo de ejecucin. En la Figura 7.2 se aprecia cmo una aplicacin soli-
cita el valor de una propiedad de un Bean. Mediante el paquete de introspeccin se busca el
mtodo apropiado y se invoca, devolviendo el valor resultante de su ejecucin.
Otro ejemplo de utilizacin de la introspeccin en la plataforma Java es la posibili-
dad de convertir cualquier objeto a una secuencia de bytes27, para posteriormente poder
almacenarlo en disco o transmitirlo a travs de una red de computadores. Un objeto en
Java que herede del interface java.io.Serializable, sin necesidad de implementar
ningn mtodo, podr ser convertido a una secuencia de bytes. Cmo es posible conocer
el estado del objeto en tiempo de ejecucin? Mediante el acceso introspectivo a ste [Ec-
kel2000].

26
En Java los arrays son objetos primitivos.
27
Tambin denominado serializacin (serialization).

87
CAPTULO 7

objeto

agregado

n descripcin id

Representacin en
series de bytes

Serializacin

Acceso
Introspectivo

objeto Agregado:Clase
agregado:Clase id:int
n:int descripcin:String

Figura 7.3: Conversin de un objeto a una secuencia de bytes, mediante un acceso introspectivo.

Mediante el paquete java.reflect se va consultando el valor de todos los atri-


butos del objeto y convirtiendo stos a bytes. Si un atributo de un objeto es a su vez otro
objeto, se repite el proceso de forma recursiva. Del mismo modo es posible crear un objeto
a raz de un conjunto de bytes siguiendo el proceso inverso.

CORBA
CORBA (Common Object Request Broker Architecture) es un ambicioso proyecto del
consorcio OMG (Object Management Group) enfocado a disear un middleware que proporcio-
ne una arquitectura de objetos distribuidos, en la que puedan definirse e interoperar distin-
tos componentes, sin tener en cuenta el lenguaje y la plataforma en la que stos hayan sido
implementados [OMG97].
En el desarrollo de CORBA, se utiliz el concepto de introspeccin para permitir
crear aplicaciones distribuidas portables y flexibles, capaces de reaccionar a futuros cambios
producidos en el sistema y, por lo tanto, no dependientes de una interfaz de acceso monol-
tica. Para ello, CORBA define un modo de realizar invocaciones dinmicas a mtodos de
objetos remotos DII, Dynamic Invocation Interface [OMG95] sin necesidad de conocer stos
en el momento de crear la aplicacin cliente.

Objetos Cliente Implementacin de Objetos Servidor

Skeletons
Invocacin Stubs Interfaz Skeletons Adaptador
Dinmicos
Dinmica del ORB Estticos Objetos
SDI
DDI

Object Request Broker


Almacn de
Almacn de
Interfaces
Implementacin

Figura 7.4: Elementos de la arquitectura de objetos distribuidos CORBA.

88
Panormica de Utilizacin de Reflectividad

Como se muestra en la Figura 7.428, CORBA proporciona metadatos de los objetos


existentes en tiempo de ejecucin, guardando en el almacn de interfaces (Interface Reposito-
ry) las descripciones de las interfaces de todos los objetos CORBA. El mdulo de invoca-
cin dinmica, DII, apoyndose en el almacn de interfaces, permite al cliente conectarse al
ORB, solicitar la descripcin de un objeto, analizarla, y posteriormente invocar al mtodo
adecuado.
El acceso dinmico a mtodos de objetos distribuidos tiene una serie de ventajas.
No es necesaria la existencia de stubs para el cliente, el acceso se desarrolla en su
totalidad en tiempo de ejecucin.
Para compilar la aplicacin cliente que realiza las llamadas a los objetos servido-
res, no es necesario haber implementado previamente el servidor.
En las modificaciones del servidor no es necesario recompilar la especificacin
IDL para el cliente; ste es capaz de amoldarse a los cambios.
La depuracin del cliente es ms sencilla puesto que podremos ver el aspecto
del servidor desde la plataforma cliente, sin necesidad de llevar una traza parale-
la de otro proceso.
Los mensajes de error no producen una parada en la ejecucin sino que pueden
ser controlados desde la aplicacin cliente.
El control de versiones de objetos servidores puede ser llevado a cabo mediante
el descubrimiento de los nuevos objetos, coexistiendo as distintas versiones de
aplicaciones CORBA.
Es la base para crear un sistema de componentes CORBA [OMG98].
Servidor de
Objetos CORBA

Ejecucin
7
Mtodo
5 Seleccin 1 Peticin de Red de
del Mtodo Interfaz de Objeto Computadores 2 Localizacin
del Objeto

ORB
Obtencin
3
de la Interfaz
Cliente de 4 Devolucin
6 Peticin de Devolucin de
Objetos CORBA Invocacin Mtodo 8 de la Interfaz
la invocacin del
mtodo
Almacn de
Interfaces

Figura 7.5: Invocacin dinmica de un mtodo en CORBA utilizando DII.

En la Figura 7.5 se aprecia cmo un cliente, mediante la utilizacin del ORB, solici-
ta al mdulo DII del servidor de objetos CORBA la interfaz de un objeto. ste localiza la
descripcin del objeto en el almacn de interfaces y se lo pasa al cliente. Finalmente, el
cliente selecciona el mtodo deseado envindole al objeto servidor el mensaje oportuno.
Todo este proceso se puede llevar a cabo de forma independiente a la implementacin del

28
Para obtener una descripcin ms detallada del funcionamiento de cada uno de los mdulos de la arqui-
tectura CORBA, consltese [OMG95] o [Orfali98].

89
CAPTULO 7

objeto, puesto que en todo momento se trabaja con las descripciones de sus interfaces en
nico un lenguaje: IDL (Interface Definition Language) [OMG96].
Bajo el mismo escenario de la Figura 7.5, se puede suponer el caso de no encontrar
el objeto, o mtodo de ste, deseado por el cliente. En este caso no se producir un error
en tiempo de ejecucin, sino que el cliente podr tener una respuesta adicional a esta situa-
cin.
El inconveniente del uso introspectivo de CORBA es, como en todos los sistemas
que aumentan su grado de flexibilidad, la prdida de eficiencia en tiempo de ejecucin pro-
ducida por la computacin adicional necesaria para obtener la informacin introspectiva.

COM
COM (Component Object Model) es un modelo binario de interaccin de objetos cons-
truido por Microsoft [Microsoft95], cuyo principal objetivo es la creacin de aplicaciones
mediante la unin de distintas partes componentes creadas en distintos lenguajes de pro-
gramacin [Kirtland99]. El acceso a los componentes se realiza, al igual que en CORBA, a
travs de interfaces (interface).
Al tratarse de cdigo binario, nativo de una plataforma tras su compilacin previa,
no puede obtenerse directamente la descripcin de cada componente. La informacin ne-
cesaria para obtener introspeccin, al igual que en CORBA, se aade al propio objeto para
que pueda ofrecerla en tiempo de ejecucin. La gran diferencia frente a la postura de
CORBA es que en COM la descripcin del componente la posee l mismo y no un alma-
cn de interfaces externo.
En COM un objeto puede implementar un nmero indefinido de interfaces, pero
cmo podemos conocer y obtener stos en tiempo de ejecucin? Cmo se ofrece la in-
trospeccin? Mediante la utilizacin de un interface predefinido, denominado IUnknown.
Todo interface en COM hereda de IUnknown y ste obliga a implementar tres m-
todos: AddRef, Release y QueryInterface [Box99]. Este ltimo mtodo,
QueryInterface, permite conocer a partir de un objeto el conjunto de interfaces que
ste implementa. De esta forma un objeto es capaz de ofrecer informacin acerca de s
mismo: introspeccin.

90
Panormica de Utilizacin de Reflectividad

Interfaces COM

InterfaceA
Se invoca a cualquier
4 mtodo de los Componente
Interfaces A o B COM

MtodoA3
MtodoA2
MtodoA1
2 Se invoca a

IUnknown
QueryInterface
QueryInterface AddRef
Release
Se accede al Objeto

MtodoB1
MtodoB2
MtodoB3
1
Interface IUnknown COM

Se obtiene el
3
Interface A o B
InterfaceB

Figura 7.6: Sistema de introspeccin en el modelo de componentes COM.

El cliente de un componente COM le pide a ste su interface por defecto, obtenien-


do una referencia a un interface IUnknown todos los interfaces heredan de ste. Mediante
la referencia obtenida, le pregunta al objeto si implementa un determinado interface invo-
cando a su mtodo QueryInterface. En el caso afirmativo, el cliente consigue una nue-
va referencia al interface deseado, pudiendo pasarle cualquier mensaje que ste especifique.
Microsoft aument el sistema de componentes COM hacindolo distribuido
DCOM [Brown98], apoyndose para ello en la introspeccin descrita. Posteriormente le
aadi caractersticas propias de sistemas de componentes transaccionales, rebautizndolo
como COM+ [Kirtland99b].

7.1.1 Aportaciones y Carencias de los Sistemas Estudiados


En este punto hemos visto cmo es importante la caracterstica introspectiva en el
desarrollo de una plataforma. Desde el punto de vista del programador, es necesaria para
realizar operaciones seguras respecto al tipo (RTTI de C++) o para almacenar objetos en
disco (Serializacin de la plataforma Java). Desde el punto de vista de un sistema operati-
vo, es necesaria para desarrollar un sistema de componentes (COM). Desde el punto de
vista de entornos distribuidos, es necesaria para desarrollar aplicaciones flexibles (CORBA
y Java).
La utilizacin de la introspeccin queda patente con numerosos ejemplos prcticos
de sistemas actuales reales. En el desarrollo de aplicaciones de comercio electrnico, es
comn utilizar la transferencia de informacin independiente de la plataforma y autodes-
criptiva en formato XML [W3C98]. Mediante la utilizacin de una librera DOM
[W3C98b] o SAX [Megginson2000] es posible conocer los datos en tiempo de ejecucin
(introspeccin), eliminando el acoplamiento que se produce entre el cliente y el servidor en
muchos sistemas distribuidos. De esta forma, las aplicaciones ganan en flexibilidad pudin-
dose adaptar a los futuros cambios.

91
CAPTULO 7

En el desarrollo de una plataforma de computacin flexible, la introspeccin es una


caracterstica fundamental a ser otorgada ( 2.1.5.2) a su motor computacional, obtenindo-
se as un primer grado de flexibilidad gracias al conocimiento dinmico de la totalidad del
sistema ( 2.3.1).

7.2 Sistemas Dotados de Reflectividad Estructural


Fijndonos en la clasificacin realizada en el captulo anterior, en 6.3.1 se define
un sistema dotado de la capacidad de acceder y modificar su estructura como estructural-
mente reflectivo. Estudiaremos casos reales de este tipo de sistemas y analizaremos sus
ventajas e inconvenientes en funcin de los requisitos definidos en el captulo 2.

Smalltalk-80
Es uno de los primeros entornos de programacin que se han basado en reflectivi-
dad estructural. El sistema Smalltalk-80 se puede dividir en dos elementos:
La imagen virtual, que es una coleccin de objetos que proporcionan funciona-
lidades de diversos tipos.
La mquina virtual, que interpreta la imagen virtual y las aplicaciones de usuario.
En un principio se carga la imagen virtual en memoria y la mquina va interpretan-
do el cdigo. Si deseamos conocer la estructura de alguna de las clases existentes, su des-
cripcin, el conjunto de los mtodos que posee o incluso la implementacin de stos, po-
demos utilizar una aplicacin desarrollada en el sistema denominada browser [Mevel87]
(Figura 7.7). El browser es una aplicacin diseada en Smalltalk que accede a todos los obje-
tos clase29 existentes en el sistema, y muestra su estructura y descripcin. De la misma for-
ma, se puede acceder a los mtodos de stas. Este es un caso de utilizacin de la introspec-
cin que ofrece el sistema. Gracias a la introspeccin, se consigue una documentacin di-
nmicamente actualizada de las clases del sistema.

29
En Smalltalk-80 todas las clases se identifican como un objeto en tiempo de ejecucin. Los objetos que
identifican clases son instancias de clases derivadas de la clase Class.

92
Panormica de Utilizacin de Reflectividad

Figura 7.7: Anlisis del mtodo inspect del objeto de clase Object, con la aplicacin Browser de
Smalltalk-80.

De la misma forma que las clases, haciendo uso de sus caractersticas reflectivas, los
objetos existentes en tiempo de ejecucin pueden ser inspeccionados gracias al mensaje
inspect [Goldberg89]. Mediante esta aplicacin tambin podremos modificar los valores de
los distintos atributos de los objetos.
Vemos en la Figura 7.8, cmo es posible hacer uso de la reflectividad estructural
para modificar la estructura de una aplicacin en tiempo de ejecucin. Una utilidad dada al
mensaje inspect es la depuracin de una aplicacin sin necesidad de generar cdigo intruso a
la hora de compilar.

93
CAPTULO 7

Figura 7.8: Invocando al mtodo inspect del objeto Object desde un espacio de trabajo de Smalltalk-
80, obtenemos un acceso a las distintas partes de la instancia.

Lo buscado en el diseo de Smalltalk era obtener un sistema fcilmente manejable


por personas que no fuesen informticos. Para ello se identific el paradigma de la orienta-
cin a objetos y la reflectividad estructural. Una vez diseada una aplicacin consultando la
informacin necesaria de las clases en el browser, se puede depurar sta accediendo y modi-
ficando los estados de los objetos en tiempo de ejecucin. Se accede al error de un mtodo
de una clase y se modifica su cdigo, todo ello haciendo uso de la reflectividad estructural
en tiempo de ejecucin del sistema.
Hemos visto cmo en Smalltalk-80 se utilizaron de forma bsica los conceptos de
reflectividad estructural e introspeccin, para obtener un entorno sencillo de manejar y
autodocumentado.
La semntica del lenguaje Smalltalk viene dada por una serie de primitivas bsicas
de computacin de la mquina virtual, no modificables por el programador; carece por lo
tanto de reflectividad computacional.

Self, Proyecto Merlin


El sistema Self fue construido como una simplificacin del sistema Smalltalk y tam-
bin estaba constituido por una mquina virtual y un entorno de programacin basado en
el lenguaje Self [Ungar87]. La reduccin principal respecto a Smalltalk se centr en la elimi-
nacin del concepto de clase, dejando tan slo la abstraccin del objeto. Este tipo de len-
guajes orientados a objetos han sido denominados basados en prototipos
profundizaremos en el estudio de stos en el captulo 8.
Este sistema, orientado a objetos puro e interpretado, fue utilizado en el estudio de
desarrollo de tcnicas de optimizacin propias de los lenguajes orientados a objetos
[Chambers91]. Fueron aplicados mtodos de compilacin continua y compilacin adapta-
ble [Hlzle94], mtodos que actualmente han sido implantados a plataformas comerciales
como Java [Sun98].

94
Panormica de Utilizacin de Reflectividad

El proyecto Merlin se cre para hacer que los ordenadores fuesen fcilmente utili-
zados por los humanos, ofreciendo sistemas de persistencia y distribucin implcitos [As-
sumpcao93]. El lenguaje seleccionado para desarrollar este sistema fue Self.
Para conseguir flexibilidad en el sistema, trataron de ampliar la mquina virtual con
un conjunto de primitivas de reflectividad (regions, reflectors, meta-spaces) [Cointe92]. La com-
plejidad de sta creci de tal forma que su portabilidad a distintas plataformas se convirti
en algo inviable [Assumpcao95]. Assumpao propone en [Assumpcao95] el siguiente con-
junto de pasos para construir un sistema portable con capacidades reflectivas:
1. Implementar, sobre cualquier lenguaje de programacin, un pequeo intrprete
de un subconjunto del lenguaje a interpretar. En su caso un intrprete de tiny-
Self. El requisito fundamental es que ste tenga reflectividad estructural.
2. Sobre lenguaje (tinySelf), se desarrolla un intrprete del lenguaje buscado (Self),
con todas sus caractersticas.
3. Implementamos una interfaz de modificacin de las operaciones deseadas. La
codificacin de un intrprete en su propio lenguaje ofrece total flexibilidad: to-
do su comportamiento se puede modificar incluso las primitivas computacio-
nales puesto que tinySelf posee reflectividad estructural dinmica. Slo debe-
mos implementar un protocolo de acceso a la modificacin de las operaciones
deseadas.

Aplicacin
Self

Self
Mediante Reflectividad
Estructural una aplicacin
accede y modifica el Interpreta
modo en el que es
interpretada
Segundo
Nivel
Computacional
Intrprete
Self

Lenguajes de
Programacin TinySelf

Interpreta

Primer
Nivel
Intrprete Computacional
TinySelf

Lenguaje C

Figura 7.9: Consiguiendo reflectividad mediante la introduccin de un nuevo intrprete.

El resultado es un intrprete de Self que permite modificar determinados elementos


de su computacin, siempre que stos hayan sido tenidos en cuenta en el desarrollo del
intrprete.
El principal problema es la eficiencia del sistema. El desarrollar dos niveles compu-
tacionales (intrprete de intrprete) ralentiza la ejecucin de la aplicacin codificada en Self.
Lo que se propone para salvar este obstculo [Assumpcao95] es implementar un traductor
de cdigo tinySelf a otro lenguaje que pueda ser compilado a cdigo nativo. Una vez des-

95
CAPTULO 7

arrollado ste, traducir el cdigo propio del intrprete de Self codificado en el lenguaje
tinySelf a cdigo nativo, reduciendo as un nivel computacional.

Aplicacin Aplicacin
Self Self

Self Self

Interpreta Interpreta

nico
Intrprete Nivel
Segundo Intrprete Compilador Computacional
Nativo
Nivel Self TinySelf
Self
Computacional
TinySelf

Interpreta

Primer Intrprete
Nivel TinySelf
Computacional
Lenguaje C

Figura 7.10: Reduccin de un nivel de computacin en la torre de intrpretes.

El resultado se muestra en la Figura 7.10: un nico intrprete de Self en lugar de los


dos anteriores. Sin embargo, el producto final tendra dos inconvenientes:
1. Una vez que traduzcamos el intrprete, ste no podr ofrecer la modificacin
de una caracterstica que no haya sido prevista con anterioridad. Si queremos
aadir alguna, deberemos volver al sistema de los dos intrpretes, codificarla,
probarla y, cuando no exista ningn error, volver a generar el intrprete nativo.
2. La implementacin de un traductor de tinySelf a un lenguaje compilado es una
tarea difcil, puesto que el cdigo generado deber estar dotado de la informa-
cin necesaria para ofrecer reflectividad estructural en tiempo de ejecucin.
Existen sistemas que implementan estas tcnicas como por ejemplo Iguana
[Gowing96].
Al mismo tiempo, la ejecucin de un cdigo que ofrece informacin modifica-
ble dinmicamente sus objetos ocupa ms espacio, y aade una ralentizacin
en sus tiempos de ejecucin.

ObjVlisp
ObjVlisp es un sistema creado como una evolucin de Smalltalk-76 [Ingalls78],
desarrollado como un sistema extensible capaz de modificar y ampliar determinadas fun-
cionalidades de los lenguajes orientados a objetos [Cointe88].
El modelo computacional del sistema es definido por la implementacin de una
mquina virtual en el lenguaje Lisp [Steele90]; sta est dotada de un conjunto de primitivas
que trabajan con la abstraccin principal del objeto. El modelo computacional del ncleo
del sistema se define con seis postulados [Cointe88]:
1. Un objeto est compuesto de un conjunto de miembros que pueden representar
informacin de ste (atributos) y su comportamiento (mtodos). La diferencia
entre ambos es que los mtodos son susceptibles de ser evaluados. Los miem-

96
Panormica de Utilizacin de Reflectividad

bros de un objeto pueden conocerse y modificarse dinmicamente (reflectividad


estructural).
2. La nica forma de llevar a cabo una computacin sobre un objeto es envindole
un mensaje indicativo del mtodo que queramos ejecutar.
3. Todo objeto ha de pertenecer a una clase que especifique su estructura y com-
portamiento. Los objetos se crearn dinmicamente como instancias de una cla-
se.
4. Una clase es tambin un objeto instancia de otra clase denominada metaclase.
Por lo tanto, aplicando el punto 3, una metaclase define la estructura y el com-
portamiento de sus clases instanciadas. La metaclase inicial primitiva se deno-
mina CLASS, y es construida como instancia de s misma.
5. Una clase puede definirse como subclase de otra(s) clase(s). Este mecanismo de
herencia permite compartir los miembros de las clases base por sus clases deri-
vadas. El objeto raz en la jerarqua de herencia se denomina OBJECT.
6. Los miembros definidos por una clase describen un mbito global para todos
los objetos instanciados a partir de dicha clase; todos sus objetos pueden acce-
der a dichos miembros.
A partir de los seis puntos anteriores, se deduce que son establecidos, en tiempo de
ejecucin, dos grafos de objetos en funcin de dos tipos de asociaciones existentes entre
ellos: la asociacin hereda de en la que el objeto raz es OBJECT y la asociacin ins-
tancia de con objeto raz CLASS. Un ejemplo de ambos grafos se muestra en la siguiente
figura:

CLASS MetaClaseB

Objeto
Clase
Metaclase
ClaseA ClaseB
Instancia de
Hereda de
OBJECT ObjetoB1

ObjetoB2
ObjetoA2
ObjetoA1

Figura 7.11: Doble grafo de objetos en el sistema ObjVlisp.

La plataforma permite extender el sistema computacional gracias a la creacin di-


nmica de objetos y a la extensin de los existentes. Los nuevos objetos ofrecen un mayor
nivel de abstraccin al usuario del sistema. Esto es una consecuencia directa de aplicar la
reflectividad estructural en tiempo de ejecucin.
El sistema soporta un mecanismo de adaptabilidad basado en el concepto de meta-
clase. Si queremos modificar el comportamiento de los objetos instancia de una clase, po-
demos crear una nueva metaclase y establecer una asociacin entre la clase y sta, mediante
la relacin es instancia de. El resultado es la modificacin de parte de la semntica de los
objetos de dicha clase. En la Figura 7.11, la semntica de los objetos instancia de la clase B
es definida por su metaclase B.

97
CAPTULO 7

Las distintas modificaciones que puede hacer una metaclase en el funcionamiento


de los objetos de una clase son:
Modificacin del funcionamiento del mecanismo de herencia.
Alteracin de la forma en la que se crean los objetos, implementando un nuevo
comportamiento de la primitiva make-object.
Cambio de la accin llevada a cabo en la recepcin de un mensaje.
Utilizacin de otro tipo de contenedor para coleccionar los miembros de un ob-
jeto.
Modificacin del acceso a los miembros, estableciendo un mecanismo de ocul-
tacin de la informacin.

Linguistic Reflection in Java


Para Graham Kirby y Ron Morrison Linguistic Reflection es la capacidad de un pro-
grama para, en tiempo de ejecucin, generar nuevos fragmentos de cdigo e integrarlos en
su entorno de ejecucin30 [Kirby98]. Implementaron un entorno de trabajo en el que aad-
an al lenguaje de programacin Java esta caracterstica.
La capacidad de un sistema reflectivo para adaptarse a un contexto en tiempo de
ejecucin es opuesta al concepto de tipo, que limita, en tiempo de compilacin, el conjunto
de operaciones aplicables a un objeto [Cardelli97]. El objetivo del prototipo implementado
es ofrecer la generacin dinmica de cdigo sin perder el sistema de tipos del lenguaje Java
[Gosling96].
Como se muestra en la Figura 7.12, los pasos llevados a cabo en la evaluacin di-
nmica de cdigo son:
1. La aplicacin inicial es ejecutada por una implementacin de la mquina virtual
de Java.
2. La aplicacin genera cdigo dinmicamente en funcin de los requisitos pro-
pios de su contexto de ejecucin.
3. Este nuevo fragmento de cdigo es compilado a cdigo binario de la mquina
virtual, mediante un compilador de Java codificado en Java. Este proceso se
realiza con la comprobacin esttica de tipos propia del lenguaje.
4. La implementacin de una clase derivada de la clase ClassLoader [Gos-
ling96] permite cargar dinmicamente el cdigo generado, para pasar a formar
parte del entorno computacional de la aplicacin inicial.

30
El concepto definido como linguistic reflection no es el mismo que definamos en 6.3.1 como re-
flectividad lingstica.

98
Panormica de Utilizacin de Reflectividad

Aplicacin en
Ejecucin Creacin dinmica
de cdigo Java
2 Compilador
class MiClase { Java
Aplicacin ... Aplicacin
Java } 3 Java
Compilacin
Ejecucin de a cdigo binario
1 la aplicacin
Java 4 Carga dinmica de la
ClassLoader nueva aplicacin creada

Java Virtual
Machine

Figura 7.12: Evaluacin dinmica de cdigo creado en tiempo de ejecucin.

La aportacin principal del sistema es soportar la codificacin de aplicaciones gen-


ricas en tiempo de ejecucin y seguras respecto al tipo. ste es un concepto similar a las
plantillas (templates) del lenguaje C++ [Stroustrup98], pero resueltas dinmicamente en lugar
de determinar su tipo en tiempo de compilacin. Como caso prctico, se han implementa-
do productos cartesianos de tablas de una base de datos relacional, as como contenedores
de objetos seguros respecto al tipo, ambos genricos dinmicamente.
En lo referente a reflectividad, el sistema no aporta nada frente a la introspeccin
ofrecida por la plataforma Java [Sun97d]. Sin embargo, la posibilidad de crear cdigo din-
micamente ofrece facilidades propias de plataformas dotadas de reflectividad estructural
como Smalltalk. La implementacin mediante un intrprete puro [Cueva98] hubiese mucho
ms sencilla, pero menos eficiente en tiempo de ejecucin.

Python
Python es un lenguaje de programacin orientado a objetos, portable e interpretado
[Rossum2001]. Su desarrollo comenz en 1990 en el CWI de Amsterdam. El lenguaje po-
see mdulos, paquetes, clases, excepciones y un sistema de comprobacin de tipos dinmi-
co. La implementacin del intrprete de Python ha sido portada a diferentes plataformas
como UNIX, Windows, DOS, OS/2, Mac y Amiga.
El entorno de programacin de Python ofrece en tiempo de ejecucin determina-
das funcionalidades de reflectividad estructural [Andersen98]:
Modificacin dinmica de la clase de un objeto. Todo objeto posee un atributo
denominado __class__ que hace referencia a su clase (las clases tambin son
objetos). La modificacin de esta referencia implica la modificacin del tipo del
objeto.
Acceso al rbol de herencia. Toda clase posee un atributo __bases__ que refe-
rencia una coleccin de sus clases base modificables dinmicamente.
Acceso a los atributos y mtodos de un objeto. Tanto los objetos como las cla-
ses poseen un diccionario de sus miembros (__dict__) que puede ser consul-
tado y modificado dinmicamente.
Control de acceso a los atributos. El acceso a los atributos de una clase puede
ser modificado con la definicin de los mtodos de clases __getattr__ y
__setattr__.
Adems, el intrprete del lenguaje ofrece numerosa informacin del sistema en
tiempo de ejecucin: introspeccin. Sobre la reflectividad estructural del lenguaje se han
construido mdulos que aumentan las caractersticas reflectivas del entorno de programa-

99
CAPTULO 7

cin [Andersen98], ofreciendo un mayor nivel de abstraccin basndose en el concepto de


metaobjeto [Kiczales91].

7.2.1 Aportaciones y Carencias de los Sistemas Estudiados


Los sistemas dotados de reflectividad estructural ofrecen una mayor flexibilidad que
los que nicamente ofrecen introspeccin. En Java, una aplicacin puede modificar su flujo
en funcin de su estado conocindolo mediante introspeccin; en Smalltalk, adems
puede modificar su estructura dinmicamente gracias a la reflectividad estructural. Si ana-
lizamos la dicotoma anterior desde el punto de vista de la seguridad, para una plataforma
comercial sera peligroso ofrecer reflectividad estructural, puesto que cualquier aplicacin
podra acceder y modificar la estructura del sistema. Esta discusin se detalla en 6.4.
Los sistemas estudiados ofrecen conocimiento automtico de su estructura ( 2.3.1)
y su modificacin ( 2.3.2). Si se codifican todas las primitivas computacionales sobre el
mismo lenguaje, al ofrecer ste reflectividad estructural, se podrn adaptar a cualquier con-
texto dinmicamente. Solo tendremos que acceder a stas y modificar su implementacin.
Mediante este mecanismo implementado en el proyecto Merlin y en ObjVLisp, obtenemos
la adaptabilidad del entorno de programacin ( 2.2).
Una de las caractersticas analizadas tanto en el lenguaje Python como en el desa-
rrollo del sistema ObjVlisp, es la modificacin de la semntica del lenguaje para un objeto o
una clase. En estos ejemplos, mediante el uso de la reflectividad estructural, es posible mo-
dificar el mecanismo de interpretacin de la recepcin de un mensaje para una clase; modi-
ficando estructuralmente una metaclase en ObjVlisp se puede conseguir este objetivo. Sin
embargo, no estamos obteniendo la modificacin del comportamiento para el sistema glo-
bal caracterstica propia de la reflectividad computacional. Estos sistemas carecen por
tanto de la modificacin dinmica de su semntica ( 2.3.3).
Finalmente comentaremos cmo el proyecto Merlin propuso implementar un in-
trprete de Self codificado en tinySelf para ofrecer reflectividad computacional. Aunque
sta no es una tarea sencilla, s que supone un mecanismo de implementacin para obtener
un sistema computacionalmente reflectivo ( 2.3.3). Utilizaremos esta idea para llevar a
cabo el diseo de nuestro entorno computacionalmente reflectivo sin restricciones
(captulo 11).

7.3 Reflectividad en Tiempo de Compilacin


Basndonos en la clasificacin realizada en el captulo anterior, la reflectividad en
tiempo de compilacin se produce en fase de traduccin independientemente de lo que el
sistema permita reflejar. En este tipo de sistemas una aplicacin puede adaptarse a un con-
texto dinmicamente, siempre y cuando los cambios hayan sido tenidos en cuenta en su
cdigo fuente puesto que toda su informacin se genera tiempo de compilacin. Si en
tiempo de ejecucin aparecieren exigencias no previstas en fase de desarrollo del sistema,
stas no podran solventarse dinmicamente; debera recodificarse y recompilarse el siste-
ma.

OpenC++
OpenC++ [Chiba95] es un lenguaje de programacin que ofrece caractersticas re-
flectivas a los programadores de C++. Su caracterstica principal es la eficiencia dinmica
de las aplicaciones creadas: no existe una sobrecarga computacional en tiempo de ejecu-

100
Panormica de Utilizacin de Reflectividad

cin. Est enfocado a amoldar el lenguaje de programacin y su semntica al problema para


poder desarrollar las aplicaciones a su nivel de abstraccin adecuado.
El modo en el que son generadas las aplicaciones se centra en un preproceso de c-
digo fuente. Una aplicacin se codifica en OpenC++ pudiendo hacer uso de sus caracters-
ticas reflectivas. sta es traducida a cdigo C++ que, tras compilarse mediante cualquier
compilador estndar, genera la aplicacin final adaptable en el grado estipulado cuando
fue codificada.
La arquitectura presenta el concepto de metaobjeto popularizado por Gregor Kic-
zales [Kiczales91] para modificar la semntica determinados elementos del lenguaje. En
concreto, para las clases y funciones miembro, se puede modificar el modo en el que stas
son traducidas al cdigo C++ final.
Metaobjetos
por omisin Modificacin
del lenguaje
Metaobjetos Aplicacin C++ Fuente

Fichero
Compilador Traduccin C++ Compilador
OpenC++ metaobjetos C++
Cdigo Fichero Fichero Aplicacin
Fuente C++ C++ 3
1 2 Final
OpenC++
Fichero Fichero Fichero Fichero
C++ C++ C++ C++

Modificacin de
metaobjetos Traduccin sin
modificacin

Figura 7.13: Fases de compilacin de cdigo fuente OpenC++.

Tomando cdigo OpenC++ como entrada, el traductor de este lenguaje genera


C++ estndar como salida. Este proceso consta de 2 fases mostradas en la Figura 7.13. En
la primera fase, se crea el rbol sintctico relativo a las clases y funciones miembros de la
aplicacin, para crearse un metaobjeto por cada uno de dichos elementos sintcticos.
Por omisin, los metaobjetos son instancias de una clase Class (si el elemento sin-
tctico es una clase), o bien de una clase Function (cuando se trate de un mtodo). Estas
clases traducen el cdigo sin aadir ninguna modificacin. En el caso de que una clase o un
mtodo hayan sido definidos mediante un metaobjeto en OpenC++, stos sern instancias
de clases derivadas de las dos mencionadas anteriormente; dichas clases definirn la forma
en la que se traducir el cdigo fuente asociado a los metaobjetos. sta es la segunda fase
de traduccin que concluye con la generacin de la aplicacin final por un compilador de
C++.
El sistema ofrece un mecanismo de preproceso para poder amoldar el lenguaje de
programacin C++ [Stroustrup98] a las necesidades del programador. Adems de poder
modificar parte de la semntica de mtodos y clases (reflectividad computacional),
OpenC++ ofrece la posibilidad de aadir palabras reservadas al lenguaje, para implementar
modificadores de tipos, clases y el operador new (reflectividad lingstica). Est enfocado a
la creacin de libreras para poder crear un sistema de separacin de aspectos en programa-
cin ( 5.3).

OpenJava
Una vez analizadas y estudiadas las tcnicas y ventajas en la utilizacin de reflectivi-
dad en tiempo de compilacin, Shigeru Chiba aument las caractersticas reflectivas del
lenguaje de programacin Java, denominndose ste OpenJava [Chiba98].

101
CAPTULO 7

El lenguaje Java ofrece introspeccin por medio de la clase java.lang.Class


[Sun97d], entre otras. Mediante la creacin de una nueva clase, OJClass, y el preproceso
de cdigo OpenJava realizado por el OpenJava compiler, disearon un lenguaje capaz de ofre-
cer reflectividad en tiempo de compilacin de las siguientes caractersticas:
Modificacin del comportamiento de determinadas operaciones sobre los obje-
tos, como invocacin a mtodos o acceso a sus atributos (reflectividad compu-
tacional restringida).
Reflectividad estructural. A la introspeccin ofrecida por la plataforma de Java
( 7.1), se aaden a los objetos y clases funcionalidades propias de reflectividad
estructural ( 7.2).
Modificacin de la sintaxis del lenguaje. Pueden crearse nuevas instrucciones,
operadores y palabras reservadas (reflectividad lingstica).
Modificacin de los aspectos semnticos del lenguaje. Es posible modificar la
promocin o coercin de tipos [Cueva95b].
OpenJava mejora las posibilidades ofrecidas por su hermano OpenC++, sin nece-
sidad de modificar la implementacin de la mquina abstracta como sucede, por ejemplo,
en el caso de MetaXa [Kleinder96]. Esto supone dos ventajas:
1. Al no modificarse la mquina virtual, no se generan distintas versiones de sta
con la consecuente prdida de portabilidad de su cdigo fuente [Ortin2001].
2. Al no ofrecer adaptabilidad dinmica, no supone una prdida de eficiencia en
tiempo de ejecucin.
El lenguaje de programacin OpenJava se ha utilizado para describir la solucin de
problemas mediante patrones de diseo [GOF94] en el nivel de abstraccin adecuado [Tat-
subori98]; el lenguaje se modific para amoldar su sintaxis a los patrones adapter y visitor
[GOF94].

Java Dynamic Proxy Classes


En la edicin estndar de la plataforma Java2 (Java Standard Edition) versin 1.2.3 se
ha aumentado el paquete java.lang.reflect, para ofrecer un mecanismo de modifi-
cacin del paso de mensajes de una determinada clase; este tipo de clase se denomina proxy
(apoderadas) [Sun99].
Una clase proxy especifica la implementacin de un conjunto ordenado de interfa-
ces. La clase es creada dinmicamente especificando su manejador de invocaciones
(InvocationHandler). Cada vez que se invoque a un mtodo de las interfaces imple-
mentadas, la clase apoderada ejecutar el mtodo invoke de su manejador; ste podr
modificar su semntica en funcin del contexto dinmico existente. El diagrama de clases
que ofrece este marco de trabajo se muestra a continuacin:

102
Panormica de Utilizacin de Reflectividad

java.lang.reflect.InvocationHandler java.lang.reflec.Proxy

invoke() 1 newProxyInstance()

<<Interface>> <<Interface>> <<Interface>>


InterfaceA InterfaceB InterfaceC

InterfacesImplementation

Figura 7.14: Diagrama de clases de la implementacin de un manejador de invocaciones.

La clase es creada dinmicamente especificando las interfaces a implementar, un


cargador de clases (ClassLoader [Gosling96]) y una implementacin del manejador de
invocaciones (InvocationHandler); esta funcionalidad la ofrece el mtodo de clase
newProxyInstance de la clase Proxy.
La adaptabilidad del sistema se centra en la implementacin del mtodo invoke
del manejador. Este mtodo recibe el objeto real al que se ha pasado el mensaje, el identifi-
cador del mtodo y sus parmetros. Haciendo uso del sistema introspectivo de la platafor-
ma Java [Sun97d], podremos conocer e invocar el mtodo que deseemos en funcin de los
requisitos existentes en tiempo de ejecucin.
Con este mecanismo, la plataforma de Java ofrece un grado de flexibilidad superior
a la introspeccin existente en versiones anteriores; permite modificar la semntica del paso
de mensajes. Sin embargo, las distintas interpretaciones de dicha semntica han de ser es-
pecificadas en tiempo de compilacin, para ser seleccionadas posteriormente de forma di-
nmica.
El resultado es un conjunto de clases que, haciendo uso de la introspeccin de la
plataforma, permite simular la modificacin de una parte del comportamiento del sistema.
No obstante, como indicbamos en 7.2.1, no estamos en un grado computacional de
reflectividad, al no permitir la modificacin de dicho comportamiento para todo el sistema
se modifica tan solo para los objetos instancia de una clase.

7.3.1 Aportaciones y Carencias de los Sistemas Estudiados


La principal carencia de los sistemas reflectivos en tiempo de compilacin es la in-
capacidad de poder amoldarse a situaciones no previstas en fase de desarrollo. Toda la
adaptabilidad de un sistema, deber definirse cuando ste es construido y, una vez que est
ejecutndose, no podr adecuarse de otra manera ( 2.3.3). Por otro lado, al determinarse el
grado de flexibilidad en tiempo de compilacin, estos sistemas son ms eficientes que los
adaptables dinmicamente.
Teniendo en cuenta el nivel de reflexin ofrecido, los sistemas estudiados presentan
una mayor informacin a reflejar que los que estudiaremos en el siguiente punto. La reflec-

103
CAPTULO 7

tividad del lenguaje o modificacin de ste se ofrece comnmente en sistemas reflectivos


estticos, cuando en los dinmicos supone una carencia ( 2.3.5).
La compilacin previa del cdigo fuente, permite utilizar lenguajes seguros respecto
al tipo [Cardelli97], eliminando una elevado nmero de errores en tiempo de ejecucin
propio de sistemas de naturaleza interpretada; por ejemplo Python [Rossum2001].
Como veremos en el estudio de los sistemas reflectivos dinmicos basados en Meta-
Object Protocols (MOPs) ( 7.4.1), existe una restriccin previa de lo que puede ser modifica-
do. En el estudio de los sistemas reflectivos en tiempo de compilacin, vemos cmo tam-
bin sucede lo mismo: el lenguaje define qu partes de l mismo pueden ser adaptadas (
2.3.4). La diferencia es que en los sistemas analizados, dicha restriccin se produce en fase
de compilacin, frente a la restriccin dinmica producida en el uso de MOPs.

7.4 Reflectividad Computacional basada en Meta-Object


Protocols
Los sistemas reflectivos que permiten modificar parte de su semntica en tiempo de
ejecucin son comnmente implementados utilizando el concepto de protocolo de
metaobjeto (Meta-Object Protocol, MOP). Estos MOPs definen un modo de acceso
(protocolo) del sistema base al metasistema, permitiendo modificar parte de su propio
comportamiento dinmicamente.
En este punto analizaremos brevemente un conjunto de sistemas que utilizan
MOPs para modificar su semntica dinmicamente, para posteriormente hacer una sntesis
global de sus aportaciones y carencias.

Closette
Closette [Kiczales91] es un subconjunto del lenguaje de programacin CLOS [Stee-
le90]. Fue creado para implementar un MOP del lenguaje CLOS, permitiendo modificar
dinmicamente aspectos semnticos y estructurales de este lenguaje. La implementacin se
bas en desarrollar un intrprete de este subconjunto de CLOS sobre el propio lenguaje
CLOS, capaz de ofrecer un protocolo de acceso a su metasistema.
Existen dos niveles computacionales: el nivel del intrprete de CLOS (metasistema),
y el del intrprete de Closette (sistema base) desarrollado sobre el primero. El acceso del
sistema base al metasistema se realiza mediante un sistema de macros; el cdigo Closette se
expande a cdigo CLOS que, al ser evaluado, puede acceder a su metasistema. La defini-
cin de la interfaz de estas macros constituye el MOP del sistema.
El diseo de este MOP para el lenguaje CLOS se centra en el concepto de metaob-
jeto. Un metaobjeto es cualquier abstraccin, estructural o computacional, del metasistema
susceptible de ser modificada por su sistema base. Un metaobjeto no es necesariamente
una representacin de un objeto en su sistema base; puede representar una clase o la se-
mntica de la invocacin a un mtodo. El modo en el que se puede llevar a cabo la modifi-
cacin de los metaobjetos es definido por el MOP.
La implementacin del sistema fue llevada a cabo en tres capas, mostradas en la
Figura 7.1:
1. La capa de macros; define la forma en la que se va a interpretar el subconjunto
de CLOS definido, establecindolo mediante traducciones a cdigo CLOS. En
el caso de que no existiese un MOP, esta traduccin sera la identidad; el cdigo
Closette se traducira a cdigo CLOS sin ningn cambio.

104
Panormica de Utilizacin de Reflectividad

2. La capa de pegamento (glue). Son un conjunto de funciones desarrolladas en


CLOS que facilitan el acceso a los objetos del metasistema, para as facilitar la
implementacin de la traduccin de las macros. Como ejemplo, podemos citar
la funcin find-class que obtiene el metaobjeto representativo de una clase,
cuyo identificador es pasado como parmetro.
3. La capa de nivel inferior. Es la representacin en CLOS (metasistema) de la es-
tructura y comportamiento del sistema base. Todas aquellas partes del sistema
que deseen ser reflectivas, debern ser implementadas como metaobjetos.
Sistema Base
MOP
(closette) Cdigo
Closette

Capa Macros:
Ejecuta Traduccin
Closette/CLOS In
vo
ca
ci
Metasistema n
(CLOS)

Intrprete
Acceso Capa
Closette
pegamento

Ejecuta Metaobjetos

Capa de nivel inferior


Intrprete
CLOS

Figura 7.15: Arquitectura del MOP desarrollado para el lenguaje CLOS.

MetaXa31
MetaXa es un sistema basado en el lenguaje y plataforma Java que aade a ste ca-
ractersticas reflectivas en tiempo de ejecucin, permitiendo modificar parte de la semntica
de la implementacin de la mquina virtual [Golm97]. El diseo de la plataforma est
orientado a dar soporte a la demanda de creacin de aplicaciones flexibles, que puedan
adaptarse a requerimientos dinmicos como distribucin, seguridad, persistencia, tolerancia
a fallos o sincronizacin de tareas [Kleinder96].
El modo en el que se deben desarrollar aplicaciones en MetaXa se centra en el con-
cepto de metaprogramacin (meta-programming) [Maes87]: separacin del cdigo funcional
del cdigo no funcional. La parte funcional de una aplicacin se centra en el modelado del
dominio de la aplicacin (nivel base), mientras que el cdigo no funcional formaliza la su-
pervisin o modelado de determinados aspectos propios cdigo funcional (metasistema).
MetaXa permite separar estos dos niveles de cdigo fuente y establecer entre ellos un me-
canismo de conexin causal en tiempo de ejecucin.
El sistema de computacin de MetaXa se apoya sobre la implementacin de objetos
funcionales y metaobjetos conectados a los primeros a un metaobjeto se le puede conec-
tar objetos, referencias y clases; de forma genrica utilizaremos el trmino objeto. Cuando
un metaobjeto est conectado a un objeto sobre el que sucede una accin, el sistema pro-
voca un evento en el metaobjeto indicndole la operacin solicitada en el sistema base. La
implementacin del metasistema permite modificar la semntica de la accin provocadora

31
Anteriormente conocido como MetaJava.

105
CAPTULO 7

del evento. La computacin del sistema base es suspendida de forma sncrona, hasta que el
metasistema finalice la interpretacin del evento capturado.

Programacin Mquina Virtual


de MetaObjetos MetaXa

Compilacin Interpretacin

Conexin
entre ambos
Sistema en Ejecucin
Lenguaje Binario
Mquina Virtual
MetaXa
Metasistema
Programacin
de Objetos Base Sistema
base
Lenguaje Java

Figura 7.16: Fases en la creacin de una aplicacin en MetaXa.

Si un metaobjeto recibe el evento method-enter, la accin por omisin ser ejecutar el


mtodo apropiado. Sin embargo, el metaobjeto puede sobreescribir el mtodo
eventMethodEnter para modificar el modo en el que se interpreta la recepcin de un
mensaje.
En MetaXa, para hacer el sistema lo ms eficiente posible, inicialmente ningn ob-
jeto est conectado a un metaobjeto. En tiempo de ejecucin se producen las conexiones
apropiadas para modificar los comportamientos solicitados por el programador.
La implementacin de la plataforma reflectiva de MetaXa toma la mquina virtual
de Java [Sun95] y aade sus nuevas caractersticas reflectivas mediante la implementacin
de mtodos nativos residentes en una librera de enlace dinmico [Sun97c].
Uno de los principales inconvenientes del diseo abordado es el de la modificacin
del comportamiento individual de un objeto. Al residir el comportamiento de todo objeto
en su clase, qu sucede si deseamos modificar la semntica de una sola instancia de dicha
clase? MetaXa crea una nueva clase para el objeto denominada clase sombra (Shadow Class)
con las siguientes caractersticas [Golm97c]:
Una clase y su clase sombra asociada son iguales para el nivel base.
La clase sombra difiere de la original en las modificaciones realizadas en el me-
tasistema.
Los mtodos y atributos de clase (static) son compartidos por ambas clases.

106
Panormica de Utilizacin de Reflectividad

Objeto A Modificacin Objeto A


del comportamiento
del objeto A
Clase
Clase Sombra C
Tipo
Clase Tipo Sistema
Clase
Clase C Base
Tipo
Tipo
Clase C
Clase
Objeto B Objeto B

Figura 7.17: Creacin dinmica de una clase sombra en MetaXa para modificar el comportamiento
de una instancia de una clase.

Hay que solventar un conjunto de problemas para mantener coherente el sistema


en la utilizacin de las clases sombra [Golm97c]:
1. Consistencia de atributos. La modificacin de los atributos de una clase ha de
mantenerse coherente con su representacin sombra.
2. Identidad de clase. Hay que tener en cuenta que el tipo de una clase y el de su
clase sombra han de ser el mismo, aunque tengan distinta identidad.
3. Objetos de la clase. Cuando el sistema utilice el objeto representante de una cla-
se (en Java una clase genera un objeto en tiempo de ejecucin) han de tratarse
paralelamente el de la clase original y el de su sombra. Un ejemplo puede ser las
operaciones monitorenter y monitorexit de la mquina virtual [Ven-
ners98], que tratan los objetos clase como monitores de sincronizacin; ha de
ser el mismo monitor el de la clase sombra que el de la real.
4. Recolector de basura. Las clases sombra deber limpiarse cuando el objeto no
tenga asociado un metaobjeto.
5. Consistencia de cdigo. Tendr que ser mantenida cuando se produzca la crea-
cin de una clase sombra a la hora de estar ejecutndose un mtodo de la clase
original.
6. Consumo de memoria. La duplicidad de una clase produce elevados consumos
de memoria; debern idearse tcnicas para reducir estos consumos.
7. Herencia. La creacin de una clase sombra, cuando la clase inicial es derivada de
otra, obliga a la produccin de otra clase sombra de la clase base original. Este
proceso ha de expandirse de forma recursiva.
La complejidad surgida por el concepto de clase en un sistema reflectivo hace afir-
mar a los propios autores del sistema, cmo los lenguajes basados en prototipos como Self
[Ungar87] o Moostrap solucionan estos problemas de una forma ms coherente
[Golm97c].

Iguana
La mayora de los sistemas reflectivos, adaptables en tiempo de ejecucin y basados
en MOPs, son desarrollados mediante la interpretacin de cdigo; la ejecucin de cdigo
nativo no suele ser comn en este tipo de entornos. La principal razn es que los intrpre-
tes tienen que construir toda la informacin propia de la estructura y la semntica de la
aplicacin a la hora de ejecutar sta. Si un entorno reflectivo trata de modificar la estructura
o comportamiento de un sistema, ser ms sencillo ofrecer esta informacin si la ejecucin
de la aplicacin es interpretada.

107
CAPTULO 7

En el caso de los compiladores, la informacin relativa al sistema es creada en


tiempo de compilacin y generalmente almacenada en la tabla de smbolos [Cueva92b]
para llevar a cabo todo tipo de comprobacin de tipos [Cueva95b] y generacin de cdigo
[Aho90]; una vez compilada la aplicacin, dicha informacin deja de existir. En el caso de
un depurador (debugger), parte de la informacin es mantenida en tiempo de ejecucin para
poder conocer el estado de computacin (introspeccin) y permitir modificar su estructura
(reflectividad estructural dinmica). El precio a pagar en este caso es un aumento de tama-
o de la aplicacin, y una ralentizacin de su ejecucin.
El sistema Iguana ofrece reflectividad computacional en tiempo de ejecucin basa-
da en un MOP, compilando cdigo C++ a la plataforma nativa destino [Gowing96]. En la
generacin de cdigo, de forma contraria a un depurador, Iguana no genera informacin de
toda la estructura y comportamiento del sistema. Por omisin, compila el cdigo origen
C++ a la plataforma destino sin ningn tipo de informacin dinmica. El programador ha
de especificar qu parte del sistema desea que sea adaptable en tiempo de ejecucin, de
modo que el sistema generar el cdigo oportuno para que sea reflectivo.
Iguana define dos conceptos para especificar el grado de adaptabilidad de una apli-
cacin:
1. Categoras de cosificacin (Reification Categories). Indican al compilador dnde
debe producirse la cosificacin del sistema. Son elementos susceptibles de ser
adaptados en Iguana; ejemplos son clases, mtodos, objetos, creacin y destruc-
cin de objetos, invocacin a mtodos o recepcin de mensajes, entre otros.
2. Definicin mltiple de MOPs (Multiple fine-grained MOPs). El programador ha de
definir la forma en la que el sistema base va a acceder a su informacin dinmi-
ca, es decir se ha de especificar el MOP de acceso al metasistema.
La implementacin de Iguana est basada en el desarrollo de un preprocesador que
lee el cdigo fuente Iguana una extensin del C++ y traduce toda la informacin especi-
fica del MOP, a cdigo C++ con informacin dinmica adicional adaptable en tiempo de
ejecucin (el cdigo C++ no reflectivo no sufre proceso de traduccin alguno). Una vez
que la fase de preproceso haya sido completada, Iguana invocar a un compilador de C++
para generar la aplicacin final nativa, adaptable dinmicamente.

Cognac
Cognac [Murata94] es un sistema orientado a objetos basado en clases, cuya inten-
cin es proporcionar un entorno de programacin de sistemas operativos orientados a ob-
jetos como Apertos [Yokote92]. El lenguaje de programacin de Cognac es intencional-
mente similar a Smalltalk-80 [Goldberg89]; para aumentar su eficiencia, se le ha aadido
comprobacin esttica de tipos [Cardelli97].
Los principales objetivos del sistema son:
Uniformidad y simplicidad. Para el programador slo debe haber un tipo de ob-
jeto concurrente, sin diferenciar ejecucin sncrona de asncrona.
Eficiencia. Necesaria para desarrollar un sistema operativo.
Seguridad. Deber tratarse de minimizar el nmero de errores en tiempo de eje-
cucin; de ah la introduccin de tipos estticos al lenguaje.
Migracin. En el sistema los objetos debern poder moverse de una plataforma
fsica a otra, para seleccionar el entorno de ejecucin que ms les convenga.

108
Panormica de Utilizacin de Reflectividad

Metaprogramacin. El sistema podr programarse separando las distintas in-


cumbencias y aspectos de las aplicaciones, diferenciando entre el cdigo fun-
cional del no funcional.
La arquitectura del sistema est compuesta de cinco elementos:
1. El front-end del compilador. El cdigo fuente Cognac es traducido a un cdigo
intermedio independiente de la plataforma destino seleccionada. El compilador
selecciona la informacin propia de las clases y la almacena, para su posterior
uso, en el sistema de clases (quinto elemento).
2. El back-end del compilador. Esta parte del compilador toma el cdigo interme-
dio y lo traduce a cdigo binario propio de la plataforma fsica utilizada. Crea
un conjunto de funciones traducidas de cada una de las rutinas del lenguaje de
alto nivel.
3. Librera de soporte dinmico (Run-time Support Library). Es el motor principal de
ejecucin. Enva una peticin al sistema de clases para conocer el mtodo apro-
piado del objeto implcito a invocar; una vez identificado ste en el cdigo nati-
vo, carga la funcin apropiada y la ejecuta.
4. Intrprete. Aplicacin nativa capaz de ejecutar el cdigo intermedio de la apli-
cacin. Ser utilizado cuando el sistema requiera reflejarse dinmicamente. La
ejecucin del cdigo en este modo se ralentiza frente a la ejecucin nativa.
5. Sistema de clases. Informacin dinmica relativa a las clases y mtodos del sis-
tema.
El proceso de reflexin dinmica y los papeles de las distintas partes del sistema se
muestran en la Figura 7.18. La ejecucin del sistema es controlada por la librera de soporte
dinmico, que lee la informacin relativa al mensaje solicitado, busca ste entre el cdigo
nativo y lo ejecuta. Cuando se utiliza un metaobjeto dinmicamente, el motor de ejecucin
pasa a ser el intrprete, que ejecuta el cdigo intermedio de dicho metaobjeto. El compor-
tamiento del sistema es derogado por la interpretacin del metaobjeto creado; ste dicta la
nueva semntica del sistema.

Cdigo fuente Font-End del Cdigo Back-End del


Cognac Compilador Intermedio Compilador

Ejecucin Ejecucin
Reflectiva Seleccin y
Ejecucin Cdigo
Nativo
Insercin de Intrprete
Informacin

Lectura
Librera de
Soporte
Dinmico

Sistema Leer Informacin Ejecucin


Monoltica
de Clases

Figura 7.18: Arquitectura y ejecucin de una aplicacin en Cognac.

109
CAPTULO 7

Guanar
Para el desarrollo de la librera MOLDS [Oliva98] de componentes de metasistema
reusables, enfocados a la creacin de aplicaciones de naturaleza distribuida ofreciendo
caractersticas de persistencia, distribucin y replicacin, indiferentemente de la aplicacin
desarrollada (separacin de incumbencias) , se desarroll la plataforma computacional-
mente reflectiva Guanar [Oliva98b]. Guanar es una ampliacin de la implementacin de
la mquina virtual de Java, Kaffe OpenVM, otorgndole la capacidad de ser reflectiva
computacionalmente en tiempo de ejecucin mediante un MOP [Oliva98c].
El mecanismo de reflectividad ofrecido al programador est centrado en el concep-
to de metaobjeto. Cuando se enlaza un metaobjeto a una operacin del sistema, la semnti-
ca de dicha operacin es derogada por la evaluacin del metaobjeto. El modo en el que sea
desarrollado este metaobjeto definir dinmicamente el nuevo comportamiento de la ope-
racin modificada.
El concepto de metaobjeto es utilizado por multitud de MOPs y, la combinacin de
stos, se suele llevar a cabo mediante el patrn de diseo Cadena de Responsabilidad
(Chain of Responsibility) [GOF94]: cada metaobjeto es responsable de invocar al siguiente
metaobjeto enlazado con su misma operacin, y devolver el resultado de ste. Este esque-
ma de funcionamiento es poco flexible y todo metaobjeto necesita modificar su compor-
tamiento en funcin del resto de metaobjetos (Figura 7.19).
Cadena de Responsabilidad

Operacin1
mo1 : MetaObject Operacin2 mo2 : OperacinN moN : MetaObject Operacin

Respuesta2
MetaObject Respuesta2
Respuesta1 Respuesta
MetaSistema

Sistema Base Modificacin del


Significado de la operacin
cliente servidor
Operacin
Operacin

Figura 7.19 :Utilizacin del patrn Chain of Responsibility para asociar mltiples metaobjetos.

Guanar aborda este problema con el uso del patrn Composicin (Composite)
[GOF94], permitiendo establecer combinaciones de comportamiento ms independientes y
flexibles [Oliva99]. Cada operacin puede tener enlazado un nico metaobjeto primario,
denominado compositor (composer). ste, haciendo uso del patrn Composicin, podr
acceder a una coleccin de metaobjetos mediante una estructura de grafo. Como se mues-
tra en la Figura 7.20, cada uno de los elementos de un compositor puede ser un metaobjeto
u otro compositor.

110
Panormica de Utilizacin de Reflectividad

Diagrama de Objetos

: Compositor : MetaObject

MetaMetaSistema

Diagrama de Clases
: MetaObject : MetaObject

Interfaz
*

: Compositor : Compositor

MetaObject Compositor : MetaObject

: MetaObject

MetaSistema Especificacin
Sistema Base Comportamiento

objeto1 objeto2 objeto3

Figura 7.20: Utilizacin del patrn Composite para asociar mltiples metaobjetos.

El modo en el que cada compositor establece el nuevo comportamiento de su ope-


racin asociada en funcin de los metaobjetos utilizados, viene definido por una configura-
cin adicional denominada metaconfiguracin. De esta forma, separamos la estructura de
los metaobjetos de su secuencia de evaluacin, haciendo el sistema ms flexible y reutiliza-
ble.
La parte realmente novedosa de este sistema radica en la forma en la que se pueden
combinar mltiples comportamientos a una operacin reflectiva, as como el establecimien-
to de metacomportamientos de un metaobjeto (metametaobjetos). Establece un mecanis-
mo escalable y flexible, basado en el patrn de diseo Composite.

Dalang
Dalang [Welch98] es una extensin reflectiva del API de Java [Kramer96], que aa-
de reflectividad computacional para modificar nicamente el paso de mensajes del sistema,
de un modo restringido. Implementa dos mecanismos de reflectividad: en tiempo de com-
pilacin (esttica) y en tiempo de ejecucin (dinmica).
El conjunto de clases utilizadas en el esquema esttico se muestra en la Figura 7.21.
Dada una clase C cuyo paso de mensajes deseemos modificar, Dalang sustituye dicha clase
por otra nueva con la misma interfaz y nombre, renombrando la original esto es posible
gracias a la introspeccin de la plataforma Java [Sun97d]. La nueva clase posee un objeto de
la clase original en la que delegar la ejecucin de todos sus mtodos. Sin embargo, poseer
la capacidad de ejecutar, previa y posteriormente a la invocacin del mtodo, cdigo adi-
cional que pueda efectuar transformaciones de comportamiento (en la Figura 7.21, este
cdigo reside en la implementacin de los mtodos beforeMethod y afterMethod).

111
CAPTULO 7

C
-objeto C Renombrada
C method()
beforeMethod() 1 method()
method() afterMethod()

Esquema creado
Clase antes de para la modificacin
la transformacin beforeMethod() del paso de mensajes
objeto.method() a la clase C
afterMethod()

Figura 7.21: Transformacin de una clase en Dalang para obtener reflectividad.

La reflectividad dinmica del sistema se obtiene aadiendo al esquema anterior la


implementacin de un cargador de cdigo capaz de realizar la carga dinmica de las nuevas
clases en el sistema. La plataforma Java ofrece fcilmente esta posibilidad mediante la im-
plementacin de una clase derivada de ClassLoader [Gosling96].
Esta arquitectura posee un conjunto de inconvenientes:
Transparencia. Se permite modificar el paso de mensajes de un conjunto de ob-
jetos (las instancias de la clase renombrada); sin embargo, no es posible modifi-
car la semntica del paso de mensajes para todo es sistema.
Grado de reflectividad. La modificacin de la semntica se reduce al paso de
mensajes y se realiza en un grado bastante reducido ejecucin anterior y poste-
rior de cdigo adicional.
Eficiencia. La creacin dinmica de clases requiere una compilacin al cdigo
nativo de la plataforma, con la consecuente ralentizacin en tiempo de ejecu-
cin.
Su principal ventaja es que no modifica la mquina virtual de Java ni el cdigo exis-
tente en su plataforma; de esta forma, el sistema no pierde la portabilidad del cdigo Java y
es compatible con cualquier aplicacin desarrollada para esta plataforma virtual.

NeoClasstalk
Tras los estudios de reflectividad estructural llevados a cabo con el sistema ObjV-
lisp (analizado en 7.2), la arquitectura evolucion hacia una ampliacin de Smalltalk
[Goldberg83] denominada Classtalk [Mulet94]; su principal objetivo era utilizar esta plata-
forma como medio de estudio experimental en el desarrollo de aplicaciones estructural-
mente reflectivas. Continuando con el estudio de aplicaciones basadas en reflectividad, el
desarrollo de un MOP que permitiese modificar el comportamiento de las instancias de una
clase hizo que el sistema se renombrase a NeoClasstalk [Rivard96].
La aproximacin que utilizaron para aadir reflectividad computacional a Neo-
Classtalk fue la utilizacin del concepto de metaclase32, propio del lenguaje Smalltalk. Una
metaclase define la forma en la que van a comportarse sus instancias, es decir, sus clases
asociadas el concepto de metaclase es tomado como un mecanismo para definir la semn-
tica computacional de las clases instanciadas. Sobre este sistema, se desarrollaron metacla-

32
Al igual que en los lenguajes orientados a objetos basados en clases, un objeto es una instancia de una
clase, el concepto de metaclase define una clase como instancia de una metaclase la cual define el com-
portamiento de todas sus clases asociadas.

112
Panormica de Utilizacin de Reflectividad

ses genricas para poder ampliar las caractersticas del lenguaje [Ledoux96] tales como la
definicin de mtodos con pre y poscondiciones, clases de las que no se pueda heredar o la
creacin de clases que tan slo puedan tener una nica instancia patrn de diseo Singleton
[GOF94].
El modo en el que se modifica el comportamiento se centra en la modificacin di-
nmica de la metaclase de una clase. Como se muestra en la Figura 7.22, existe una metacla-
se por omisin denominada StandardClass; esta metaclase define el comportamiento
general de una clase en el lenguaje de programacin Smalltalk. El nuevo comportamiento
deseado deber implementarse en una nueva metaclase, derivada de StandardClass.
Clase cuyas Metaclase que define
instancias poseen el instanceof el comportamiento
ClaseA StandardClass
comportamiento por genric o de toda clase
defecto en Sm allt alk

Las instancias de Nueva met aclase


la clase B, t endrn ins tanceof que modifica el
ClaseB Metaclase
una m odificac in de comportamiento de
su comportamient o s us instancias
inicial

Figura 7.22: MOP de NeoClasstalk utilizando metaclases.

En NeoClasstalk, los objetos pueden cambiar de clase dinmicamente, modificando


su asociacin instanceof. Si modificamos esta referencia en el caso de una clase, esta-
remos modificando su metaclase y, por tanto, modificando su comportamiento.
Una de las utilizaciones prcticas de este sistema fue el desarrollo de OpenJava [Le-
doux99], un ORB capaz de adaptarse dinmicamente a los requisitos del programador
CORBA [OMG98]. Mediante la modificacin del comportamiento basado en metaclases,
aade una mayor flexibilidad al middleware CORBA consiguiendo:
Modificacin dinmica del protocolo de comunicaciones. La utilizacin de obje-
tos delegados (proxy) permite ser configurada para modificar el comportamiento
del paso de mensajes, seleccionando dinmicamente el protocolo deseado.
Migracin de objetos servidores dinmicamente.
Replicacin de objetos servidores.
Implementacin de un sistema dinmico de cach.
Gestin dinmica de tipos. Accediendo dinmicamente a las especificaciones de
los interfaces de los objetos servidores (archivos IDL), se pueden implementar
comprobaciones de tipo en tiempo de ejecucin.
El desarrollo de todo el sistema fue llevado a cabo siguiendo la separacin de in-
cumbencias: la parte de una aplicacin que modele el dominio del problema se deber sepa-
rar del resto de cdigo que pueda ser reutilizado para otras aplicaciones, y modele un aspec-
to global a varios sistemas.

Moostrap
Moostrap [Mulet93] es un lenguaje orientado a objetos reflectivo basado en proto-
tipos, implementado como un intrprete desarrollado en Scheme [Abelson2000].

113
CAPTULO 7

Acorde a la definicin de la mayor parte de los lenguajes basados en prototipos, de-


fine un nmero reducido de primitivas computacionales que va extendiendo mediante la
utilizacin de sus caractersticas estructuralmente reflectivas, para ofrecer un mayor nivel de
abstraccin en la programacin de aplicaciones. La abstraccin del objeto la entidad bsi-
ca en los lenguajes basados en prototipos queda definida con primitivas de reflectividad
estructural:
Un objeto viene definido como un conjunto de miembros (slots). stos pueden
constituir datos representativos del estado dinmico del objeto (atributos) o su
comportamiento (mtodos). La diferencia entre los dos tipos de miembros, es
que los segundos pueden ser evaluados, describiendo la ejecucin de un com-
portamiento33.
Adicin dinmica de miembros a un objeto. Todo objeto posee el miembro
computacional primitivo addSharedSlots capaz de aadir dinmicamente
un slot a un objeto.
Eliminacin dinmica de miembros de un objeto, mediante la primitiva
removeSlot.
Mediante sus capacidades estructuralmente reflectivas, extiende las primitivas inicia-
les para ofrecer un mayor nivel de abstraccin al programador de aplicaciones. Un ejemplo
de esto es la definicin del mecanismo de herencia, apoyndose en su reflectividad estruc-
tural dinmica [Mulet93]: si un objeto recibe un mensaje y no tiene un miembro con dicho
nombre, se obtiene su miembro parent y se le enva dicho mensaje a este objeto, conti-
nuando este proceso de un modo recursivo.
Adems de reflectividad estructural, Moostrap define un MOP para permitir modi-
ficar el comportamiento de seleccin y ejecucin de un mtodo de un objeto, ante la recep-
cin de un mensaje. La semntica de la derogacin de estas dos operaciones viene definida
por el concepto de metaobjeto [Kiczales91], utilizado en la mayor parte de los MOPs exis-
tentes.
El paso de un mensaje puede modificarse en dos fases: primero, ejecutndose el
metaobjeto asociado a la seleccin del miembro y, posteriormente, interpretando el com-
portamiento definido por el metaobjeto que derogue la ejecucin del mtodo.
Utilizando Moostrap, se trat de definir una metodologa para crear metacompor-
tamientos mediante la programacin de metaobjetos en Moostrap [Mulet95].

7.4.1 Aportaciones y Carencias de los Sistemas Estudiados


En la totalidad de los MOPs estudiados, se permite la modificacin dinmica de
parte del comportamiento del mismo ( 2.3.3), y, en casos como Dalang, dicha modifica-
cin se puede realizar en fase de compilacin para obtener una mayor eficiencia en tiempo
de ejecucin.
El concepto de MOP establece un modo de acceso del sistema base al metasistema,
identifica el comportamiento que puede ser modificado. El establecimiento de este proto-
colo previamente a la ejecucin de la aplicacin supone una restriccin a priori de la semn-
tica que podr ser modificada dinmicamente. De esta forma, un MOP implica una restric-
cin en la que un sistema puede modificar su propio comportamiento ( 2.3.4).

33
Este proceso de convertir datos en computacin, lo definimos descosificacin al tratarse del proceso
contrario de cosificacin definido en el captulo 6.

114
Panormica de Utilizacin de Reflectividad

Una proposicin para resolver esta limitacin de los MOPs pasa por ampliar ste
cuando sea necesario [Golm98]; verbigracia, si un MOP no contempla la modificacin de la
semntica de la creacin de objetos, podemos modificarlo para que sea adaptable. Sin em-
bargo, como se muestra en la Figura 7.23, la modificacin del MOP supone la modificacin
del intrprete, dando lugar a distintas versiones del mismo y a la prdida de la portabilidad
del cdigo existente para las versiones anteriores [Ortn2001].
Es posible ejecutar
cdigo v.1 con el
intrprete v.2?
Cdigo Fuente v.1 Cdigo Fuente v.2

Acceso al
Metasistema
Ejecuta mediante un Modificacin Ejecuta
MOP del MOP

Resto Resto
Intrprete Intrprete
Implementacin Modificacin
del MOP del MOP

Intrprete v. 1 Intrprete v. 2

Figura 7.23: Prdida de la portabilidad cdigo de un intrprete, al modificar su MOP.

Los sistemas basados en MOPs otorgan una flexibilidad dinmica de su comporta-


miento pero, de forma contraria a las tcnicas estudiadas en 7.2, carecen de la posibilidad
de modificar el lenguaje con el que son desarrolladas sus aplicaciones ( 2.3.5) se limitan a
modificar la semntica de stos.
La mayor carencia de los sistemas reflectivos es su eficiencia en ejecucin. La utili-
zacin de intrpretes es ms comn, pero las aplicaciones finales poseen tiempos de ejecu-
cin ms elevados que si hubieren sido compiladas a cdigo nativo. A raz de analizar los
sistemas estudiados podemos decir:
1. La implementacin de un MOP en un sistema interpretado (por ejemplo, Me-
taXa) es ms sencilla y menos eficiente que el desarrollo de un traductor a un
lenguaje compilable, como por ejemplo Iguana. En este caso, el sistema debe
poseer informacin dinmica adicional para poder acceder y modificar sta en
tiempo de ejecucin.
Un ejemplo de la complejidad mencionada es la posibilidad de conocer dinmi-
camente el tipo de un objeto en C++ (RTTI, RunTime Type Information) [Strous-
trup98]. Esta caracterstica supone modificar la generacin de cdigo, para que
todo objeto posea la informacin propia de su tipo generalmente la ejecucin
de una aplicacin nativa no necesita esta informacin y por tanto no se genera.
2. Puesto que los sistemas compilados poseen mayor eficiencia frente a los inter-
pretados, que ofrecen una mayor sencillez a la hora de implementar sistemas
flexibles, la unin de las dos tcnicas de generacin de aplicaciones puede dar
lugar a un compromiso eficaz.
En el caso de Cognac, todo el sistema se ejecuta en tiempo dinmico excepto
aquella parte que se identifica como reflectiva; en este momento un intrprete
ejecuta el cdigo intermedio que define el nuevo comportamiento. Para el sis-
tema Iguana todo el cdigo es traducido sin informacin dinmica, salvo aqul
que va a ser adaptado.
3. El desarrollo de un MOP en dos niveles de interpretacin (Closette) es ms
sencillo que si slo elegimos uno (MetaXa). Si necesitamos modificar el MOP

115
CAPTULO 7

de Closette, deberemos hacerlo sobre el primer intrprete; en el caso de Me-


taXa, deberemos recodificar la mquina virtual.
Finalmente comentar, poniendo por ejemplo a Moostrap, que la reflectividad es-
tructural y computacional son dos mecanismos tiles a la hora de desarrollar un sistema
extensible y adaptable, a partir de un conjunto de primitivas reducidas ( 2.2.1). Los mode-
los computacionales orientados a objetos basados en prototipos, facilitan su implementa-
cin.

7.5 Intrpretes Metacirculares


Dentro del captulo anterior, en el 6.2, razonbamos acerca del concepto de re-
flectividad computacional utilizando la metfora de una torre de intrpretes. Cuando una
aplicacin pueda acceder a su nivel inferior, podr modificar su comportamiento. Si lo que
desea es modificar la semntica de su semntica (el modo en el que se interpreta su com-
portamiento), deber acceder en la torre a un nivel computacional dos unidades inferior.
El proceso de acceder, desde un nivel en la torre de intrpretes definida por Smith
[Smith82], a niveles inferiores puede, tericamente, extenderse hasta el infinito al fin y al
cabo, todo intrprete ser ejecutado o animado por otro. Las implementaciones de intr-
pretes capaces de ofrecer esta abstraccin se han denominado intrpretes metacirculares
(metacircular interpreters) [Wand88].

3-Lisp
La idea de la torre infinita de intrpretes propuesta por Smith [Smith82] en el mbi-
to terico tuvo distintas implementaciones en un futuro inmediato [Rivires84].
El desarrollo de los prototipos de intrpretes metacirculares comenz por la im-
plementacin de lenguajes de computacin sencilla. El diseo de un intrprete capaz de
ejecutar un nmero infinito de niveles computacionales, supone una elevada complejidad
que crece a medida que aumentan las capacidades computacionales del lenguaje a interpre-
tar. El primer prototipo metacircular desarrollado, denominado 3-Lisp [Wand88], interpre-
ta un subconjunto del lenguaje Lisp [Steele90], y permite cosificar y reflejar un nmero
indefinido de niveles computacionales.
El estado computacional que ser reflejado en este lenguaje est formado por tres
elementos [Wand88]:
Entorno (environment): Identifica el enlace entre identificadores y sus valores en
tiempo de ejecucin.
Continuacin (continuation): Define el contexto de control. Recibe el valor de-
vuelto de una funcin y lo sita en la expresin que se est evaluando, en la po-
sicin en la que aparece la llamada a la funcin ya ejecutada.
Almacn (store): Describe el estado global de la computacin en el que se inclu-
yen contextos de ejecucin e informacin sobre los sistemas de entrada y salida.
De esta forma, el estado de computacin de un intrprete denominado metaconti-
nacin (metacontinuation) [Wand88] queda definido formalmente por tres valores (e, r, k),
que podrn ser accedidos desde el metasistema como un conjunto de tres datos (cosifica-
cin). La capacidad de representar formalmente y mediante datos el estado computacional
de una aplicacin en tiempo de ejecucin, aumenta en complejidad al aumentar el nivel de
abstraccin del lenguaje de programacin en el que haya sido codificada. Por esta causa, la

116
Panormica de Utilizacin de Reflectividad

mayora de los prototipos de intrpretes metacirculares desarrollados computan lenguajes


de semntica reducida.

Accede Accede
Cdigo Cdigo
3-Lisp 3-Lisp

Ejecuta Cosificacin Ejecuta


(reification)

Nivel 3 (e,r,k) Sistema


Base
Intrprete Modifica Intrprete a
Sistema Reflexin Mo dific Nivel 2 (e,r,k) Meta
3-Lisp Nivel 2 (e,r,k) 3-Lisp
Base (reflection) Sistema

Nivel 1 (e,r,k) Meta Nivel 1 (e,r,k)


Sistema

Nivel 0 (e,r,k) Nivel 0 (e,r,k)

Pila de Pila de
Estados Estados
Computacionales Computacionales

Figura 7.24: Implementacin de un intrprete metacircular de 3-Lisp.

En la Figura 7.24 se aprecia el funcionamiento de los prototipos de interpretacin


de 3-Lisp. Existe un programa codificado en 3-Lisp que posibilita el cambio de nivel con
las operaciones reify (aumento de nivel) y reflect (reduccin de nivel). Un intrprete del sub-
conjunto de Lisp definido va leyendo y ejecutando el lenguaje fuente. La ejecucin de la
aplicacin supone la modificacin de los tres valores que definen el estado computacional
de la aplicacin (e, r, k). En la interpretacin se puede producir un cambio de nivel de
computacin:
Cosificacin (reify): Se apila el valor del estado computacional existente (e, r, k) y
se crea un nuevo estado de computacin (e, r, k). Ahora el intrprete trabaja
sobre este nuevo contexto y la aplicacin puede modificar los tres valores de
cualquier nivel inferior, como si de datos se tratase.
Reflexin (reflect): Se desapila el contexto actual volviendo al estado anterior
existente en la pila. La ejecucin contina donde haba cesado antes de hacer la
ltima cosificacin.
Las condiciones necesarias para implementar un prototipo de estas caractersticas
son bsicamente dos:
1. Expresividad computacional mediante un nico lenguaje. Puesto que realmente
existe un nico intrprete (ver Figura 7.24), ste estar obligado a animar un so-
lo lenguaje de programacin. En todos los niveles computacionales deber utili-
zarse por tanto el mismo lenguaje de programacin.
2. Identificacin formal del estado computacional. La semntica computacional
del lenguaje deber representarse como un conjunto de datos manipulables por
el programa. La complejidad de este proceso es excesivamente elevada para la
mayora de los lenguajes de alto nivel.

ABCL/R2
La familia de lenguajes ABCL fue creada para llevar a cabo investigacin relativa al
paralelismo y orientacin a objetos. Inicialmente se desarroll un modelo de computacin
concurrente denominado ABCM/1 (An object-Based Concurrent computation Model) y su lengua-
je asociado ABCL/1 (An object-Based Concurrent Language) [Yonezawa90].

117
CAPTULO 7

En la implementacin de un modelo computacional concurrente, la reflectividad


computacional ofrece la posibilidad de representar la estructura y la computacin concu-
rrente mediante datos (cosificacin), utilizando abstracciones apropiadas. En la definicin
del lenguaje ABCL/R (ABCL reflectivo) [Watanabe88], a partir de todo objeto x puede
obtenerse su metaobjeto x que representa, mediante su estructura, el estado computa-
cional de x. Se implementa un mecanismo de conexin causal, para que los cambios del
metaobjeto se reflejen en el objeto original. La operacin puede aplicarse tanto a obje-
tos como a metaobjetos, tratndose pues de una implementacin de una torre infinita de
intrpretes (intrprete metacircular).
Para facilitar la coordinacin entre metaobjetos del mismo tipo, y para definir com-
portamientos similares de un grupo de objetos, la definicin del lenguaje ABCL/R2 [Mat-
suoka91] aada el concepto de metagrupo: metaobjeto que define el comportamiento de
un conjunto de objetos del sistema base. Para implementar la adicin de metagrupos, sur-
gen determinadas ampliaciones del sistema:
1. Nuevos objetos de ncleo (kernel objects) para gestionar los grupos: The Group
Mangager, The Primary Metaobject Generator y The Primary Evaluator.
2. Se crea un paralelismo entre dos torres de intrpretes: la torre de metaobjetos
(activada mediante la operacin ) y la torre de metagrupos (activada median-
te la operacin ).
3. Objetos no cosificables (non-refying objects). Se ofrece la posibilidad de definir ob-
jetos no reflectivos para eliminar la creacin de su metaobjeto adicional y obte-
ner as mejoras de rendimiento.

MetaJ
MetaJ [Doudence99] es un prototipo que trata de ofrecer las caractersticas propias
de un intrprete metacircular para un subconjunto del lenguaje de programacin Java [Gos-
ling96]. Expresado siempre en Java, el intrprete permite cosificar objetos para acceder a su
propia representacin interna (reflectividad estructural) y a la representacin interna de su
semntica (reflectividad computacional).
Inicialmente el intrprete procesa lxica y sintcticamente el cdigo fuente, creando
un rbol sintctico con nodos representativos de las distintas construcciones sintcticas del
lenguaje. El mtodo eval de cada uno de estos nodos representar la semntica asociada a
cada uno de sus elementos sintcticos.
Conforme la interpretacin del rbol se va llevando a cabo, se van creando objetos
representativos de los creados por el usuario en la ejecucin de la aplicacin. Todos los
objetos creados poseen el mtodo reify que nos devuelve un metaobjeto: representacin
interna del objeto que nos permite acceder a su estructura (atributos, mtodos y clase), as
como a su comportamiento (por ejemplo, la bsqueda de atributos o la recepcin de men-
sajes). Podremos obtener as:
1. Reflectividad estructural: Accediendo y modificando la estructura del metaobje-
to, se obtiene una modificacin estructural del objeto; existe un mecanismo de
conexin causal que refleja los cambios realizados en todo metaobjeto.
2. Reflectividad computacional: Se consigue modificando la clase de una instancia
por una clase derivada que derogue el mtodo que especifica la semntica a alte-
rar. En la Figura 7.25 se muestra cmo se modifica la clase del metaobjeto para
ser otra con la redefinicin del mtodo lookupMethod, encargada de gestio-
nar la recepcin de mensajes.

118
Panormica de Utilizacin de Reflectividad

BaseInstance ModificacinRecepcinMensajes
Modificacin de
la semntica de
lookupMethod()
la gestin de
... lookupMethod() mensajes

class : BaseInstance class :


ModificacinRecepcinMensajes

Se rompe la asociacin
con la clase anterior y
se asocia a la nueva que
modifica la recepcin de
Clase de la que es instancia mensajes

objeto metaObjeto

Lista de Atributos

: Attribute

Figura 7.25: Modificacin de la clase de un objeto, para obtener la modificacin de la semntica de


la recepcin de mensajes.

La parte novedosa de MetaJ sobre el resto de sistemas estudiados a lo largo de este


captulo reside en la capacidad de poder cosificar metaobjetos en el grado que deseemos. Si
invocamos al mtodo reify de un metaobjeto, obtendremos la representacin de un me-
taobjeto pudiendo modificar as la semntica de su comportamiento. El acceso reflectivo
no posee un lmite de niveles, constituyndose as como un caso particular de un intrprete
metacircular.

7.5.1 Aportaciones y Carencias de los Sistemas Estudiados


Los sistemas estudiados ofrecen el mayor nivel de flexibilidad computacional res-
pecto al dominio de niveles computacionales a modificar. El acceso a cualquier elemento
de la torre de intrpretes permite modificar la semntica del sistema en cualquier grado. Sin
embargo, aunque tericamente facilita la comprensin del concepto de reflectividad, en un
campo ms pragmtico puede suponer determinados inconvenientes. La posibilidad de
acceso simultneo a distintos niveles puede producir la prdida del conocimiento de la se-
mntica del sistema, sin conocerse realmente cul es el significado del lenguaje de progra-
macin [Foote90]. Un sistema de seguridad en la utilizacin de la reflectividad sera impres-
cindible en este caso 6.4.
En los sistemas estudiados, se ha dado precedencia a ofrecer un nmero indefinido
de niveles de computacin accesibles, frente a ofrecer un mayor grado de informacin a
cosificar. Si tomamos 3-Lisp como ejemplo, ofrece la cosificacin del estado computacio-
nal de la aplicacin, pero no permite modificar la semntica del lenguaje ( 2.3.3); el intr-
prete es monoltico e invariable.
Para conseguir este requisito mediante la implementacin de infinitos niveles, debe-
ra especificarse la semntica del lenguaje en el propio estado de computacin, extrayndola
del intrprete monoltico.

119
CAPTULO 7

En el caso de MetaJ, se restringe a priori el nmero de operaciones semnticas a


modificar, puesto que han de estar predefinidas como mtodos de una clase de comporta-
miento. No existe pues, una flexibilidad no restringida a priori ( 2.3.4). Adems, la modifi-
cacin a llevar a cabo en el comportamiento ha de especificarse en tiempo de compilacin
( 2.4.8).
Como conclusin, cabe mencionar que a la hora de desarrollar un sistema reflecti-
vo, es ms til ahondar en la cantidad de informacin a cosificar y el modo en el que sta
pueda ser expresada, que aumentar el nmero de niveles computacionales cosificables.
Un punto adicional a destacar, propio del sistema ABCL/R2, es su definicin de
metagrupos. Vemos cmo se utiliza este concepto para agrupar el comportamiento de un
conjunto de objetos en una sola abstraccin. Para conseguirlo, se introducen un conjunto
de entidades adicionales y dos torres de interpretacin paralelas. Si bien la agrupacin de
metaobjetos puede ser atrayente para reducir la complejidad del metasistema, deberamos
buscar un mecanismo auxiliar ms sencillo para conseguir dicha funcionalidad los objetos
rasgo o trait de los sistemas orientados a objetos basados en prototipos (captulo 8), nos
pueden ofrecer esta abstraccin de un modo sencillo.

7.6 Conclusiones
A lo largo de este captulo, estudiando distintos tipos de sistemas reflectivos, hemos
visto cmo la reflectividad es una tcnica que puede ser empleada para obtener flexibilidad
en un sistema computacional en el captulo 8 vimos un conjunto de tcnicas alternativas.
En este punto, analizaremos qu puede aportar esta tcnica a los objetivos buscados en esta
tesis ( 1.2), as como las limitaciones encontradas.
Puesto que el concepto de sistema reflectivo puede ser catalogado de diversos mo-
dos (clasificacin realizada en el captulo anterior), analizaremos globalmente los sistemas
reflectivos teniendo en cuenta tres criterios: cundo se produce la reflexin, qu se refleja y
el nmero de niveles computacionales utilizado.

7.6.1 Momento en el que se Produce el Reflejo


La reflectividad en tiempo de ejecucin otorga un elevado grado de flexibilidad al
sistema, puesto que ste puede adaptarse a contextos impredecibles en fase de diseo.
Cuando una aplicacin necesita poder especificar nuevos requisitos dinmicamente, la re-
flectividad en tiempo de compilacin no es suficiente.
Sin embargo, la reflectividad esttica posee una ventaja directa sobre la dinmica: la
eficiencia de las aplicaciones en tiempo de ejecucin. La adaptabilidad dinmica de un sis-
tema produce una ralentizacin del mismo en su ejecucin.
Desde el punto de vista emprico, podemos ver cmo los sistemas estticos ofrecen
reflectividad del lenguaje de programacin, cuando esto no ocurre en ningn sistema din-
mico; el lenguaje de programacin en estos casos se mantiene inamovible.

7.6.2 Informacin Reflejada


El primer nivel de informacin a reflejar es la estructura del sistema en un modo de
slo lectura: introspeccin ( 7.1). La caracterstica prctica de este nivel de reflectividad
queda patente en el nmero de sistemas comerciales que la utilizan. Permite desarrollar

120
Panormica de Utilizacin de Reflectividad

fcilmente sistemas de componentes, de persistencia, comprobaciones de tipo dinmicas, o


middlewares de distribucin.
Para el sistema de computacin flexible buscado en esta tesis, adems de todas las
utilidades prcticas estudiadas en 7.1, ofrece un mecanismo de autodocumentacin real y
dinmica, y un conocimiento dinmico exacto del estado del sistema.
El segundo grado de informacin a reflejar es la reflectividad estructural, en la que
se permite tanto el acceso como la modificacin dinmica de la estructura del sistema. A
nivel prctico existen muchas posibilidades para este tipo de sistemas, muchas de ellas to-
dava no explotadas. Ejemplos pueden ser interfaces grficas adaptables mediante la incrus-
tacin, eliminacin y modificacin dinmica de la estructura de los objetos grficos, aplica-
ciones de bases de datos que trabajen con un abanico de informacin adaptable en tiempo
de ejecucin, o la apertura a un nuevo modo de programacin adaptable dinmicamente
[Golm98] y creacin de nuevos patrones de diseo [Ferreira98].
Para el desarrollo de nuestro sistema, al igual que fue utilizada en Smalltalk, Self y
Moostrap, la reflectividad estructural puede emplearse para hacer un sistema extendido de
un conjunto reducido de primitivas computacionales, programando la mayor parte de ste
en su propio lenguaje y consiguiendo as adaptabilidad el sistema posee la capacidad de
modificarse a s mismo, al estar escrito en su propio lenguaje y portabilidad cualquier
intrprete de las primitivas computacionales bsicas podr ejecutar el sistema en su totali-
dad.
Cuando la semntica del sistema puede modificarse, nos encontramos en el tercer
nivel de esta clasificacin: reflectividad computacional. ste ofrece una flexibilidad elevada
para todo el sistema en su conjunto. Se ha utilizado en la mayora de casos a nivel de proto-
tipo, aplicndose a depuradores (debuggers), compilacin dinmica (JIT, Just In Time compila-
tion), desarrollo de aplicaciones en tiempo real, o creacin de sistemas de persistencia y dis-
tribucin.
En los sistemas estudiados aparecen limitaciones respecto al grado de modificacin
de la semntica adaptable, y a la imposibilidad de modificar el lenguaje de programacin (
7.4.1). Ambas restricciones han sido especificadas como necesaria su superacin en esta
tesis requisitos 2.3.4 y 2.3.5). Por lo tanto, nuestro sistema deber tener un mecanismo
no restrictivo de modificacin de su semntica, as como la capacidad de modificar y selec-
cionar dinmicamente su lenguaje de programacin (cuarto y ltimo nivel de informacin a
reflejar).

7.6.3 Niveles Computacionales Reflectivos


En la torre de intrpretes enunciada por Smith [Smith82], analizada en el captulo
anterior, el acceso de un sistema a su metasistema se representaba como el salto al intrpre-
te que ejecutaba dicha aplicacin. En un sistema reflectivo, podemos preguntarnos cuntos
niveles computacionales necesitamos y qu ganaramos introduciendo ms.
Coincidiendo con la mayora de los autores, un sistema altamente flexible y maneja-
ble es aqul que ofrece una elevada anchura y no altura de su torre de intrpretes. Esto
quiere decir que es ms til obtener una forma sencilla y potente de modificacin del meta-
sistema desde el sistema base anchura de la torre, que la capacidad de modificar el com-
portamiento del lenguaje que especifica el comportamiento, denominado metacomporta-
miento altura de la torre.
Como hemos especificado en 7.5.1, la posibilidad de acceder un nmero infinito
de niveles de computacin, puede hacer al programador perder la semntica real del siste-

121
CAPTULO 7

ma con el que est trabajando. Por esto, reduciremos el nivel computacional necesario para
nuestro sistema a dos y trataremos de darle la mayor expresividad posible; sin restricciones.

122
CAPTULO 8:
LENGUAJES ORIENTADOS A OBJETOS BASADOS EN
PROTOTIPOS

Segn la nocin utilizada para agrupar objetos de igual comportamiento en un mo-


delo computacional orientado a objetos, es posible establecer la siguiente clasificacin de
lenguajes [Evins94]:
Lenguajes orientados a objetos basados en clases.
Lenguajes orientados a objetos basados en prototipos.
Estudiaremos las semejanzas y disimilitudes existentes entre ambos, y analizaremos
las ventajas e inconvenientes que cada uno de los modelos aporta.

8.1 Clases y Prototipos


El modelo computacional de objetos basado en clases se apoya en la agrupacin de
objetos de igual estructura y comportamiento, como instancias de una misma clase
[Booch94]. Se establece as una relacin necesaria de instanciacin entre objetos y clases;
no es posible crear y utilizar un objeto, si no se ha definido previamente la clase a la que
pertenece.
La estructura esttica de un objeto y su comportamiento en funcin de su estado,
son definidos por una clase mediante sus atributos y sus mtodos respectivamente. Cuando
se crea un objeto como instancia de una clase, su estado quedar definido por un conjunto
dinmico de valores para cada uno de los atributos de la estructura definida por su clase,
variando ste dinmicamente.
En el modelo computacional basado en objetos, no existe el concepto de clase; la
nica abstraccin existente es el objeto [Borning86]. Un objeto describe su estructura (con-
junto de atributos), su estado (los valores de stos) y su comportamiento (la implementa-
cin de los mtodos que pueda interpretar).
La herencia es un mecanismo jerrquico de delegacin de mensajes existente tam-
bin en el modelo de prototipos. Si se le enva un mensaje a un objeto, se analiza si ste
posee un mtodo que lo implemente y, si as fuere, lo ejecuta; en caso contrario se repite
este proceso para sus objetos padre, en el cado de que los hubiere.

123
CAPTULO 8

La relacin de herencia entre objetos basados en prototipos es una asociacin ms,


dotada de una semntica adicional la especificada en el prrafo anterior. En el caso del
lenguaje de programacin Self [Ungar87], la identificacin de esta semntica especial es
denotada por la definicin del miembro parent. El objeto asociado mediante este miem-
bro es realmente el objeto padre. Al tratarse la herencia como una asociacin, es posible
modificar en tiempo de ejecucin el objeto padre al que se hace referencia, obteniendo as
un mecanismo de herencia dinmica o delegacin.
Vemos como, al eliminar el concepto de clase en el modelo, la aproximacin de
prototipos resulta ms sencilla. Sin embargo, es posible agrupar objetos con el mismo
comportamiento, al igual que lo hacen las clases?
Utilizando nicamente el concepto de objeto tambin podremos agrupar compor-
tamientos. Si se crean objetos que nicamente posean mtodos, stos describirn el com-
portamiento comn de todos sus objetos derivados. Este tipo de objetos se denomina de
caracterstica o rasgo (trait) [Lieberman86]. En la Figura 8.1, el objeto trait Object define
el comportamiento toString de todos los objetos. Del mismo modo, Point define el
comportamiento de sus dos objetos derivados.

Object
Object Object
id:String Objetos
clone() clone()
toString()
toString() toString()
clone()

ObjectPrototype Point ObjectPrototype Point

id=none add() id=p id=none add()


Point

x,y:Integer Derogacin

p PointPrototype p
add(p:Point) PointPrototype

x=245 id=none id=p


x=0 y=0
y=-23 x=0 y=0 x=245
p:Point y=-23

id=p Clonacin de Objetos


x=245 Clonacin de Objetos
y=-23

a) Modelo basado b) Modelo basado en prototipos c) Modelo basado en prototipos


en clases con herencia mltiple con herencia simple

Figura 8.1: Representacin de clases y objetos en los dos modelos.

Del mismo modo que hemos agrupado objetos de igual comportamiento, podemos
cuestionarnos la posibilidad de agruparlos por estructura. Un prototipo es un objeto des-
criptor de una estructura comn, utilizado para hacer copias exactas de l clonaciones. En
este modelo computacional, mediante la utilizacin de prototipos y la primitiva de clona-
cin, se obtiene la misma funcionalidad que la de instanciacin o creacin de objetos a tra-
vs de una clase en su modelo homlogo.
En la Figura 8.1, la creacin de un punto pasa por la clonacin de su prototipo. s-
te posee la estructura comn de todos los puntos (atributos x e y), su estado inicial (am-
bos valores iguales a cero) y el comportamiento comn definido por el objeto trait
Object. Vemos en la figura tambin, cmo es posible representar el diseo mediante la
utilizacin de un sistema computacional dotado tan solo de herencia simple.

124
Lenguajes Orientados a Objetos Basados en Prototipos

Como ejemplos de lenguajes orientados a objetos basados en prototipos podemos


mencionar a Self [Ungar87, Chambers89], Moostrap [Mulet93], ObjectLisp, Cecil [Cham-
bers93], NewtonScript [Swaine94] o PROXY [Leavenworth93].

8.2 Utilizacin de Lenguajes Orientados a Objetos Basados en


Prototipos
En este apartado evaluaremos las ventajas existentes en la utilizacin del modelo
orientado a objetos basado en prototipos, dejando para el prximo sus inconvenientes
frente al que utiliza clases.

8.2.1 Reduccin Semntica


Una de las caractersticas destacables en el modelo de prototipos, al llevarse a cabo
una comparacin con su homlogo, reside en la simplicidad obtenida al:
1. Eliminar el concepto de clase. No es necesario crear una clase para todo objeto.
2. Suprimir la dependencia necesaria existente entre un objeto y una clase. Siempre
ha de existir entre ellos una relacin de instanciacin, y el estado del objeto ha
de ser coherente con la estructura defina por su clase.
3. Eliminar la comprobacin esttica de tipos. Un objeto slo puede recibir los
mensajes implementados por su clase y superclases. En un sistema basado en
clases, esta comprobacin es realizada en tiempo de compilacin.
En el caso del modelo basado en prototipos, al constituirse la herencia como un
mecanismo dinmico (delegacin), es imposible llevar a cabo esta validacin es-
tticamente; el conocimiento de esta informacin slo puede efectuarse dinmi-
camente34.

8.2.2 Inexistencia de Prdida de Expresividad


La sencillez del modelo computacional que se basa nicamente en objetos puede
hacernos creer que supone una prdida en la expresividad de los lenguajes que lo utilizan.
Sin embargo, se han realizado estudios que demuestran que la utilizacin de prototipos no
supone prdida alguna de expresividad [Ungar91, Evins94]: toda semntica representable
mediante el modelo de clases puede ser traducida al modelo de prototipos. Su demostra-
cin ha quedado patente en la implementacin de compiladores de lenguajes basados en
clases, como Self y Java, a la plataforma Self que utiliza prototipos [Wolczko96].
Sin nimo de ahondar en la traduccin de conceptos de un modelo a otro, mostra-
remos un ejemplo de traduccin de la nocin de miembro de clase, existente en la mayora
de los lenguajes de programacin basados en clases.

34
Es por esta razn por la que los sistemas basados en prototipos utilizan un sistema dinmico de tipos
[Chambers89], o bien carecen de su inferencia [Cardelli97].

125
CAPTULO 8

Point
Point
nPoints=2
x,y:Integer
nPoints:Integer add()
incPoints()
add(p:Point)
incPoints()

p:Point PointPrototype p

x=245 id=none x=245


y=-23 x=0 y=0 y=-23

a) Modelo basado
b) Modelo basado en prototipos
en clases

Figura 8.2: Miembros de clase en ambos modelos orientados a objetos.

Como se muestra en la figura anterior, la clase Point posee un atributo de clase


que cuenta el nmero de instancias creadas, y un mtodo de clase que permite incrementar
ste. La ubicacin de ambos en el modelo de prototipos se sita en el objeto trait. ste, y
no uno de sus derivados, ser el que reciba los mensajes de clase y ser su propio estado el
que determine el resultado de su ejecucin (puesto que el mtodo incPoints incrementa
el atributo nPoints que pertenece al objeto trait). La utilizacin de este servicio se de-
mandar mediante la clase (objeto Point) y no mediante una de sus instancias.

8.2.3 Traduccin Intuitiva de Modelos


La traduccin del modelo basado en clases de un mayor nivel de abstraccin al
modelo que utiliza prototipos se produce de un modo intuitivo para el programador. Por
ejemplo, el programador de aplicaciones que selecciona un lenguaje de programacin como
Python [Rossum2001] o Java [Gosling96], ha de tener en mente esta traduccin.
Aunque los dos lenguajes mencionados en el prrafo anterior poseen un modelo
computacional basado en clases, una vez compilado su cdigo fuente, en fase de ejecucin,
el modelo computacional empleado est basado en prototipos. En tiempo de ejecucin las
abstracciones de clases son substituidas por objetos que representan stas. As, en Python,
el atributo __class__ de todo objeto nos devuelve su objeto-clase asociado; en Java, el
mtodo getClass nos devuelve un objeto del tipo Class.
Por esta traduccin entre modelos intuitiva, la sencillez del modelo de prototipos y
la carencia de prdida en su expresividad, Wolczko propone los prototipos como modelo
universal de computacin de lenguajes orientados a objetos [Wolczko96]. Llevando a cabo
la traduccin de cualquier lenguaje a un nico modelo, la interaccin intuitiva entre aplica-
ciones se podra lograr independientemente del lenguaje que hay sido utilizado para su
construccin.

8.2.4 Coherencia en Entornos Reflectivos


Dos problemas existentes en el campo de las bases de datos son la evolucin y
mantenimiento de versiones de esquemas. Pueden definirse de la siguiente forma [Rod-
dick95]:
Evolucin de esquemas (schema evolution): Capacidad de una base de datos para
permitir la modificacin de su diseo, sin incurrir en prdida de informacin.

126
Lenguajes Orientados a Objetos Basados en Prototipos

Mantenimiento de versiones de esquemas (schema versioning): Se produce cuando,


tras haberse llevado a cabo un proceso de evolucin del esquema, la base de da-
tos permite acceder a la informacin tanto de un modo retrospectivo, como
mediante la estructura actual, manteniendo as la informacin para cada versin
de esquema existente.
Con el surgimiento de las bases de datos orientadas a objetos, este problema es tras-
ladado al concepto de clase: el esquema estructura y comportamiento de un objeto queda
determinado por la clase de la que es instancia. Cmo se deber adaptar un objeto si es
modificada su clase?
La cuestin surgida en el punto anterior brota de igual modo en el caso de utilizar
un modelo computacional basado en clases que est dotado de reflectividad estructural (
6.3.1). Qu sucede con los estados de los objetos si modifico la estructura de su clase?
Cmo puedo modificar la estructura de un nico objeto? Existen distintas aproximacio-
nes.
Una de las soluciones aportadas, sin necesidad de eliminar el concepto de clase, es
la enfocada a obtener mantenimiento de versiones del esquema. El sistema MetaXa
[Golm97], estudiado en 7.4, implementa esta solucin mediante la creacin de las deno-
minadas clases sombra (shadow classes). En este sistema, siempre que se modifique una clase
se crea una copia (sombra) de la clase antigua, se modifica sta, y se asocian los objetos
nuevos a esta clase, manteniendo los existentes como instancias de la versin anterior.

Modelo de computacin Tipos existentes


existente para el intrprete para el programador

ObjetoA Clase Tipo


Clase A Clase A

ObjetoB
Clase

ObjetoA Clase Tipo


Clase A Clase A

ObjetoB
Clase Clase A Tipo

La modificacin del comportamiento del


objeto B, mediante la reimplementacin
de uno de sus mtodos, produce la creacin
de una clase sombra A, de igual tipo para
el programador

Figura 8.3: Creacin de una clase sombra para la modificacin del comportamiento de un objeto.

La implementacin de este mecanismo ha de tener en cuenta que la clase original y


la sombra, aun siendo distintas, debern poseer la misma identidad, es decir, el programa-
dor de aplicaciones no deber tener nocin de la existencia de ambas. La implementacin
de este mantenimiento de versiones de clases es complejo y conlleva a un determinado
nmero de incoherencias del modelo computacional [Golm97c]. Los propios autores del
sistema, en [Golm97c], mencionan que sera ms sencilla su implementacin si se hiciese
uso del modelo basado en prototipos.
La modificacin de la estructura y comportamiento de objetos en un sistema basa-
do en prototipos es ms sencilla de implementar, y no genera incoherencias en dicho mo-
delo por ejemplo, el sistema Moostrap [Mulet93]. Distintos escenarios son:

127
CAPTULO 8

1. La modificacin de la estructura de un nico objeto se obtiene al modificar di-


rectamente ste.
2. La modificacin de la estructura de los nuevos objetos a crear se lleva a cabo
mediante la modificacin del prototipo utilizado.
3. La modificacin del comportamiento de todos los objetos de un grupo, se ob-
tiene mediante la manipulacin del objeto trait correspondiente.
4. La modificacin de los nuevos objetos a crear, o de nicamente uno de los exis-
tentes, se puede alcanzar mediante la clonacin del objeto de comportamiento
seleccionado y su posterior modificacin.
En este modelo, es el programador el que lleva el peso de agrupar los objetos por
comportamiento y estructura; de este modo tambin puede identificar lo que realmente
desea modificar (el grupo, uno en concreto o los sucesivos).

8.3 Conclusiones
En funcin de la clasificacin establecida al comienzo de este captulo, veamos
cmo los modelos computacionales orientados a objetos podan utilizar clases o simple-
mente objetos. Como veamos en el punto anterior, la utilizacin del modelo computacio-
nal basado en prototipos aporta un conjunto de ventajas. Sin embargo, los lenguajes que
utilizan clases tambin poseen virtudes:
El nivel de abstraccin ofrecido por las clases es ms elevado, permitiendo ex-
presar al programador un modelo ms cercano al problema a resolver.
La agrupacin obligada de objetos mediante la definicin de clases exige al pro-
gramador la divisin de las aplicaciones a desarrollar en abstracciones a mode-
lar.
La definicin de los tipos de objetos mediante sus clases permite detectar en
tiempo de compilacin errores de tipo, reduciendo as del nmero de errores a
producidos en tiempo de ejecucin y facilitando la labor del desarrollador.
En funcin del estudio realizado de ambos modelos, podemos afirmar como con-
clusin que los sistemas basados en clases estn ms orientados a la programacin, mien-
tras que la utilizacin de prototipos est ms acorde con el desarrollo de una plataforma
computacional. Como ejemplo pragmtico de esto, podemos mencionar cmo determina-
dos lenguajes basados en clases, como Java o Python, traducen su semntica de programa-
cin basada en clases a un modelo computacional de objetos, en su fase de ejecucin.

128
CAPTULO 9:
ARQUITECTURA DEL SISTEMA

Una vez descritos todos los objetivos y requisitos a conseguir, estudiado los distin-
tos sistemas y tcnicas existentes en la consecucin de stos, y evaluadas las aportaciones y
carencias de los mismos, describiremos la arquitectura general del sistema innovador pro-
puesto en esta tesis, analizando brevemente su estructura y los objetivos generales a cum-
plir por cada uno de sus elementos.
Profundizaremos en captulos posteriores en la descripcin de cada uno de los ele-
mentos del sistema, as como en la justificacin de las tcnicas seleccionadas y el cumpli-
miento de los objetivos marcados.

9.1 Capas del Sistema


El sistema est dividido en tres capas o elementos bien diferenciados, que pueden
apreciarse en la siguiente figura:

129
CAPTULO 9

Sistema Reflectivo
No Restrictivo
Aplicacin Aplicacin
en B en A
ejecucin
modificacin modificacin

Especificacin Intrprete Especificacin


Lenguaje B Genrico Lenguaje A

utilizacin utilizacin

Funcionalidades Funcionalidades
de Distribucin de Persistencia

Entorno de Programacin ejecucin


ejecucin

Mquina Abstracta

Figura 9.1: Arquitectura del sistema.

9.1.1 Mquina Abstracta


El motor computacional del sistema es la implementacin de una mquina abstracta
mquina virtual. Todo el cdigo ejecutado por sta es portable y, por tanto, independiente
de la plataforma fsica empleada.
Posteriormente ahondaremos en las ventajas de codificar el sistema sobre una m-
quina abstracta ( 9.3) y en la arquitectura y diseo de sta (captulo 10 y captulo 12), mas
la ventaja a destacar en este momento es que todo el sistema comparte el mismo modelo
computacional y ste es independiente de la plataforma.

9.1.2 Entorno de Programacin


Sobre la mquina abstracta se desarrolla un cdigo que facilite la labor del progra-
mador. Este cdigo es portable, independiente del lenguaje (cualquier aplicacin en el sis-
tema, codificada en cualquier lenguaje, puede utilizarlo) e independiente de la plataforma.
La mquina abstracta ha de poseer la caracterstica de ser extensible para, sin nece-
sidad de modificar su implementacin, pueda desarrollarse sobre ella un entorno de pro-
gramacin con funcionalidades de un mayor nivel de abstraccin, como distribucin o per-
sistencia.

9.1.3 Sistema Reflectivo No Restrictivo


Hasta esta tercera y ltima capa, todas las aplicaciones del sistema se desarrollan
sobre el lenguaje nativo de la mquina abstracta. Este lenguaje posee una semntica fija
para sus aplicaciones. Mediante esta capa se otorga independencia del lenguaje al sistema y
flexibilidad dinmica, sin restricciones previas, de los lenguajes a utilizar.

130
Arquitectura del Sistema

Un intrprete genrico toma la especificacin de un lenguaje y ejecuta una aplica-


cin codificada en ste. La aplicacin puede hacer uso del entorno de programacin e in-
teractuar con otras aplicaciones codificadas en otros lenguajes. Adicionalmente podr mo-
dificar la especificacin del lenguaje utilizado, reflejndose estos cambios en la adaptacin
de la semntica de la propia aplicacin, de forma instantnea.

9.2 nico Modelo Computacional de Objetos


Adicionalmente al conjunto de requisitos obtenidos por la utilizacin de una m-
quina abstracta vase el captulo 16, la utilizacin de sta est justificada por la seleccin
de un nico modelo computacional de objetos, cualesquiera sean el lenguaje y plataforma
seleccionados.
La idea es que todo el cdigo se ejecute sobre el modelo de objetos soportado por
la mquina virtual35, y que las aplicaciones puedan interactuar entre s independientemente
de su lenguaje de programacin. La codificacin del entorno de programacin sobre el
lenguaje propio de la mquina, facilita la utilizacin de ste sin dependencia alguna del len-
guaje a utilizar.
Una de las tareas a llevar a cabo por el intrprete genrico del sistema reflectivo es
traducir las aplicaciones codificadas mediante un lenguaje de programacin, a su corres-
pondencia en el modelo computacional de la mquina abstracta. Una vez este proceso haya
sido llevado a cabo, la aplicacin podr interaccionar con el resto del sistema como si
hubiese sido codificada sobre su lenguaje nativo.

35
Para saber ms acerca del modelo computacional de objetos utilizado por la mquina abstracta, as
como la justificacin de su eleccin, consltese el captulo 10.

131
CAPTULO 9

Aplicacin en el Aplicacin en el
Lenguaje B Entorno Computacional Lenguaje A
de la Mquina Abstracta
Intrprete Genrico

Traduccin Traduccin

Aplicacin B
Aplicacin A

Interaccin entre las


distintas aplicaciones

Entorno de
computacin

Objetos
primitivos

Mquina
Abstracta

Figura 9.2: Interaccin entre distintos objetos de un mismo espacio computacional.

Como se muestra en la figura anterior, la mquina abstracta parte de un conjunto


mnimo de objetos primitivos funcionalidad bsica; la reduccin del conjunto de stos
facilita su portabilidad. Haciendo uso de la extensibilidad de esta plataforma virtual, se de-
sarrolla cdigo que eleva el nivel de abstraccin en la programacin de la plataforma
entorno de programacin, facilitando la tarea del programador.
El programador elige un lenguaje de programacin y, en la interpretacin de ste, su
modelo es traducido al propio de la plataforma abstracta. Con el nico modelo de objetos
existente, la interaccin de aplicaciones es directa, reutilizando en todo momento las fun-
cionalidades desarrolladas, indistintamente del lenguaje de programacin utilizado.
El resultado es un nico espacio computacional de interaccin de objetos que ofre-
cen sus servicios al resto del sistema. La procedencia de cada uno de ellos es intrascenden-
te, puesto que la mquina computa stos de modo uniforme.

9.3 Mquina Abstracta


La mquina abstracta supone el motor computacional del conjunto del sistema. La
migracin de ste a una plataforma pasa por la recompilacin de su implementacin para el
nuevo sistema nativo. El modelo computacional de objetos definido por sta representar
el propio del sistema y la forma en la que las distintas aplicaciones interacten entre s.
stos son los objetivos generales a alcanzar:

132
Arquitectura del Sistema

9.3.1 Conjunto Reducido de Primitivas


La mquina abstracta ha de poder implantarse en entornos heterogneos. Cualquier
sistema computacional, por reducido que ste sea, deber ser capaz de instalar una imple-
mentacin. La reduccin del nmero de primitivas computacionales facilita su implantacin
en plataformas heterogneas.
El diseo de una plataforma de computacin reducida facilita la migracin del sis-
tema. Si el cdigo de la mquina es portable, la portabilidad total del sistema se reduce a la
implantacin de la mquina en distintas plataformas. Por lo tanto, la reduccin de su tama-
o minimiza el esfuerzo para llevar a cabo nuevas implantaciones.

9.3.2 Mecanismo de Extensibilidad


Dado que el nmero de primitivas computacionales de la mquina abstracta debe
ser lo ms reducido posible, el lenguaje de programacin poseer un bajo nivel de abstrac-
cin. Para ofrecer al programador de aplicaciones un mayor conjunto de funcionalidades y
un mayor nivel de abstraccin, es necesario que la mquina abstracta posea un mecanismo
de extensibilidad.
Un problema tpico en la creacin de mquinas abstractas es la ampliacin de sus
funcionalidades mediante la inclusin de instrucciones, aumentando as la funcionalidad e
implementacin de sta. Un ejemplo es el desarrollo de la mquina abstracta del sistema
integral orientado a objetos Oviedo3 [lvarez97]. Inicialmente ofreca las caractersticas
propias de una plataforma orientada a objetos pura. Posteriormente, distintas versiones
fueron implementndose aadiendo caractersticas de persistencia [Ortin97], seguridad
mediante capacidades [Daz2000], planificadores genricos de tareas [Tajes2000] y un sis-
tema de distribucin [lvarez2000].
La existencia de mltiples versiones de implementaciones de la mquina abstracta,
la prdida de portabilidad de su cdigo, la complejidad de implementar una nica mquina
virtual con el conjunto total de sus caractersticas, y la prdida de sencillez en su implemen-
tacin para poder implantarla en entornos heterogneos, son los resultados de seguir este
diseo errneo.
La ampliacin de la abstraccin del sistema ha de codificarse en el propio lenguaje
de programacin de la mquina, a partir de sus primitivas computacionales. El hecho de
que ste sea cdigo propio de la mquina, hace que sea portable a cualquier plataforma. El
resultado es una mquina virtual de sencilla implementacin y, sobre ella, un cdigo porta-
ble que amplia el nivel de abstraccin para el programador, cualquiera que sea la plataforma
existente.

133
CAPTULO 9

Aplicacin
de Usuario

Utilizacin de Funcionalidades

Entorno de
computacin

Extensin de Funcionalidades

Mquina
Primitivas Abstracta

Figura 9.3: Extensibilidad de las funcionalidades primitivas de la mquina abstracta.

Para que lo propuesto pueda llevarse a cabo sin necesidad de modificar la imple-
mentacin de la mquina abstracta, es necesario que sta posea un mecanismo de extensibi-
lidad. Un ejemplo de esta extensin del nivel de abstraccin, es la codificacin de la segun-
da capa de este sistema: el entorno de programacin.

9.3.3 Seleccin del Modelo Computacional


El nivel de abstraccin proporcionado por la mquina abstracta es propio del mo-
delo computacional utilizado por todo el sistema. La seleccin del correcto nivel de abs-
traccin que ofrezca el modelo de computacin es una tarea difcil: un bajo nivel de abs-
traccin hace ms compleja la interoperabilidad de aplicaciones, mientras que si ste es
demasiado elevado, podr suponer que plataforma sea dependiente del lenguaje.
El modelo a elegir ha de permitir representar la computacin de cualquier lenguaje
de programacin, ser sencillo para poder ser implementada su computacin de un modo
reducido, y no su suponer un cambio de expresividad elevado para que puedan interactuar
entre s las aplicaciones codificadas en distintos lenguajes de un modo natural.

9.3.4 Interaccin Directa entre Aplicaciones


Puesto que el objetivo de esta tesis es conseguir un entorno de programacin de
aplicaciones flexible, que permita su interaccin indistintamente del lenguaje de programa-
cin elegido para desarrollarlas, el motor computacional del mismo la mquina abstracta
ha de facilitar la comunicacin entre ellas.
Si tomamos por ejemplo la mquina virtual de Java [Sun95], cada aplicacin que se
ejecuta necesita un proceso con la ejecucin de la mquina virtual que interprete este cdi-
go, suponiendo as la interaccin entre estas aplicaciones una comunicacin entre dos pro-
cesos distintos dentro del sistema operativo existente. Mecanismos adicionales como el uso
de sockets o RPCs (Remote Procedure Calls), son comnmente utilizados en la intercomunica-
cin de estos procesos.

134
Arquitectura del Sistema

Nuestra mquina abstracta deber ser capaz de ejecutar aplicaciones en paralelo, fa-
cilitando la intercomunicacin entre stas, y estableciendo un espacio de nombres nico en
el que el paso de mensajes entre las distintas aplicaciones sea similar a la invocacin de m-
todos de un objeto del mismo programa.

9.3.5 Evaluacin Dinmica de Datos como Cdigo


Esta caracterstica es utilizada en la implementacin de la tercera capa del sistema;
supone la posibilidad de crear y modificar dinmicamente una informacin datos, y
hacer posteriormente que la mquina abstracta los interprete como computacin cdigo.
Si, como mencionbamos en 6.1, el hecho de representar el comportamiento co-
mo datos manipulables por un proceso se define como cosificacin, el proceso contrario
en el que stos se evalan, puede definirse como descosificacin. Ejemplos de esta carac-
terstica en lenguajes de programacin conocidos son la posibilidad de evaluar una lista
como cdigo mediante la funcin eval de Lisp [Steele90], o la funcin exec de Python
[Rossum2001] tomando cadenas de caracteres.
Esta peculiaridad de la mquina es utilizada por el intrprete genrico de la capa del
sistema reflectivo. Como se muestra en la Figura 9.1, una aplicacin deber ser capaz de
modificar la especificacin de su lenguaje. Para ello, generar dinmicamente un cdigo
evaluable por la mquina no por el intrprete que, al ejecutarse en el entorno de sta,
podr modificar la especificacin del lenguaje existente en el mismo nivel computacional.
Este sistema ser detallado en el captulo 11.

9.4 Entorno de Programacin


Respecto al software flexible desarrollado sobre la plataforma abstracta, enfocado a
elevar el nivel de abstraccin del sistema, debe ser desarrollado siguiendo un conjunto de
objetivos bsicos. Enunciaremos stos para posteriormente estudiar su diseo en el
captulo 10.

9.4.1 Portabilidad e Independencia del Lenguaje


La codificacin del entorno de programacin ha de ser independiente de toda plata-
forma fsica y lenguaje de programacin. Para codificar una nica vez ste e instalarlo en
cualquier sistema, el cdigo no deber tener dependencia alguna de la plataforma fsica
donde se implante. Del mismo modo, cualquier aplicacin desarrollada sobre cualquier
lenguaje, deber poder utilizar los servicios ofertados por este cdigo; no deber existir
restriccin alguna al respecto.
La nica tarea a tener en cuenta a la hora de implantar el entorno de programacin
en una plataforma, es la seleccin del subconjunto de funcionalidades que deseemos insta-
lar. En funcin de las necesidades del sistema, de su potencia de cmputo y de la memoria
disponible, el sistema demandar una parte o la totalidad de las funcionalidades del entorno
de programacin.

9.4.2 Adaptabilidad
Puesto que el objetivo principal de esta tesis es el desarrollo de un sistema compu-
tacional flexible, la adaptabilidad de sus funcionalidades es una caracterstica primordial. El

135
CAPTULO 9

entorno de programacin deber aumentar el nivel de abstraccin del sistema, ofreciendo


nuevas funcionalidades; sin embargo, es importante que stas sean adaptables.
Si el entorno de programacin ofrece funcionalidades de persistencia, stas debern
ser flexibles respecto al entorno fsico utilizado para almacenar los objetos. Adems, si el
programador deseare introducir su propio sistema de persistencia, su diseo debera estar
enfocado a minimizar el nmero de pasos necesarios para implantarlo.
La adaptabilidad tambin ha de aplicarse a las primitivas de la mquina abstracta. Si
codificamos todo el software utilizando estas primitivas, las aplicaciones perdern adaptabi-
lidad al ser variables de computaciones constantes la semntica de las primitivas se man-
tiene invariable. Sin embargo, del mismo modo que fue diseada la imagen computacional
de Smalltalk [Ingalls78], la semntica de las primitivas pueden extenderse con nuevas ruti-
nas adaptables36. Si se programa haciendo uso de las segundas, el cdigo generado podr
adaptar su funcionalidad modificando la extensin de las primitivas.
El objetivo buscado es que la totalidad de las funcionalidades ofrecidas por esta ca-
pa del sistema sean adaptables a las distintas necesidades de los programadores.

9.4.3 Introspeccin
La implantacin del entorno de programacin en sistemas computacionales hetero-
gneos requiere el conocimiento dinmico del subconjunto de funcionalidades instaladas en
cada plataforma. Si una plataforma no ofrece las caractersticas de persistencia por limita-
ciones de espacio, el cdigo de usuario deber tener la posibilidad de consultar si esta fun-
cionalidad ha sido implantada, antes de hacer uso de ella.
El objetivo de desarrollo del sistema en entornos heterogneos, y la posibilidad de
crear aplicaciones en el conjunto de plataformas existentes como si de un nico ordenador
se tratase, requiere la existencia de un mecanismo que permita analizar y conocer un siste-
ma desde s mismo introspeccin.

9.5 Sistema Reflectivo No Restrictivo


En el anlisis de cualquier sistema reflectivo, siempre se ha de tener en cuenta el
debate Hamiltonians versus Jeffersonians [Foote92] que expresbamos en 6.4. Por un lado
est la flexibilidad otorgada al programador para hacer sus aplicaciones lo ms adaptables y
extensibles posible Jeffersonians; por otro lado, la posibilidad de modificar indefinidamente
el sistema puede conllevar a estados incoherentes de computacin y semnticas ininteligi-
bles [Foote90] Hamiltonians.
Nuestro principal objetivo es desarrollar un estudio para la creacin de un sistema
flexible con un elevado grado de adaptabilidad. Por esta razn, nos centraremos en la ver-
tiente Jeffersoniana, tratando de encontrar el mayor nivel de adaptabilidad posible. Una vez
obtenido ste, podra disearse un sistema de seguridad encargado de controlar el nivel de
reflexin permitido a cada uno de los usuarios. Sin embargo, este propsito queda fuera de
los objetivos marcados dentro de esta tesis.
A continuacin analizaremos los puntos ms significativos de esta capa del sistema.

36
En Smalltalk, para acceder a un atributo indexado de un objeto la primitiva a utilizar es basicAt. Sin
embargo, su utilizacin es desaconsejada frente al mensaje at [Mevel87]; este segundo mtodo se im-
plementa haciendo uso de la primitiva, teniendo en cuenta la jerarqua objetos establecida por la relacin
de herencia.

136
Arquitectura del Sistema

9.5.1 Caractersticas Adaptables


Basndose en la clasificacin de adaptabilidad descrita en 6.3, deber otorgarse al
sistema las siguientes caractersticas de adaptabilidad:
1. Conocimiento dinmico del entorno. El conjunto del sistema ha de ser intros-
pectivo, ofreciendo la posibilidad de conocer su estado y descripcin dinmi-
camente.
2. Acceso y modificacin de su estructura. La estructura de los objetos existentes
deber ser manipulable en tiempo de ejecucin, para conseguir adaptabilidad es-
tructural dinmica.
3. Semntica computacional. La semntica computacional del sistema deber po-
der conocerse, modificarse y ampliarse. De esta forma, una aplicacin en ejecu-
cin podr ser adaptada sin necesidad de modificar su cdigo fuente ni finalizar
su ejecucin.
4. Configuracin del lenguaje de programacin. Cualquier aplicacin deber ser
capaz de modificar su propio lenguaje de programacin para amoldarlo a sus
necesidades especficas de expresividad.
Como estudiamos en el captulo 7, no existe sistema alguno dotado de la capacidad
de ser adaptable en todas estas caractersticas.

9.5.2 Independencia del Lenguaje


Para esta capa del sistema, las aplicaciones debern constituir procesos computa-
cionales susceptibles de interactuar con el resto de aplicaciones existentes, sin que el
lenguaje de programacin sea una variable adicional del programa. Mediante algn
mecanismo de implementacin, el programador deber ser capaz de desarrollar
aplicaciones o fracciones de aplicaciones en el lenguaje que l desee, sin que ello restrinja
el modo en el que se interacte con el resto del sistema.
La programacin de aplicaciones no deber verse limitada a los lenguajes de pro-
gramacin ms conocidos; el sistema deber constituir un entorno de desarrollo e interac-
cin de lenguajes de propsito especfico.
Deber contemplarse la posibilidad de que la propia aplicacin describa su lenguaje
hacindola autosuficiente para su ejecucin, permitiendo el desarrollo de aplicaciones que
realmente expresen computacin por s solas no exista dependencia de la implementacin
de un intrprete del lenguaje empleado.

9.5.3 Grado de Flexibilidad de la Semntica Computacional


Como hemos definido en 9.5.1, una de las caractersticas a hacer adaptable en
nuestro sistema es su semntica computacional. Esta faceta implica la posibilidad de adap-
tar dinmicamente una aplicacin, sin necesidad de modificar su cdigo fuente.
El modo en el que expresamos la semntica de un lenguaje es mediante otro
lenguaje de especificacin de semnticas [Mosses92]. Si accedemos y modificamos la
semntica del lenguaje de programacin, lo haremos mediante el lenguaje de especificacin
de semnticas. Podemos observar pues, como ste es un concepto recursivo: cmo
definimos la semntica del lenguaje de especificacin de semnticas?

137
CAPTULO 9

La flexibilidad de modificar la semntica de un lenguaje puede pasar por modificar,


a su vez, la semntica del lenguaje de especificacin de su semntica. La pregunta que de-
bemos hacernos es si esta facultad es o no realmente necesaria para la consecucin de los
requisitos de nuestro sistema.
Tras el estudio en 7.5 de los sistemas que permiten modificar la semntica de
cualquier lenguaje de un modo recursivo en infinitos niveles (intrpretes metacirculares),
concluimos las siguientes afirmaciones:
La posibilidad de modificar la semntica de semnticas en un grado indefinido
puede llevar a la prdida del conocimiento de la semntica real existente en el
sistema no conoceremos el comportamiento real de la ejecucin de una ins-
truccin.
Los beneficios aportados por la utilizacin de elevar la flexibilidad a ms de un
nivel computacional son muy limitados [Foote90].
La mayora de los sistemas limitan el espectro de la semntica computacional a
flexibilizar, es decir, no son capaces de modificar la totalidad de su comporta-
miento.
Aproximacin Vertical

Infinitos niveles
computacionales

Intrprete Semntica
Utiliza Semntica
Semntica
Semntica
Aproximacin Horizontal
Semntica
Lenguaje
Adapta Utiliza Semntica
Ejecuta Intrprete
Lenguaje

Semntica Ejecuta
Intrprete Utiliza
Semntica Semntica
Lenguaje Aplicacin
Adapta
Adapta
Ejecuta Adaptabilidad
total de la
Intrprete Utiliza Semntica semntica
Lenguaje
Ejecuta
Adaptabilidad
Aplicacin de una parte
Adapta de la semntica

Figura 9.4: Distintas aproximaciones en la consecucin de adaptabilidad en la semntica del siste-


ma.

En funcin del resumen del estudio realizado en este punto, y buscando la mayor
flexibilidad computacional de nuestro sistema, limitaremos la modificacin de la semntica
computacional a un nivel dos grados de altura, pero obligando a que sta permita modi-
ficar la totalidad de sus computaciones grado de anchura ilimitado.

9.5.4 Adaptabilidad No Restrictiva


En el anlisis efectuado en el punto anterior, requeramos la necesidad de modificar
la semntica de cualquier faceta computacional del sistema. Para este punto, se demanda
que el mecanismo de modificacin de la semntica no imponga restricciones previas la eje-
cucin de dichas modificaciones.

138
Arquitectura del Sistema

Existen sistemas que permiten modificar cualquier semntica computacional, esta-


bleciendo previamente el protocolo de acceso a ellas ( 7.4.1). Si para una aplicacin, una
vez codificada y ejecutada, se desea modificar algn aspecto no previsto con anterioridad,
su adaptacin dinmica no ser factible. En este tipo de sistemas no es posible desarrollar
aplicaciones adaptables a contextos desconocidos en fase de desarrollo. Su flexibilidad est
condicionada al conocimiento de a qu deber adaptarse previamente a su ejecucin.
La adaptabilidad de nuestro sistema no deber necesitar el conocimiento previo de
aquello que sea susceptible de ser modificado. Deber desarrollar un mecanismo de flexibi-
lidad no restrictivo, en el que cualquier caracterstica podr ser adaptada sin necesidad de
estimarlo previamente.

139
CAPTULO 10:
ARQUITECTURA DE LA MQUINA ABSTRACTA

Partiendo de los requisitos impuestos en el captulo 2 y los objetivos globales de es-


ta tesis, analizaremos las alternativas estudiadas en la seccin del estado del arte y, basndo-
nos en su evaluacin, adoptaremos los criterios de diseo generales (arquitectura) en la
construccin de la mquina abstracta.
Fundamentalmente, los principales objetivos a obtener en el diseo de la platafor-
ma, se pueden reducir a los siguientes: portabilidad, heterogeneidad, extensibilidad y adap-
tabilidad. Centrndonos en estos pilares, describiremos su arquitectura para posteriormen-
te, en el captulo 12, presentar su diseo.
En el apndice A se describe finalmente un diseo para la implementacin de una
mquina virtual acorde a la mquina abstracta descrita. Se debe recordar la diferencia exis-
tente entre mquina abstracta y virtual, descrita en captulo 3: una mquina virtual es un
intrprete software de la especificacin de una mquina abstracta.

10.1 Caractersticas Principales de la Mquina Abstracta


En este apartado, enunciaremos los requisitos de la mquina abstracta, evaluaremos
posibles alternativas, y justificaremos y explicaremos la solucin a emplear.

10.1.1 Reduccin de Primitivas Computacionales


Buscando la portabilidad global del sistema y la implantacin de ste en entornos
computacionales heterogneos, el nmero de primitivas de la plataforma deber reducirse
al mnimo. Seleccionando la cantidad mnima de primitivas a implementar por la mquina,
obtenemos dos beneficios:
1. La implantacin de sta en mltiples plataformas, al ser reducida la implemen-
tacin de su mquina virtual, se llevar a cabo de un modo sencillo, obteniendo
as una elevada portabilidad.
2. Su tamao reducido implica la posibilidad de implantacin en sistemas compu-
tacionales de capacidad restringida; tanto en dispositivos fsicos de capacidad

141
CAPTULO 10

limitada de cmputo, como en otras aplicaciones que deseen interpretar su len-


guaje37.
La obtencin de los dos beneficios anteriores producidos al reducir las operaciones
primitivas de nuestro sistema de computacin, qued demostrada empricamente en el de-
sarrollo de los sistemas operativos basados en microncleo, estudiados en 5.6.
En el diseo de la mquina abstracta distinguiremos entre dos tipos distintos de
primitivas, siendo un conjunto de stas variable mientras que el otro se deber mantener
inalterable:
1. Primitivas computacionales. Definen el sistema computacional de la mquina
abstracta. Supone la semntica del lenguaje de la mquina que toda mquina vir-
tual deber implementar. El conjunto de estas primitivas es invariable. Ejemplos
de estas operaciones pueden ser el modo en el que se crea un objeto o se inter-
preta el paso de un mensaje.
2. Primitivas operacionales. Suponen la semntica primitiva de una operacin in-
dependiente del funcionamiento de la mquina. Un ejemplo puede ser la forma
en la que se suman dos enteros o el almacenamiento de un byte en un sistema
persistente.
Este conjunto de primitivas operacionales ha de reducirse al mnimo; sin em-
bargo, en ocasiones puede ser necesaria su ampliacin. Un ejemplo puede ser la
inclusin de nmeros racionales en el lgebra operacional de la mquina. Esta
ampliacin debe llevarse a cabo sin necesidad de modificar la implementacin
de la mquina, de forma que el cdigo existente para nuestra plataforma no
pierda nunca su capacidad de ser ejecutado la mquina virtual no deber sufrir
modificacin alguna.

Op1
Op2
Primitivas
Op3 Operacionales
v.2
Una vez reemplazada Op4
la nueva semntica
operacional, ambas
aplicaciones siguen
siendo vlidas Reemplazamiento
Aplicacin 1 del componente

Acceso
Cdigo
Aplicacin 1 Op1
Fuente Ejecucin Mquina Virtual
Inicial Op2
Primitivas
Primitivas Op3 Operacionales
Computacionales v.1
Cdigo Fuente Op4
Utiliza nueva Ejecucin Acceso
Primitiva Aplicacin 2

Aplicacin 2

Plataforma Fsica
de Ejecucin

Figura 10.1: Ampliacin de la semntica operacional de la mquina virtual sin perder la portabili-
dad de sus aplicaciones.

37
Como ejemplo real podemos tomar la implementacin de la mquina virtual de Java (JVM, Java Vir-
tual Machine) [Lindholm96] como parte de un navegador Web, dedicada a ejecutar cdigo Java descar-
gado dinmicamente de la red.

142
Arquitectura de la Mquina Abstracta

La ampliacin del sistema debe llevarse a cabo sin modificar la interfaz del m-
dulo de primitivas operaciones existente con anterioridad. De este modo, la pla-
taforma es adaptable a cualquier entorno, no existirn distintas versiones del in-
trprete, y las aplicaciones no quedarn desfasadas.

10.1.2 Extensibilidad
El hecho de disear la mquina abstracta con el menor nmero de primitivas posi-
ble ayuda a que sta sea fcilmente implantada en diversas plataformas. Sin embargo, el
bajo nivel de abstraccin de su lenguaje hace complejo el desarrollo de aplicaciones sobre
sta. Un mecanismo de extensibilidad de la plataforma computacional ser necesario para
obtener un mayor nivel de abstraccin.
En el estudio de los sistemas que hacen uso de la introspeccin ( 7.1) y de la
reflectividad estructural ( 7.2), vimos cmo ambos conceptos pueden ser utilizados para
implementar sistemas extensibles. En concreto, en el caso de los sistemas Smalltalk, Self y
ObjVlisp, esta extensibilidad se ha empleado en la creacin de entornos computacionales
diseados sobre mquinas abstractas.
Mediante introspeccin, podremos conocer dinmicamente la estructura dinmica
de un objeto (sus mtodos, atributos y el nmero de veces que es referenciado por otros
objetos, por ejemplo). Haciendo uso de esta informacin, se podr desarrollar un sistema
de persistencia, un tratamiento de excepciones, o incluso un recolector de basura, gracias al
conocimiento estructural de cada objeto.
En el caso de haber implementado un sistema de persistencia o un sistema de dis-
tribucin con movilidad de objetos, la reflectividad estructural puede ser utilizada para
crear dinmicamente un objeto y aadirle sus atributos y mtodos oportunos. El desarrollo
de estas funcionalidades eleva el nivel de abstraccin computacional existente inicialmente
significando la extensin del mismo.
El hecho de implementar un entorno de programacin haciendo uso del propio
lenguaje de la mquina y de su facultad extensiva, implica que la totalidad del cdigo de
dicho entorno ser independiente de la plataforma, y que no ser necesario modificar la
implementacin de la mquina virtual dando lugar a distintas versiones se perdera as la
posibilidad de ejecutar cdigo de versiones anteriores.

10.1.3 Definicin del Modelo Computacional


La seleccin correcta del modelo computacional a seguir por la mquina abstracta
es una tarea compleja. Por un lado, ha de ser lo suficientemente sencilla como para satisfa-
cer el criterio de reducir al mnimo su nmero de primitivas computacionales ( 10.1.1); por
el otro, deber ofrecer un nivel de abstraccin que permita la interaccin entre aplicaciones
de un modo sencillo, independientemente del lenguaje de programacin seleccionado por
el programador.
Los modelos computacionales orientados a objetos estn siendo ampliamente utili-
zados en la actualidad. Sin embargo, la implementacin del conjunto global de sus caracte-
rsticas [Booch94] supondra que la mquina virtual poseyese un tamao demasiado elevado
para implantarlo en plataformas con poca capacidad de procesamiento. Tomando el mode-
lo de objetos de Smalltalk y reducindolo computacionalmente, se cre un modelo de obje-
tos ms limitado basado en el concepto de prototipo (captulo 8). Este modelo de objetos
era ms sencillo de implementar y, lo ms importante, no perda expresividad frente al mo-

143
CAPTULO 10

delo basado en clases: todo lo representable en un lenguaje orientado a objetos basado en


clases, se puede expresar mediante el uso de prototipos [Ungar91].
Como explicbamos en el captulo 8, el modelo orientado a objetos basado en pro-
totipos elimina el concepto de clase. Adems de reducirse la semntica de sus operaciones
sin prdida alguna de expresividad, la eliminacin del concepto de clase es til y coherente
en entornos estructuralmente reflectivos. La utilizacin de reflectividad estructural con el
modelo basado en clases produce la aparicin de un problema denominado evolucin de
esquemas (scheme evolution) [Roddick95].
Qu sucede si queremos modificar la estructura de un nico objeto de una clase
sin alterar el resto de sus instancias? Cmo se amoldan los objetos al eliminar, modificar o
aumentar alguno de los atributos de su clase? Existen soluciones de compromiso como la
creacin de clases sombra (shadow classes), implementada por la plataforma reflectiva Me-
taXa ( 7.4), de elevada complejidad de implementacin y resultados poco satisfactorios.
En la utilizacin del modelo de prototipos, estas modificaciones no conllevan a incoheren-
cias en el lenguaje de programacin vase el captulo 8.
Conocidos lenguajes de programacin, como Smalltalk, Java y Python, utilizan este
modelo computacional en tiempo de ejecucin. Aunque en tiempo de diseo exista el con-
cepto de clase, ste es traducido en la ejecucin de la aplicacin al de objeto, convirtindose
as toda clase en un objeto.
La eleccin del modelo computacional orientado a objetos basado en prototipos
para la mquina abstracta, y por tanto para el conjunto del sistema, se justifica por varias
razones:
1. El modelo computacional es ms sencillo que el basado en clases.
2. Existe una traduccin directa y evidente del modelo de clases al de prototipos,
utilizado por la mayora de los lenguajes actuales vase el captulo 8.
3. La utilizacin del modelo no supone prdida de expresividad alguna.
4. Se amolda mejor a un esquema computacional estructuralmente reflectivo.

10.1.4 Adaptabilidad
Los sistemas operativos basados en microncleo ( 5.6) obtienen una adaptabilidad
de sus servicios, que ofrecen mediante la definicin de una interfaz para cada tipo de servi-
cio. Cualquier rutina que implemente las operaciones definidas por la interfaz, puede for-
mar parte del sistema operativo y sustituir a otro ya existente, obtenindose as un grado de
adaptabilidad respecto a sus servicios.
La idea de separar el ncleo computacional de los mayores niveles de abstraccin es
adoptada en nuestro sistema, separando la implementacin de la mquina virtual de la codi-
ficacin del entorno de programacin. Sin embargo, la especificacin previa de las interfa-
ces de los distintos servicios, limita el nmero y tipo de servicios que pueden implantarse
en nuestra plataforma entorno de programacin.
La introspeccin y reflectividad estructural de nuestra mquina, sern utilizadas
tambin como mecanismos de adaptabilidad. En un entorno de computacin heterogneo,
una aplicacin puede hacer uso de la introspeccin para conocer los servicios existentes en
la plataforma existente. En funcin de los servicios existentes, podr llevar a cabo una fun-
cionalidad u otra, adaptndose as al contexto de ejecucin presente.

144
Arquitectura de la Mquina Abstracta

Haciendo uso de la reflectividad estructural ofrecida, la estructura de un objeto que


ofrezca un determinado tipo de servicio podr modificarse para derogar dicha funcionali-
dad en otros, sin necesidad de establecer previamente la interfaz de funcionamiento como
sucede en los sistemas basados en microncleo.
Siguiendo con los criterios reflectivos de diseo del proyecto Merlin [Assump-
cao95] desarrollado sobre el lenguaje Self, los objetos primitivos se extienden con la im-
plementacin de nuevos objetos en el mismo lenguaje. La totalidad del sistema ser codifi-
cado utilizando estos nuevos objetos. Si queremos modificar el significado de una de sus
primitivas, modificamos la estructura del objeto alguno de sus mtodos, o bien lo susti-
tuimos por otro nuevo. De esta forma, todo el software es adaptable dinmicamente al no
utilizar de forma directa las funcionalidades de los objetos primitivos.
Como ejemplo de lo comentado en el prrafo anterior, podemos codificar un obje-
to encargado de crear objetos haciendo uso de la primitiva existente para esto. Todo el
entorno de programacin se codificar haciendo uso de este nuevo objeto. Si se desea im-
plementar un sistema de persistencia, podr modificarse la funcionalidad de ste para hacer
que la creacin de dichos objetos implique su escritura en disco.
Otro modo de utilizar la reflectividad estructural para el desarrollo de aplicaciones
adaptables es mediante la codificacin de stas en funcin de la estructura de sus objetos.
La informacin de alta de elementos en una base de datos del men de una aplicacin, po-
dr adaptarse dinmicamente haciendo uso de esta capacidad.

10.1.5 Interaccin Directa entre Aplicaciones


La adaptabilidad del sistema ha ofrecerse tanto para una misma aplicacin, como
entre distintas aplicaciones, de forma que la ejecucin de un programa pueda adaptar el
funcionamiento de otro. Del mismo modo, la interaccin entre aplicaciones es requerida
para que la intercomunicacin entre ellas, indiferentemente del lenguaje de programacin
utilizado, sea factible ya que el motor computacional base de todo el sistema es la mquina
abstracta.
El acceso desde una aplicacin a los objetos de otra ha de producirse de igual modo
que el acceso a sus propios objetos, sin necesidad de utilizar una capa intermedia de soft-
ware. En el caso de la mquina virtual de Java [Sun95], la ejecucin de cada aplicacin im-
plica la creacin de una nueva instancia de la mquina que interprete su cdigo. Para inter-
comunicar estos dos procesos, es necesaria una capa software adicional como por ejemplo
RMI (Remote Method Invocation) [Sun97b].
Para minimizar la complejidad en la interaccin de aplicaciones, el diseo de la m-
quina abstracta ha de llevarse a cabo teniendo en cuenta que sta supondr un nico proce-
so en el sistema operativo en el que est hospedada. Las aplicaciones en una misma plata-
forma se ejecutarn en el mismo espacio de direcciones, interaccionando a travs de un
espacio de nombres que tenga en consideracin, para cada objeto, la aplicacin en la que
fue creado.

10.1.6 Manipulacin Dinmica del Comportamiento


La introspeccin y reflectividad estructural de la mquina nos permite conocer y
modificar dinmicamente la estructura de un objeto. En el modelo computacional basado
en prototipos, la estructura de un objeto comprende tanto sus propiedades (atributos) co-
mo sus mtodos. Por lo tanto, para ofrecer conocimiento dinmico real de la estructura de
un objeto, es necesario acceder y manipular su comportamiento.

145
CAPTULO 10

La representacin de la computacin como datos manipulables recibe el nombre de


cosificacin ( 6.1). El hecho de tratar dinmicamente instrucciones como datos, conlleva
la necesidad de que la plataforma computacional implemente un mecanismo de evaluacin
o descosificacin de dicha informacin. La posibilidad de manipular dinmicamente cdigo
como si de datos se tratase supone:
1. La viabilidad de modificacin dinmica del comportamiento de los objetos.
2. El desarrollo de aplicaciones que se adapten a comportamientos imprevisibles
en tiempo de diseo, surgidos cuando sta ya est desarrollada y en ejecucin.
3. La factibilidad de depurar, modificar y ampliar una aplicacin en ejecucin,
puesto que se puede especificar dinmicamente la creacin y modificacin de
nuevos comportamientos.
Vemos cmo esta caracterstica impuesta a la mquina abstracta est enfocada hacia
la obtencin de un sistema computacional ms flexible.

10.2 Tcnicas de Diseo Seleccionadas


Como hemos justificado en este captulo, el diseo de la mquina abstracta, raz
computacional del conjunto del sistema, deber disearse siguiendo los siguientes criterios:
1. Ha de reducirse al mnimo el nmero de primitivas computacionales y opera-
cionales.
2. La implementacin de las primitivas operacionales ha de separarse de las com-
putacionales, siguiendo un mecanismo que permita al usuario extenderlas, sin
modificar la implementacin de la mquina virtual existente.
3. El sistema computacional deber ofrecer funcionalidades introspectivas.
4. La reflectividad estructural permitir al usuario modificar los atributos y mto-
dos existentes para cada objeto.
5. El sistema computacional seguir un modelo orientado a objetos, basado en
prototipos.
6. La ejecucin de cada una de las aplicaciones en una misma plataforma fsica se
llevar a cabo en el mismo espacio de direcciones, y la interaccin entre objetos
de distintas aplicaciones se producir sin ninguna capa software adicional.
7. Deber permitirse el tratamiento del comportamiento de cada objeto como si
de datos se tratase, implementndose un mecanismo de evaluacin o descosifi-
cacin de datos dinmico.

146
CAPTULO 11:
ARQUITECTURA DEL SISTEMA REFLECTIVO NO
RESTRICTIVO

A raz de la estructuracin de nuestro sistema en capas, presentada en el captulo 9,


estudiaremos en este ttulo la arquitectura de la tercera y ltima que representaba un siste-
ma computacional adaptable sin restriccin alguna, independiente del lenguaje.
La arquitectura presentada deber cumplir todos los objetivos generales impuestos
en el captulo 9, analizando y justificando la utilizacin de las tcnicas existentes descritas
en captulos anteriores, y definiendo el esquema general del funcionamiento del sistema
sin entrar en consideraciones propias de diseo (captulo 14).
Puesto que el desarrollo de esta ltima capa del sistema se llevar a cabo sobre el
sistema computacional descrito por la mquina abstracta, la arquitectura propuesta deman-
dar unos requisitos computacionales a la plataforma base. Finalmente, enunciaremos estos
requisitos que debern satisfacerse en el diseo de la primera capa.

11.1 Anlisis de Tcnicas de Obtencin de Sistemas Flexibles


En el captulo 5 estudiamos un conjunto de distintas tcnicas utilizadas por sistemas
para obtener distintos grados de flexibilidad computacional. Por el contrario, en el captulo
7 todos los casos analizados utilizaban la misma idea para conseguir adaptabilidad: reflecti-
vidad. Analizaremos las aportaciones de estos dos grupos de sistemas.

11.1.1 Sistemas Flexibles No Reflectivos


Exceptuando los sistemas operativos basados en microncleo, el conjunto de
aproximaciones descritas en el captulo 5 poseen un tratamiento esttico de las aplicaciones,
buscando siempre la separacin de incumbencias o aspectos. En el conjunto de mtodos
existentes, se desarrolla por un lado la funcionalidad central de una aplicacin y por otro se
especifican aspectos como por ejemplo persistencia, distribucin o planificacin de hilos.
Se trata de separar el cdigo funcional de cada aplicacin de las incumbencias propias de
mltiples aplicaciones, susceptibles de ser reutilizadas.
El resultado es el desarrollo de software reutilizable y flexible respecto a un conjun-
to de aspectos carentes de dinamicidad. Estas tcnicas estn demasiado enfocadas a la crea-

147
CAPTULO 11

cin de software susceptible de ser adaptado por diversas incumbencias, careciendo de la


posibilidad de crear aplicaciones flexibles en tiempo de ejecucin.
Si tomamos, por ejemplo, la tcnica de desarrollo de aplicaciones orientadas a as-
pectos, observamos que es necesario desarrollar la funcionalidad de la aplicacin por un
lado, y por otro definir los aspectos reutilizables a cualquier aplicacin por ejemplo, los
aspectos persistencia y optimizacin en velocidad. Una vez creadas las distintas partes
de la aplicacin, se crea el cdigo final de sta mediante el tejedor de aspectos (aspect weaver)
traductor de aplicaciones en funcin de los aspectos definidos.
La principal carencia del funcionamiento descrito reside en la imposibilidad de mo-
dificar dinmicamente los aspectos de una aplicacin. De forma aadida, la aplicacin no
puede adaptar su funcionalidad principal en tiempo de ejecucin. Estas limitaciones se de-
ben a la orientacin distinta de objetivos de este tipo de sistemas respecto buscado en esta
tesis: la separacin de incumbencias est ms enmarcada en campos de reutilizacin de
cdigo, ingeniera del software o creacin de un paradigma de programacin, que en la
flexibilidad dinmica.
Como comentaremos en el captulo 15, el sistema reflectivo desarrollado puede ser
utilizado como una plataforma en la que sea factible el conocimiento, seleccin y modifica-
cin dinmica de los distintos aspectos de una aplicacin, sin necesidad de finalizar su eje-
cucin.

11.1.2 Sistemas Reflectivos


La reflectividad supone ms una tcnica de lenguajes de programacin que de inge-
niara del software o desarrollo de aplicaciones. Los lenguajes de programacin reflectivos
permiten modificar o acceder, en un determinado grado, a un conjunto de sus propias ca-
ractersticas o de sus aplicaciones, utilizando para ello distintos mecanismos de implemen-
tacin.
Nos centraremos en una de las clasificaciones de reflectividad identificadas en 6.3:
Cundo se produce el reflejo. Los sistemas reflectivos que son adaptables en tiempo de
compilacin generan las mismas carencias que los que acabamos de analizar ( 11.1.1): limi-
tan su adaptabilidad al momento en el que la aplicacin es creada, careciendo de flexibilidad
dinmica.
Es por tanto necesario centrarse en los sistemas reflectivos adaptables en tiempo de
ejecucin, capaces de ofertar adaptabilidad dinmica mediante el empleo de tcnicas de
procesamiento de lenguajes en la mayora de los casos, mediante intrpretes. Este tipo de
sistemas se distingue de los estticos fundamentalmente en:
Ofrecen la adaptabilidad de las aplicaciones en tiempo de ejecucin.
La adaptabilidad dinmica supone una ralentizacin de la ejecucin de las apli-
caciones al no producirse sta en fase de compilacin.
De algn modo, la flexibilidad dinmica ganada se paga con tiempos de ejecucin
ms elevados.

11.1.2.1 Reflectividad Dinmica


Siguiendo con el estudio desarrollado en el captulo 7 y centrndonos en los objeti-
vos principales de esta tesis ( 1.2), las tcnicas estudiadas ms cercanas a ofrecer la flexibi-
lidad buscada son las reflectivas en tiempo de ejecucin. Dentro de esta clasificacin tene-

148
Arquitectura del Sistema Reflectivo No Restrictivo

mos dos grupos: intrpretes metacirculares y sistemas basados en MOPs (Meta-Object Proto-
cols).
Los intrpretes metacirculares ofrecen una torre infinita [Wand88] de intrpretes re-
flectivos, en el que slo parte de la semntica del sistema es adaptable. Como hemos co-
mentado y justificado en 9.5.3, estos sistemas no ofrecen un grado total de adaptacin
semntica y pueden conllevar a la prdida del conocimiento real de la semntica del siste-
ma, escapndose as de los objetivos marcados.
Los entornos computacionales basados en MOPs limitan el nmero de niveles
computacionales a dos, ofreciendo un protocolo de acceso desde el nivel superior al subya-
cente. Esta idea es similar a la buscada, pero, como se muestra en la Figura 11.1, posee un
conjunto de limitaciones:
Aplicacin de Usuario

MOP
Ejecuta

Metaobjetos

Intrprete
Intrprete

La ampliacin del MOP


o de los metaobjetos
implica una nueva
versin del intrprete

Figura 11.1: Estructura general de un MOP.

1. La especificacin del MOP supone una restriccin a priori. El protocolo debe


contemplar lo que ser adaptable dinmicamente. Esta especificacin a realizar
previamente a la ejecucin de una aplicacin implica que sta no podr adaptar-
se a cualquier requisito surgido dinmicamente ha de estar contemplado en el
protocolo.
2. La expresividad de los metaobjetos es restringida. El modo en el que una carac-
terstica del sistema ofrece su adaptabilidad es mediante el concepto de metaob-
jeto [Kiczales91]: si algo es adaptable, se representar mediante un metaobjeto y
sus mtodos ofrecern la forma en la que puede adaptarse.
3. No existe una expresividad sin restriccin de la adaptabilidad del sistema. Slo
podr adaptarse dinmicamente aquello que posea un metaobjeto, y ste podr
adaptarse tan slo en funcin de los mtodos que ofrezca.
4. Uno de los procesos de desarrollo de MOPs propuesto por Michael Golm
[Golm98] se basa en la ampliacin del protocolo y de los servicios de los me-
taobjetos bajo demanda: si algo no es adaptable, se modifica la especificacin
del protocolo o del metaobjeto y se vuelve a generar la aplicacin.

149
CAPTULO 11

5. El criterio propuesto por Golm elimina la adaptabilidad dinmica sin restriccio-


nes buscada en esta tesis y, adicionalmente, supone la generacin de distintas
versiones del intrprete y por tanto del lenguaje, perdiendo as la portabilidad
del cdigo existente con anterioridad ( 7.4.1).
6. La estructura establecida en los sistemas que utilizan MOPs es siempre depen-
diente de un nico lenguaje de programacin.

11.2 Sistema Computacional Reflectivo Sin Restricciones


Apoyndonos en la definicin de un sistema reflectivo como aqul que puede acce-
der a niveles computacionales inferiores dentro de su torre de interpretacin [Wand88],
hemos justificado en 9.5.3 la necesidad de una altura de dos niveles interpretacin de un
intrprete y una anchura absoluta acceso al metasistema no restrictivo. Esto quiere decir
que slo son necesarios dos niveles de interpretacin, pero que el nivel superior ha de po-
der modificar cualquier caracterstica computacional del nivel subyacente que le da vida.
Recordando los objetivos marcados para esta ltima capa del sistema ( 9.5), pode-
mos abreviar enunciando las principales caractersticas que ha de aportar frente a un siste-
ma basado en un MOP:
1. No debe ser necesario estipular lo que va a adaptarse previamente a la ejecucin
de la aplicacin.
2. Debe existir un mecanismo de expresividad en el que cualquier caracterstica del
sistema pueda adaptarse dinmicamente horizontalidad total.
3. El sistema debe ser totalmente independiente del lenguaje.
4. Los grados de flexibilidad a conseguir son: introspeccin, estructural, semntica
y lenguaje.
El esquema a seguir se muestra en la siguiente figura38:

38
En este apartado slo estudiaremos la funcionalidad de cada una de las partes del esquema. En puntos
sucesivos, profundizaremos acerca de cmo desarrollar stas.

150
Arquitectura del Sistema Reflectivo No Restrictivo

Computacional 1
Introspeccin y Reflectividad Estructural Reflectividad Computacional y Lingstica

Reflectividad Introspeccin y
Aplicacin A Aplicacin B
Nivel

Computacional Reflectividad
y Lingstica Estructural

Tabla de smbolos
Especificacin Lenguaje A Tabla de smbolos Especificacin
de aplicacin A
Nivel Computacional 0

de aplicacin B Lenguaje B
Ejecuta

Accede y Accede
Accede y Accede
modifica
modifica

Intrprete Genrico

Figura 11.2: Esquema general del sistema computacional no restrictivo.

Una de las diferencias frente a los intrpretes convencionales es la creacin de un


intrprete genrico independiente del lenguaje. Este procesador ha de ser capaz de ejecutar
cualquier aplicacin escrita sobre cualquier lenguaje de programacin. De este modo, la
entrada a este programa no se limita, como en la mayora de los intrpretes, a la aplicacin a
ejecutar; est parametrizado adems con la especificacin del lenguaje en el que dicha apli-
cacin haya sido codificada.
Implementando un intrprete genrico en el que las dos entradas son la aplicacin a
procesar y la especificacin del lenguaje en el que sta haya sido escrita, conseguimos hacer
que el sistema computacional sea independiente del lenguaje.
Para cada aplicacin evaluada, el intrprete genrico deber crear un contexto de
ejecucin o tabla de smbolos dinmica, en el que aparezcan todos los objetos39 creados a
raz de ejecutar el programa. Se trata de ubicar todos los objetos creados en el contexto de
ejecucin de la aplicacin en un nico espacio de nombres.
La flexibilidad del sistema se obtiene cuando, en tiempo de ejecucin, la aplicacin
accede a la especificacin de su lenguaje, o bien a su tabla de smbolos existente. El resulta-
do de estos accesos supone distintos grados de flexibilidad:
1. Si analiza, sin modificar, su tabla de smbolos supondr introspeccin.
2. En el caso de modificar los elementos de su tabla de smbolos, la flexibilidad
obtenida es reflectividad estructural.
3. El acceso y modificacin de la semntica propia de la especificacin de su len-
guaje de programacin significar reflectividad computacional.
4. La modificacin de las caractersticas lxicas o sintcticas de su lenguaje produ-
cirn una adaptacin lingstica.

39
El trmino objeto aqu denota cualquier elemento o smbolo existente en el contexto de ejecucin de la
aplicacin. Un objeto puede ser, por tanto, una funcin, variable, clase u objeto propiamente dicho.

151
CAPTULO 11

El modo en el que las aplicaciones de usuario accedan a su tabla de smbolos y a la


especificacin de su lenguaje, no deber poseer restriccin alguna. La horizontalidad de este
acceso ha de ser plena.
Para conseguir lo propuesto, la principal dificultad radica en la separacin de los
dos niveles computacionales mostrados en la Figura 11.2. El nivel computacional de aplica-
cin poseer su propio lenguaje y semntica, mientras que el nivel subyacente que le da
vida el intrprete poseer una semntica y lenguaje no necesariamente similar. El ncleo
de nuestro sistema se centra en un salto computacional del nivel de aplicacin al de inter-
pretacin; cmo puede una aplicacin modificar, sin restriccin alguna, el intrprete que lo
est ejecutando?40

11.2.1 Salto Computacional


La raz computacional de nuestro sistema est soportada por una implementacin,
hardware o software, de nuestra mquina abstracta. Sobre su dominio computacional, se
desarrolla el intrprete genrico independiente del lenguaje de programacin.
La especificacin de cada lenguaje a interpretar se llevar a cabo mediante una es-
tructura de objetos, representativa de su descripcin lxica, sintctica y semntica. Este
grupo de objetos sigue el modelo computacional descrito por la mquina y, por tanto, per-
tenece tambin a su espacio computacional.
En la ejecucin de una aplicacin por un intrprete, ste siempre debe mantener di-
nmicamente una representacin de sus smbolos en memoria. Como describamos en el
punto anterior, el intrprete genrico ofrecer stos al resto de aplicaciones existentes en el
sistema. De esta forma, por cada aplicacin ejecutada por el intrprete, se ofrecer una lista
de objetos representativos de su tabla de smbolos.
Siguiendo este esquema, y como se muestra en la Figura 11.3, el dominio computa-
cional de la mquina abstracta incluye el intrprete genrico y, por cada aplicacin, el con-
junto de objetos que representan la especificacin de su lenguaje y la representacin de sus
smbolos existentes en tiempo de ejecucin.

40
Es importante darse cuenta cmo una primera aproximacin para solucionar el problema planteado es
la utilizacin de un MOP. Sin embargo, como hemos comentado en 11.1.2.1, los MOPs establecen
restricciones de acceso en el salto computacional.

152
Arquitectura del Sistema Reflectivo No Restrictivo

a=10*2;
b=a/-18;
Lenguaje de alto a;
nivel codificado b;
en el lenguaje de Reify {
programacin vars["a"]=1
seleccionado vars["a"]=2
}
a;
b; Lenguaje de la
mquina abstracta
Reify { a ejecutar por el
code=... nivel computacional
language.["asignment"]. inferior
El intrprete toma actions.append(code)
el cdigo de mquina }
abstracta y lo evala a=10*2;
en el entorno computacional
de la mquina: salto Entorno Computacional Aplicacin
computacional

Ejecuta

code=...
Especificacin Intrprete Tabla de vars["a"]=1
language.["asignment"].
actions.append(code) del Lenguaje Genrico Smbolos vars["a"]=2

Entorno Computacional de la Mquina Abstracta

Figura 11.3: Salto computacional producido en la torre de intrpretes.

En el espacio computacional del intrprete se encuentran las aplicaciones de usuario


codificadas en distintos lenguajes de programacin. Cualquiera que sea el lenguaje de pro-
gramacin utilizado, una aplicacin de usuario tiene siempre una instruccin de acceso al
metasistema reify. Dentro de esta instruccin entre llaves el programador podr utili-
zar cdigo de su nivel computacional inferior: cdigo propio de la mquina abstracta. As,
una aplicacin poseer la expresividad de su lenguaje ms la propia de la mquina abstracta.
Siempre el que intrprete genrico analice una instruccin reify en un programa
de usuario, en lugar de evaluarla como una sentencia propia del lenguaje interpretado, se-
guir los siguientes pasos:
1. Tomar la consecucin de instrucciones codificadas en el lenguaje de la mqui-
na abstracta, como una cadena de caracteres.
2. Evaluar o descosificar los datos obtenidos, para que sean computados como
instrucciones por la mquina abstracta.
El resultado es que el cdigo de usuario ubicado dentro de la instruccin de cosifi-
cacin es ejecutado por el nivel computacional inferior al resto de cdigo de la aplicacin.
Es en este momento en el que se produce un salto computacional real en el sistema.
Para que la implementacin del mecanismo descrito anteriormente sea factible, la
posibilidad de evaluar o descosificar dinmicamente cadenas de caracteres como computa-
cin ser uno de los requisitos impuestos a la mquina abstracta.
La interaccin directa entre aplicaciones es otro de los requisitos impuestos a la pla-
taforma virtual en la descripcin global de la arquitectura del sistema. Cualquier aplicacin,
desarrollada en cualquier lenguaje, podr interaccionar directamente sin necesidad de una
capa software adicional con el resto de aplicaciones existentes. De este modo, el cdigo de
la aplicacin propio de la instruccin reify, al ser ejecutado en el entorno computacional
de la mquina, podr acceder a cualquier aplicacin dentro de este dominio, y en concreto a
su tabla de smbolos y a la especificacin de su lenguaje:

153
CAPTULO 11

1. Si analiza, mediante la introspeccin ofrecida por la mquina abstracta, su pro-


pia tabla de smbolos, estar obteniendo informacin acerca de su propia ejecu-
cin: introspeccin de su propio dominio computacional.
2. Si modifica la estructura de alguno de sus smbolos, haciendo uso de la reflecti-
vidad estructural de la mquina, el resultado es reflectividad estructural de su
nivel computacional.
3. La modificacin, mediante la utilizacin de la reflectividad estructural de la m-
quina, de las reglas semnticas del lenguaje de programacin supone reflectivi-
dad computacional o de comportamiento.
4. Si la parte a modificar de su lenguaje es su especificacin lxica o sintctica, el
resultado obtenido es reflectividad lingstica del nivel computacional de usua-
rio.
Vemos como otros dos requisitos necesarios en la mquina abstracta para llevar a
cabo los procesos descritos son introspeccin y reflectividad estructural de su dominio
computacional.
Finalmente comentaremos que la evaluacin de una aplicacin debe realizarse por
el intrprete genrico analizando dinmicamente la especificacin de su lenguaje, de forma
que la modificacin de sta conlleve automticamente al reflejo de los cambios realizados.
De este modo, no es necesaria la implementacin de un mecanismo de conexin causal (
6.1) ni la duplicacin de informacin mediante metaobjetos, puesto que el intrprete ejecu-
ta la aplicacin derogando parte de su evaluacin en la representacin de su lenguaje.

11.2.2 Representacin Estructural de Lenguajes y Aplicaciones


El salto computacional real ofrecido por nuestro sistema cobra importancia en el
momento en el que la aplicacin de usuario accede a las estructuras de objetos representan-
tes de su lenguaje de programacin o de su tabla de smbolos. Indicaremos brevemente
cmo pueden representarse stos para que su manipulacin, gracias a la reflectividad es-
tructural de la mquina abstracta, sea posible. Una descripcin ms detallada puede obte-
nerse del diseo del prototipo realizado en el captulo 14, Diseo de un Prototipo de
Computacin Reflectiva Sin Restricciones.
La representacin de los lenguajes de programacin a utilizar en nuestro sistema se
lleva a cabo mediante estructuras de objetos que representan gramticas libres de contexto,
para las descripciones lxicas y sintcticas, y reglas semnticas expresadas mediante cdigo
de la plataforma virtual. Su expresividad es la propia de una definicin dirigida por sintaxis
[Aho90], utilizando el lenguaje de la mquina abstracta como lenguaje de descripcin se-
mntica.
Para liberar al usuario de la necesidad de crear estas estructuras de objetos, se dise-
a un metalenguaje de descripcin de lenguajes de programacin con las caractersticas
mencionadas; la especificacin de la gramtica de una implementacin de este metalenguaje
se describe en el 283apndice B. El procesamiento de cdigo expresado mediante este me-
talenguaje supondr la creacin de la estructura de objetos representativa del lenguaje espe-
cificado.
A modo de ejemplo, mostraremos la traduccin de la siguiente definicin dirigida
por sintaxis:

S ::= B S r1: Regla en Cdigo Mquina Abstracta

154
Arquitectura del Sistema Reflectivo No Restrictivo

r2: Regla en Cdigo Mquina Abstracta


| C D r3: Regla en Cdigo Mquina Abstracta
B ::= B
C ::= C
D ::= D

Los smbolos terminales se han mostrado entre comillas dobles. Las reglas semnti-
cas r1, r2 y r3 se codificarn mediante el lenguaje de la mquina abstracta. Las produc-
ciones cuyo smbolo gramatical a su izquierda es S, forman parte de la descripcin sintcti-
ca del lenguaje. Las tres ltimas reglas representan su especificacin lxica.
El procesamiento de la descripcin del lenguaje anterior, crea su especificacin me-
diante objetos siguiendo la estructura mostrada en la Figura 11.4. Cada una de las reglas
posee un objeto que representa el smbolo gramatical no terminal de su parte izquierda.
ste est asociado a tantos objetos como partes derechas posea dicha produccin. Cada
una de las partes derechas hace referencia a una lista de smbolos gramaticales parte dere-
cha de la produccin y a una lista con todas las regla semnticas asociadas.

B:NoTerminal S:NoTerminal

smbolosGramaticales
:ParteDerecha
reglasSemnticas

r1:ReglaSemntica r2:ReglaSemntica
partesDerechas

C:NoTerminal D:NoTerminal

smbolosGramaticales
:ParteDerecha
reglasSemnticas

r3:ReglaSemntica
S:NoTerminal

partesDerechas smbolosGramaticales
B:NoTerminal :ParteDerecha B:Terminal

partesDerechas smbolosGramaticales
C:NoTerminal :ParteDerecha C:Terminal

partesDerechas smbolosGramaticales
D:NoTerminal :ParteDerecha D:Terminal

Figura 11.4: Especificacin de un lenguaje de programacin mediante una estructura de objetos.

Una vez creada esta estructura, se analizar una aplicacin codificada mediante el
lenguaje descrito, utilizando un algoritmo descendente de anlisis sintctico [Aho90]. Con-
forme se vaya examinando sta, se ir creando su rbol sintctico. Cada nodo de este rbol,
guardar una referencia a la representacin de su lenguaje de programacin. En concreto,
para cada nodo propio de un smbolo no terminal, se establecer una relacin con la parte
derecha de la produccin elegida en la creacin del rbol vase la Figura 11.5.
La evaluacin de la aplicacin supone el recorrido del rbol, ejecutando las reglas
semnticas asociadas a la descripcin de su lenguaje. La relacin establecida entre el rbol,
representante de la aplicacin, y la estructura que especifica su lenguaje de programacin,
supone que la modificacin del lenguaje implique automticamente su actualizacin o refle-
jo en la aplicacin de usuario; esta conexin es conocida como conexin causal [Maes87b].

155
CAPTULO 11

Especificacin
Lenguaje de B:NoTerminal S:NoTerminal
rbol Sintctico
Programacin
smbolosGramaticales
:ParteDerecha
reglasSemnticas

r1:ReglaSemntica r2:ReglaSemntica
S:Nodo
S:NoTerminal
C:NoTerminal D:NoTerminal

smbolosGramaticales
S:Nodo :ParteDerecha
reglasSemnticas

r3:ReglaSemntica

smbolosGramaticales
B:Nodo :ParteDerecha B:Terminal

smbolosGramaticales
C:Nodo :ParteDerecha C:Terminal

smbolosGramaticales
D:Nodo :ParteDerecha D:Terminal

C:Nodo D:Nodo B:Nodo D:NoTerminal

C:NoTerminal
partes
B:NoTerminal
derechas

Figura 11.5: Creacin del rbol sintctico asociado a la especificacin de un lenguaje.

El modo en el que se recorre el rbol no sigue un algoritmo predeterminado, como


por ejemplo el propio de un esquema descendente de traduccin [Aho90]. La regla semn-
tica del smbolo inicial de la gramtica, ha de indicar cmo se evala la ejecucin del primer
nodo del rbol; este proceso se extiende de un modo recursivo al resto de elementos del
rbol41.
Por cada aplicacin en nuestro sistema existir un objeto representante de sta. Ca-
da objeto de aplicacin poseer una referencia a su rbol sintctico, a su lenguaje de pro-
gramacin, y a su tabla de smbolos dinmica contexto de ejecucin.
Objeto Representante
de una aplicacin
Tabla de Smbolos Lenguaje

Aplicacin

Contexto de Ejecucin

rbol Sintctico Especificacin del Lenguaje

Figura 11.6: Principal informacin existente para cada aplicacin en ejecucin.

Accediendo a la lista de objetos representante de su tabla de smbolos mediante la


introspeccin y reflectividad estructural ofrecida por la mquina abstracta, se le brinda al

41
Para obtener ms informacin acerca de cmo describir la evaluacin del rbol, consltese el diseo
(captulo 14) o manual de usuario (apndice B) del prototipo implementado.

156
Arquitectura del Sistema Reflectivo No Restrictivo

programador de aplicaciones introspeccin y reflectividad estructural del lenguaje de pro-


gramacin que haya seleccionado.

11.3 Beneficios del Sistema Presentado


Enlazando con el anlisis realizado en 11.1 de tcnicas utilizadas para obtener sis-
temas computacionales flexibles, ste es el conjunto de beneficios aportados frente a los
sistemas basados en MOPs:
1. No se establece un protocolo que restringe previamente las caractersticas sus-
ceptibles de ser adaptadas. Cualquier aplicacin puede modificar cualquier ca-
racterstica de su lenguaje de programacin y de su contexto de ejecucin, sin
restriccin alguna, en tiempo de ejecucin.
2. No existe una expresividad limitada. El modo en el que podemos modificar una
aplicacin se expresa mediante un lenguaje de computacin: el lenguaje de la
mquina abstracta. De este modo, la expresividad ofrecida es en s un lenguaje
de acceso y modificacin de lenguajes, cuya evaluacin supone un salto real en
los dos niveles de computacin existentes.
3. Independencia del lenguaje. La separacin de la especificacin del lenguaje de
programacin a interpretar, del intrprete en s, supone una independencia del
lenguaje en el esquema ofrecido. Las caractersticas ofrecidas por el sistema no
implican la utilizacin de un lenguaje de programacin especfico. Sin embargo,
el lenguaje de adaptacin dinmica siempre es el mismo: el lenguaje de la m-
quina abstracta.
4. Se ofrece cuatro niveles de adaptabilidad: introspeccin, estructura dinmica,
comportamiento y lenguaje.
5. Existe una conexin causal directa sin necesidad de duplicar informacin. La
utilizacin de metaobjetos supone:
Duplicidad de informacin para ofrecer caractersticas del sistema. Cual-
quier caracterstica adaptable es ofrecida al programador a travs de un me-
taobjeto. Un objeto adaptable implica as la creacin paralela de un metaob-
jeto.
Implementacin de un mecanismo de conexin causal. Los reflejos de ac-
tualizacin de metaobjetos en el sistema base han de implementarse me-
diante un mecanismo adicional.
Ambas restricciones no aparecen en el sistema presentado.
6. Adaptabilidad cruzada. Cualquier aplicacin puede adaptar dinmicamente a otra
existente en el sistema, sin necesidad de que ambas utilicen el mismo lenguaje de
programacin. Esta posibilidad atribuye a nuestro sistema la capacidad de consti-
tuirse como un entorno computacional de separacin de incumbencias (concerns)
en tiempo de ejecucin y sin restriccin alguna.
Como punto negativo, los sistemas basados en MOPs poseen una mayor eficiencia
en tiempo de ejecucin. El hecho de duplicar la informacin a reflejar mediante el uso de
metaobjetos y la restriccin impuesta por el uso de un MOP, se justifica mediante el diseo
seguido en el que slo se usa un nivel computacional un nico intrprete. Si el usuario de
un MOP no identifica ningn elemento como adaptable, no existe casi penalizacin en los
tiempos de ejecucin. Sin embargo, nuestro esquema de dos niveles de computacin hace

157
CAPTULO 11

que el sistema posea tiempos de ejecucin ms elevados, indistintamente de la utilizacin o


no de las caractersticas reflectivas.

11.4 Requisitos Impuestos a la Mquina Abstracta


Analizando los requisitos necesarios impuestos a la mquina abstracta para poder
desarrollarse el sistema reflectivo propuesto, podemos enumerarlos del siguiente modo:
1. Introspeccin. Para que el programador pueda conocer la tabla de smbolos
existente en la ejecucin de su aplicacin y la especificacin del lenguaje de pro-
gramacin utilizado, la plataforma computacional deber poseer caractersticas
introspectivas.
2. Evaluacin o descosificacin de datos. El intrprete genrico toma el cdigo de
la mquina abstracta a evaluar como una cadena de caracteres. ste deber ser
interpretado por la mquina como instrucciones, no como datos. Este meca-
nismo de conversin de datos a computacin es necesario, pues, para desarro-
llar el sistema presentado.
3. Reflectividad estructural. El cdigo de la mquina abstracta evaluado en el nivel
computacional subyacente al propio de la aplicacin, requiere esta caracterstica
para poder adaptar la especificacin de su lenguaje y los objetos existentes en su
contexto de ejecucin.
4. Interaccin directa entre aplicaciones. Puesto que el cdigo a descosificar por la
mquina abstracta accede a otras aplicaciones desarrolladas sobre sta
especificacin del lenguaje y tabla de smbolos, la interaccin entre aplicacio-
nes computadas por la mquina es necesaria. Su uso tambin queda patente en
la adaptacin de una aplicacin por otra existente en el sistema.
Como tesis propuesta, afirmaremos que un entorno computacional que ofrezca es-
tas caractersticas ser vlido para desarrollar esta capa del sistema reflectivo42. La demos-
tracin de esta proposicin ha sido llevada a cabo mediante la implementacin de un
prototipo cuyo diseo es descrito en el captulo 14, y su utilizacin en el apndice B.

42
Tan solo nos referimos al desarrollo de esta capa del sistema. Para obtener la totalidad de los benefi-
cios, deberemos desarrollar sta sobre una plataforma virtual poseedora de las caractersticas descritas en
el captulo 9 y en el captulo 10.

158
CAPTULO 12:
DISEO DE LA MQUINA ABSTRACTA

Basndonos en los criterios de diseo especificados en la arquitectura de la mquina


abstracta, captulo 10, disearemos sta mediante la especificacin lxica y sintctica de
cada una de sus instrucciones, definiendo su semntica mediante los cambios producidos
en su estado computacional.
Describiremos la plataforma virtual sin profundizar en la implementacin de la
misma. El diseo de un prototipo de su implementacin mquina virtual ser mostrado
como un apndice en el apndice A.
Una vez descritas las funcionalidades bsicas de la mquina, haciendo uso de su ca-
pacidad de extensibilidad, ampliaremos levemente su abstraccin mediante la codificacin
de funcionalidades adicionales, como operaciones lgicas, aritmticas, de comparacin,
iteracin, y creacin de abstracciones y entidades.

12.1 Especificacin de la Mquina Abstracta


La principal caracterstica a definir dentro del modelo computacional ofrecido por
la mquina abstracta, es su nocin de objeto. Identificbamos como criterio de diseo a
seguir en su arquitectura el modelo computacional de objetos basado en prototipos. De
esta forma, el objeto supone la abstraccin base de su modelo computacional.

12.1.1 Nocin de Objeto


En tiempo de ejecucin, la mquina alberga un conjunto de objetos. El modo de
acceder y utilizar stos, es mediante referencias: si queremos utilizar los servicios ofrecidos
por un objeto o conocer su estado, debemos utilizar una referencia a ste.
Un objeto est constituido por un conjunto de referencias a otros objetos. Estas re-
ferencias entre objetos denotan distintas semnticas de relaciones como general-especfico,
asociacin o todo-parte.
Dada una referencia a un objeto, podemos conocer el conjunto de referencias que
ste posee, observando su estado, estructura y comportamiento introspeccin. Del mismo
modo, el conjunto de referencias que posee puede modificarse dinmicamente permitiendo
la insercin, borrado y actualizacin de nuevas referencias en tiempo de ejecucin
reflectividad estructural.

159
CAPTULO 12

Un objeto puede denotar en s informacin (datos) o comportamiento. La represen-


tacin de ambos se produce del mismo modo, mas la representacin del comportamiento
puede evaluarse o descosificarse43, es decir, traducir dinmicamente su informacin en una
computacin para la mquina abstracta. El comportamiento de un objeto viene denotado
por sus objetos asociados que representan computacin; su estado es descrito por aquellos
asociados que simbolizan nicamente informacin.

12.1.2 Entorno de Programacin


La mquina virtual interpretar el lenguaje de la mquina abstracta que definiremos
en este documento. El estado computacional inicial de la mquina abstracta viene dado por
un conjunto de objetos primitivos, descritos en 12.1.3, que ofrecen su funcionalidad com-
putacional bsica. Uno de los criterios definidos en la arquitectura de la mquina, captulo
10, requiere reducir al mnimo el nmero de objetos primitivos, para otorgar el mayor
grado de heterogeneidad posible a la plataforma base, facilitando as la implantacin de sta
en sistemas dotados de una capacidad computacional restringida.
Al igual que sucede en la plataforma de Smalltalk, al inicializar la mquina abstracta
sta interpreta una imagen del entorno de computacin: codificacin, en el propio lenguaje
de la mquina, de un entorno de programacin que eleve el nivel de abstraccin inicial de la
plataforma. Partiendo de la posibilidad de acceso a todos los objetos existentes en tiempo
de ejecucin, se ir creando nuevas abstracciones para conseguir un mayor nivel de abstrac-
cin extensibilidad.
Introspeccin y reflectividad estructural son las tcnicas ofrecidas para obtener el
mecanismo de extensibilidad buscado captulo 10. El hecho de codificar la extensin
computacional de la mquina en su propio lenguaje supone los siguientes beneficios:
1. El entorno de programacin al completo es portable a cualquier plataforma.
2. No se crean distintas versiones de la mquina virtual, perdiendo la portabilidad
de aplicaciones de versiones anteriores.
3. El tamao de la implementacin de la plataforma virtual no es excesivo y puede
implantarse en un nmero elevado de entornos computacionales.
Para cada una de las funcionalidades desarrolladas en el entorno de programacin
(persistencia, distribucin, planificacin genrica de hilos y recoleccin de basura), se debe-
r proporcionar un grado de adaptabilidad que permita modificar y adaptar dinmicamente
los mecanismos, tcnicas y protocolos utilizados, en funcin de los requerimientos surgi-
dos.

12.1.3 Objetos Primitivos


Inicialmente la mquina abstracta posee el siguiente conjunto de objetos primitivos,
as como las referencias propias para acceder a ellos:
Objeto nil. Objeto ancestro que ofrece las funcionalidades bsicas de cual-
quier objeto de nuestra plataforma.
Objetos cadenas de caracteres. Representan la informacin indivisible de nues-
tro sistema. Esta informacin puede representar simplemente datos, o compu-
tacin a ser evaluada.

43
Proceso inverso de cosificar: convertir en datos una computacin.

160
Diseo de la Mquina Abstracta

Objeto Extern. Identifica el mecanismo de adicin de primitivas operacionales


a nuestra plataforma, cuyo requerimiento fue impuesto en el captulo 10.
Objeto System. Representa la coleccin de todos los objetos existentes en la
plataforma real utilizada. Implica un mecanismo introspectivo de conocimiento
de los objetos existentes en la ejecucin de cada mquina.

Referencias
El acceso a un objeto se ha de realizar siempre mediante una referencia. Un objeto
como tal no tiene un nombre propio, pero s una referencia a ste. Por abreviar, a lo largo
de este documento expresaremos el objeto R en lugar de el objeto referenciado por R,
aunque realmente R sea una referencia al objeto.
Una referencia ofrece un mecanismo de acceso a los servicios propios de un objeto:
su estado (datos) y comportamiento (computacin). Mediante la utilizacin de una referen-
cia a un objeto, podremos conocer y modificar su estado, as como solicitar el desencade-
namiento de cualquiera de los comportamientos que ste desarrolle.

12.1.3.1 Objeto nil


Inicialmente existe el objeto nil, ancestro de todo objeto, al que se puede acceder
mediante la referencia nil. Este objeto, al igual que cualquier otro, posee un conjunto de
referencias a otros objetos. Todo objeto tendr al menos dos referencias miembro:
id: Referencia a un objeto cadena de caracteres, que identifica de forma nica
el objeto. Esta unicidad ha de ser universal, es decir, no puede existir colisin de
identificadores con otro objeto, aunque se encuentre en otra plataforma
super: Referencia al objeto padre o base del objeto actual.
El objeto al que se puede acceder a travs de nil, posee como referencia super
una referencia a l mismo, y como referencia id una referencia al objeto <nil>.
Pero, qu es el objeto <nil>? Un objeto cadena de caracteres. Cada vez que se
necesite un objeto cadena de caracteres, se podr utilizar una referencia a l identificando la
cadena de caracteres entre los delimitadores lxicos < y >. De esta forma, este tipo de obje-
tos se van creando implcitamente por el programador, mediante la utilizacin de referen-
cias nombradas entre < y >.

12.1.3.2 Objetos Cadenas de Caracteres


Para la mquina abstracta, un objeto cadena de caracteres significar la forma bsica
de representar cualquier dato. Adems, la plataforma permite evaluar o descosificar44 estos
objetos, representando as su computacin o comportamiento.
Hemos visto cmo todo objeto posee una referencia a otro objeto cadena de carac-
teres que identifica al primero de forma nica. Para el objeto nil, su referencia id lo aso-
cia al objeto <nil>. Este objeto, a su vez, posee como referencia id una referencia a s
mismo, y como referencia super una referencia al objeto de rasgo (trait) String.
En los lenguajes orientados a objetos basados en prototipos, el concepto de clase es
sustituido por el concepto de objeto trait vase el captulo 8. Estos objetos no son trata-
dos computacionalmente de un modo especial; son un objeto ms. El programador es el
encargado de utilizarlos para agrupar objetos con comportamiento y estructura similares.
44
Al igual que sucede con la invocacin de la funcin eval del LISP o exec de Python.

161
CAPTULO 12

De este modo, el objeto trait String define el comportamiento de todos los obje-
tos de tipo cadena de caracteres. Para obtener una mayor claridad de cdigo, la plataforma
y el entorno de computacin han sido desarrollados siguiendo la notacin de identificar los
objetos de rasgo con su primera letra en mayscula.
En la siguiente figura mostramos las asociaciones existentes entre los objetos primi-
tivos mencionados.

super
nil
id

Objetos

super
String
id

Referencias super
id <nil>
<String> super
id

Figura 12.1: Objetos primitivos nil y String.

Vemos cmo, siguiendo los criterios de diseo especificados, el identificador del


objeto String es el objeto <String>, as como su objeto padre es el objeto nil.
Las cadenas de caracteres de este lenguaje han de poder anidarse. Existirn cadenas
de caracteres dentro de otras cadenas de caracteres. El autmata que las reconoce y su gra-
mtica equivalente no puede ser de tipo 3 o regular, como las clsicas, comprendidas entre
una pareja del mismo delimitador [Cueva91]. Por lo tanto, las cadenas de caracteres son
declaradas como sentencias de un lenguaje de tipo 2, libre de contexto, y necesitan un ele-
mento lxico de apertura y cierre distinto: < y > respectivamente.
Los objetos cadenas de caracteres son el elemento primitivo de representacin de
datos y computacin para nuestra plataforma. Haciendo uso de la capacidad de reflectivi-
dad estructural, podremos acceder en tiempo de ejecucin a la estructura y estado de cual-
quier objeto, as como a la implementacin de todos los mtodos no primitivos de la m-
quina y del entorno de computacin45.
Las cadenas de caracteres poseern las siguientes de caractersticas:
Podrn anidarse. Dentro de una cadena representativa de cdigo, podremos ne-
cesitar representar a su vez otra cadena de caracteres. De este modo, deber
permitirse la introduccin de cualquier conjunto de cadenas de caracteres, de
forma recursiva.
Podrn contener caracteres especiales sin necesidad de utilizar cdigos de esca-
pe. Podremos utilizar cadenas de caracteres de ms de una lnea as como intro-
ducir tabuladores dentro de sta.
Representacin de delimitadores. Cmo se introducen los caracteres < y > de-
ntro de la propia cadena, sin que indiquen una subcadena? Con el carcter de
escape \, teniendo as dos caracteres distintos \> y \< que no indicarn anida-

45
Esta capacidad hace que el sistema sea dinmicamente introspectivo.

162
Diseo de la Mquina Abstracta

miento de cadenas de caracteres, y cuya representacin a la hora de visualizarlos


ser > y < respectivamente.
Utilizacin de caracteres de escape. Se podrn utilizar, si se desea, los caracteres
de escape \n, \\ y \t, en lugar de su propia representacin.
Caracteres desodos. Puesto que el sistema ser autodocumentado mediante in-
trospeccin, ser necesario representar dicha documentacin de forma elegante.
Sin embargo, en la codificacin de aplicaciones, puede surgir la necesidad de in-
dentar (sangrar) el cdigo. No obstante, no se desea que aparezcan los tabula-
dores de indentacin en la documentacin. Debemos identificar un modo de
ignorar caracteres para su posterior documentacin.
Se establecen bloques de caracteres que ignorar el analizador lxico y no apare-
cern al acceder posteriormente a ellos. Estos caracteres sern los comprendidos
entre \*. Por ejemplo, podremos evaluar lo siguiente:

nil:<set>(<==>,<\*
\* o <- params:<0>;
\* \* sID <- o:<id>;
\* \* return <- sID:<==>(<nil>);\*
\* >);

Posteriormente, si accedemos al objeto asociado a nil mediante la referencia ==


tendremos:

< o <- params:<0>;


sID <- o:<id>;
return <- sID:<==>(<nil>); >

Para mostrar el cdigo con mayor legibilidad, la indentacin de cadenas de caracte-


res con los caracteres de escape se obviar a partir de aqu, a lo largo de este captulo.

12.1.3.3 Objeto Extern


Como se identific en el captulo 10, separaremos las primitivas computacionales
de las operacionales, permitiendo ampliar las segundas mediante un mecanismo de interco-
nexin estndar con el sistema operativo hospedado.
La mquina abstracta posee las siguientes primitivas:
Primitivas Computacionales. Propias de la semntica del funcionamiento de la
mquina. Podemos mencionar el mecanismo de acceso a los miembros, la eva-
luacin o descosificacin de objetos, y el mecanismo de delegacin o herencia
dinmica. Estas primitivas son implementadas en la mquina virtual y no puede
modificarse su semntica.
Primitivas Operacionales. Se representan mediante objetos evaluables que espe-
cifican la semntica de operaciones, no representables mediante las existentes
inicialmente en la plataforma. Este tipo de semntica podr ampliarse en fun-
cin de los requisitos de la plataforma.
Ejemplos de este tipo de primitivas son: operaciones aritmticas, tratamiento de
cadenas de caracteres, acceso a disco, primitivas de distribucin o interfaces gr-
ficas.
Para desarrollar un mecanismo de ampliacin de primitivas operacionales, se nece-
sita un protocolo de comunicacin con las implementaciones externas de los objetos primi-

163
CAPTULO 12

tivos operacionales, utilizando un mecanismo de interconexin estndar que sea coherente


con el diseo de la mquina. En funcin del sistema operativo existente en la implantacin
de la plataforma virtual, se utilizar un mecanismo de interconexin que permita ampliar la
semntica operacional, de un modo estndar ejemplos de esto pueden ser sistemas de
componentes o libreras de enlace dinmico.
Mediante la utilizacin de este sistema de ampliacin de primitivas, la mquina no
tendr nunca que reemplazarse, no se perder portabilidad de su cdigo, y la plataforma
computacional poseer la posibilidad de ampliar sus operaciones concretas de una plata-
forma46.
La referencia Extern apunta a un objeto primitivo que posee un miembro id con
valor <Extern>, un miembro super haciendo referencia a nil, y un miembro invoke.
Este ltimo objeto es el encargado de representar todas las primitivas operacionales exter-
nas; mediante el paso parmetros, indicaremos qu primitiva externa debe evaluar.

Referencias a
Objetos String
Implementaciones
super Externas
nil
id <nil>

super
Extern
id <Extern>
invoke
Mecanismo de
intercomunicacin
super estndar para el sistema
String
id <String> operativo seleccionado
en la implantacin de la
mquina

Mquina Abstracta

Sistema Operativo

Figura 12.2: Acceso a las primitivas operacionales externas mediante el mtodo invoke del objeto
Extern.

La sintaxis de invocaciones al mtodo invoke tendr como parmetros la referen-


cia al objeto donde se ubica el miembro, la referencia al nombre del miembro, la referencia
al parmetro implcito y los parmetros de la invocacin veremos en 12.1.4.4 la sintaxis
de invocacin de mtodos.

12.1.3.4 Objeto System


La reflectividad estructural de la plataforma nos permite acceder a los objetos y a la
estructura de stos, de forma dinmica. Para conocer y acceder a su estructura, veremos
cmo los miembros de nil ofrecen las primitivas de contenedor. El objeto trait System
ser el encargado de ofrecer el conocimiento dinmico de los objetos existentes en la plata-
forma, as como una referencia para trabajar con ellos introspeccin global del sistema.
El objeto System nos permite acceder al entorno de ejecucin de la plataforma.
Es un objeto que posee por padre a nil, y que tiene un miembro objects que hace

46
Las distintas versiones de mquinas virtuales de la plataforma de Java [Kramer96], supone que el desa-
rrollo de applets para las ltimas versiones actuales de sta, no puedan ser ejecutados por aquellos clien-
tes que posean navegadores con versiones anteriores.

164
Diseo de la Mquina Abstracta

referencia a un objeto contenedor: posee, adems de los miembros super e id, un miem-
bro por cada objeto existente en tiempo de ejecucin, siendo cada referencia miembro el
id del objeto asociado.

super
nil id <nil>

super
System id <System>
objects super
id
nil
super String
String
id <String>
System
Extern
...
super
Extern
id <Extern>
invoke
Resto de Objetos como las
cadenas de caracteres <nil>,
<System>, <String> o <Extern>

Figura 12.3: Acceso a los objetos de la mquina abstracta mediante el objeto System.

Todas las primitivas de acceso a la plataforma fsica real o acceso al medio (la plata-
forma concreta en la que se est ejecutando la mquina abstracta), se ubicarn como miem-
bros de este objeto. Un ejemplo es el mtodo localhost del sistema de distribucin (
13.4) que nos devuelve el identificador de la mquina en la red de computadores.

12.1.4 Posibles Evaluaciones


Esta mquina abstracta posee un conjunto inicial de objetos con una estructura es-
tablecida. A raz de stos, crearemos la computacin bsica de la plataforma y posterior-
mente un entorno de computacin. El modo de construir computaciones es llevado a cabo
por el programador, mediante el siguiente conjunto de instrucciones:
1. Creacin de referencias. Podremos declarar una referencia en el contexto actual
de ejecucin para su posterior utilizacin.
2. Asignacin de referencias. Podremos hacer que una referencia apunte (se quede
con la identidad) al objeto asociado a otra referencia existente.
3. Acceso a los miembros. Podremos acceder a cualquier miembro de un objeto
en tiempo de ejecucin.
4. Descosificacin o evaluacin de un miembro sobre un objeto. Podremos eva-
luar como comportamiento (instrucciones) un dato que sea miembro de un ob-
jeto. Este objeto ser sobre el que actuar la computacin: el objeto implcito.
5. Comentarios. Como hemos mencionado, la autodocumentacin, y por tanto el
acceso a los comentarios utilizados, es una caracterstica propia de la platafor-
ma. Los comentarios no se eliminarn por el analizador lxico, aunque su com-
putacin resulte nula.

165
CAPTULO 12

6. Descosificacin o evaluacin de objetos cadena de caracteres. Cualquier se-


cuencia de instrucciones de las anteriormente enumeradas, podr tratarse como
datos (objetos cadenas de caracteres) y evaluarse como computacin.
Una instruccin finalizar siempre con el carcter punto y coma.

12.1.4.1 Creacin de Referencias


Una referencia es el mecanismo de acceso a un objeto. La ejecucin de la mquina
parte de la existencia de un conjunto inicial de referencias. El usuario podr utilizar stas y
crear otras para acceder a los distintos objetos del sistema.
Cada vez que se evala o descosifica un objeto, se crea un nuevo contexto de ejecu-
cin sobre el contexto existente vase 12.2.2. En ste contexto se pueden crear nuevas
referencias, adems de acceder a las referencias del contexto padre. Si aplicamos esta pro-
piedad de modo transitivo, en realidad es factible acceder a cualquier contexto padre.
Una referencia ha de ser nica en su contexto. Al destruirse un contexto (finalizar
su ejecucin) se liberan sus referencias, pero no los objetos a los que stas acceden47. La
creacin de una nueva referencia en el contexto de ejecucin se realiza mediante el compo-
nente lxico ->. Si la referencia en ese contexto ya exista, la evaluacin es nula. Inicial-
mente una referencia posee la identidad apunta al objeto nil.

-> nuevaRef;
-> otraRef;

La creacin de referencias en un contexto, unido a la posibilidad de acceder desde


un contexto a otro padre, puede provocar conflictos de nombres. Si una referencia existe
en un contexto y en alguno de los contextos padre, no se podr acceder desde el contexto
actual a las referencias de igual nombre en contextos padre. Esto representar un problema
en la evaluacin de miembros que toman un cdigo como parmetro que accede a referen-
cias del contexto padre; veremos posteriormente una solucin a este problema.
Al tratar con un modelo de objetos basado en prototipos, no necesitamos declarar
tipos para las referencias. Todo el proceso de validacin semntica, as como la inferencia
de tipos, se produce en tiempo de ejecucin.

12.1.4.2 Asignacin de Referencias


Hemos visto cmo crear nuevas referencias en un contexto. Una referencia es el
mecanismo de acceso a un objeto. Podremos asignar referencias con el token <-

nuevaRef <- String;


otraRef <- <Hola a todos>;

La asignacin de referencias produce un nuevo modo de acceso al objeto que esta-


ba siendo utilizado por la referencia situada a la derecha de la flecha. El sentido de la asig-
nacin es el indicado por la flecha. La referencia que obtiene un nuevo valor, pierde la
identidad del objeto que estaba utilizando.

12.1.4.3 Acceso a los Miembros


Hemos visto qu aspecto inicial tiene la mquina abstracta, y cmo se estructura y
representa un objeto en memoria. Ahora mostraremos cmo se accede a los objetos exis-
tentes para su posterior manipulacin.
47
La liberacin de las referencias de un contexto no implica la destruccin de los objetos referenciados,
pero s supone el decremento en una unidad de su miembro refCount.

166
Diseo de la Mquina Abstracta

Como hemos comentado en la introduccin de este captulo, hay que tener en


cuenta que la abstraccin base de la mquina es el objeto (orientacin a objetos mediante
prototipos), y que un objeto se define como un conjunto de referencias a otros objetos a
los que podremos acceder en tiempo de ejecucin. Un objeto es, por tanto, un contenedor
indirecto de otros objetos48.
Dado un objeto, accedemos a l mediante una referencia. Mediante sta, accedemos
al conjunto de objetos asociados al objeto referenciado. La sintaxis consiste en separar la
referencia al objeto y la referencia al objeto que indica el nombre del miembro, mediante el
componente lxico dos puntos:

nil:<id>;
String:<super>;
<id>:<id>;

Todas las expresiones anteriores devuelven referencias a objetos: el objeto <nil>


en el primer caso, el objeto nil para el segundo ejemplo, y el objeto <id> en la tercera
lnea. La referencia devuelta puede asignarse a una referencia existente en el contexto, me-
diante la asignacin de referencias, para la posterior utilizacin del objeto referenciado:

ancho <- rectangulo:<ancho>;

En el contexto de ejecucin actual se pueden utilizar referencias locales a este con-


texto. En el ejemplo anterior, la referencia devuelta en el acceso al miembro se asigna a la
referencia local ancho. Si sta no exista previamente, se crea. Ahora existe otro medio
(otra referencia), para acceder al objeto miembro ancho.

12.1.4.4 Evaluacin o Descosificacin de Objetos Miembro


Mediante la adicin de miembros que denotan secuencias de instrucciones, puede
aadirse comportamiento a los objetos del sistema. La invocacin de un mtodo se repre-
sentar mediante la evaluacin de un miembro descosificable, indicando el objeto o par-
metro implcito sobre el que se actuar al que se le enviar el mensaje.

Referencia al objeto Nombre del miembro Parmetros


sobre el que se acta
Invocacin RefObj : refNomMiembro ( refParams )
Sncrona
Invocacin RefObj : refNomMiembro ) refParams (
Asncrona
Una vez accedido el objeto a evaluar, especificando siempre el parmetro implcito
u objeto sobre el que se acta, se podr evaluar ste de modo sncrono (esperando el hilo
actual a la finalizacin de su ejecucin) o asncrono (crendose un nuevo hilo sobre el con-
texto existente). Los parmetros se pasan en ambos casos mediante un conjunto de refe-
rencias, separadas por comas.
En la evaluacin sncrona de un de un objeto podr devolverse una referencia a un
objeto. Sin embargo, puesto que en la evaluacin asncrona no existe una espera a la finali-
zacin de la invocacin, no podr asignarse ninguna referencia devuelta.

perimetro <- rectangulo:<perimetro>(<cm>);

48
No contiene los propios objetos (composicin) supeditando el ciclo de vida de stos al suyo, sino que
contiene referencias a otros objetos que siguen existiendo aunque finalice la existencia del contenedor.

167
CAPTULO 12

rectangulo:<dibujar>)(;

12.1.4.5 Comentarios
Una instruccin puede ser una referencia a un objeto cadena de caracteres. La utili-
zacin de esta posibilidad es de carcter documental para dicha instruccin. Si mantenemos
la poltica comn en procesadores de lenguajes de eliminar los comentarios en el anlisis
lxico, al acceder a la computacin o instrucciones de la plataforma como datos, perdere-
mos los comentarios. Para la mquina abstracta, un comentario posee entidad lxica y sin-
tctica, pero no semntica. La evaluacin de un comentario es nula, pero no es eliminada
por el analizador lxico.
Accediendo a los miembros de un objeto, podrn conocerse los comentarios que el
programador haya identificado como necesarios. Si queremos dejar constancia de un co-
mentario nicamente en el archivo de entrada, sin que aparezca posteriormente, podremos
utilizar los caracteres a desor en las cadenas de caracteres ( 12.1.3.2):

< * Comentario para la posteridad * >;


...
< Comentario temporal que slo queda en el archivo fuente >;
...

12.1.4.6 Evaluacin de Objetos Cadena de Caracteres


No siempre es necesario evaluar un objeto como miembro. Puede interesar crear
una instruccin o conjunto de instrucciones como datos, para posteriormente evaluarlas.
La forma de representar instrucciones como datos, es utilizando objetos cadena de caracte-
res. Una vez creada la cadena, se podr descosificar o evaluar sta de forma sncrona o
asncrona.

< perimetro <- rectangulo:<perimetro>(<cm>); > ();


< rectangulo:<dibujar>)(; > )(;

La evaluacin de un objeto cadena de caracteres se produce en un contexto nuevo


creado sobre el contexto actual (el contexto en el que se evala dicho objeto). Veremos
posteriormente cmo estas evaluaciones pueden devolver valores a los contextos padre, y
cmo acceder a las referencias de stos desde el contexto creado.

12.1.5 Delegacin o Herencia Dinmica


El mecanismo de herencia ha sido utilizado en el paradigma de la orientacin a ob-
jetos para reutilizar cdigo e implementar aplicaciones adaptables. En nuestro lenguaje, la
evaluacin de un objeto indicando el parmetro implcito, no implica que el objeto miem-
bro deba estar en ese objeto; puede formar parte de un objeto base padre.
La especificacin de una referencia a un objeto mediante el miembro super, indica
dnde se deber buscar el miembro no encontrado el paso de un mensaje. En el caso de
que esto ocurra, se seguir el proceso de bsqueda de modo recursivo en el objeto referen-
ciado por super. Esta bsqueda finalizar cuando se cumpla que la referencia super del
objeto examinado es una referencia a s mismo, tratndose entonces del objeto ancestro
nil.
Este mecanismo de herencia es dinmico, es decir, se puede modificar la referencia
al objeto padre en tiempo de ejecucin. La flexibilidad que esta capacidad otorga, hace que
el mecanismo obtenido se defina como delegacin y, en alguna bibliografa, como herencia
dinmica.

168
Diseo de la Mquina Abstracta

12.1.6 Reflectividad Estructural y Computacional


La flexibilidad es el principal objetivo a obtener en el diseo de esta plataforma. Se
trata de especificar una mquina abstracta computacionalmente simple y, apoyndonos en
la extensibilidad y adaptabilidad otorgadas, construir un entorno de computacin de un
mayor nivel de abstraccin. La consecucin de este objetivo se debe llevar a cabo sin nece-
sidad de modificar la mquina, aumentando su funcionalidad mediante su propio lenguaje.
Como hemos comentado a lo largo de esta tesis, la propiedad de reflectividad es-
tructural es un mecanismo til para conseguir los objetivos mencionados. Mediante un
conjunto de primitivas, podremos acceder a la estructura y comportamiento de cualquier
objeto existente en tiempo de ejecucin, para conocer, modificar o ampliar dinmicamente
cualquiera de sus miembros.
Como identificamos en el captulo 6, la reflectividad computacional es un meca-
nismo utilizado para otorgar flexibilidad en la semntica computacional de la mquina abs-
tracta. Al igual que multitud de sistemas (estudiados en el captulo 7), para nuestra mquina
utilizaremos un protocolo de metaobjetos (MOP) reducido, obteniendo as un mecanismo
dinmico de flexibilidad computacional, con una expresividad restringida.
Determinadas primitivas computacionales de la mquina podrn modificarse me-
diante el propio lenguaje del sistema haciendo uso de un pequeo MOP. Mediante un me-
canismo de reflectividad computacional restringido49, la mquina facilitar al programador
la posibilidad de modificar una serie de primitivas computacionales. De esta forma, no es
necesario modificar la mquina para introducir nuevas caractersticas, pudiendo adaptar
stas mediante su propio lenguaje.
La mquina abstracta ofrece un MOP para modificar la semntica de las siguientes
primitivas computacionales:
Acceso a los miembros de un objeto, mediante la modificacin del significado
del operador dos puntos.
Descosificacin o evaluacin sncrona y asncrona de objetos, mediante la mo-
dificacin de los operadores parntesis; tanto para objetos miembro evaluables,
como para objetos cadena de caracteres.
Veremos posteriormente en este documento la sintaxis del MOP que nos permite
adaptar estas primitivas en el lenguaje en 13.3.3 introducimos la adaptacin del acceso al
miembro y en 13.2.3 mostramos la modificacin de la evaluacin de cdigo.

12.1.7 Objetos Miembro Primitivos


Existe un conjunto de objetos primitivos relativos al funcionamiento de la mquina
abstracta. Estos objetos poseen una semntica definida por la propia mquina, y por tanto
no estn implementados en su propio lenguaje.
Podemos clasificarlos as:
Creacin, destruccin y referencias de objetos.
Objeto Miembro Parmetros Descripcin
nil new - Crea un objeto nuevo con dos referen-

49
Esta restriccin supone establecer un protocolo a priori para identificar una sintaxis de modificacin de
la semntica de un conjunto reducido de primitivas.

169
CAPTULO 12

Objeto Miembro Parmetros Descripcin


cias miembro: id a un objeto deriva-
do de String con su identificacin
nica50 y super a nil.
nil delete - Libera la memoria del objeto implcito.
nil getRefCount - Devuelve un objeto cadena de caracte-
res, indicando el nmero de referencias
existentes dinmicamente a este obje-
to51.
Acceso a los objetos mediante reflectividad estructural.
Objeto Miembro Parmetros Descripcin
nil set 1: Referencia a Asigna un nuevo miembro con un nom-
la clave bre (clave) al objeto implcito. Si la refe-
2: Referencia rencia no exista, la crea.
al contenido
nil has 1: Referencia a Devuelve un objeto lgico indicando si
la clave existe o no la clave indicada.
nil firstKey - Devuelve una referencia a un objeto ca-
dena de caracteres que indica el nombre
del primer miembro.
nil nextKey 1:Referencia a Devuelve la referencia a la siguiente clave
la clave o nil si no hay ms.
nil remove 1: Referencia a Elimina la entrada con la clave pasada. El
la clave objeto al que apunta no es liberado.
nil get 1: Referencia a Devuelve la referencia asociada al nombre
la clave de la clave pasada52 o nil si no existe.
Sincronizacin de hilos.
Objeto Miembro Parmetros Descripcin
nil enter - Trata de acceder al monitor propio del ob-
jeto implcito. Si ya est utilizado, se blo-
quea en espera.

50
El hecho de otorgar identificadores nicos no es una tarea sencilla. Hay que tener en cuenta que puede
haber multitud de mquinas en distintas plataformas, y los objetos de cada una debern tener identificado-
res globalmente nicos. Para ello, utilizaremos los identificadores universalmente nicos especificados
por el Open Software Foundations Distributed Computing Environment (OSF DCE) [Kirtland99], repre-
sentando los IDs como cadenas de caracteres representativas de nmeros de 32 bytes entre caracteres {} y
en base 16.
51
La utilidad principal de este miembro introspectivo, es facilitar al programador la implementacin de
distintos recolectores de basura en el propio lenguaje de la mquina, sin necesidad de modificar su im-
plementacin ( 13.1).
52
Esta primitiva tiene la misma funcin que el acceso a un miembro mediante el uso del operador dos
puntos. Sin embargo, se utilizar una u otra en los sistemas de persistencia y distribucin para diferenciar
entre objetos locales y en RAM, frente a objetos remotos y persistentes vase el diseo de los servicios
de distribucin y persistencia.

170
Diseo de la Mquina Abstracta

Objeto Miembro Parmetros Descripcin


nil exit - Libera el recurso propio del objeto implci-
to. El siguiente hilo esperando, entrar a l.
Si no existiese ninguno, la evaluacin es
nula.
A continuacin se presentarn ejemplos del empleo de estos objetos miembro pri-
mitivos, para ampliar el nivel de abstraccin de la plataforma, expresndolo en su propio
lenguaje.

12.2 Extensin de la Mquina Abstracta


Hasta este punto, hemos descrito el funcionamiento primitivo de la mquina abs-
tracta, mencionando las primitivas computacionales ofrecidas y los mecanismos a utilizar
para extender sus abstracciones mediante los miembros primitivos del objeto nil. A par-
tir de este punto, extenderemos, haciendo uso del propio lenguaje de la mquina, su capa-
cidad computacional, sin necesidad de modificar el cdigo fuente de la mquina virtual.
Al igual que la plataforma de Smalltalk [Krasner83], la programacin llevada a cabo
ser un conjunto de sentencias codificadas en un archivo imagen. Inicialmente la platafor-
ma ejecutar el cdigo de este archivo para extender su abstraccin.

12.2.1 Creacin de Nuevas Abstracciones


Vamos a ver cmo podemos crear nuevos objetos en el sistema. Inicialmente tene-
mos los objetos String, nil, System y Extern. Para poder aadir funcionalidades al
conjunto de todos los objetos existentes en la plataforma, podremos crear un objeto ances-
tro Object que implemente estas funcionalidades. Este diseo ha sido adoptado por nu-
merosos lenguajes como Smalltalk, Object Pascal o Java.
Podramos introducir estas funcionalidades en el objeto ancestro existente nil. Sin
embargo, dejaremos en nil aquellas capacidades semnticas primitivas que nos ofrece la
plataforma53.
Creamos inicialmente un objeto, almacenndolo en una referencia global (de con-
texto 0) Object:

-> Object;
Object <- nil:<new>();
Object:<set>(<id>,<Object>);

Un criterio seguido en la creacin de esta plataforma, es separar los objetos que re-
presentan estados de una entidad de los objetos que representan comportamiento de un
grupo. Este tipo de objetos, de comportamiento o rasgo, se suelen denominar objetos trait.
Las referencias a este tipo de objetos las definiremos con la primera letra en mayscula; el
resto, con la primera en minscula54.
Otro convenio seguido es la definicin de la referencia miembro <id> de cualquier
objeto de la plataforma (no un objeto de usuario), y cambiarlo al nombre de su referencia

53
En este punto en el que nos encontramos ampliando el nivel de abstraccin de la plataforma mediante
su propio lenguaje, pueden llevarse a cabo multitud de diseos para definir la estructura de su lenguaje.
Esto es una muestra la flexibilidad otorgada.
54
Simplemente es un convenio para poder leer el cdigo de una forma ms sencilla.

171
CAPTULO 12

en el contexto global. Por ejemplo, al crear el objeto Object en el caso anterior, su identi-
ficador ser un nmero hexadecimal comprendido entre { y } funcionamiento de la pri-
mitiva new. Para identificarlo como objeto perteneciente a la plataforma, su miembro
<id> se modifica al nombre de su referencia: <Object>.
Puesto que Object va a ser el objeto base directa o indirectamente de cualquier
objeto de la plataforma, exceptuando nil, modificaremos el objeto base de String,
Extern y System:

String:<set>(<super>,Object);
Extern:<set>(<super>,Object);
System:<set>(<super>,Object);

La plataforma va a tener una forma de operar basada en valores lgicos bivaluados.


El objeto trait Boolean identificar el comportamiento de este tipo de objetos:

-> Boolean;
Boolean <- nil:<new>();
Boolean:<set>(<id>,<Boolean>);
Boolean:<set>(<super>,Object);

Aunque la plataforma no proporcione primitivas lgicas, definiremos dos objetos


true y false que representarn respectivamente las constantes positiva y negativa en la
lgica de la mquina.

-> true;
true <- nil:<new>();
true:<set>(<id>,<true>);
true:<set>(<super>,Boolean);
-> false;
false <- nil:<new>();
false:<set>(<id>,<false>);
false:<set>(<super>,Boolean);

nil

Relaciones
de herencia
Object

Extern Boolean String System

true false Objetos, indicando


su identificador

Figura 12.4: Objetos existentes en tiempo de ejecucin.

12.2.2 Evaluacin de Objetos


Hasta ahora hemos creado objetos y modificado su estructura, utilizando objetos
evaluables primitivos como los miembros del objeto nil, new y set. Hemos comentado
tambin, que el comportamiento de los objetos viene dado por la evaluacin dinmica de
objetos. Veremos a continuacin la semntica propia de la evaluacin de este tipo de obje-
tos.

172
Diseo de la Mquina Abstracta

12.2.2.1 Evaluacin de Objetos Miembro


Para aadir un objeto miembro evaluable a otro objeto, deberemos ejecutar el m-
todo <set> del objeto en cuestin, pasndole como parmetros el nombre del miembro a
crear, y un objeto String representativo del cdigo que se evaluar en la invocacin del
mtodo.
Cuando se evale o ejecute el miembro creado, se construir un nuevo contexto de
ejecucin en el hilo existente. En este nuevo contexto, se pueden crear nuevas referencias
que se destruirn al finalizar el mismo. Un contexto podr acceder a las referencias del con-
texto que lo cre contexto padre. Una referencia de un contexto oculta las referencias de
igual nombre, ubicadas en sus contextos padre.

devolucin <- objeto:<miembro>(parmetros);

El nuevo contexto, creado en la invocacin o evaluacin de un objeto miembro, se


caracteriza por tener las siguientes referencias adicionales:
sender: Esta referencia posee la identidad del objeto utilizado para acceder al
miembro. Es el parmetro u objeto implcito sobre el que actuar la computa-
cin del miembro al evaluarse. En el ejemplo anterior, es una referencia a
objeto.

mySelf: Referencia al objeto que posee el miembro que se est evaluando. Es-
ta referencia no tiene por qu tener el mismo valor que sender, puesto que el
miembro que se evala puede ser distinto al parmetro implcito, gracias al me-
canismo de delegacin. En el ejemplo anterior, mySelf puede ser una referen-
cia a objeto o a alguno de sus objetos padre directa o indirectamente.
params: Esta referencia apunta a un objeto contenedor de los parmetros pa-
sados. Si no se han pasado parmetros, apuntar a nil.
El objeto contenedor de parmetros, params, tendr los dos miembros de todo
objeto, ms un miembro por cada parmetro. Los miembros estn etiquetados
con nmeros del cero al nmero de parmetros menos uno.

parmetroPrimero <- params:<0>;


parmetroSegundo <- params:<1>;

return: Referencia que posee la identidad del objeto devuelto por la evalua-
cin del mtodo. Si la evaluacin del miembro es asncrona, la referencia
return no ser creada, puesto que este tipo de invocaciones no puede devol-
ver ningn objeto.
En nuestro ejemplo, el objeto que asociemos a la referencia return dentro del
mtodo ser el objeto al que apunte la referencia devolucin, despus de su
invocacin.
Un ejemplo de implementacin del miembro suma de un objeto Entero puede
ser:

Entero:<set>(<suma>,<
-> param;
param <- params:<0>;
return <- sender:<+>(parametro);
>);

173
CAPTULO 12

En su evaluacin, param es el nico parmetro pasado, sender es el objeto impl-


cito utilizado en su invocacin (el objeto Entero o alguno de sus derivados), mySelf es
una referencia a Entero, y la devolucin del mtodo es el resultado de otra evaluacin.

12.2.2.2 Evaluacin de Objetos Cadena de Caracteres


Adems de poder evaluar objetos miembro que actan sobre objetos implcitos,
mediante la referencia sender, tambin podemos evaluar objetos cadena de caracteres, sin
necesidad de utilizar un objeto implcito.
Este tipo de evaluacin provoca la creacin de un nuevo contexto, al igual que la
evaluacin de un miembro. El contexto creado puede tambin crear nuevas referencias, as
como acceder a las referencias del contexto padre. De forma adicional, podr devolver un
valor si no se evala de forma asncrona y recibir parmetros.
Posee, por tanto, las referencias params y return, y carece de sender y
mySelf. De esta forma, si en algn contexto padre existieren estas referencias, se podra
disponer de stas desde el nuevo contexto creado, aunque no hayan sido definidas en el
actual.

devolucin <- <Instruccin>(parmetros);

12.2.3 Creacin de Objetos Evaluables


A raz de la semntica de evaluacin de objetos, aadiremos funcionalidad compu-
tacional a los objetos creados en 12.2.1.

12.2.3.1 Creacin de Objetos con Identificador


El miembro new del objeto nil ofrece la posibilidad de crear objetos con un iden-
tificador nico. Hemos visto cmo los identificadores de los objetos creados, constituyen-
tes de la plataforma, son modificados por un identificador legible por el humano true,
false, Boolean u Object. A lo largo de la creacin del entorno de programacin, este
criterio de modificacin de identificadores seguir llevndose a cabo. Para facilitar este pro-
ceso, se asignar a Object un miembro newWithId que implemente este algoritmo:

Object:<set>(<newWithId>,<
-> ID;
ID <- params:<0>;
return <- self:<new>();
return:<set>(<id>,ID);
>);

El parmetro pasado en la evaluacin del miembro, es el identificador a asignar al


objeto creado.

12.2.3.2 Igualdad de Objetos


La comparacin de igualdad de objetos se apoya en la primitiva de comparacin de
igualdad de cadenas de caracteres. Este funcionamiento semntico de comparacin de ca-
denas forma parte del protocolo de invocaciones externas computacin operacional bsi-
ca, 12.1.3.3.

String:<set>(<==>,<
-> sParam;
sParam <- params:<0>;

174
Diseo de la Mquina Abstracta

return <- Extern:<invoke>(<String>,<==>,sender,sParam);


>);

Para poder comparar cualquier objeto implcito, excepto nil, aadimos el miem-
bro de igualdad al objeto trait Object, que compara dos objetos a partir de sus identifica-
dores nicos.

Object:<set>(<==>,<
-> oParam;
-> sParamID;
-> sSenderID;
oParam <- params:<0>;
sParamID <- oParam:<id>;
sSenderID <- sender:<id>;
return <- sParamID:<==>(sSenderID);
>);

Aadimos a nil el mtodo == para poder compararlo cualquier otro objeto:

nil:<set>(<==>,<
-> oParam;
-> sParamID;
oParam <- params:<0>;
sParamID <- oParam:<id>;
return <- sParamID:<==>(<nil>);
>);

12.2.3.3 Operaciones Lgicas


Definimos, sobre las dos constantes lgicas, dos mtodos para la evaluacin de un
parmetro en funcin de su valor lgico. En la descosificacin de los miembros ifTrue e
ifFalse, se pasa como parmetro el cdigo a evaluar, representado como un objeto ca-
dena de caracteres.

true:<set>(<ifTrue>,<
-> _sTrueCode;
_sTrueCode <- params:<0>;
return <- _sTrueCode();
>);
true:<set>(<ifFalse>,<>);
false:<set>(<ifTrue>,<>);
false:<set>(<ifFalse>,<
-> _sFalseCode;
_sFalseCode <- params:<0>;
return <- _sFalseCode();
>);

En el objeto Boolean introducimos los mtodos if e ifElse.

Boolean:<set>(<if>,<
-> _sCode;
_sCode <- params:<0>;
return <- sender:<ifTrue>(_sCode);
>);
Boolean:<set>(<ifElse>,<
-> _sIfCode;
-> _sElseCode;
_sIfCode <- params:<0>;
_sElseCode <- params:<1>;
sender:<ifTrue>(_sIfCode);
sender:<ifFalse>(_sElseCode);
>);

175
CAPTULO 12

Aadimos al objeto trait Boolean las posibilidades de negar un objeto lgico y de


calcular las operaciones lgicas binarias and y or.

Boolean:<set>(<not>,<
-> _booleanNot_result;
sender:<ifElse>(
<_booleanNot_result <- false;>,
<_booleanNot_result <- true;>
);
return <- _booleanNot_result;
>);
Boolean:<set>(<and>,<
-> _booleanAnd_result;
-> _booleanAnd_bParam;
_booleanAnd_bParam <- params:<0>;
sender:<ifElse>(
< _booleanAnd_bParam:<ifElse>(
< _booleanAnd_result <- true; >,
< _booleanAnd_result <- false; >
);>,
< _booleanAnd_result <- false; >
)
return <- _booleanAnd_result;
>);
Boolean:<set>(<or>,<
-> _booleanOr_result;
-> _booleanOr_bParam;
_booleanOr_bParam <- params:<0>;
sender:<ifElse>(
< _booleanOr_result <- true; >,
< _booleanOr_bParam:<ifElse>(
< _booleanOr_result <- true; >,
< _booleanOr_result <- false; >
);>
);
return <- _booleanOr_result;
>);

En 12.1.4.1, se anticip el problema de ocultacin de referencias de los contextos


padre por la creacin de referencias locales de igual nombre. Supongamos el siguiente
ejemplo de programacin:

...
-> _sIfCode;
<* Campo booleano que expresa una condicin lgica *>;
booleano:<ifElse>(
< _sIfCode <- <Booleano es True> >; ,
< _sIfCode <- <Booleano es False>; );
<* Qu vale _sIfCode aqu? *>;
...

Escribiendo este cdigo, pretendemos que, en funcin de un valor, lgico la refe-


rencia _sIfCode posea un determinado valor; pero no lo conseguimos. La evaluacin del
miembro ifElse crea una referencia en su contexto (un nivel superior al actual) con
nombre _sIfCode. Los dos parmetros pasados se evalan en un contexto superior al
ltimo, accedindose a la referencia _sIfCode del contexto del miembro ifElse, y no al
deseado.
Como criterio general de programacin, definiremos nombres absolutos siempre
que queramos acceder a una referencia de un contexto padre desde cdigo a evaluar. Los
nombres absolutos podrn ser generados anteponiendo el nombre del objeto y del mtodo,

176
Diseo de la Mquina Abstracta

al nombre de la referencia55. Esto sucede en la referencia sCode del miembro while de


String que implementaremos posteriormente, as como en la referencia result de los
mtodos and, or y not de Boolean.
El criterio de utilizar referencias absolutas cuando accedamos a ellas desde contex-
tos derivados es una tarea sencilla para el generador de cdigo de un compilador. Sin em-
bargo, cuando codifiquemos directamente el entorno de programacin, el sistema no nos
obliga a codificar con este criterio, y deberemos proteger la sobreescritura de referencias.
De esta forma, siempre que un contexto cree referencias y posteriormente evale un cdi-
go pasado como parmetro, las referencias creadas comenzarn con el carcter subrayado
(_). Reservamos, pues, los identificadores que comiencen con este carcter para el desa-
rrollo de la plataforma, y no generar as ocultacin de referencias.

12.2.3.4 Iteraciones
Para programar de modo estructurado ser necesario soportar algn tipo de ins-
truccin iterativa. En nuestro caso crearemos esta funcionalidad basndonos en la evalua-
cin de objetos miembro y en la recursividad56. Implementaremos un mtodo while como
miembro del objeto String, siguiendo el siguiente diagrama de flujo:

false
< Condicin >

true

< Cuerpo Bucle >

Figura 12.5: Organigrama de la evaluacin del mtodo while.

La condicin, objeto implcito de la invocacin, ser representada como una cadena


de caracteres evaluable de forma sncrona y sin parmetros. En cada iteracin se evaluar
este objeto, que ser el parmetro implcito de la invocacin. La evaluacin de este tipo de
condicin deber devolver un valor lgico que, en caso de ser true, producir la evalua-
cin del cuerpo del bucle.
El cuerpo del bucle while es un objeto cadena de caracteres que ser evaluado de
forma sncrona. El cuerpo del bucle puede recibir parmetros que se le pasarn mediante
un objeto contenedor. Este objeto coleccionar los n parmetros etiquetndolos desde 0
hasta n-1.
55
Como tcnica de programacin, es una tarea tediosa puesto que ha de ser el programador el que lleve
esta responsabilidad. Sin embargo, el lenguaje de la mquina abstracta es un lenguaje de bajo nivel y no
est pensado para codificar directamente aplicaciones de usuario sobre l. Un compilador de un lenguaje
de alto nivel, podr generar automticamente las referencias siguiendo el criterio definido.
56
Obviamente la recursividad har que las estructuras iterativas sean menos eficientes que las existentes
en otras plataformas. Como se menciona en 12.2.3.6, la plataforma requiere la implementacin de la
optimizacin de recursividad por la cola (Tail Recursion Optimisation) [Kessin99] que disminuye la dife-
rencia de eficiencia. Sin embargo, queremos dejar constancia que la eficiencia no es un objetivo de nues-
tro diseo.

177
CAPTULO 12

La evaluacin del miembro while de un objeto cadena de caracteres objeto im-


plcito representante de la condicin a evaluar, recibir como primer parmetro el objeto
que representa el cuerpo del bucle y, como segundo, un objeto contenedor de los parme-
tros a pasar al cuerpo del while.
Como ejemplo, supongamos que nos encontramos en un contexto de ejecucin en
el que existen las referencias ref, objeto, metodo, param0 y param1 y deseamos:
Que en cada iteracin se compare la referencia ref con nil. Si la compara-
cin es cierta, se sigue iterando.
Que en cada iteracin, se evale el mtodo con nombre metodo, miembro de
objeto, pasndole los parmetros param0 y param1. El resultado de la eva-
luacin deber ser asignado a ref.
Una secuencia de instrucciones utilizadas en el contexto es la siguiente:

-> cParams
cParams <- nil:<new>()
cParams:<set>(<super>,Object)
cParams:<set>(<0>,objeto);
cParams:<set>(<1>,metodo);
cParams:<set>(<2>,param0);
cParams:<set>(<3>,param1);
< return <- ref:<==>(nil); >:<while> (
< -> cParams;
cParams <- params:<0>;
oObjeto <- cParams:<0>;
sMetodo <- cParams:<1>;
oParam0 <- cParams:<2>;
oParam1 <- cParams:<3>;
ref <- oObjeto:sMetodo(oParam0,oParam1);

>,
cParams
);

Realmente, el paso de todos los parmetros existentes en el contexto padre del nue-
vo contexto creado, para la evaluacin del miembro while es innecesario, puesto que des-
de un contexto se pueden acceder a las referencias de sus contextos padre.

Pila de Contextos

return params Contexto while

ref objeto metodo Contexto existente


param0 param1 antes de la invocacin

String nil extern Contexto Global

Figura 12.6: Referencias existentes en los contextos de ejecucin del miembro while.

Si se ejecuta el cuerpo del bucle como un contexto hijo del contexto que posee las
referencias ref, objeto, metodo, param0 y param1, no es necesario pasar stas como

178
Diseo de la Mquina Abstracta

parmetros al cuerpo. El paso de parmetros se utiliza precisamente cuando esto no ocurre


uno de los posibles usos, es el paso de parmetros de referencias a miembros. La imple-
mentacin anterior podra reducirse al siguiente cdigo:

< return <- ref:<==>(nil); >:<while> (


< ref <- objeto:metodo(param0,param1); > ,
nil
);

La implementacin del mtodo while evala la condicin objeto implcito,


sender y, en el caso de que sea cierta, se ejecutar el cuerpo seguido de una llamada re-
cursiva a la evaluacin del objeto while.

String:<set>(<while>,<
-> _stringWhile_sCode;
-> _stringWhile_cParams;
-> _bCond;
-> _stringWhile_sender
_stringWhile_sCode <- params:<0>;
_stringWhile_cParams <- params:<1>;
<* Condition is evaluated *>;
_bCond <- sender();
_stringWhile_sender <- sender;
_bCond:<if>(<
<* The while-code is evaluated *>;
_stringWhile_sCode(_stringWhile_cParams);
_stringWhile_sender:<while>(_stringWhile_sCode,
_stringWhile_cParams);
>);
>);

12.2.3.5 Recorrido de Miembros


El tratamiento genrico de todos los miembros de un objeto ser un proceso til en
su tratamiento introspectivo. Su clonacin, replicacin o almacenamiento en disco, son
ejemplos para los que la evaluacin de una rutina sobre todos los miembros de un objeto,
hace que se facilite su implementacin.
Implementaremos un mtodo forEach del objeto Object que permitir evaluar,
de forma iterativa, un cdigo con un determinado parmetro, para todos los miembros del
objeto implcito, excluyendo id y super. La invocacin de este mtodo ser de la forma:

objeto:<forEach>(<Cdigo a Evaluar>,parmetro);

El primer parmetro ser un cdigo a evaluar de forma sncrona, recibiendo ste, en


cada evaluacin, tres parmetros:
Como primer parmetro recibir una referencia a la clave o nombre del miem-
bro del objeto, propio de la iteracin.
El segundo parmetro ser una referencia al miembro asociado al nombre re-
presentado por el primer parmetro.
El ltimo parmetro ser el segundo argumento pasado en la evaluacin del
miembro forEach.
Implementaremos este miembro de la siguiente forma:

Object:<set>(<forEach>,<
-> _objectForEach_sCode;
-> _objectForEach_sKey;

179
CAPTULO 12

-> _objectForEach_cParams;
-> _objectForEach_sender;
_objectForEach_sCode <- params:<0>;
_objectForEach_cParams <- params:<1>;
_objectForEach_sKey <- sender:<firstKey>();
_objectForEach_sender <- sender;
<return <- _objectForEach_sKey:<!=>(nil);>:<while>(<
-> _bNotIsId;
-> _bNotIsSuper;
-> _bIsMember;
_bNotIsId <- _objectForEach_sKey:<!=>(<id>);
_bNotIsSuper <- _objectForEach_sKey:<!=>(<super>);
_bIsMember <- _bNotIsId:<and>(_bNotIsSuper);
_bIsMember:<ifTrue>(<
->_oContent;
_oContent <- _objectForEach_sender:
_objectForEach_sKey;
_objectForEach_sCode(_objectForEach_sKey,
_oContent,_objectForEach_cParams);
>);
_objectForEach_sKey <- _objectForEach_sender:<nextKey>(
_objectForEach_sKey);
>, nil);
>);

En la clonacin de objetos implementada en 12.2.7.2, se muestra un ejemplo de la


utilizacin de este miembro.

12.2.3.6 Bucles Infinitos


Hemos implementado iteraciones mediante llamadas recursivas, siendo stas menos
eficientes que los saltos en la ejecucin de cdigo ms propios de las mquinas fsicas
existentes. Sin embargo, a la hora de implementar un bucle infinito, este inconveniente de
ineficiencia se traduce en un error en tiempo de ejecucin: la llamada recursiva sin condi-
cin de parada agotar los recursos de nuestro sistema, desbordando la pila de contextos.
Para que nuestra mquina abstracta permita evaluar bucles infinitos mediante recur-
sividad, sin que se produzcan errores de ejecucin, es necesario implementar la optimiza-
cin de recursividad por la cola (Tail Recursion Optimisation) [Kessin99], implementada por
otros lenguajes como Scheme [Abelson2000].
La optimizacin comentada, puede realizarse cuando la ltima instruccin de un
mtodo es una evaluacin de un miembro o de una cadena de caracteres, y su resultado es
lo que devuelve este mtodo se le asigna a return. En el caso de que el mtodo se est
evaluando de forma asncrona, la ltima premisa no es necesaria.
En el caso de que la condicin mencionada en el prrafo anterior se cumpla, la in-
vocacin constituyente de la ltima instruccin no necesitar un nuevo contexto de ejecu-
cin. Pongamos un escenario como ejemplo:

Objeto:<set>(<metodo>,<
-> referencia1;
-> referencia2;
-> referencia3;
...
return <- referencia2:<otroMetodo>(referencia1,referencia3);
>);

El estado de la pila de contextos en la ejecucin de la ltima sentencia es:

180
Diseo de la Mquina Abstracta

referencia1
referencia2
referencia3 Contexto
del Mtodo
return params
Sender mySelf

Contextos de otras

invocaciones

String nil extern ... Contexto Global

Figura 12.7: Estado de la pila de contextos en la evaluacin del mtodo.

Si no se crea un nuevo contexto en la invocacin de otroMetodo, sucede lo si-


guiente:
1. Se sobreescribe el valor de sender, mySelf y params con los de la nueva in-
vocacin. No supone un problema puesto que, cuando finalice la ejecucin del
mtodo, estos valores no se utilizarn, ya que la evaluacin del mtodo es la l-
tima sentencia.
2. La referencia al valor de devolucin (return) se sobreescribe. Esto podra ser
un problema, puesto que no tiene por qu coincidir la devolucin de
otroMetodo con la de metodo. Por lo tanto, para llevar a cabo esta optimiza-
cin, es necesario que ambas coincidan, es decir, que la devolucin de la invo-
cacin de otroMetodo se asigne a return segunda premisa.
3. Las referencias locales existen en el contexto de la ejecucin de otroMtodo.
Esta caracterstica la ofrece nuestra mquina, al permitir acceder a los contextos
padre.
Si deseamos implementar un cdigo que se ejecute repetitivamente de forma inde-
finida, deberemos situar como ltima lnea de ste una invocacin a s mismo, y que la de-
volucin de dicha invocacin sea asignada a return. De esta forma, la mquina no gene-
rar un error de ejecucin.

12.2.4 Aritmtica de la Plataforma


En la mayora de los lenguajes de programacin existe el concepto de tipo, para re-
ducir el nmero de errores de programacin en tiempo de ejecucin, y para obtener una
mayor eficiencia en la representacin de la informacin. Nuestra plataforma no posee pro-
ceso de compilacin en su lenguaje nativo, por lo que no identifica tipos en su lenguaje de
programacin (un compilador de Java o C++ a esta plataforma, s podra realizar una com-
probacin esttica de tipos). Para la mquina abstracta, la comprobacin de tipos se realiza
en tiempo de ejecucin, para conocer si un determinado objeto posee un miembro
comprobacin dinmica de tipos [Cardelli97].
Aunque sea negativo respecto a la eficiencia de la plataforma, no identificamos ti-
pos relacionados con valores numricos, sino que manejamos una nica constante: la cade-

181
CAPTULO 12

na de caracteres. Determinadas evaluaciones sobrecargadas57 sobre este tipo de datos, im-


plementar dinmicamente una inferencia del tipo asociado, para conocer la semntica de la
operacin a realizar. Este proceso adicional conlleva una prdida de eficiencia frente a la
utilizacin de tipos estticos, puesto que es el usuario quien identifica el tipo de cualquier
objeto. Sin embargo, de este modo se reduce el nmero de primitivas operacionales de la
plataforma.
Los objetos cadena de caracteres pueden identificar tres semnticas totalmente dis-
tintas:
Semntica numrica. La representacin de los datos se interpretar como un
contenido numrico. Se podrn realizar operaciones numricas tpicas sobre es-
tos datos, teniendo en cuenta que se puede establecer, a su vez, una clasificacin
numrica como58:
1. Entera. Constantes enteras con signo opcional.
2. Real. Representacin real en formato de punto fijo y mantisa ms exponen-
te.
Semntica computacional. Las cadenas de caracteres pueden poseer datos eva-
luables o descosificables, para producir computacin de la plataforma.
Semntica de datos. Las cadenas de caracteres podrn ser datos cuyo significado
ser interpretado por el humano.
En los rangos numricos preestablecidos por los lenguajes de programacin, se es-
pecifica el tamao que necesitar una variable de dicho tipo. En nuestra plataforma no de-
finimos tamaos mximos, sino que stos se limitan al tamao de la plataforma fsica de
ejecucin. Al representar los valores numricos como cadenas de caracteres, no limitare-
mos su longitud59.
Es importante observar que tanto la clasificacin de tipos numricos (enteros y re-
ales), como la no-restriccin de rangos en stos, es posible modificarlos en cualquier mo-
mento, sin necesidad de modificar la mquina abstracta. Al separar la semntica de las ope-
raciones de la propia plataforma, rompemos con las definiciones monolticas clsicas de
mquinas virtuales, y nos permite definir su lenguaje con diversas caractersticas
adaptabilidad. Un ejemplo sera primar la eficiencia optando por:
Definir nuevos tipos numricos basados en objetos traits al igual que Smalltalk.
Definir rangos mximos para los valores numricos.
No definir mensajes sobrecargados con distintas semnticas que necesiten ana-
lizar lxicamente el tipo de dato.

12.2.4.1 Miembros de Semntica Aritmtica


Existe un conjunto de mensajes polimrficos respecto al tipo de dato numrico al
que puede ser aplicado. Los siguientes objetos son miembros del objeto trait String, que
define la semntica obvia para valores numricos enteros y reales:

57
Operacin sobrecargada en relacin con la teora de tipos definida por Luca Cardelli [Cardelli97].
58
Podemos insertar ms grupos de representacin numrica, como por ejemplo nmeros racionales, sin
necesidad de modificar la mquina, puesto que esta semntica estar implementada de forma externa.
59
Java permite utilizar los tipos simples restringiendo su rango, pero tambin posee la clase
java.math.BigInteger para representar enteros sin lmites [Gosling96].

182
Diseo de la Mquina Abstracta

Miembro +: Suma.
Miembro -: Diferencia
Miembro *: Producto.
Miembro /: Divisin.
Para todos estos miembros se define la semntica de tipos de la siguiente forma60:
Si los dos operandos son ambos nmeros enteros, el objeto devuelto es un n-
mero entero.
Si los dos operandos son numricos y uno de ellos es real, el resultado es num-
rico y real.
Si alguno de los dos no posee semntica numrica, el resultado es nil, excepto
en el caso del miembro +, en que se devuelve una concatenacin de las cadenas
de caracteres.
Adems definimos:
Miembro %: Semntica de resto sobre nmeros enteros. Devuelve nil en el ca-
so de que al menos uno de los dos operandos no sea un nmero entero.
A continuacin aadimos esta computacin a la plataforma:

String:<set>(<+>,<
-> sParam;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,<+>,sender,sParam);
>);
String:<set>(<->,<
-> sParam;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,<->,sender,sParam);
>);
String:<set>(<*>,<
-> sParams;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,<*>,sender,sParam);
>);
String:<set>(</>,<
-> sParam;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,</>,sender,sParam);
>);
String:<set>(<%>,<
-> sParam;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,<%>,sender,sParam);
>);

12.2.5 Miembros Polimrficos de Comparacin


Definimos un conjunto de miembros polimrficos de comparacin en el objeto
String; todos ellos devuelven objetos lgicos. Su significado va a ser siempre el mismo,
aunque trabaje con distintos tipos de datos inferidos dinmicamente:

60
Estas expresiones de tipo podran variar introduciendo por ejemplo el lgebra de nmeros racionales.

183
CAPTULO 12

Miembro ==. Comparacin de igualdad. Se podr comparar valores numricos


y datos cadena de caracteres polimrficamente. Por ejemplo, la comparacin
<3.2>:<==>(<32E-1>) debe devolver true, aunque la comparacin lexico-
grfica como cadena de caracteres resulte falsa.
Miembro !=. Comparacin de desigualdad.
Miembro >. Comparacin mayor.
Miembro >=. Comparacin mayor o igual.
Miembro <. Comparacin menor.
Miembro <=. Comparacin menor o igual.
Para implementar estas operaciones polimrficas de comparacin, apoyndonos en
primitivas externas, slo necesitamos dos de ellas y las operaciones lgicas ya definidas.
Vamos a definir como primitivas, las operaciones de igualdad y mayor:
Operaciones a implementar Implementacin sobre primitivas Igual y Mayor
Distinto NOT( Igual )
Mayor o Igual OR( Igual, Mayor )
Menor AND( NOT( Mayor ), Distinto )
Menor o Igual NOT( Mayor )
Reducimos as el nmero de primitivas a implementar, codificando las operaciones
de la siguiente forma (la operacin de igualdad ha sido implementada previamente):

String:<set>(<\>>,<
-> sParam;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,<\>>,sender,sParam);
>);
String:<set>(<!=>,<
-> sParam;
-> bEqual;
sParam <- params:<0>;
bEqual <- sender:<==>(sParam);
return <- bEqual:<not>();
>);
String:<set>(<\>=>,<
-> sParam;
-> bEqual;
-> bGreater;
sParam <- params:<0>;
bEqual <- sender:<==>(sParam);
bGreater <- sender:<\>>(sParam);
return <- bEqual:<or>(bGreater);
>);
String:<set>(<\<>,<
-> sParam;
-> bGreater;
-> bNotGreater;
-> bNotEqual;
sParam <- params:<0>;
bGreater <- sender:<\>>(sParam);
bNotGreater <- bGreater:<not>();
bNotEqual <- sender:<!=>(sParam);
return <- bNotGreater:<and>(bNotEqual);
>);

184
Diseo de la Mquina Abstracta

String:<set>(<\<=>,<
-> sParam;
-> bGreater;
sParam <- params:<0>;
bGreater <- sender:<\>>(sParam);
return <- bGreater:<not>();
>);

12.2.6 Miembros de Objetos Cadena de Caracteres


Como miembros del objeto String, tratando los objetos como datos simples (no
numricos ni computacin), definimos tres primitivas que nos facilitarn el manejo de estos
datos:
Miembro append. Este miembro siempre devolver la concatenacin del pa-
rmetro implcito y el parmetro pasado. Esta semntica se produce con el
miembro +, siempre que alguno de los operandos no sea numrico.
Miembro length. Devuelve un objeto cadena de caracteres con semntica en-
tera, indicando el nmero de caracteres que posee el parmetro implcito.
Miembro subString. Recibe dos parmetros cadena de caracteres de semn-
tica numrica. El primero indica una posicin; el segundo, el nmero de carac-
teres a raz de los cuales se devolver un objeto cadena de caracteres, que con-
tenga el nmero indicado, a partir de la posicin sealada por el primer parme-
tro, dentro del objeto implcito.
Para pasar dos parmetros con una sola referencia, creamos un objeto contene-
dor con dos miembros etiquetados como <0> y <1>.
Estas operaciones son todas de semntica primitiva:

String:<set>(<append>,<
-> sParam;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,<append>,sender,sParam);
>);
String:<set>(<length>,<
-> sParam;
sParam <- params:<0>;
return <- Extern:<invoke>(<String>,<length>,sender,sParam);
>);
String:<set>(<subString>,<
-> sp0;
-> sp1;
-> sPs;
sp0 <- params:<0>;
sp1 <- params:<1>;
sPs <- nil:<new>();
sPs:<set>(<super>,Object);
sPs:<set>(<0>,sp0);
sPs:<set>(<1>,sp1);
return <- Extern:<invoke>(<String>,<subString>,sender,sPs);
>);

12.2.7 Creacin de Abstracciones e Instancias


El concepto de abstraccin, en un lenguaje de programacin orientado a objetos
basado en clases, viene designado por las clases [Booch94]. Las instancias u objetos de s-
tas son entidades concretas, con igual estructura comportamiento definidos por su clase.

185
CAPTULO 12

En lenguajes orientados a objetos basados en prototipos, no existe el concepto de


clase ni el concepto de instancia de sta; slo existe el concepto de objeto. La computacin
o comportamiento genrico de un grupo de objetos, podemos identificarlo en objetos de
rasgo (trait); las instancias o datos concretos, en copias creadas mediante reflectividad es-
tructural de prototipos creados a priori. De esta forma, tendremos la misma expresividad
que el modelo de clases, pero con tan slo la abstraccin del objeto [Evins94].

Modelo Basado Modelo Basado


en Prototipos en Clases

nil

Coche
Object
color Clase

pintar
Coche
Objeto
trait pintar

<azul>
miCoche:Coche
Objeto o
prototipoCoche miCoche Instancia
color=azul
color color

Copia del prototipo

Figura 12.8: Modelo basado en clases frente al basado en prototipos.

La delegacin es fundamental para especificar comportamientos y estructuras co-


munes entre objetos: si, al recibir un mensaje, un objeto no posee un miembro con igual
nombre que el mensaje, delega la ejecucin de este mtodo en su objeto padre; si ste lti-
mo especifica dicho comportamiento (objeto trait), estar definiendo el funcionamiento
genrico de todos sus objetos derivados.
Siguiendo con este diseo de identificacin de abstracciones y entidades, crearemos
funcionalidades para ayudar al programador a realizar estas operaciones de forma automti-
ca, extendiendo as la abstraccin de la plataforma.

12.2.7.1 Creacin de Abstracciones


Para englobar el comportamiento y estructura de un conjunto de objetos, vamos a
utilizar el concepto de objeto trait en el modelo de prototipos, de forma similar a la crea-
cin de clases en los modelos de objetos clsicos.
La creacin de este tipo de objetos deber realizarse de forma automtica, mediante
la invocacin a un mtodo. Para ello, implementaremos en Object un miembro
newChild, que nos permita crear un descendiente directo del objeto utilizado como pa-
rmetro implcito.

Object:<set>(<newChild>,<
-> newTrait;
newTrait <- sender:<new>();
newTrait:<set>(<super>,sender);
return <- newTrait;
>);

186
Diseo de la Mquina Abstracta

Si queremos crear un objeto trait Figura que derive de Object, podremos hacer-
lo mediante la utilizacin de este miembro. Volviendo a evaluar el mismo miembro, pero
utilizando como parmetro implcito el objeto Figura, podremos crear un objeto deriva-
do de este ltimo.

figuraTrait <- Object:<newChild>();


elipseTrait <- figuraTrait:<newChild>();

En ocasiones, necesitaremos crear objetos de comportamiento y asignarle un identi-


ficador determinado. El miembro newChildWithId de Object implementa estos dos
pasos en una sola abstraccin.

Object:<set>(<newChildWithId>,<
-> newTrait;
-> ID;
ID <- params:<0>;
newTrait <- sender:<newChild>();
newTrait:<set>(<id>,ID);
return <- newTrait;
>);

Ahora podremos hacer:

figuraTrait <- Object:<newChildWithId>(<{Figura}>);


elipseTrait <- figuraTrait:<newChildWithId>(<{Elipse}>);

La instanciacin producida en los lenguajes basados en clases supone crear zonas


de memoria, en las que una entidad concreta (objeto), de una representacin genrica (cla-
se), pueda almacenar sus propios datos.
En el modelo de prototipos, el proceso de instanciacin puede traducirse a una co-
pia de prototipos. En nuestro diseo de la imagen de la plataforma, todo objeto de rasgo
poseer una referencia a un objeto-instancia prototpico, que albergar los datos caracters-
ticos de cualquier entidad definida por la abstraccin representada: su estructura [Booch94].
Cuando queramos crear un objeto, copiaremos el prototipo y modificaremos los
valores de los miembros de la copia, representando el estado de la nueva entidad. De este
modo, los objetos trait expresan, no slo agrupacin de comportamientos, sino tambin
estructuras comunes al igual que las clases.
Puesto que la plataforma no separa los objetos trait de los representativos de enti-
dades, debemos ser nosotros, en la creacin de la extensin del lenguaje de la mquina, los
que ofrezcamos esta distincin. As, un objeto de rasgo debe poseer una referencia a su
prototipo, ofreciendo un mtodo de instanciacin automtico. Haciendo uso de la reflecti-
vidad estructural ofrecida por la mquina, implementaremos un miembro newPrototype
del objeto Object, que permita crear prototipos, si no existiesen previamente, de un obje-
to de comportamiento.

Object:<set>(<newPrototype>,<
-> bAlreadyExists;
-> objectNewPrototype_result;
-> objectNewPrototype_oTrait;
bAlreadyExists <- sender:<has>(<prototype>);
objectNewPrototype_oTrait <- sender;
bAlreadyExists:<ifElse>(<
-> oPrototype;
oPrototype <- objectNewPrototype_oTrait:<newChild>();
objectNewPrototype_oTrait:<set>(<prototype>,oPrototype);
objectNewPrototype_result <- oPrototype; >
,<

187
CAPTULO 12

objectNewPrototype_result <-
objectNewPrototype_oTrait:<prototype>;
>);
return <- objectNewPrototype_result;
>);

Pasndole a un objeto trait el mensaje newPrototype, se le asignar un miembro


prototype que apunte a un nuevo objeto derivado de ste, devolvindolo como resulta-
do de la invocacin.

12.2.7.2 Copia de Prototipos


Hemos desarrollado cdigo para la creacin automtica de objetos derivados y de
objetos prototipo. El siguiente paso es crear un mecanismo para la copia de prototipos de
objetos trait. Para ello, analizaremos el siguiente ejemplo de herencia simple en dos niveles,
tanto para el modelo basado en clases, como para su traduccin a nuestro diseo.
Modelo Basado Modelo Basado
en Clases
en Prototipos

Figura
nil
x, y

mover
Object mostrar
ocultar

Figura

prototype
Rectngulo Circunferencia
mover
mostrar ancho, alto radio
ocultar
mostrar mostrar

Rectngulo Circunferencia :Rectngulo


x<0> :Circunferencia
mostrar mostrar y<0> ancho=10
prototype prototype alto=20 radio=15
x=10 x=12
y=30 y=2
ancho<0> x<10> x<12> radio<0>
alto<0> y<30> y<2>
ancho<10> radio<15>
alto<20>

Figura 12.9: Abstraccin e instanciacin en modelos basados en clases y prototipos.

Como se muestra en la figura, la creacin de una instancia no se limita simplemente


a la copia de un objeto aunque utilicemos la expresin copia de prototipos. Al crear una
instancia de una clase que posee otras clases heredadas, la representacin en memoria del
objeto creado constituye la unin de todas las estructuras representadas ascendentemente
en el rbol. De esta forma, la creacin de una instancia de Rectngulo supone crear una
zona de memoria para albergar sus propiedades alto y ancho propias del rectngulo ,
as como las propiedades x e y referentes a su condicin de Figura.
De forma paralela, la construccin de objetos a raz de la copia de prototipos, debe-
r llevarse a cabo de igual modo que su representacin en el modelo de clases. El objeto
Rectngulo posee un prototipo con las propiedades ancho y alto. La creacin de un
objeto rectngulo no se reduce a copiar este prototipo, sino que se deben aadir las
propiedades de los objetos prototipos heredados en nuestro caso los de Figura y
Object, si los hubiere.

188
Diseo de la Mquina Abstracta

Antes de implementar el algoritmo de instanciacin, definiremos la forma en la que


vamos a copiar cada miembro de un objeto prototipo. Cada objeto definir polimrfica-
mente cmo se han de realizar sus copias, mediante la implementacin del miembro
clone.
Los objetos primitivos de tipo String, al ser constantes, implementan sus clona-
ciones como la devolucin del propio objeto. Esto mismo sucede en el caso de los objetos
constantes lgicos true y false.

String:<set>(<clone>,< return <- sender; >);


Boolean:<set>(<clone>,< return <- sender; >);

La clonacin de cualquier objeto distinto de String consistir en un algoritmo re-


cursivo que se desglosa en los siguientes pasos:
Creacin de un objeto derivado del mismo objeto base del objeto a copiar.
Creacin de tantos miembros como miembros tiene el objeto a clonar.
Cada miembro creado ser la clonacin de los miembros originales, excluyendo
id y super.

Object:<set>(<clone>,<
-> objectClone_oNewObject;
-> oSenderSuper;
-> sCode;
oSenderSuper <- sender:<super>;
objectClone_oNewObject <- sender:<new>();
objectClone_oNewObject:<set>(<super>,oSenderSuper);
sCode <- <
-> sKey;
-> oContent;
-> bIsContentNil;
-> oNewContent;
sKey <- params:<0>;
oContent <- params:<1>;
bIsContentNil <- oContent:<==>(nil);
bIsContentNil:<ifFalse>(< oNewContent <-
oContent:<clone>(); >);
objectClone_oNewObject:<set>(sKey,oNewContent);
>;
sender:<forEach>(sCode,nil);
return <- objectClone_oNewObject);
>);

La implementacin de la instanciacin de un objeto a travs de la copia de prototi-


pos se realizar mediante el miembro copyPrototypes del objeto Object, siguiendo
los siguientes pasos:
Creacin de un objeto hermano (de igual padre) que el objeto prototipo del trait
utilizado como parmetro implcito.
Iterar con todos los prototipos partiendo del prototipo actual, en sentido as-
cendente, hasta el objeto nil, haciendo:
1. Tomar el prototipo, si lo tiene definido, del objeto que se est analizando.
2. Aadir al objeto creado una clonacin de cada miembro del prototipo anali-
zado, mediante la utilizacin de los mtodos forEach y clone.

Object:<set>(<copyPrototypes>,<
-> objectCopyPrototypes_oTrait;

189
CAPTULO 12

-> objectCopyPrototypes_oNewObject;
objectCopyPrototypes_oNewObject <- sender:<newChild>();
objectCopyPrototypes_oTrait <- sender;
<return <- objectCopyPrototypes_oTrait:<!=>nil;>:<while>(<
-> bHasPrototype;
bHasPrototype <- objectCopyPrototypes_oTrait:<has>(
<prototype>);
bHasPrototype:<ifTrue>(<
-> sCode;
-> oPrototype;
oPrototype <- objectCopyPrototypes_oTrait:
<prototype>;
sCode <- <
-> sKey;
-> objectCopyPrototypes_oContent;
-> objectCopyPrototypes_oClone;
-> bIsNotContentNil;
sKey <- params:<0>;
objectCopyPrototypes_oContent <- params:<1>;
bIsNotContentNil <-
objectCopyPrototypes_oContent:
<!=>(nil);
bIsNotContentNil:<ifTrue>(<
objectCopyPrototypes_oClone <-
objectCopyPrototypes_oContent:
<clone>();>);
objectCopyPrototypes_oNewObject:<set>(sKey,
objectCopyPrototypes_oClone);
>;
oPrototype:<forEach>(sCode,nil);
>);
objectCopyPrototypes_oTrait <-
objectCopyPrototypes_oTrait:<super>;
>, nil);
return <- objectCopyPrototypes_oNewObject;
>);

12.2.8 Implementaciones Externas Requeridas


La funcionalidad ofrecida por la plataforma hasta este momento definicin de una
lgica y sus operaciones ( 12.2.3.3), comparacin de objetos (12.2.5), iteracin (12.2.3.4),
tratamiento genrico de miembros (12.2.3.5), aritmtica numrica real y entera (12.2.4),
tratamiento de cadenas de caracteres (12.2.6), creacin de abstracciones (12.2.7.1) e ins-
tanciacin (12.2.7.2) ha sido desarrollada mediante su propio lenguaje de programacin,
extendiendo su nivel de abstraccin. El conjunto de primitivas operacionales utilizadas
externamente ha sido el siguiente:
Objeto Miembro Parmetros Descripcin
String == 1: Objeto String Compara dos objetos String y devuelve
una referencia a un valor lgico. Esta
operacin posee semntica numrica y
lxica.
String > 1: Objeto String Compara dos objetos String y devuelve
una referencia a un valor lgico. Esta
operacin posee semntica numrica y
lxica.
String + 1: Objeto String Realiza la operacin suma de forma
polimrfica: Semntica numrica y lxi-
ca si no representa nmeros.

190
Diseo de la Mquina Abstracta

Objeto Miembro Parmetros Descripcin


String - 1: Objeto String Realiza la operacin diferencia binaria
de forma polimrfica: Semntica num-
rica en cualquier formato.
String / 1: Objeto String Realiza la operacin divisin de forma
polimrfica: Semntica numrica en
cualquier formato.
String * 1: Objeto String Realiza la operacin producto de forma
polimrfica: Semntica numrica en
cualquier formato.
String % 1: Objeto String Realiza la operacin mdulo de forma
polimrfica: Semntica numrica tan
solo para enteros.
String append 1: Objeto String Devuelve el resultado de concatenar el
parmetro implcito y el parmetro pa-
sado.
String length - Devuelve la longitud en caracteres del
parmetro implcito.
String subString 1: Entero Devuelve un objeto cadena de caracte-
res resultado de tomar el segundo pa-
2: Entero
rmetro de caracteres a partir del carc-
ter con posicin primer parmetro.

12.3 Implantacin y Acceso a la Plataforma


La mquina abstracta del entorno de computacin ser implementada como un
proceso dentro de un determinado sistema operativo61. La mquina deber ser capaz de
interactuar con otras aplicaciones del sistema operativo, as como con otras mquinas abs-
tractas distribuidas a lo largo de una red de computadores.
La implantacin de la mquina abstracta ha de proporcionar al usuario la ilusin de
poseer otro microprocesador, capaz de computar cdigo de esta plataforma, y que pueda
interactuar a su vez con el sistema operativo existente. De este modo, la una aplicacin de
nuestra plataforma podr intercomunicarse con otra aplicacin o con una vista grfica de
sta dentro del sistema operativo en el que se haya sido hospedada.
Sobre cada plataforma real, se elegir un protocolo de interconexin de procesos,
para poder abrir el proceso de la mquina abstracta a otras aplicaciones del sistema operati-
vo. En cada sistema operativo podr existir un protocolo de interconexin distinto como
COM, CORBA o Sockets TCP/IP. Un ejemplo de una aplicacin nativa al operativo, puede
ser un editor e intrprete de programacin en el lenguaje de la mquina abstracta, que enve
las instrucciones a la plataforma, y los resultados de la interpretacin sean visualizados gr-
ficamente.

61
Su implementacin fsica tambin podr llevarse a cabo, al igual que la plataforma Java ha implemen-
tado su picoJava [Sun97].

191
CAPTULO 12

Protocolo de
interconexin de
procesos del sistema
Aplicacin nativa en un Sistema Operativo operativo seleccionado
Archivo Edicin Ver Herramientas Ayuda

Interfaz de Mquina Abstracta


la mquina

Mensaje Protocolo de invocacin


a libreras del sistema
Este es el texto de un operativo seleccionado
mensaje mostrado al
usuario Interfaz de las
implementaciones
Aceptar Cancelar externas

Implementaciones
Externas
Aplicacin Nativa del Sistema Operativo Seleccionado

Figura 12.10: Acceso a la mquina abstracta desde aplicaciones del sistema operativo seleccionado.

En la figura anterior se muestra cmo una aplicacin puede acceder a la plataforma,


utilizando un mecanismo estndar de interconexin de procesos dentro del sistema opera-
tivo seleccionado en la implantacin. Para computar instrucciones por la mquina, puede
requerirse el acceso a implementaciones externas y, para acceder a stas, la plataforma utili-
zar un mecanismo estndar de invocacin a libreras extensibles.
Puesto que la interconexin entre las aplicaciones y la mquina abstracta ser de-
pendiente del sistema operativo utilizado, no podremos transferir entre ellos objetos de
nuestra plataforma. As, las primitivas de intercomunicacin utilizaran nicamente cadenas
de caracteres, eliminando el establecimiento previo de representacin de la informacin62.
La interfaz de llamadas que la mquina abstracta ofrece al sistema operativo utiliza-
do es la siguiente:
1. newReference. Como nico parmetro recibe el nombre de la referencia que
se desea crear en el contexto inicial. Esta referencia se eliminar (finalizar su
contexto) al finalizar la ejecucin de la mquina abstracta.
2. getMember. Recibe como parmetros el identificador del objeto implcito y el
nombre del miembro a acceder. Devuelve el identificador del miembro selec-
cionado.
3. evaluateMemberSync. Evala un miembro de forma sncrona. Recibe como
parmetros el identificador del objeto implcito, el identificador del objeto a
partir del cual se realiza la bsqueda del miembro (para encontrar a mySelf), el
nombre del miembro, y los identificadores de los parmetros63.
La especificacin del objeto a raz del cual se va a realizar la bsqueda del
miembro no tiene mucho sentido en la interfaz local de usuario siempre coin-
cidirn. Sin embargo, la separacin de la referencia sender y mySelf es nece-
saria en la invocacin entre mquinas abstractas distribuidas en concreto, en el
caso en el que el objeto trait se halle en una mquina distinta al referenciado por
sender.

62
Realmente, las cadenas de caracteres van a representar los identificadores nicos de los objetos utiliza-
dos por la mquina abstracta.
63
Puesto que no podemos suponer que la interconexin entre procesos posea sobrecarga, los identificado-
res de los parmetros se pasarn como un nico argumento cadena de caracteres, separando cada elemen-
to con el carcter coma.

192
Diseo de la Mquina Abstracta

La devolucin del mtodo es el identificador del objeto referenciado por


return, tras la ejecucin del mtodo.
4. evaluateMemberAsync. Evala un miembro de forma asncrona. Los par-
metros son los mismos que en la evaluacin sncrona, salvo que no se obtiene
un resultado.
5. evaluateStringSync. Evala un objeto cadena de caracteres de forma sn-
crona en el contexto cero. Recibe como parmetros el objeto y una cadena de
caracteres con todos los identificadores de los parmetros. Devuelve el identifi-
cador del objeto devuelto.
6. evaluateStringAsync. Evala un objeto cadena de caracteres de forma
asncrona. Recibe los mismos parmetros que la evaluacin sncrona y no de-
vuelve ningn valor.
La interfaz de llamadas ser siempre el mismo; el mecanismo de intercomunicacin
entre el proceso de la aplicacin y el proceso de la mquina abstracta, ser dependiente del
sistema operativo utilizado.

193
CAPTULO 13:
DISEO DEL ENTORNO DE PROGRAMACIN

Una vez descrita la mquina abstracta, presentaremos la estructura global del desa-
rrollo de funcionalidades del entorno de programacin desarrollado, sin entrar en un nivel
elevado de detalle64, sirviendo como demostracin de la extensibilidad y adaptabilidad ofre-
cidas por la plataforma.
Basndonos en la arquitectura presentada para el sistema (captulo 9), el entorno de
programacin supone una ampliacin de las funcionalidades computacionales ofrecidas
inicialmente por la plataforma, utilizando para ello su propio lenguaje, sin necesidad de
modificar la implementacin de la mquina virtual.
Como ejemplo demostrativo de la flexibilidad de la plataforma diseada, mostrare-
mos cmo llevar a cabo la implementacin de sistemas de persistencia, distribucin, plani-
ficacin de hilos y recoleccin de basura; todas ellas desarrolladas sobre la propia platafor-
ma y diseadas de forma adaptable de forma que puedan ser introducidos nuevos meca-
nismos dinmicamente, sin necesidad de modificar la aplicacin.

13.1 Recoleccin de Basura


Haciendo uso de:
La introspeccin de la plataforma para descubrir sus objetos existentes en tiem-
po de ejecucin, mediante la utilizacin del objeto System.
La reflectividad estructural ofrecida por todo objeto para crear, modificar y co-
nocer todos sus miembros.
La introspeccin ofrecida en el conocimiento del nmero de referencias que
apuntan dinmicamente a un objeto miembro primitivo getRefCount del
objeto nil.
La primitiva de destruccin de objetos en superficie delete.

64
Por motivos de espacio, reduciremos la presentacin del entorno de computacin a anlisis y diseo,
sin mostrar toda su codificacin. Para acceder a ella, consltese [Dez2001].

195
CAPTULO 13

Se disear un sistema de recoleccin de basura que sea capaz de eliminar autom-


ticamente los objetos no referenciados de nuestro sistema. ste ser codificado en el pro-
pio lenguaje de la mquina, demostrando su faceta extensible.
El diseo ser adaptable a distintos algoritmos de recoleccin, as como a distintas
polticas de invocacin a ste. La configuracin de ambos parmetros podr llevarse a cabo
dinmicamente, sin necesidad de finalizar la ejecucin de ninguna aplicacin
adaptabilidad.

13.1.1 Diseo General del Sistema


Mediante la extensibilidad ofrecida por la mquina abstracta, desarrollaremos en su
propio lenguaje un sistema de recoleccin de basura, genrico respecto al algoritmo y a la
poltica de ejecucin del limpiado de objetos. El conjunto de objetos utilizados, se muestra
en la siguiente figura:
Object
new

GCAlgorithm gc GCPolicy
algorithm gc
policy
wakeUp
wait
start
setGCAlgorithm
refCountGC
setGCPolicy
Algorithm
amountOf
clean ObjectsCreated
Policy
alpha, nObjects
objectCreated

Figura 13.1: Objetos utilizados en el diseo del recolector de basura.

El objeto central es gc, recolector de basura (Garbage Collector). ste posee una refe-
rencia miembro a su algoritmo de limpiado, algorithm, y a su poltica de activacin,
policy cundo salta el algoritmo de eliminacin de objetos, como un nuevo hilo. Am-
bos parmetros son adaptables dinmicamente, siguiendo el patrn de diseo Template Met-
hod [GOF94].
Todo algoritmo de recoleccin deber ser objeto derivado de GCAlgorithm e im-
plementar nicamente un miembro evaluable clean. Cualquier poltica a utilizar activar la
eliminacin de objetos como un nuevo hilo del sistema mtodo wakeUp. Un objeto deri-
vado de GCPolicy, simplemente deber invocar a este mtodo cuando surja el evento
apropiado.

13.1.2 Recoleccin Genrica


Mediante la utilizacin del patrn Template Method, el sistema implementa el mtodo
start, derogando el limpiado de objetos en el mtodo clean de su miembro
algorithm. El mtodo clean utiliza el propio objeto gc como monitor. El resultado es
un bucle infinito que espera la apertura del monitor, para ejecutar el mtodo clean de su
asociado algorithm, y volver a dormirse.
Para la ejecucin del recolector de basura, se ha de seleccionar la poltica y el algo-
ritmo a utilizar, y se deja el sistema dormido a la espera de evaluar nuevas instrucciones

196
Diseo del Entorno de Programacin

desde el sistema operativo65 invocando a su mtodo start. Estos dos parmetros son
totalmente adaptables en tiempo de ejecucin, mediante la utilizacin de los mtodos
setGCAlgorithm y setGCPolicy.

gc:<setGCAlgorithm>(refCountGC);
gc:<setPolicy>(amountOfObjectsCreatedPolicy);
gc:<start>();

13.1.3 Algoritmos de Recoleccin


Como hemos visto en el punto anterior, el algoritmo genrico de activacin del re-
colector de basura espera a que se active su invocacin, para evaluar el miembro clean del
algoritmo seleccionado. Cualquier objeto derivado de GCAlgorithm que implemente este
mtodo, podr ser utilizado como recolector de basura. Su adaptacin dinmica ser lleva-
da a cabo a travs del mtodo setGCAlgorithm del objeto gc. La implementacin de
este mtodo deber utilizar su objeto padre como monitor para sincronizarse con
setGCAlgorithm, eliminando la posibilidad de modificar ste en plena ejecucin del
algoritmo.
Un algoritmo de ejemplo (refCountGCAlgoritm) puede ser aqul que recorre
todos los objetos del sistema y, tras invocar a su mtodo getRefCount, elimina aqullos
que posean nicamente una referencia a ellos esta nica referencia es la que posee todo
objeto, como miembro del objeto System.
La existencia de referencias cclicas entre objetos inaccesibles y que por tanto de-
ban eliminarse puede detectarse haciendo uso de la reflectividad estructural. A partir de un
objeto, podemos analizar todos sus miembros de forma recursiva, para detectar posibles
ciclos.
Este algoritmo es un ejemplo del desarrollo de un recolector de basura en su propio
lenguaje, sirviendo como ejemplo demostrativo de la extensibilidad del sistema. Otros algo-
ritmos ms sofisticados pueden implementarse y registrarse mediante setGCAlgorithm,
demostrando as su adaptabilidad.

13.1.4 Polticas de Activacin


El diseo del sistema se basa en activar la limpieza de objetos cuando se produzca
un determinado evento. Tanto el algoritmo de recoleccin como el modo (poltica) de ge-
nerar estos eventos, son configurables en el sistema. Cada invocacin al mtodo wakeUp
sincronizado con setGCPolicy, utilizando el monitor GCPolicy provoca la ejecucin
del algoritmo de recoleccin abriendo el monitor gc.
Una implementacin de poltica de invocaciones al recolector de basura, puede ser
la superacin de un umbral de creacin de objetos alpha. Cada vez que se cree un obje-
to, se incrementa un contador y, si ste supera el umbral, se invoca al recolector de basura
(wakeUp).
La implementacin de
esta poltica es desarrollada en el objeto
amountOfObjectsCreatedPolicy. Para controlar la creacin de objetos, derogamos
el mtodo new de nil, ubicando una nueva implementacin en Object: cada vez que se

65
Si se desea ejecutar ms instrucciones de la imagen, la invocacin al mtodo start puede realizarse
de forma asncrona.

197
CAPTULO 13

ejecute ste, se crea el objeto y se invoca al mtodo objectCreated de


amountOfObjectsCreatedPolicy.

13.2 Planificacin de Hilos


La plataforma ha sido diseada con primitivas de multitarea. La creacin de hilos se
puede realizar mediante la invocacin asncrona de mtodos. La sincronizacin de los dis-
tintos hilos se puede obtener mediante el uso de los objetos como si fuesen monitores: los
miembros primitivos enter y exit del objeto nil, sincronizan el hilo activo en funcin
del recurso identificado por el objeto implcito. Las instrucciones primitivas de la platafor-
ma han de ser consideradas de ejecucin atmica.
Al igual que la mquina virtual de Java [Sun95], la especificacin de nuestra plata-
forma ofrece un sistema computacional multihilo, pero deja el modo en el que se realice su
planificacin como dependiente de la implementacin de la mquina virtual. La mquina
abstracta no especifica cmo han de ejecutarse sus distintos hilos.
Siguiendo con los criterios de diseo de nuestro sistema, el planificador de hilos
deber construirse sobre su propio lenguaje (extensibilidad), y podr adaptarse dinmica-
mente a las necesidades del usuario (adaptabilidad). Construiremos, pues, una jerarqua de
objetos, cuyos servicios nos permitan ofrecer al usuario un sistema de control flexible del
planificador de hilos del entorno de computacin. Se podr implementar cualquier tipo de
planificador, se podr seleccionar uno en tiempo de ejecucin y modificar posteriormente,
as como aadir planificadores nuevos.

13.2.1 Creacin de Mtodos


La forma de evaluar cdigo primitivamente en nuestra plataforma es llevada a cabo
por la mquina en la evaluacin de objetos miembros o de cadenas de caracteres. La eva-
luacin sncrona de este cdigo se produce creando un nuevo contexto en el hilo activo; la
evaluacin asncrona crea un contexto para un hilo nuevo.
La planificacin de los hilos creados por invocaciones asncronas no puede ser con-
trolada, puesto que queda libre a la implementacin de la mquina virtual. Para modificar
este funcionamiento:
Crearemos la nocin del concepto de mtodo. Un mtodo ser un objeto
miembro que podr evaluarse tanto sncrona, como asncronamente. El modo
en el que podemos definir cmo se evala un objeto distinto a una cadena de
caracteres es gracias una primitiva de reflectividad computacional ofrecida por
la mquina abstracta.
Adicin de cdigo intruso de sincronizacin. A la cadena de caracteres que de-
fine el cdigo de un mtodo, se le aadir, manipulando ste como si fuese in-
formacin (cosificacin), cdigo adicional encargado de sincronizar su ejecu-
cin en funcin del planificador seleccionado.
Un mtodo ser un objeto derivado de un trait Method:

-> Method;
Method <- Object:<newChildWithId>(<Method>);

El objeto Method ser el objeto base de todos los objetos miembro evaluables y
planificables del entorno de computacin. Cada objeto derivado de l, identificar un m-

198
Diseo del Entorno de Programacin

todo de un objeto. Cada uno de ellos y por lo tanto su prototipo deber tener un miem-
bro code que identifique el cdigo del mtodo66:

< -> prototype;


prototype <- Method:<newPrototype>();
prototype:<set>(<code>,nil); >();

La creacin de un objeto mtodo se realizar a partir del miembro newMethod del


objeto Object. Cuando una clase desee crear un mtodo, invocar a su mtodo
newMethod (heredado de Object) para que aada el cdigo planificable. Por ejemplo:

Circunferencia:<newMethod>(<permetro>,<
-> radio;
radio <- sender:<radio>;
return <- <2>;
return <- return:<*>(<3.141592>);
return <- return:<*>(radio);
>);

La implementacin del mtodo newMethod, crea un objeto derivado de Method


mediante la copia de prototipos, lo aade como miembro del objeto implcito, e inserta el
cdigo intruso de sincronizacin a su miembro code mediante el mtodo setCode.

Object:<set>(<newMethod>,<
-> sName;
-> sCode;
-> method;
sName <- params:<0>;
sCode <- params:<1>;
method <- Method:<copyPrototypes>();
sender:<set>(sName,method);
method:<setCode>(sCode);
>);

13.2.2 Introduccin de Cdigo Intruso de Sincronizacin


La inclusin del cdigo de sincronizacin en la cadena de caracteres referenciada
por code, es llevada a cabo por la implementacin del mtodo setCode. Entre cada una
de sus instrucciones se inserta un punto de espera de ejecucin, mediante la utilizacin de
un monitor: _execMonitor. La apertura de este monitor, para que pueda ser ejecutada
una instruccin de cdigo, es llevada a cabo mediante otro monitor: _controlMonitor.
Inicialmente se hace que los dos monitores estn ocupados:

_controlMonitor:<enter>();
_execMonitor:<enter>();

Antes de cada instruccin, se libera el monitor de control y se espera por el de eje-


cucin. Esto hace que la ejecucin de la instruccin quede a expensas de abrir el monitor
de ejecucin. As, las dos lneas a anteponer a cada instruccin son:

_controlMonitor:<exit>();
_execMonitor:<enter>();

Para cada hilo de ejecucin de un mtodo, habr otro hilo de control encargado de
abrir el monitor de ejecucin, para que se ejecute una nica instruccin del mtodo. As,

66
El cdigo mostrado ha sido evaluado como una cadena de caracteres para no crear la referencia
prototype en el contexto global.

199
CAPTULO 13

este hilo de control ejecuta el siguiente cdigo para que se pueda evaluar una instruccin
del mtodo:

_controlMonitor:<enter>();
_execMonitor:<exit>();
_controlMonitor:<enter>();

Inicialmente ocupa el monitor de control; posteriormente, libera el monitor de eje-


cucin, permitiendo la evaluacin de una instruccin; su finalizacin bloquea el hilo, a la
espera de que se nos notifique la finalizacin de la ejecucin de la instruccin.
El resultado, como se muestra en la Figura 13.2, es que:
La ejecucin de una instruccin espera a que se abra el monitor de control.
Una vez ejecutada la instruccin del mtodo, tras haber abierto
_execMonitor por el hilo de control, se abre el monitor de control indicando
que la sentencia ha sido evaluada.

_controlMonitor:<enter>()
Inicializacin
_execMonitor:<enter>()

Hilo de
Hilo de
Ejecucin
Control
_controlMonitor:<exit>() _controlMonitor:<enter>()

_execMonitor:<enter>() _execMonitor:<exit>()

instruccin 1 _controlMonitor:<enter>()

_controlMonitor:<exit>()
_execMonitor:<enter>()
Cada vez que se desee
instruccin 2 ejecutar una instruccin
_controlMonitor:<exit>() del mtodo, se
evaluarn estas tres
_execMonitor:<enter>()
_execMonitor:<exit>() instrucciones
instruccin 3 Abre el semforo
_controlMonitor:<exit>()
_controlMonitor:<exit>()
Abre el semforo

Figura 13.2: Inclusin de cdigo intruso para la sincronizacin de hilos.

Tras la
ltima instruccin de un mtodo, simplemente se abre
_controlMonitor, para liberar su hilo de control asociado.

13.2.3 MOP para la Evaluacin de Cdigo


La mquina abstracta, mediante reflectividad computacional basada en un MOP,
ofrece la posibilidad de modificar el comportamiento de la evaluacin de objetos. Al eva-
luar sncrona o asncronamente un objeto miembro o un objeto cadena de caracteres, la
semntica de la evaluacin puede ser modificada.
El protocolo de modificacin de la semntica (MOP), se basa en definir un miem-
bro () o )( del objeto a evaluar67. En el momento en que un objeto vaya a ser evalua-
67
El objeto ha de poseer estos miembros si quiere modificar la semntica de evaluacin. No es suficiente
si posee dicho miembro uno de sus objetos padre.

200
Diseo del Entorno de Programacin

do, si posee un miembro () o )(, se evaluarn stos en lugar del propio objeto () si
la invocacin es sncrona, y )( si es asncrona.
De este modo, todo objeto mtodo descendiente de Method poseer un miem-
bro () y )( que evaluar el miembro code de un modo sincronizado. Para el ejemplo
del mtodo permetro de Circunferencia, tendramos la siguiente estructura:
Object

Circunferencia String
Permetro

Method
prototype
Cdigo
Permetro Cdigo de Evaluacin
Planificada Asncrona

code
)(
() Cdigo de Evaluacin
Planificada Sncrona
code
()
)(

Figura 13.3: Representacin de un mtodo planificable.

La inclusin de los miembros () y )( en el prototipo de Method, hace que, en la


creacin de cualquier mtodo, se derogue la evaluacin de su cdigo en las rutinas de eva-
luacin planificada sncrona y asncrona.

13.2.4 Creacin de Hilos


La modificacin de la semntica de la invocacin asncrona, supone la creacin de
un nuevo hilo planificable por el usuario. Cada hilo creado en la invocacin asncrona de
un mtodo, ser representado por un objeto derivado del nuevo objeto trait Thread. Co-
mo se muestra en la Figura 13.4, cada objeto clonado del prototipo de ste posee:
Un objeto monitor para controlar la finalizacin de la ejecucin de una senten-
cia relativa a su hilo: controlMonitor.
Un monitor para permitir ejecutar una nueva instruccin del hilo:
execMonitor.

Un valor lgico que le diga si ha finalizado la ejecucin del hilo:


isThreadFinished. Inicialmente tendr un valor falso.

Un objeto cadena de caracteres con semntica numrica (number) que va a ser


su identificador de hilo en ejecucin.
El objeto trait Thread implementar un mtodo evaluate, cuya funcionalidad
ser la ejecucin de las instrucciones asociadas al hilo que representa. En concreto, ejecuta-
r las tres instrucciones del hilo de control, mostradas en la parte derecha de la Figura 13.2.

201
CAPTULO 13

13.2.5 Planificacin Genrica


El conjunto de objetos utilizados en el diseo de planificacin genrica es el si-
guiente:

Object

newMethod

Coleccin de
mltiples Threads

threadPool Scheduler
Method Thread
n scheduler threadPool
prototype prototype pool
currentThread
setCode evaluate start

controlMonitor
code
execMonitor
() number randomScheduler fifoScheduler ...
)( isThreadFinished nextThread nextThread

Implementacin
de nuevos
Planificadores

Figura 13.4: Diseo general del sistema genrico de planificacin de hilos.

El conjunto global de hilos est en la abstraccin threadPool: su miembro pool


es un contenedor de todos los hilos planificables existentes en la mquina. La planificacin
genrica de hilos comienza cuando se invoca asncronamente a su miembro start. Esta
ejecucin va tomando los distintos hilos del sistema en funcin del planificador selecciona-
do, y ejecuta una instruccin de cada uno de ellos invocacin del mtodo evaluate de
cada Thread.
La referencia al planificador seleccionado, adaptable dinmicamente, es aqulla aso-
ciada al miembro scheduler de threadPool. La modificacin dinmica de este miem-
bro, supone la adaptacin instantnea al planificador seleccionado.
El diseo de la planificacin genrica se ha llevado a cabo siguiendo el patrn de di-
seo Mtodo Plantilla (Template Method) [GOF94]. El objeto genrico de planificacin,
Scheduler, define el algoritmo general de planificacin, y cada objeto derivado, represen-
tante de un planificador determinado, implementa su funcionalidad especfica a travs del
mtodo nextThread. Este mtodo ha de devolver, a raz de conocer el hilo actual de
ejecucin miembro currentThread de Scheduler, el siguiente hilo a evaluar, si-
guiendo su poltica de planificacin especfica.
Ejemplos de implementaciones de planificadores genricos son fifoScheduler
y randomScheduler. El usuario podr aadir cualquier otro, derivado de Scheduler,
con tan slo implementar el mtodo nextThread. Una vez hecho esto, sin necesidad de
haber parado la ejecucin del sistema, podr seleccionarse el nuevo planificador mediante
la evaluacin de la siguiente instruccin:

threadPool:<set>(<scheduler>,nuevoPlanificador);

202
Diseo del Entorno de Programacin

13.3 Sistema de Persistencia


Dentro del entorno de programacin, se disear un sistema de persistencia, en el
que tanto los datos como la computacin podrn persistir68, siendo el mecanismo, formato
y poltica, parmetros dinmicamente adaptables por el usuario.
Como se ha estudiado en el captulo 8, el modelo computacional orientado a obje-
tos basado en prototipos proporciona una mayor facilidad a la hora de implementar un
sistema de persistencia: eliminamos la relacin estrecha existente entre un objeto y su clase,
substituyndola por una relacin de delegacin. La modificacin, eliminacin o ampliacin
de comportamientos, manipulando los objetos de rasgo, no lleva al modelo de objetos a
estados inconsistentes.
El desarrollo del sistema de persistencia hace uso intensivo de las caractersticas re-
flectivas ofrecidas por la plataforma:
Mediante introspeccin, un objeto conoce su estado y comportamiento, y
actualiza stos en una memoria persistente.
Mediante reflectividad estructural, se construye un objeto a raz de una infor-
macin obtenida de un dispositivo persistente.
Mediante reflectividad computacional un MOP, se modifica el acceso a los
miembros de un objeto para poder implementar un objeto delegado (proxy): ob-
jeto que no se encuentra realmente en la memoria, pero que es capaz de delegar
el acceso y obtencin de sus miembros, en un sistema de persistencia69.

13.3.1 Diseo General del Sistema


La siguiente figura muestra el conjunto de objetos utilizados en el desarrollo del sis-
tema de persistencia:

68
Al tratar la computacin como datos, la persistencia de computacin es realmente persistencia de datos
cadenas de caracteres.
69
Este concepto ser tambin utilizado en el sistema de distribucin: un objeto delegado es la representa-
cin local de un objeto que realmente est ubicado en otra mquina.

203
CAPTULO 13

Object

Stream

has, set PersistenceStream has, set


remove remove
firstKey doProxy,undoProxy firstKey
nextKey newProxy, colon nextKey

RDB XML
Persistence Persistence
Stream Stream

primitives primitives
get, exists get, exists
new, delete new, delete

Cada objeto derivado de PersistenceStream


representa un flujo distinto de persistencia

Figura 13.5: Conjunto de objetos utilizados en el diseo del sistema de persistencia.

El sistema de persistencia tiene ciertas similitudes con el de distribucin ( 13.4). En


ambos casos, los objetos se obtienen de un flujo (Stream), ya sea de una memoria persisten-
te, o bien de un dispositivo de comunicacin. Las funcionalidades comunes a ambos siste-
mas han sido ubicadas como mtodos del objeto trait Stream. Las funcionalidades propias
de cualquier flujo de persistencia, de forma independiente al mecanismo seleccionado por
el usuario, son representadas por los miembros del objeto PersistenceStream.
Al igual que el desarrollo del sistema de planificacin genrica de hilos, el diseo del
sistema de persistencia est centrado en la utilizacin del patrn de diseo Mtodo Planti-
lla (Template Method) [GOF94]. Cada uno de los distintos sistemas de persistencia a implan-
tar en la plataforma, son objetos derivados de PersistenceStream; la implementacin
de los miembros get, exists, new, delete y primitive, los hace susceptibles de ser
utilizados como flujos de persistencia.

13.3.2 Implantacin de un Flujo de Persistencia


Cada flujo de persistencia distinto ha de implementar un conjunto de operaciones
bsicas, sobre las que se crearn funcionalidades de mayor nivel de abstraccin. En concre-
to, las primitivas bsicas a desarrollar son los siguientes miembros:
exists. Nos dice si un determinado objeto tiene una entrada en el sistema de
persistencia, pasndole como nico parmetro el identificador del objeto.
delete. Elimina el espacio utilizado por un objeto en el sistema de persisten-
cia; si tuviere un conjunto de miembros, eliminara tambin las referencias a s-
tos.
new. Tomando un parmetro representativo de un identificador de un objeto,
produce la creacin del espacio apropiado para albergar un objeto con dicho

204
Diseo del Entorno de Programacin

id. Si este objeto existiere previamente, se eliminara su espacio y todas sus re-
ferencias a sus miembros.
get. Pasndole el identificador del objeto implcito y el nombre del miembro
solicitado, devuelve el valor (el identificador70) almacenado para este par de va-
lores.
Cuando un objeto se hace persistente, se crear un objeto delegado (proxy) de ste
que interacte con el sistema de persistencia. El nuevo objeto delegado no poseer los
miembros del objeto original, sino que los ir a buscar al flujo de persistencia asociado. De
este modo, las funcionalidades bsicas de reflectividad estructural debern ser redefinidas.
Por ejemplo, cuando preguntemos a un objeto proxy si un objeto persistente tiene un
miembro (has), o queramos conocer la primera clave de sus miembros (firstKey), debe-
remos consultar esta informacin en el disco, en lugar de buscar en el propio objeto proxy.
Todas las operaciones primitivas que varen su semntica en el uso de objetos per-
sistentes, estarn situadas en un objeto contenedor asociado al miembro primitives de
cada uno de los flujos de persistencia. Por cada operacin primitiva, tendremos la imple-
mentacin de su nueva semntica. Cuando se evale una de estas operaciones en un objeto
proxy, ejecutaremos la nueva semntica.
Cada primitiva recibir como primer parmetro el objeto implcito, o lo que es lo
mismo, el objeto contenedor. El resto de los parmetros sern el conjunto de parmetros
pasados a cada primitiva original. Las primitivas implementadas en cada sistema de persis-
tencia son:
has. Accede al sistema de persistencia y nos dice si el parmetro implcito po-
see el miembro pasado.
remove. Elimina del parmetro implcito el miembro pasado.

set. Asigna al parmetro implcito una referencia (una entrada en el sistema de


persistencia) a un miembro pasado. Si ya exista un valor, lo sobreescribe.
firstKey. Devuelve la primera clave o nombre del parmetro implcito.

nextKey. Devuelve la siguiente clave o nombre del parmetro pasado asociado


al parmetro implcito.
Estas primitivas estarn implementadas haciendo uso del protocolo de invocacin
externa (objeto Extern), puesto que todas dependen de la plataforma fsica acceden a un
sistema de persistencia. Sobre ellas, se disea un sistema genrico de persistencia (patrn de
diseo Template Method), haciendo que ste funcione de forma independiente al flujo espec-
fico seleccionado adaptabilidad.

13.3.3 MOP para Acceso al Miembro


Cuando un objeto sea persistente, tendr modificada la semntica de la primitiva de
acceso a sus miembros operador :. Delegar su funcionalidad en un canal o flujo de
datos (sistemas de persistencia y distribucin); cada vez que queramos acceder o evaluar
uno de sus miembros, la bsqueda se realizar en una base de datos o en una plataforma
remota.

70
Para cada objeto se guarda su identificador y una coleccin de pares formados por el nombre de cada
miembro y su identificador asociado.

205
CAPTULO 13

La modificacin de la semntica de acceso a los miembros de un objeto, es llevada a


cabo con la adicin de un miembro : a ese objeto. Cada vez que se intente evaluar o
acceder a un miembro de un objeto que tenga un mtodo :, la mquina invocar a ste
en lugar de ofrecer su funcionamiento primitivo.
A la hora de implementar un miembro : que derogue la funcionalidad de acceso
a los miembros, el protocolo semntico de la invocacin (MOP) es descrito por las siguien-
tes referencias cuando se invoque a este miembro, stas sern las referencias pasadas:
mySelf: Referencia al objeto en el que se ha implementado el miembro :.
Ser el objeto implcito o alguno de sus objetos padre. En cualquier caso, ser
siembre un objeto proxy, representante de un objeto persistente o remoto.
sender: Referencia al objeto implcito.

return: Referencia que apuntar al valor devuelto por el acceso a un miembro


o por la invocacin sncrona de un mtodo.
params: Referencia que apunta a un objeto contenedor. Cada miembro de este
objeto est numerado consecutivamente a partir de cero. Sus valores son:
Desde 0 al nmero de parmetros pasados (n) menos uno, sern referencias
a los parmetros pasados. En el caso de que se haya producido un acceso a
un miembro (no haya evaluacin), no existen estas referencias.
Miembro n: Es una referencia a un valor lgico. Indica si se ha producido
una invocacin (true) o un acceso (false).
Miembro n+1: Referencia al nombre del miembro objeto cadena de carac-
teres.
Miembro n+2: Valor lgico que indica si la invocacin a sido realizada sn-
crona (true) o asncronamente (false).
El algoritmo de acceso a los miembros de un objeto persistente es siempre igual. Su
implementacin ha sido llevada a cabo de forma polimrfica respecto al de flujo de persis-
tencia utilizado. Su cdigo est ubicado en el miembro colon del objeto
PersistenceStream, mostrado en la Figura 13.5.

13.3.4 Objetos Delegados


Como hemos comentado al principio de la presentacin del sistema de persistencia,
el diseo de este mdulo est centrado en el concepto de objeto que delega, mediante re-
flectividad computacional, la funcionalidad de acceso a sus miembros en un flujo de persis-
tencia.
El MOP ofrecido por la mquina abstracta para modificar la semntica del acceso a
sus miembros, obliga a que todo objeto proxy posea un miembro :. Este miembro ser
una referencia al mtodo colon de PersistenceStream, que implementa el algoritmo
de acceso a los miembros del objeto implcito sobre un flujo de persistencia; este flujo ser
definido por el miembro _stream que todo objeto proxy ha de tener.
Un objeto delegado ha de poseer, por tanto, adems de los miembros id y super,
las dos referencias:

206
Diseo del Entorno de Programacin

:, que indica la nueva semntica de acceso a sus miembros, apuntando siem-


pre al miembro colon de PersistenceStream.
_stream, que hace referencia al flujo fsico seleccionado para dar persisten-
cia al objeto real, representado por el objeto proxy.
Cuando queramos que un objeto pase a ser persistente crendose un objeto proxy
, se almacenar su identificador nico en el sistema de persistencia. Para cada uno de sus
miembros, deberemos especificar si deseamos que se hagan o no persistentes. Esta deter-
minacin est en funcin de la semntica del problema. Normalmente se divide en relacio-
nes de composicin en las que los miembros se hacen persistentes, y en relaciones de aso-
ciacin en las que el programador deber decidir71 [Ortn97b]. Nuestra plataforma no dis-
tingue entre tipos de asociaciones, as que debemos de proporcionar un mecanismo para
discernir entre estas situaciones.
El grado de profundidad para la realizacin de los objetos proxy, ser especificado
por un objeto cadena de caracteres evaluable. ste se ejecutar sncronamente para cada
miembro, pasndole en cada evaluacin tres parmetros: el objeto tratado, el nombre del
miembro y el miembro. Si el resultado de la evaluacin es true, el miembro se har persis-
tente. En caso contrario, el miembro seguir siendo temporal.
Si queremos, por ejemplo, que todos los miembros sean persistentes, el siguiente
objeto definir la poltica de profundidad:

< return <- true; >

Si deseamos que todos los miembros de un objeto sean persistentes, excepto su


asociado autor, el objeto indicativo de la poltica de profundidad sera:

< -> miembro;


miembro <- params:<1>;
return <- miembro:<!=>(<autor>); >

El miembro doProxy de PesistenceStream utilizando como parmetro im-


plcito en la invocacin un flujo especfico de persistencia convierte el primer parmetro
pasado a un objeto delegado, utilizando como poltica de profundidad el objeto cadena de
caracteres pasado como segundo parmetro.
Si deseamos hacer que miLibro pase a ser persistente, al igual que todos sus
miembros excepto autor, en un sistema basado en una base de datos relacional
(RDBPersistenceStream), evaluaremos la siguiente instruccin:

RDBPersistenceStream:<doProxy>(miLibro,
< -> miembro;
miembro <- params:<1>;
return <- miembro:<!=>(<autor>);
>);

La transformacin llevada a cabo se muestra en la siguiente figura:

71
De ah la palabra reservada transient utilizada en el mecanismo de serializacin de la plataforma Java.

207
CAPTULO 13

Estado Persistente en una BD Relacional


Estado Inicial
Persistence
String Object Stream
Object colon

Cdigo de
{Libro} {Libro} has set
modificacin remove
de acceso a _stream firstKey RDB
leer Persistence
abrir los miembros nextKey
: Stream
primitives

{miLibro} {miLibro}
pginas autor {autor}
autor _stream
ao <1998>
:

{pginas} {autor}

Figura 13.6: Transformacin llevada a cabo al hacer persistente el objeto miLibro.

Los objetos que pasan a ser delegados son miLibro, Libro y pginas. El obje-
to Object no pasa a ser persistente, porque forma parte de los objetos propios de la plata-
forma72. Si en el sistema no existiese ninguna referencia al objeto pginas, el recolector
de basura podra eliminar ste, puesto que el objeto proxy miLibro ya no hace referencia a
l por esta razn no se muestra en la Figura 13.6. El objeto podr recuperarse automti-
camente del sistema de persistencia, cuando el usuario acceda a l a travs del objeto
miLibro.

13.3.5 Recuperacin de Objetos Persistentes


El tratamiento de objetos persistentes es transparente al usuario [Ortn99c]. El pro-
gramador no ha de notar diferencia alguna en el tratamiento y utilizacin de objetos persis-
tentes, frente a los objetos temporales residentes en la memoria principal.
Un objeto persistente puede poseer un ciclo de vida mayor al programa que lo cre
[Booch94]. As, el programador puede hacer un objeto persistente (doProxy) y trabajar
con l en disco a travs de un objeto delegado; una vez finalizado el programa, la elimina-
cin de la referencia al proxy har que, si no existe otra referencia al ste, el objeto se libere
automticamente por el recolector de basura, quedando constancia de ste nicamente en
el dispositivo de persistencia.
En la ejecucin de una aplicacin, puede interesar recuperar un objeto persistente
almacenado en otro momento por cualquier aplicacin. Para seguir con el diseo estableci-
do, permitiremos crear un nuevo objeto proxy de un objeto almacenado previamente en
disco. Lo nico que necesitamos conocer de l, es su identificador nico.
El mtodo newProxy de PersistenceStream, tomar un identificador de un
objeto como nico parmetro, y devolver un objeto delegado del objeto persistente que
posea dicho identificador. Como objeto implcito de esta invocacin, deberemos utilizar un
objeto representativo de un flujo de persistencia.

72
La separacin entre objetos de usuario y objetos de plataforma es llevada a cabo por un convenio de
identificadores. Los identificadores que poseen los caracteres { y }, son propios de objetos de usuario.

208
Diseo del Entorno de Programacin

Partiendo de un objeto delegado del sistema de persistencia, el mtodo


undoProxy de PersistenceStream permitir recuperar a la memoria principal, a par-
tir de un objeto delegado, el objeto inicial asociado. Este proceso no implica la eliminacin
del objeto del sistema de persistencia, sino la supresin de la relacin existente entre ste y
su proxy (si queremos eliminar el objeto deberemos invocar al miembro delete del siste-
ma de persistencia).
A igual que a la hora hacer objetos persistentes ( 13.3.4), se utilizarn objetos que
definan poltica de profundidad: el segundo parmetro pasado a la invocacin de
undoProxy, es un objeto cadena de caracteres que define la profundidad de recuperacin
de sus miembros, siguiendo un proceso recursivo vase 13.3.4.

13.4 Sistema de Distribucin


Dentro del entorno de programacin, la capa de distribucin permitir acceder a
objetos de mquinas remotas, moverlos entre distintas plataformas, y recuperarlos de otras
mquinas. El sistema diseado es adaptable dinmicamente a la utilizacin de distintos pro-
tocolos y representaciones, as como abierto a cualquier otro que el programador desee
aadir.
Partiendo de un conjunto de primitivas bsicas de distribucin implementadas de
forma externa (en el objeto trait Extern), y haciendo uso de la reflectividad estructural de
la mquina abstracta, podremos construir un sistema de distribucin, en el que los objetos
puedan moverse entre las distintas mquinas virtuales interconectadas entre s, extendiendo
as el nivel de abstraccin de la plataforma.
La funcionalidad central del diseo del sistema de distribucin reside en el concepto
de objeto delegado (proxy), utilizado tambin en el diseo del sistema de persistencia (
13.3). Los objetos proxy delegan sus peticiones de acceso a miembros y evaluacin de stos
en objetos distribuidos en otras mquinas virtuales. Para implementar stos, haremos uso
de la reflectividad computacional ofrecida por la mquina, gracias a la inclusin del MOP
que permite modificar la semntica de acceso al miembro descrito en 13.3.3.

13.4.1 Diseo General del Sistema


La siguiente figura muestra el conjunto de objetos utilizado en el diseo del sistema
de distribucin, desarrollando ste para dos protocolos de ejemplo, y tomando como mues-
tra la implantacin de la mquina virtual en dos plataformas remotas mquina A y mqui-
na B:

209
CAPTULO 13

Object

mquinaB Stream
mquinaA

NetworkStream
getMachineStream,
newProxy, doProxy,
undoProxy, colon

COM Socket
NetworkStream NetworkStream
remoteMachines remoteMachines
prototype prototype

machine <localhost> machine <mquinaA>


machine <mquinaB> machine <localhost>
port <10024> port <10024>

Figura 13.7: Objetos utilizados en el desarrollo del sistema de distribucin.

El concepto de flujo de informacin fue utilizado en el diseo del sistema de persis-


tencia. Como comentbamos entonces, tanto el sistema de persistencia como el de distri-
bucin, pueden plantearse como un modo de transferir objetos a travs de un flujo. De esta
forma, el objeto trait Stream representa un flujo genrico de informacin. La abstraccin
NetworkStream, simboliza de un modo genrico los flujos de distribucin de objetos, sin
tener en cuenta el protocolo utilizado.
Las operaciones dependientes de cada uno de los protocolos a utilizar para interco-
nectar distintas mquinas abstractas, se situarn en objetos derivados de NetworkStream.
Como ejemplo, se muestran los servicios sobre dos protocolos como Sockets TCP/IP y
COM. La utilizacin de un nuevo protocolo se limitar a la adicin de un objeto, derivado
de NetworkStream, que implemente los miembros de estas clases derivadas. El sistema
ser capaz de amoldarse al nuevo protocolo, al haber sido diseado utilizando el patrn de
diseo Template Method [GOF94].
Cada uno de los objetos derivados de NetworkStream ofrece las primitivas de in-
terconexin del protocolo que representa. Los objetos derivados a su vez de stos identifi-
carn la mquina y, si fuere necesario, cualquier otro parmetro de la conexin73 que se
desea establecer, teniendo en cuenta el protocolo seleccionado.
Cada protocolo poseer un prototipo y, haciendo copias de ste, podremos crear
flujos (streams) de conexin con una mquina determinada en el caso de los sockets, tam-
bin en un puerto determinado. Los servicios propios del protocolo se heredarn del obje-
to padre, al igual que los mtodos propios de NetworkStream.

73
Por ejemplo, haciendo uso de sockets TCP/IP, es necesario definir un puerto que no haya sido reserva-
do por otra aplicacin distribuida.

210
Diseo del Entorno de Programacin

Una vez creada una copia de un prototipo, debe cambiarse el valor del atributo
machine por el nombre de la mquina destino. Este objeto ser el utilizado por el objeto
proxy para delegar sus peticiones en un objeto remoto situado en la mquina indicada.
Para evitar que se cree un objeto nuevo derivado del protocolo cada vez que que-
ramos conectarnos con una mquina remota, se lleva un control de los objetos creados,
mediante la coleccin de stos por el miembro remoteMachines del protocolo. El obje-
to creado contendr un miembro por cada mquina abstracta remota utilizada previamente.
El nombre de cada miembro ser el nombre de la mquina remota; el miembro en s ser
una copia del prototipo que identifique la conexin con la mquina, bajo el protocolo se-
leccionado.
El control de acceso y la creacin de los flujos remotos, se llevarn a cabo a travs
del mtodo getMachineStream. Recibe el nombre de la mquina remota y devuelve un
objeto derivado del protocolo a utilizar (el objeto implcito), cuyo destino es la mquina
virtual solicitada.
La primera vez que se solicite la creacin de un flujo con una mquina a travs de
un protocolo, se crear un objeto nuevo derivado del protocolo en cuestin como copia de
su prototipo, y se almacenar como miembro del objeto asociado al atributo
remoteMachines.

13.4.2 Primitivas del Sistema de Distribucin


Tal y como se ha diseado el sistema de distribucin, una mquina abstracta ha de
permitir al usuario conocer su identificacin dentro de la red de computadores. Este identi-
ficador se obtiene evaluando el miembro localHost del objeto System implementado
como primitiva operacional de invocacin externa.
El resto de primitivas de distribucin se basan en permitir acceder a la interfaz de
intercomunicacin de una mquina abstracta remota, definida por las seis operaciones des-
critas en 12.3. En la siguiente figura, se muestra cmo la implementacin externa de stas
ha de lograr acceder a las funcionalidades propias ofrecidas por una mquina remota.

211
CAPTULO 13

Aplicacin A Protocolo de
Archivo Edicin Ver Ayuda interconexin de
procesos del
sistema operativo A
Mquina Virtual
Sistema Operativo A

Protocolo de invocacin
Aplicacin Nativa del a libreras del sistema
Sistema Operativo A operativo A

Implementaciones
Externas en Sistema
Sistema Operativo A Operativo A

Primitivas de invocacin remota del sistema


de distribucin, bajo un protocolo estndar

Sistema Operativo B
Implementaciones
Externas en Sistema
Operativo B

Aplicacin Nativa del


Sistema Operativo B Protocolo de invocacin
a libreras del sistema
Aplicacin B operativo B

Texto propio de un
mensaje de la aplicacin B
en el SO B Protocolo de
interconexin de Mquina Virtual
Aceptar Cancelar
procesos del Sistema Operativo B
sistema operativo B

Figura 13.8: Interconexin de dos implementaciones distribuidas de la mquina abstracta.

Las primitivas que ha de implementar todo protocolo, para formar parte del sistema
de distribucin diseado, son:
newReference. Creacin de una referencia en el contexto raz.

getMember. Acceso a un miembro de un objeto.

primitiveEvaluateString. Evaluacin un objeto cadena de caracteres de


forma sncrona y asncrona.
primitiveEvaluateMember. Evaluacin de un miembro de un objeto, de
forma sncrona y asncrona.

13.4.3 Objetos Delegados


La caracterstica comn a toda arquitectura de objetos distribuidos (COM, CORBA
o Java RMI, por ejemplo) es el acceso a objetos remotos a travs de una referencia. Obte-
niendo en una plataforma local una referencia a un objeto remoto, podremos pasarle a ste
un mensaje y provocar as una ejecucin remota del mtodo asociado. En nuestro entorno
de computacin, es posible realizar este tipo de acceso remoto a travs de la utilizacin de
objetos delegados.

212
Diseo del Entorno de Programacin

Como introdujimos en el sistema de persistencia ( 13.3), un objeto delegado o


proxy posee un miembro _stream que identifica el flujo de donde obtiene su informacin,
y otro miembro : que sustituye la semntica de funcionamiento de acceso al miembro (
13.3.3), buscndolos en el flujo indicado por _stream.
Para crear un objeto delegado de otro existente en una mquina remota, es necesa-
rio obtener un flujo con la mquina y protocolo deseados (getMachineStream), y, utili-
zando ste como parmetro implcito, invocar a su mtodo newProxy pasndole el identi-
ficador nico del objeto deseado. El resultado es la devolucin de un nuevo objeto proxy
que delega todas las peticiones en el objeto remoto cada vez que se evale un miembro de
este objeto desde la plataforma local, se computar su cdigo en la mquina destino.
El siguiente cdigo devuelve un objeto delegado de miObjeto, ubicado en
mquinaA, utilizando sockets TCP/IP:

< -> stream;


stream <- SocketNetworkStream:<getMachineSteam>(<mquinaA>);
return <- stream:<newProxy>(<{miObjeto}>);
>();

Al igual que en el sistema de persistencia, el envo de un objeto a un flujo de infor-


macin se hace mediante la invocacin del mtodo doProxy del flujo seleccionado. En el
sistema de persistencia, esta operacin se traduca al almacenamiento en disco de un objeto;
en el sistema de distribucin, implica el movimiento de un objeto a la plataforma destino.
Para realizar esta operacin el programador deber:
1. Obtener una referencia al flujo deseado, indicando el tipo de protocolo a utili-
zar y la direccin de la mquina destino. Esta funcionalidad ha sido desarrollada
en el miembro getMachineStream de cada uno de los protocolos derivados
de NetworkStream.
2. Invocar al mtodo doProxy del stream obtenido, pasndole el objeto que de-
seamos mover y la poltica que indica la profundidad del movimiento, es decir,
el nmero de miembros del objeto a mover con l vase 13.3.4.
El resultado es que el objeto local se mueve a la mquina destino quedando ste
como objeto delegado del objeto remoto.
Finalmente, el mtodo a utilizar para recuperar objetos delegados es undoProxy.
Utilizando como objeto implcito el trait NetworkStream, se le pasa el objeto proxy a re-
cuperar y el objeto poltica que indique la profundidad deseada. El objeto deja de ser dele-
gado, para recuperar su representacin en la mquina local.

13.4.4 Recolector de Basura Distribuido


Un objeto proxy es una representacin virtual y local de su objeto real ubicado en
otra mquina abstracta, a la cul se tiene acceso mediante una red de computadores. Entre
un objeto delegado y su objeto real existe una asociacin virtual, es decir, una conexin
semntica, sin que realmente se haya creado una referencia a ste. Sin embargo, al no existir
realmente esta referencia, el recolector de basura podr tratar de eliminar ste sin que sea
correcto, puesto que el objeto delegado requiere su existencia.
Un objeto proxy delega toda su funcionalidad en su objeto asociado remoto. El te-
ner una o ms referencias a un objeto proxy, implica semnticamente que estas referencias
sean al objeto real. Para que esta asociacin semntica sea implementada de acuerdo con el
sistema de recoleccin de basura de la plataforma, se deber asegurar que:

213
CAPTULO 13

1. Un objeto no sea destruido mientras existan objetos delegados de ste en otras


mquinas abstractas del sistema de distribucin.
2. Un objeto se elimine por su recolector de basura, cuando todos sus objetos de-
legados hayan sido liberados y no exista en la mquina abstracta referencia al-
guna a ste.
Nuestro diseo crear un conjunto de referencias a cada objeto local que tenga al
menos un proxy en otra mquina abstracta, para que no sea destruido por el recolector de
basura. De forma paralela, se llevar un contador del nmero de objetos remotos delegados
de ste. Cuando se destruya un objeto proxy, se decrementar este contador; se eliminar la
referencia, cuando su valor sea cero. A partir de este momento, el objeto local podr ser
limpiado por el recolector, si no existe ninguna referencia local a l.
El miembro remoteProxies del objeto System implementa la creacin, recuen-
to y eliminacin de referencias, en funcin del nmero de objetos delegados de cada objeto
local.

Object

Objetos que tienen


delegados asociados en
otras plataformas

System id1

remoteProxies id2
...
localhost

references
id1 <4>
referenceCounters id2 <2>
...
proxyCreated
proxyDeleted

Figura 13.9: Objetos utilizados en el diseo del recolector de basura distribuido.

El objeto miembro references del objeto remoteProxies es un objeto con-


tenedor, cuyos miembros tienen por nombres identificadores de objetos locales, y sus refe-
rencias apuntan a los propios objetos. De forma paralela, el objeto contenedor
referenceCounters posee los mismos nombres con asociaciones a objetos cadena de
caracteres, que contabilizan el nmero de objetos proxies remotos existentes para el objeto
asociado.
Para controlar el recuento de referencias, el objeto remoteProxies ofrecer dos
mtodos para registrar la creacin y eliminacin de objetos remotos delegados de un objeto
local: proxyCreated y proxyDestroyed, respectivamente.
El miembro proxyCreated incrementa el nmero de referencias del objeto cuyo
identificador se pase como parmetro. Si no existe una referencia al objeto en el objeto
contenedor references, la crea. De la misma forma, proxyDeleted elimina los dos
miembros del identificador asociado cuando el contador pasa a ser igual a cero. Estos dos
mtodos son invocados por el sistema de distribucin, cada vez que se creen un destruyan
objetos delegados.

214
Diseo del Entorno de Programacin

13.5 Conclusiones
Los diseos llevados a cabo demuestran la capacidad de la plataforma a la hora de
extender su nivel de abstraccin, sin necesidad de modificar la implementacin de la m-
quina virtual. Toda su codificacin ha sido llevada a cabo utilizando su propio lenguaje de
programacin, evitando as la aparicin de distintas versiones de la plataforma con la con-
secuente prdida de portabilidad de cdigo. La introspeccin del sistema facilita, a una apli-
cacin, el conocimiento de los distintos mdulos del entorno de programacin que hayan
sido implantados facilitando as su despliegue en sistemas computacionales heterogneos.
Los diseos presentados para cada mdulo, as como las funcionalidades computa-
cionales ofrecidas, son meros ejemplos demostrativos de la extensibilidad y adaptabilidad
ofrecidas por la mquina. Tanto otros diseos ms sofisticados, como la implementacin
de otras capacidades computacionales, podrn ser desarrollados para ampliar el nivel de
abstraccin del sistema.
Inicialmente, la plataforma ofrece primitivas de creacin y destruccin de objetos,
reflectividad estructural de los mismos, y un pequeo MOP para modificar su semntica;
adems describe un mecanismo de delegacin y otro de evaluacin dinmica de objetos.
Sobre estas primitivas computacionales bsicas, a lo largo de este captulo, se ha mostrado
el diseo de:
Un recolector genrico de basura. Flexible dinmicamente respecto al algoritmo
y poltica de activacin, se pueden implantar distintos recolectores de basura,
haciendo uso, bsicamente, de la introspeccin ofrecida por la plataforma.
Un sistema de planificacin flexible de hilos, en el que cualquier poltica de se-
leccin puede ser desarrollada e implantada en tiempo de ejecucin. Este mdu-
lo se ha diseado principalmente mediante la manipulacin de computacin
como datos (cosificacin), la modificacin de la semntica de la evaluacin de
objetos (reflectividad computacional), y la sincronizacin de hilos por medio de
objetos utilizados como monitores.
El mdulo de persistencia, que permite utilizar objetos que delegan su funcio-
nalidad en un flujo asociado a un dispositivo persistente y representacin de-
terminados, siendo stos parmetros totalmente adaptables. Para su desarrollo
se ha utilizado: la reflectividad estructural, para almacenar, conocer y recuperar
todos los miembros de un objeto; la cosificacin, para representar computacin
como datos; y la reflectividad computacional de modificacin de acceso al
miembro, para implementar objetos delegados.
El sistema de distribucin, ha sido desarrollado de un modo similar al de persis-
tencia, delegando su funcionamiento en un flujo de conexin entre ordenado-
res. Lo conseguido es invocacin remota de mtodos y movilidad de stos entre
distintas mquinas, de un modo adaptable al protocolo seleccionado.

215
CAPTULO 14:
DISEO DE UN PROTOTIPO DE COMPUTACIN
REFLECTIVA SIN RESTRICCIONES

En este captulo se describir el diseo de un prototipo que demuestre la posibili-


dad de construir el sistema computacional de programacin flexible descrito en el captulo
9, a partir de las premisas o requisitos mnimos impuestos en 11.4.
Por simplicidad de desarrollo, se ha implementado el prototipo sobre un lenguaje
de programacin comercial que otorgue los requisitos mnimos necesarios para llevar a
cabo su codificacin74. El objetivo de este prototipo es demostrar que la consecucin de los
objetivos y requisitos propios del sistema computacional reflectivo, enunciados en los dos
primeros captulos de esta tesis, son factibles bajo las premisas mnimas expuestas en
11.4.
La implementacin del prototipo presentado sobre la mquina abstracta descrita en
el captulo 10 es totalmente factible al cumplir sta con las premisas anteriormente mencio-
nadas. Sin embargo, el desarrollo de este prototipo sobre la arquitectura de nuestra mqui-
na virtual, aportara los beneficios propios de cumplir los requisitos expuestos en 2.1 y
pragmticamente demostrados con los casos estudiados en el captulo 4.
El cdigo fuente del prototipo presentado, as como un diseo detallado y una ba-
tera de pruebas, pueden ser descargados en la URL:
http://www.di.uniovi.es/reflection/lab/prototypes.html.

14.1 Seleccin del Lenguaje de Programacin


A raz de las premisas mnimas impuestas al lenguaje de programacin para el desa-
rrollo de nuestro prototipo expuestas en 11.4, hemos elegido el lenguaje de programa-
cin Python [Rossum2001]. Puesto que el lenguaje de programacin Python tiene un ele-
vado nmero de mdulos software implementados para su reutilizacin por el programa-

74
Puesto que el objetivo de esta memoria es justificar, enunciar y evaluar una tesis, no consideramos
necesaria la implementacin de este segundo prototipo sobre el primero nuestra mquina abstracta. De-
mostramos que su desarrollo es factible bajo unas premisas computacionales que cumple la arquitectura
de nuestra mquina abstracta, e implementamos ste sobre un lenguaje de programacin comercial que
nos facilite considerablemente su desarrollo, orientndolo a la justificacin y evaluacin de nuestro estu-
dio.

217
CAPTULO 14

dor, y dispone de un interfaz grfico de programacin (TK [Lundh99]), esto permiti la


aceleracin del desarrollo del prototipo.
A continuacin enumeramos los requisitos impuestos al lenguaje, y justificaremos el
cumplimiento de stos por parte del lenguaje Python.

Introspeccin
El lenguaje de programacin Python est caracterizado por su capacidad de ofrecer
primitivas de introspeccin y reflectividad estructural, gracias a su naturaleza interpretada
[Andersen98]. A continuacin enunciamos un subconjunto de sus posibilidades introspec-
tivas:
Conocimiento dinmico del tipo de una variable. En Python no existe declara-
cin de tipos esttica; todos los tipos se infieren en tiempo de ejecucin [Carde-
lli97]. La funcin type nos devuelve dinmicamente la descripcin del tipo de
un objeto o una variable de tipo simple.
Conocimiento dinmico de la tabla de smbolos empleada en el contexto de eje-
cucin. Es posible, mediante el uso de la funcin dir, el conocer la tabla de
smbolos [Cueva92b] utilizada por el intrprete en tiempo de ejecucin; esto fa-
cilita el acceso a las variables, clases, objetos y mdulos existentes
dinmicamente.
Conocimiento de los miembros de los objetos. Cada objeto (en Python las cla-
ses tambin se representan dinmicamente mediante objetos) posee un miem-
bro __dict__ que nos devuelve un diccionario de sus miembros atributos
para los objetos, mtodos para las clases con su nombre y valor [Ros-
sum2001].
Conocimiento del rbol de herencia. Todo objeto representativo de una clase
posee un miembro __bases__ que posee una lista de sus clases base.

Reflectividad Estructural
Python no slo permite conocer dinmicamente partes de su contexto de ejecucin
(introspeccin), sino que facilita la modificacin dinmica de su estructura (reflectividad
estructural). Ejemplos de esta caracterstica son:
Creacin y modificacin dinmica de miembros. Python permite dinmicamen-
te asignar atributos a cualquier objeto mtodos en el caso de que un objeto re-
presente una clase. Si asignamos un valor a un miembro que no exista, dinmi-
camente se crea un atributo para el objeto implcito con el valor asignado.
Modificacin dinmica del tipo (clase) de un objeto. Todo objeto posee un atri-
buto __class__ que referencia a su clase. Modificar ste es posible, y el resul-
tado producido es la alteracin de su tipo.
Modificacin del rbol de herencia: herencia dinmica o delegacin. Al repre-
sentar el atributo __bases__ de una clase una lista de sus superclases, la mo-
dificacin de su valor implica un mecanismo de herencia dinmica o delegacin,
propio de lenguajes basados en prototipos como Self [Ungar87].

218
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

Creacin, Manipulacin y Evaluacin Dinmica de Cdigo


Python permite cosificar su comportamiento. Las cadenas de caracteres pueden re-
presentar cdigo, adems de datos, para poder evaluarse dinmicamente en un determinado
contexto de ejecucin. La funcin exec permite evaluar una cadena de caracteres, que
pueda haber sido creada dinmicamente, como si de cdigo se tratase. De forma adicional,
es factible pasar como parmetros la tabla de smbolos local y global del contexto de ejecu-
cin representada mediante un diccionario [Rossum2001].
Si lo que queremos es crear dinmicamente un mtodo de una clase, codificamos
mediante una cadena de caracteres una funcin y, como mostrbamos en el primer punto
de la caracterstica anterior (reflectividad estructural), asignamos sta a la clase adecuada. El
resultado de este proceso implica la posibilidad de aumentar el nmero de mensajes que
recibe un objeto en tiempo de ejecucin, sin necesidad de parar la aplicacin, y especifican-
do la semntica de cada mensaje por el usuario de la aplicacin no el programador en fase
de implementacin.

Interaccin Directa entre Aplicaciones


Como hemos comentado previamente, dentro de un mismo contexto de ejecucin
Python permite conocer y modificar la estructura de una aplicacin dinmicamente. Sin
embargo, la interaccin entre aplicaciones se debe llevar a cabo ejecutndolas en instancias
distintas del intrprete y comunicndolas mediante un middleware. Sobre esta capa interme-
dia, habra que implementar un mdulo que facilitase la intercomunicacin entre aplicacio-
nes, con la consecuente complicacin.
Una de las restricciones impuestas al lenguaje de programacin en 11.4, y cumpli-
das por la mquina abstracta presentada en el captulo 10, era crear un entorno en el que las
aplicaciones pudiesen interactuar entre s, sin necesidad de una capa intermedia, y de forma
independiente al lenguaje en el que stas hubiesen sido desarrolladas.
La interaccin entre aplicaciones Python es compleja al ejecutarse cada una en un
proceso del sistema operativo distinto. Sin embargo, los distintos hilos (threads) que una
aplicacin Python cree pueden acceder a las variables globales del hilo padre que los cre.
De esta forma, la solucin al problema surgido pas por asignar un hilo distinto a cada
aplicacin de nuestro sistema, ejecutndose ste como una nica aplicacin Python.
Como se muestra en la Figura 14.1, el hilo principal crea un objeto denominado
nitrO que sigue el patrn de diseo Fachada [GOF94]: todo el acceso al sistema se lleva a
cabo a travs de este objeto. Una vez que dentro del sistema se ejecute una nueva aplica-
cin, se crear un hilo hijo del principal, pudiendo ste acceder al objeto nitrO propio del
hilo padre. Al dar este objeto acceso a toda la funcionalidad del sistema, obtenemos una
interaccin directa entre aplicaciones de nuestro sistema, independientemente del lenguaje
utilizado75.

75
La propiedad apps del objeto nitrO nos devuelve un diccionario con todas las aplicaciones activas
dentro del sistema; el acceso a stas supone, por tanto, la interaccin entre aplicaciones.

219
CAPTULO 14

Lenguajes

Aplicaciones
Objeto nitrO
Sistema

Accesos
al sistema
a travs del
Hilo
objeto
Principal nitrO

Hilo Hilo
Hijo Hijo

Figura 14.1: Acceso al objeto nitrO desde distintos hilos representativos de aplicaciones.

14.2 Diagrama de Subsistemas


El diseo del prototipo ha sido dividido en un conjunto de subsistemas, implemen-
tados como mdulos Python. stos y sus dependencias se muestran en la siguiente vista
esttica, expresada mediante UML [Rumbaugh98]:

<<subsystem>> <<subs ystem>> <<subsystem>>


met aLang nitrO objectBrow ser

<<subsystem>> <<subsystem>> <<subs ystem>>


langSpec appSpec GI

Figura 14.2: Diagrama de subsistemas del prototipo.

220
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

14.2.1 Subsistema nitrO


Como comentbamos en el punto anterior, la interaccin directa entre las aplica-
ciones de nuestro sistema se consigue mediante la utilizacin del patrn de diseo Fachada
[GOF94], en el que se establece un nico punto de entrada al mismo. De esta forma, el
subsistema nitrO establece este punto central que permite acceder al resto de servicios
ofrecidos en el sistema.

14.2.2 Subsistema objectBrowser


El subsistema objectBrowser hace un uso directo de las caractersticas intros-
pectivas propias del lenguaje Python comentadas en el primer punto de este captulo. A
travs del objeto nitrO existente dentro del subsistema con el mismo nombre, es ofrecida
una coleccin de objetos y clases necesarias para obtener el entorno flexible de programa-
cin propuesto en esta tesis. Este subsistema muestra al usuario esta informacin de forma
dinmica.
Puesto que la cantidad de aplicaciones en ejecucin puede ser elevada, el nmero de
objetos y clases que representen a stas, y a sus respectivas especificaciones de lenguajes de
programacin, representarn una informacin ingente para el usuario. Gracias a la intros-
peccin ofrecida por Python, este subsistema analiza dinmicamente las propiedades del
objeto Fachada nitrO. El usuario podr conocer toda la informacin ofrecida dinmica-
mente por el sistema, navegando por un rbol representativo de los objetos existentes, para
posteriormente llevar a cabo la accin adecuada.
El aspecto de esta herramienta introspectiva se muestra en el manual de usuario de
este prototipo (apndice B).

14.2.3 Subsistema langSpec


Puesto que nuestra herramienta es independiente del lenguaje de programacin que
el usuario quiera utilizar, este subsistema es el encargado de representar cada lenguaje utili-
zado por una aplicacin.
Como expondremos de forma ms detallada en el siguiente punto, es necesaria la
representacin del lenguaje de programacin mediante una estructura de objetos. El con-
junto de clases ofrecidas en este mdulo, tiene por objetivo la representacin de gramticas
libres de contexto [Cueva91] y su semntica asociada.

14.2.4 Subsistema metaLang


Dado que para que una aplicacin sea ejecutada por nuestro entorno computacional
flexible es necesario conocer el lenguaje en el que sta haya sido programada, deberemos
idear un modo de representar la totalidad de lenguajes de programacin a emplear. El mo-
do en el que permitimos expresar al usuario los distintos lenguajes de programacin a utili-
zar cualquiera libre de contexto [Cueva91] es mediante otro lenguaje: un metalenguaje76.
El propsito del conjunto de clases existentes en este subsistema es procesar la es-
pecificacin del lenguaje de programacin a utilizar expresado en el metalenguaje y, si
fuere correcta, convertir su especificacin en una representacin de objetos, haciendo uso
para ello de las clases del subsistema langSpec de ah la dependencia entre ambos.
76
Este lenguaje expresa lenguajes de programacin de tipo 2. Su gramtica y representacin de semntica
pueden consultarse en el apndice B.

221
CAPTULO 14

14.2.5 Subsistema appSpec


Una vez que el lenguaje haya sido especificado por el usuario, reconocido por el
subsistema metaLang, y convertido a su representacin mediante objetos, la misin de
stos es tomar una aplicacin codificada para este lenguaje y obtener su rbol sintctico
[Cueva95] (AST, Abstract Syntax Tree [Aho90]). El conjunto de clases existentes en este sub-
sistema permite representar el rbol sintctico de una aplicacin, con sus correspondientes
enlaces a la representacin de su lenguaje, para su posterior ejecucin por el subsistema GI.

14.2.6 Subsistema GI
Tomando el rbol sintctico creado por el subsistema appSpec este subsistema
(GI, Generic Interpreter) es el encargado de ejecutar las acciones semnticas propias del len-
guaje de programacin asociado, es decir, de interpretar la aplicacin.

14.3 Subsistema metaLang


El reconocimiento de un lenguaje de programacin y la conversin de su especifi-
cacin a una estructura de objetos, es el principal objetivo de este subsistema. La descrip-
cin del lenguaje deber llevarse a cabo mediante un archivo con extensin ml o incluyen-
do sta previamente a la codificacin de una aplicacin. La especificacin formal del meta-
lenguaje, capaz de describir cualquier lenguaje libre de contexto, est descrita en el apndice
B.

14.3.1 Diagrama de Clases

Subsiste ma
metaLang

Scanner
token : int Parser
input : string
scanner scanner : Scanner
charPos : int
ogc : ObjectGrammarCreator
text : string
lineNumber : int 1
start()
getNextToken()

ogc
1

language ObjectGrammarCreator
Language
(from langSp ec) language : Language
1

Figura 14.3: Diagrama de clases del subsistema metaLang.

El conjunto de clases sigue la estructura clsica de un procesador de lenguaje para


llevar a cabo el anlisis lxico y sintctico del metalenguaje descrito en el apndice B: la

222
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

funcionalidad del mdulo de anlisis lxico es llevada a cabo por cada uno de los objetos
instancia de la clase Scanner, mientras que el sintctico es responsabilidad de los objetos
Parser.
El analizador lxico [Cueva93] obtiene su cdigo de entrada de su atributo input y
analiza ste avanzando el contador de posicin charPos. Para leer un nuevo componente
lxico, invocamos el mtodo getNextToken; el ltimo token ledo puede ser obtenido de
su propiedad token. La codificacin de sus algoritmos ha sido llevada a cabo siguiendo las
pautas propuestas por Holub [Holub90].
El analizador sintctico se ha desarrollado mediante la tcnica de traduccin de una
gramtica descendente LL1 a subprogramas [Cueva95], obteniendo un analizador sintctico
descendente recursivo sin retroceso [Aho90]. Cada smbolo no terminal de la gramtica
constituye un mtodo que desarrolla su anlisis, siendo el mtodo start el encargado de
desencadenar el proceso asignado al smbolo inicial de la gramtica [Cueva91] el anlisis
de toda la aplicacin.
El analizador sintctico demanda componentes lxicos de su propiedad scanner
y, conforme analiza el archivo fuente, va creando la representacin mediante objetos de
dicho lenguaje; su propiedad ogc, instancia de la clase ObjectGrammarCreator, posee
mtodos para facilitar dicha creacin.

14.4 Subsistema langSpec


Representa mediante asociaciones entre objetos la especificacin de un lenguaje de
programacin. El subsistema metaLang crea estas representaciones apoyndose en instan-
cias de su clase ObjectGrammarCreator. Las aplicaciones accedern dinmicamente a
esta representacin de su lenguaje de programacin para interpretar su semntica de eva-
luacin.
Podremos cuestionarnos por qu es necesaria la representacin de un lenguaje me-
diante estructuras de objetos. En el captulo 2 enuncibamos un conjunto de requisitos
relativos a la flexibilidad de nuestro sistema. Todos ellos se obtienen, como hemos indicado
en el captulo 11, al permitir a una aplicacin modificar dinmicamente la especificacin de
su lenguaje de programacin. El hecho de que una aplicacin acceda y modifique dinmi-
camente la estructura de los objetos que representan su lenguaje de programacin es facti-
ble mediante el uso de reflectividad estructural. Es por ello por lo que es necesario que el
lenguaje de programacin seleccionado ofrezca esta caracterstica.

223
CAPTULO 14

14.4.1 Diagrama de Clases


Subsistema
langSpec syntacticSpec

ruleName : string
Language
name : string NonTerminal
start : GrammarSymbol name : string Right
lexicalSpec lexicalSpec description : string options nodes
syntacticSpec ruleName : s tring options actions
skipSpec n n
notSkipSpec describe() recognise()
recognise()
describe()

nodes
GrammarSymbol actions n
n SemanticAction
action : string

execute()
0..n
skipSpec
Terminal
Lambda Reify
notSkipSpec value : string
describe() recognise()
0..n describe()
recognise() describe()
recognise() ReifySemanticAction

execute()

Figura 14.4: Diagrama de clases del subsistema langSpec.

Siguiendo con la descripcin de lenguajes de tipo 2, los elementos de una gramtica


pueden ser terminales (clase Terminal), no terminales (NonTerminal) y el elemento
vaco o lambda. Todos ellos son smbolos gramaticales, derivando pues de la clase
GrammaSymbol77. El mtodo recognise de todo smbolo gramatical est orientado a
intentar reconocer su patrn ante una aplicacin de entrada y, en el caso de que esta accin
resulte satisfactoria, crear su rbol sintctico mediante las clases del subsistema
appSpec. En la descripcin del subsistema appSpec detallaremos el modo en el que este
rbol es creado.
El mtodo describe de todos los objetos, en cualquier subsistema, tiene la misma
utilidad: ofrecer informacin descriptiva del objeto implcito.
Toda regla de una gramtica libre de contexto se puede expresar como [Cueva91]:
A, AVN, (VNVT)*
La parte de la izquierda de una regla es siempre un no terminal, mientras que la par-
te derecha es una consecucin de smbolos gramaticales. La clase Right representa cada
una de las partes derechas asociadas a un smbolo no terminal (atributo options) median-
te una regla. La coleccin de los smbolos gramaticales de la parte derecha de una regla se
almacena en el atributo nodes de los objetos de tipo Right.
Las reglas semnticas asociadas a las distintas alternativas de una produccin, que se
ejecutan cuando sta es reconocida, son instancias de la clase SemanticAction y se ac-

77
Esta clase no ha sido codificada realmente en nuestro prototipo por peculiaridades del lenguaje de pro-
gramacin utilizado. Python posee inferencia dinmica de tipos y por tanto slo verifica si un objeto pue-
de interpretar un mensaje cuando ste lo recibe en tiempo de ejecucin. De esta forma, la utilizacin de
la herencia como la derogacin de comportamiento polimrfico, no es necesaria en el lenguaje Python.
Puesto que no hay validacin esttica de tipos, no tiene utilidad implementar una clase base con mtodos
a sobrescribir por las abstracciones derivadas.

224
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

cede a ellas a travs del atributo actions de cada parte derecha. La semntica se represen-
ta mediante cdigo Python, almacenndose en la propiedad action y evalundose me-
diante el paso de mensaje execute.
La ejecucin de una regla semntica no se limita a la evaluacin de un cdigo Pyt-
hon. ste ha de evaluarse dentro de un contexto para cada aplicacin: cada aplicacin de
nuestro sistema tendr su propio espacio de direcciones con sus variables, objetos, clases y
funciones, es decir, su contexto. Este contexto se almacena en la propiedad
applicationGlobalContext de cada instancia de la clase Application del subsis-
tema appSpec.
Language es la clase principal, cuyas instancias representarn cada uno de los len-
guajes cargados en el sistema. Sus atributos name y start identifican respectivamente su
identificador nico y el smbolo no terminal inicial de la gramtica. Los atributos
lexicalSpec y syntacticSpec identifican dos diccionarios de smbolos no terminales
ubicados en la parte izquierda de una regla; la clave de los diccionarios es el identificador
nico de los no terminales. Las reglas lexicalSpec representan componentes lxicos,
mientras que syntacticSpec define la sintaxis del lenguaje.
Las propiedades skipSpec y notSkipSpec son una coleccin de terminales que
especifican aquellos elementos que deben eliminarse automticamente, o bien concatenarse
a los tokens del lenguaje de forma implcita78.
Como hemos explicado en 9.5, nuestro entorno computacional de programacin
flexible permite realizar un salto computacional del espacio de aplicacin al espacio de in-
terpretacin. Esta operacin se lleva a cabo mediante la instruccin reify, que permite
especificar al programador un cdigo a ejecutar en el contexto de interpretacin, indiferen-
temente del lenguaje utilizado. El reconocimiento de esta instruccin existente en todo
lenguaje la realiza las instancias de la clase Reify.
Puesto que la ejecucin de un cdigo de programacin se evala de modo distinto
al cdigo del nivel inferior (interpretacin), sta segunda semntica es la que deroga la rede-
finicin del mtodo execute de la clase ReifySemanticAction.

14.4.2 Especificacin de Lenguajes mediante Objetos


La flexibilidad de nuestro sistema computacional viene otorgada por la posibilidad
de ejecutar por el programador cdigo de un nivel computacional menor. Este cdigo es
evaluado en el contexto del intrprete y podr utilizarse para acceder y modificar el lenguaje
de programacin utilizados, consiguiendo as el grado de reflectividad deseado.
Puesto que la modificacin de determinadas caractersticas del lenguaje de progra-
macin utilizado en una aplicacin va a ser una tarea comn, el programador de aplicacio-
nes deber conocer el estado dinmico de los objetos que constituyen la especificacin de
un lenguaje de programacin. Para facilitar su comprensin, mostraremos un ejemplo de
parte de los objetos que representan el siguiente lenguaje79:

Language = Print
Scanner = {
"Digit Token"
digit -> "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9" ;
"Number Token"

78
Para comprender mejor la utilidad de estos elementos consltese el apndice B.
79
La descripcin del lenguaje ha sido llevada a cabo mediante el metalenguaje de nuestro sistema, especi-
ficado en el apndice B.

225
CAPTULO 14

NUMBER -> digit moreDigits ;


"Zero or more digits token"
moreDigits -> digit moreDigits
| ;
"PRINT Key Word"
PRINT -> "PRINT" ;
"SEMICOLON Token"
SEMICOLON -> ";" ;
}
Parser = {
"Initial Free-Context Rule"
S -> statement moreStatements SEMICOLON <#
nodes[1].execute()
nodes[2].execute()
#> ;
"Zero or more Statements"
moreStatements -> SEMICOLON statement moreStatements <#
nodes[2].execute()
nodes[3].execute()
#>
| ;
"Statement Rule"
statement -> _REIFY_ <#
nodes[1].execute()
#>
| printStatement <#
nodes[1].execute()
#> ;
"Print Statement"
printStatement -> PRINT NUMBER <#
write( "Integer constant: "+nodes[2].text+".\n")
#> ;
}
Skip={ "\t"; "\n"; }
NotSkip = { " "; }

El subsistema metaLang toma esta especificacin y, haciendo uso de la clase


ObjectGrammarCreator, crea un conjunto de objetos que especifiquen este lenguaje
Print. Un subconjunto de stos es:

226
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

:NonTerminal :Terminal
lexicalSpec options nodes
:Right
name=SEMICOLON value=;

nodes

:SemanticAction
print:Language :NonTerminal actions
start :Right action=nodes[1].execute()
name=S options
name=Print Nodes[2].execute()

:Reify
:NonTerminal nodes
options :Right Name=Reify
name=statement

actions
:SemanticAction

action=nodes[1].execute()
:NonTerminal
syntacticSpec name=moreStatements
:SemanticAction
actions
:Right
:NonTerminal action=nodes[1].execute()

name=printStatement

nodes

Figura 14.5: Diagrama de objetos de la especificacin del lenguaje Print.

Como se observa en la Figura 14.5, los objetos de tipo Language ofrecen la toda
especificacin cada lenguaje de programacin utilizado. ste posee una referencia start al
smbolo no terminal inicial de la gramtica y un par de diccionarios, lexicalSpec y
syntacticSpec, para representar las reglas lxicas y sintcticas respectivamente.
Cada smbolo no terminal tiene un conjunto de objetos Right, identificados me-
diante su propiedad options, que representan la parte derecha de cada produccin aso-
ciada. Las partes derechas de las producciones poseen una coleccin de smbolos gramati-
cales atributo nodes y un conjunto de acciones semnticas atributo actions.
El resultado es un grafo de objetos que representan la especificacin del lenguaje
mediante su estructura. Utilizando reflectividad estructural y la cosificacin ofrecida por la
instruccin reify, el programador puede modificar la especificacin de un lenguaje
haciendo variar as todas las aplicaciones codificadas sobre ste.

14.5 Subsistema appSpec


Una vez que el sistema ha creado la representacin en objetos del lenguaje de pro-
gramacin a utilizar, la funcionalidad de stos es llevar a cabo el anlisis sintctico del cdi-
go fuente y, en el caso de que la aplicacin sea reconocida por la gramtica, obtener el rbol
sintctico representante de sta. Las clases cuyos objetos representarn el rbol sintctico se
muestran en el siguiente diagrama de clases:

227
CAPTULO 14

14.5.1 Diagrama de Clases


Subsistema
appSpec

<<composite>>
Application
TreeNode
name : string application : Application
language : Language grammarSymbol : GrammarSymbol
rootNode : TreeNode
children 0..n
sourceCode : string application rootNode
text : string
applicationGlobalContext
option : Right children
isRunning : Boolean 1 1
window : AppWindow
describe()
nitrO : NitrO
describeWithChildren()
describeTree()
describe() execute()
application 1

1
language 1 grammarSymbol option 1
window 1
AppWindow Language GrammarSymbol Right
(from langSpec) (from langSpec)
application : Application (from langSpec)

w riteText()
update()

Figura 14.6: Diagrama de clases del subsistema appSpec.

Una aplicacin en nuestro sistema viene identificada por una instancia de la clase
Application. Sus atributos representan su identificacin (name), lenguaje asociado
(language), cdigo fuente (sourceCode), contexto de ejecucin o tabla de smbolos
(applicationGlobalContext), estado de ejecucin (isRunning) y su vista mediante
una ventana grfica (window), entre otros.
La relacin entre la clase Application y Language es de composicin, es decir,
cada vez que se ejecuta una aplicacin en un determinado lenguaje de programacin, aun-
que ste sea el mismo, se crea una nueva instancia del lenguaje. Como comentbamos en el
captulo 6, la reflectividad computacional pura debe permitir modificar todas las aplicacio-
nes del sistema que posean una misma semntica computacional (lenguaje de programa-
cin). Puesto que nuestro prototipo ha sido diseado para justificar y evaluar una tesis,
hemos seguido el criterio de utilizar un grano ms fino: cada aplicacin est asociada a una
nica representacin de un lenguaje80. De esta forma podremos modificar la semntica de
una aplicacin desde otra aplicacin codificada en el mismo lenguaje, sin que vare el com-
portamiento de la segunda aplicacin.
Cada aplicacin posee una visualizacin grfica de su ejecucin mediante una ven-
tana objeto de la clase AppWindow. El mtodo writeText muestra en ella una lnea de
texto y su contenido puede actualizarse con el paso del mensaje update.
Los nodos del rbol sintctico son instancias de la clase TreeNode, diseada me-
diante el patrn de diseo Composicin [GOF94]: cada nodo almacena una lista de sus
nodos descendientes, de forma recursiva, mediante su atributo children. El texto reco-
nocido por la gramtica para el smbolo gramatical asociado ante una aplicacin de entrada,
es almacenado en su atributo text.
80
La modificacin de todas las instancias de un lenguaje es posible y por tanto podr modificarse la se-
mntica de las aplicaciones que utilicen un mismo lenguaje de programacin. Sin embargo, aunque no se
pierda esta posibilidad, el tiempo de computacin requerido para este proceso es mayor que el necesario
en el caso de haber seguido el otro criterio de diseo.

228
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

Los nodos del rbol semntico guardan la asociacin con su smbolo gramatical del
lenguaje asociado (grammarSymbol) y, en el caso de que ste no sea un terminal, la parte
derecha de la produccin (option) elegida para obtener sus hijos.
El modo en el que se evala el rbol dando lugar a la ejecucin de la aplicacin se
lleva a cabo mediante envos de mensajes execute. Analizaremos esta funcionalidad en el
estudio del subsistema GI.

14.5.2 Creacin del rbol Sintctico


Una vez creada la especificacin del lenguaje de programacin e identificado un
programa a procesar, la invocacin al mtodo recognise del smbolo inicial de la gram-
tica, deber desencadenar el siguiente proceso:
Validar si la aplicacin pertenece al lenguaje.
Obtener el rbol sintctico de la aplicacin de entrada.
Asignar el texto reconocido a la propiedad text de cada nodo del rbol sintc-
tico creado.
El algoritmo utilizado es el de reconocimiento descendente con retroceso o back-
tracking [Cueva95], poco eficiente pero sencillo de implementar. La invocacin del mtodo
afirmar que la sentencia pertenece al lenguaje si encuentra una parte derecha de su pro-
duccin cuyos smbolos gramaticales validen la pertenencia al lenguaje, invocando a su vez
a sus mtodos recognise. Este algoritmo es de naturaleza recursiva y polimrfico
respecto al comportamiento del mensaje recognise.
Si la ejecucin del mtodo recognise es satisfactoria, se indicar la pertenencia al
lenguaje con la devolucin del rbol sintctico asociado a esa produccin. De forma parale-
la, se ir asignando a cada nodo la fraccin de cdigo reconocida por l, en su atributo
text.
Supongamos que se va a analizar, para el lenguaje Print presentado en 14.4.2, el
siguiente programa:

PRINT 45;

Cuando se le enve el mensaje recognise al smbolo gramatical statement, un


subconjunto de las operaciones desencadenadas entre los objetos pertinentes, es el mostra-
do en el siguiente diagrama de colaboracin:

229
CAPTULO 14

statement printStatement NUMBER


:TreeNode children :TreeNode children :TreeNode

text=PRINT 45 text=PRINT 45 text=45

15:new
7:new
18:new
6:recognise 6:recognise
printStatement NUMBER
5:recognise :Right
:NonTerminal :NonTerminal
16:printStatement
NUMBER
17:printStatement
statement
14:PRINT
:NonTerminal 4:None
3:recognise 7:recognise
2:recognise :Right :Reify
1:recognise None
19:statement

:Right

:Terminal 9:recognise 8:recognise


PRINT
:Right
:NonTerminal
value=PRINT
11:token 12:token

10:new 13:new

token PRINT
children children
:TreeNode :TreeNode

text=PRINT text=PRINT

Figura 14.7: Creacin del subrbol sintctico propio de una sentencia.

Como se muestra en la figura, la invocacin del mtodo recognise de un no


terminal implica la bsqueda de una parte derecha que valide la produccin. Si una es en-
contrada, el valor devuelto es el subrbol creado. En el ejemplo vemos cmo una parte
derecha statement no consigue validar la produccin al no aparecer en el cdigo fuente
una instruccin reify. A la parte derecha restante es enviado entonces el mensaje, resul-
tando positivo y obteniendo el subrbol sintctico apropiado.

14.6 Subsistema GI
Los objetivos principales de este subsistema son:
1. Invocacin del algoritmo de reconocimiento sintctico con retroceso, aportan-
do un buffer en el que se encuentra el cdigo fuente a analizar.
2. Ejecutar la aplicacin, recorriendo el rbol sintctico y evaluando los nodos
como se haya descrito en la especificacin del lenguaje.
3. Eliminar de la entrada los componentes lxicos descritos en la seccin
skipSpec.
4. Concatenar automticamente los tokens especificados como notSkipSpec
en el metalenguaje.

230
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

14.6.1 Diagrama de Clases


Subsistema
GI

GI
application : Application
buffer : ApplicationBuffer
nitrO : NitrO application Application
objectsCreation() (from appSpec)
1
evaluate()
appID : string
clearSkip()
clearNotSkip() n
apps
clearBuffer()

buffer
1 1
ApplicationBuffer nitrO
code : string <<singleton>>
position : int NitrO
text : string (from nitrO)

Figura 14.8: Diagrama de clases del subsistema GI.

Las instancias de la clase ApplicationBuffer llevan el control de la posicin en


el que el cdigo fuente est siendo analizado code almacena el cdigo y position la
posicin, as como la traduccin de ste atributo text. El archivo fuente va siendo pro-
cesado eliminando automticamente los tokens de skipSpec y concatenando, sin necesi-
dad de explicitarlo en la gramtica, los indicados en notSkipSpec; el resultado es almace-
nado en text.
Como vimos en el algoritmo expuesto en 14.5.2, cada nodo del rbol sintctico
posee el texto reconocido excluyendo e incluyendo automticamente los componentes lxi-
cos especificados en skipSpec y notSkipSpec, respectivamente. Este proceso se apoya
directamente en el atributo text de las instancias de applicationBuffer: antes de
invocar al mtodo recognise de sus hijos, almacena la posicin del buffer y, una vez
reconocidos stos, obtiene el incremento sufrido en el atributo text.
Los objetos GI llevan a cabo la traduccin de cdigo mediante los mtodos
clearSkip y clearNotSkip. El mtodo clearBuffer invoca a estos dos sucesiva-
mente hasta que no quede ningn token por limpiar en la posicin actual del cdigo fuente.
En el ejemplo del lenguaje Print, los caracteres tabulador y salto de lnea son eliminados
automticamente, mientras que los espacios en blanco se concatenan a los componentes
lxicos reconocidos.
Cada instancia de GI posee una referencia al buffer utilizado (buffer), a la aplica-
cin a ejecutar (application) y al sistema (nitrO). El mtodo objectsCreation es
el encargado de procesar la aplicacin de entrada y obtener el rbol sintctico tal y como se
explic en 14.5.2.

231
CAPTULO 14

La evaluacin del rbol sintctico es llevada a cabo mediante el mtodo evaluate


de las instancias de GI. Mostraremos a continuacin cmo se coordinan los nodos del r-
bol y las reglas semnticas para producir la ejecucin de una aplicacin.

14.6.2 Evaluacin del rbol Sintctico


Una invocacin al mtodo evaluate de una instancia de GI, hace que sta locali-
ce el nodo inicial atributo rootNode de application y le pase el mensaje execute.
En la aplicacin y lenguaje de entrada de ejemplo mostrados en este captulo, la ejecucin
del mtodo asociado produce la evaluacin del rbol siguiendo el siguiente diagrama de
colaboracin81:
grammar S
Symbol :SemanticAction
:NonTerminal
action=
actions nodes[1].execute()
2:execute()
Nodes[2].execute()
:TreeNode
1:execute() option nodes
:Right
text=PRINT 45;
grammar statement
Symbol :NonTerminal
children
grammar moreStatements
Symbol :NonTerminal

grammar SEMICOLON
Symbol :NonTerminal
7:execute()
actions
:TreeNode :TreeNode :TreeNode
3:execute()
text= text=; nodes
text=PRINT 45 :Right

children option
grammar printStatement
4:execute()
children Symbol :NonTerminal

grammar :Lambda
Symbol

:TreeNode :SemanticAction
:TreeNode
5:execute()
text= action=
text=PRINT 45
nodes[1].execute()

option nodes
children :Right
grammar PRINT
Symbol :NonTerminal
6:execute()
grammar actions NUMBER
Symbol :NonTerminal

:SemanticAction
:TreeNode :TreeNode
action=
text=PRINT text=45 write(nodes[2].text)

Figura 14.9: Evaluacin de un rbol sintctico.

Este diagrama muestra cmo los objetos del subsistema langSpec ms a la dere-
cha en la figura colaboran con los de appSpec para evaluar el rbol. Una vez que se le
pasa el mensaje execute al nodo inicial, ste obtiene las acciones de su parte derecha
(option) y les pasa el mismo mensaje. Ejecutadas las acciones asociadas, el proceso con-
cluye.

81
Los objetos descendientes de los no terminales que forman parte de la especificacin lxica han sido
omitidos para simplificar la figura. Su evaluacin sigue los mismos pasos que los descritos para el resto
de nodos.

232
Diseo de un Prototipo de Computacin Reflectiva Sin Restricciones

Para nuestro ejemplo, la accin semntica del smbolo inicial conlleva la ejecucin
de las acciones semnticas de los nodos statement y moreStatements, puesto que as se
especific en la descripcin del lenguaje. La ejecucin del nodo statement desencadena la
evaluacin del nodo printStatement y ste visualiza en su ventana la constante numrica
45, mediante la sentencia write(nodes[2].text).

14.7 Subsistema nitrO


El subsistema nitrO define el objeto nitrO que sigue el patrn de diseo Facha-
da [GOF94], ofreciendo todas las posibilidades del sistema.

14.7.1 Diagrama de Clases

Subsistema
nitrO

F achada del
<<singlet on>> s ist ema
NitrO
apps
scanner : Applicat ion
dir : string
shell : MainWindow
apps Application
appID : string
describe() n (from appSpec)
loadApplication()
loadLanguage()
execute() nitrO
executeFile()
run() 1
stop()

MainW indow
1
shell nitrO : NitrO
context
scanner
1 quit()
Scanner clearConsole()
clearOutput()
openFile()
getNextToken() view Objects()
w rite()

Figura 14.10: Diagrama de clases del subsistema nitrO.

La clase NitrO sigue el patrn de diseo Singleton [GOF94], prohibiendo la crea-


cin de ms de una instancia de dicha clase. El nico objeto creado (nitrO) ofrece el si-
guiente conjunto de servicios:
Aplicaciones del sistema y sus respectivos lenguajes, accediendo a su atributo
apps.

233
CAPTULO 14

Un pequeo intrprete de comandos (shell) que ofrece la evaluacin de cdi-


go en el sistema, una consola de salida (utilizando la funcin write) y la carga
y edicin de archivos.
El atributo dir posee la ubicacin del sistema dentro del rbol de directorios.
Permite ejecutar cualquier sentencia de cdigo dentro del sistema utilizando el
mtodo execute as como la ejecucin de archivos que tengan un conjunto
de sentencias mtodo executeFile.
Si se desea finalizar la ejecucin de una aplicacin dentro del sistema, podemos
enviarle el mensaje stop, pasando como parmetro el identificador de la apli-
cacin.
Las instancias de la clase Scanner son las encargadas de obtener los componentes
lxicos de los archivos de aplicacin, siguiendo la gramtica de aplicaciones descrita en el
apndice B. Cada vez que se desee obtener un nuevo token, se le enviar el mensaje
getNextToken.
Finalmente, la clase MainWindow supone una ventana grfica con un men, editor
y consola de salida, para ofrecer un pequeo intrprete de comandos. El cdigo Python
que se escriba ser evaluado dentro del sistema. Podremos utilizar el objeto nitrO para ac-
ceder al sistema, y la funcin write para visualizar informacin en la consola de salida82.

82
Ms informacin acerca de la utilizacin del intrprete de comandos puede obtenerse en el apndice B.

234
CAPTULO 15:
MBITOS DE APLICACIN DEL SISTEMA

Las caractersticas propias del sistema presentado en esta tesis doctoral pueden ser
empleadas en distintos mbitos de desarrollo de aplicaciones. A modo de ejemplo en la
utilizacin de todas las ventajas aportadas por el sistema, pondremos el punto de atencin
en el anlisis de grupos de aplicaciones para los que se pueda aplicar de un modo sencillo
los beneficios aportados.
De un modo general, podemos decir que el tipo de aplicaciones que mayor benefi-
cio puede obtener de la flexibilidad de nuestro sistema, son aqullas que necesiten amoldar-
se dinmicamente a requisitos imprevisibles en tiempo de desarrollo, sin que sea posible
modificar el cdigo de la aplicacin ni parar su ejecucin. Un caso prctico de esta utilidad,
es la adaptacin dinmica de aspectos: una aplicacin es definida por su cdigo funcional y,
en tiempo de ejecucin, podr inspeccionar y adaptar sus aspectos a nuevas necesidades
ejemplos de aspectos son persistencia, depuracin, distribucin, sincronizacin, monitori-
zacin, tolerancia a fallos o mediciones.
Una de las caractersticas propias de nuestro sistema es la independencia del lengua-
je de programacin a utilizar. Los distintos grados de flexibilidad aportados, de modo dife-
rente a la mayora de los sistemas existentes, no dependen del lenguaje que el programador
haya deseado utilizar.

15.1 Sistemas de Persistencia y Distribucin


ste es uno de los campos en el que ms se ha investigado la utilizacin de los dis-
tintos grados de flexibilidad ofertados por distintos sistemas [Foote90] ya sean o no re-
flectivos.
Los sistemas de persistencia y distribucin pueden plantearse mediante un criterio
de diseo comn: la utilizacin de informacin que realmente no se encuentra ubicada en
el lugar donde es demandada; esta localizacin puede suponer un sistema de
almacenamiento persistente, o bien otra computadora. Basndonos en esta similitud, vamos
a analizar las posibilidades que oferta nuestro sistema para desarrollar ambos sistemas.

235
CAPTULO 15

15.1.1 Adaptabilidad a los Cambios


Una vez desarrollada una aplicacin que haga uso de sistemas de persistencia y dis-
tribucin, puede suceder que, en el mantenimiento de sta, surja la necesidad de realizar
cambios. Siempre es deseable que la mayor parte de estos cambios supongan el menor im-
pacto posible al sistema existente minimizar el nmero de cambios a implementar.
Cambios clsicos en persistencia y distribucin son la evolucin de los esquemas de
las bases de datos (clases, en orientacin a objetos) [Roddick95], y la modificacin del con-
junto de servicios ofertados por el servidor ya sean nuevos objetos, o bien nuevos mto-
dos de los objetos existentes.
El hecho de que se pueda conocer dinmicamente la estructura de un objeto (in-
trospeccin) y que se pueda modificar sta sin restriccin alguna (reflectividad estructural),
hace que resulte factible la implementacin de un mecanismo sencillo de modificacin es-
tructural de los objetos, en el que se pueden aadir, eliminar o modificar los distintos
miembros que sea necesario adaptar evolucionando as la estructura de un conjunto de-
terminado de objetos.
En el desarrollo de aplicaciones distribuidas, cualquiera que sea la tecnologa a utili-
zar, se suele identificar el concepto de servidor y cliente de un servicio [Orfali98]. Los pa-
sos comunes a efectuar son:
1. Definir la interfaz del servicio.
2. Procesar la interfaz para conseguir el modo en el que se implementar por el
servidor (comnmente denominado skeleton) y se invocar por el cliente (stub).
3. Implementar, mediante el cdigo obtenido en el punto anterior, los clientes y
servidores de dicho servicio.
Una vez desplegado el sistema distribuido, puede surgir la necesidad de aumentar
los servicios del servidor para implementar un nuevo cliente, sin necesidad de modificar los
clientes ya existentes. Como mencionbamos en el segundo paso, la modificacin del servi-
cio generara nuevo cdigo de implementacin e invocacin, teniendo que modificar los
clientes implantados.
Clientes Objeto
Clientes
Versin 1 Servidor
Versin 2

Servicios
Stub Servicios v.1 Servicios Stub
Aadidos v.2

Objeto que, por medio


de introspeccin, invoca
al mtodo oportuno

Red de Ordenadores

Figura 15.1: Adaptabilidad a distintas versiones de servidor y cliente mediante introspeccin.

Mediante el uso de introspeccin es posible eliminar la necesidad de generar los es-


queletos del servidor: cuando el cliente invoca al objeto servidor, la recepcin del mensaje
remoto puede analizarse dinmicamente y comprobar si existe un mtodo a invocar83. Del

83
De hecho, esta implementacin ha logrado eliminar en la plataforma de Java la necesidad de los skele-
tons del servidor en la versin 2 de RMI (Remote Method Invocation) [Allamaraju2000].

236
mbitos de Aplicacin del Sistema

mismo modo, sera factible implementar un sistema de mantenimiento de versiones de


servidor al igual que en los sistemas de persistencia [Roddick95].

15.1.2 Replicacin y Movilidad de Objetos Flexible


La conversin de un objeto en un conjunto secuencial de bytes permite a la plata-
forma Java transferir dicha representacin del objeto a un sistema de almacenamiento per-
sistente, o a otra plataforma remota. El proceso anterior puede llevarse a cabo mediante
introspeccin.
5) Mediante reflectividad
estructural, se recupera el
estado y el comportamiento
Objetos Originales
de cada uno de los objetos

4) Se crea cada Objetos


uno de los objetos Replicados
1) Mediante introspeccin,
se accede al objeto y sus Representacin en
asociados convirtindolos Bytes de los objetos
en bytes
2) La informacin se 3) Se recibe la
trasmite a travs de la red informacin

Red de Ordenadores

Figura 15.2: Replicacin de objetos a travs de una red de ordenadores.

Mediante reflectividad estructural, el programador podr crear dinmicamente un


objeto e ir asignndole sus distintos atributos y mtodos tanto la estructura como el com-
portamiento de los objetos es representado mediante datos (cosificacin). En Java, el pro-
gramador no puede realizar este proceso; es la mquina virtual quien ofrece la primitiva de
obtencin dinmica del objeto [Sun97e]. La posibilidad de codificar esta funcionalidad so-
bre el propio lenguaje flexibiliza tanto el modo en el que un objeto es representado por una
informacin, como la forma de recuperarlo.
Gracias a la creacin dinmica y modificacin del estado de los objetos, el progra-
mador puede desarrollar sistemas de replicacin de informacin y migracin de objetos por
las distintas plataformas del sistema, utilizando los algoritmos y estructuras de datos que l
estime oportuno.

15.1.3 Independencia del Aspecto y Seleccin Dinmica


El mecanismo utilizado para almacenar y recuperar un objeto de disco (factores
como frecuencia, compresin o sistemas de indexacin), as como el mecanismo utilizado
para interconectar aplicaciones (protocolo y representacin utilizados), pueden desarrollar-
se de modo que sean adaptables en tiempo de ejecucin.
Como se llev a cabo en el diseo del prototipo de entorno de programacin para
la mquina abstracta (captulo 13), se puede modificar mediante reflectividad computacio-
nal la semntica del paso de mensajes para que ste acceda a un objeto remoto o persis-
tente. Una vez enviado un mensaje, se localiza el objeto y se ejecuta el mtodo apropiado
all donde est. De este modo el usuario tiene la ilusin de que es local, cuando no se en-
cuentra realmente en memoria.

237
CAPTULO 15

Objetos Objeto real


reales Objeto en otra
proxy Asociacin plataforma
proxy/objeto

Modificacin del paso Objeto Real?


Objeto Real?
de mensajes mediante No. Obtener proxy y
S, invocacin
Reflectividad enviarle a ste el mensaje
mtodo
Computacional

Red de Ordenadores

Figura 15.3: Modificacin del paso de mensajes para desarrollar el sistema de distribucin.

Adems de la transparencia ofrecida, se permite utilizar una separacin dinmica de


aspectos. El programador no desarrollar la aplicacin teniendo en cuenta que sta ser
distribuida o persistente; tan slo deber dejar constancia de su especificacin funcional.
Dinmicamente se le atribuirn aspectos adicionales como su caracterstica de persistencia
o distribucin, sin necesidad de modificar el cdigo fuente de su especificacin funcional.
Haciendo uso de la introspeccin del sistema se pueden desarrollar aplicaciones que
modifiquen automticamente sus aspectos o los parmetros de cada uno de los aspectos.
Por ejemplo, puede codificarse la modificacin del mecanismo del sistema de indexacin
en funcin de la estructura de los objetos a consultar84 [Ortin99]. Si la plataforma posee una
elevada carga de procesamiento, podr reducirse sta automticamente cambiando la fre-
cuencia de actualizaciones a disco, o incluso enviando la computacin de ciertas aplicacio-
nes a otras plataformas fsicas.

15.1.4 Agentes Mviles Inteligentes y Autodescriptivos


Haciendo uso del entorno de programacin con caractersticas de distribucin, es
posible utilizar nuestra plataforma como una plataforma de agentes mviles. Como hemos
visto, un objeto puede convertirse a una serie de bytes (mediante introspeccin), trasmitirse
a travs de una red, y recuperarse en la plataforma destino (mediante reflectividad estructu-
ral).
En la arquitectura del sistema reflectivo presentado (captulo 11), vimos cmo una
aplicacin posee una asociacin con la descripcin de su lenguaje, estando ambos represen-
tados por una estructura de objetos. Mediante la utilizacin de los servicios descritos en el
prrafo anterior, es posible mover una aplicacin y la especificacin de su lenguaje de pro-
gramacin a otra plataforma para que sea ejecutada sobre sta, aunque no posea previa-
mente la descripcin de su lenguaje.
De forma adicional, un agente es capaz de analizar dinmicamente lo existente en
su entorno (introspeccin) y tomar decisiones en funcin del contexto descubierto. Un
ejemplo podra ser el desarrollo de un agente que sea capaz de encontrar un objeto en to-
das las mquinas del sistema, codificado en un lenguaje propio no instalado en el resto de
plataformas.
Otra de las caractersticas de nuestro sistema radica en la posibilidad de crear apli-
caciones que describan su propio lenguaje captulo 11. Si se desarrolla la aplicacin con el

84
Existen sistemas de indexacin que ofrecen mejor resultados que otros en funcin del tipo de informa-
cin a buscar u operacin a realizar. Por ejemplo, nested index posee mejores resultados que multiin-
dex para la consulta, pero peores para la actualizacin [Martnez2001].

238
mbitos de Aplicacin del Sistema

lenguaje que ella misma describe, sta ser susceptible de ser descarga de cualquier servidor
y ejecutada en una plataforma de nuestro sistema, sin necesidad de tener un conocimiento
previo del lenguaje utilizado.

15.1.5 Distribucin de Aplicaciones Independientemente de su Lenguaje


La raz computacional de nuestro sistema se centra en la implementacin de una
mquina virtual capaz de ejecutar cdigo de su plataforma abstracta. Su semntica es redu-
cida para poder implantarse en cualquier hardware, sistema operativo o aplicacin por
ejemplo, un navegador de Internet. Una vez implantada la mquina, el sistema computa-
cional puede crecer con cdigo reflectivo que extienda su nivel de abstraccin, sin necesi-
dad de modificar, en ningn momento, la implementacin de la mquina virtual.
El diseo de la tercera capa de nuestro sistema consigue, mediante su intrprete ge-
nrico, una independencia total del lenguaje a interpretar. La ejecucin de cualquier pro-
grama y la interaccin entre aplicaciones es factible de un modo independiente al lenguaje
de programacin utilizado para su codificacin. De forma adicional, como se muestra en
B.2, las aplicaciones pueden contener en su propio cdigo fuente la especificacin del len-
guaje que empleen. As, dichas aplicaciones podrn ser ejecutadas sin necesidad de instalar
su lenguaje en la plataforma oportuna.
La utilizacin de la independencia del lenguaje por una aplicacin navegador que
implemente una mquina virtual de nuestra plataforma abstracta, permite ofrecer la ejecu-
cin de cualquier aplicacin, codificada sobre cualquier lenguaje de programacin, descar-
gada de un servidor. Adicionalmente, esta aplicacin podr interactuar con cualquier otro
programa desarrollado sobre nuestra plataforma, al utilizar un nico modelo computacional
de objetos.

15.2 Sistemas de Componentes


El desarrollo del sistema de componentes de Java, JavaBeans [Sun96], est direc-
tamente ligado con el concepto de introspeccin. Si se desarrolla una clase para la plata-
forma de Java, se puede utilizar sta como componente que ofrece sus mtodos pblicos;
las parejas de mtodos cuyos nombres comiencen con get y set, seguidos del mismo
identificador, describen la propiedad asociada a dicho identificador; las parejas de mtodos
que comiencen con add y remove, describen la posibilidad de gestionar eventos siguiendo
el patrn Observador (Observer) [GOF94].
La carencia de introspeccin en la plataforma nativa de los sistemas operativos de
Microsoft, obliga a su modelo de componentes COM [Microsoft95] a simular un entorno
introspectivo. Cuando se desarrolla un componente para esta plataforma, es necesario im-
plementar un mtodo QueryInterface que devuelva una referencia al interface solicitado,
en el caso de que ste sea implementado. La carencia en la utilizacin de introspeccin,
puede llevar a incoherencias en el modelo cuando no coincida la implementacin del com-
ponente con lo descrito ante la invocacin de QueryInterface.
Siguiendo con el criterio de separacin de incumbencias [Hrsch95] o aspectos
[Kiczales97], se ha profundizado comercialmente en el desarrollo de sistemas transacciona-
les de componentes de aplicacin, como EJB (Enterprise Java Beans) [Sun98b] o COM+
[Kirtland99b]. Un componente de aplicacin describe nicamente su funcionalidad y se
incrusta en un servidor de aplicaciones [Allamaraju2000]. Los distintos aspectos de este
componente tales como persistencia, transacciones, utilizacin de cach, seguridad o re-

239
CAPTULO 15

cuperacin ante los errores pueden ser descritos por el programador de un modo declara-
tivo, es decir, separado del cdigo propio del componente.
Los sistemas de componentes transaccionales de aplicaciones otorgan al desarrolla-
dor de aplicaciones una determinada flexibilidad respecto al conjunto de aspectos que, tras
un determinado anlisis de aplicaciones reales, se han identificado como comunes a la ma-
yora de programas. El programador desarrolla la lgica de su problema (business logic) y, a la
hora de implantar o desplegar su aplicacin, deja constancia de la configuracin de los as-
pectos necesarios.
El grado en el que se pueden definir los aspectos de un componente de aplicacin
estar siempre limitado por sus interfaces de acceso. Si queremos definir un sistema de
componentes de aplicacin ilimitadamente flexible, podemos hacer uso de las caractersti-
cas de reflectividad computacional: la semntica del modo en el que se utilizan los compo-
nentes puede variarse con la expresividad propia de un lenguaje de meta-comportamiento,
para separar realmente la funcionalidad de los aspectos, sin ningn tipo de restriccin pre-
establecida.
Un ejemplo de la utilizacin de reflectividad computacional en el entorno descrito,
es el propuesto por Zhixue Wu [Wu98]: toma la descripcin del modelo de servicios de
transacciones descrito por OMG [OMG94], y permite modificar su semntica, de un modo
declarativo, mediante la utilizacin de metaobjetos.

15.3 Paradigma de Programacin Dinmicamente Adaptable


La reflectividad otorga un grado elevado de flexibilidad en el desarrollo de aplica-
ciones. Igual que el polimorfismo permite especificar en tiempo de desarrollo distintos
comportamientos de abstracciones genricas, la reflectividad permite describir modifica-
ciones dinmicas en la semntica y estructura de las aplicaciones. La reflectividad es consi-
derada como un polimorfismo dotado de mayor flexibilidad [Golm98].
De modo distinto al polimorfismo y a la separacin de aspectos, la flexibilidad que
estudiaremos en este punto es obtenida dinmicamente por el sistema, sin necesidad de
finalizar su ejecucin, siendo adaptada por ella misma o cualquier otro proceso.

15.3.1 Polimorfismo Dinmico


Haciendo uso de las tecnologas orientadas a objetos, el polimorfismo posibilita la
creacin de aplicaciones que puedan ser ampliables respecto a un tipo de abstraccin, facili-
tando as su mantenimiento.
Si deseamos hacer ampliable un proceso, de forma que pueda trabajar con un n-
mero indeterminado de abstracciones, podemos identificar la interfaz de tratamiento gen-
rico de estas abstracciones mediante una clase base o un interface. Cada abstraccin real de-
rivada implementar el comportamiento genrico de un modo especfico distinto. Como se
muestra en la siguiente figura, el tratamiento genrico es programado mediante abstraccio-
nes base, pero recibiendo realmente instancias de las clases derivadas.

240
mbitos de Aplicacin del Sistema

C la s e B a s e
C la s e
o b je to
o b je to
m to d o 1 ()
m to d o 2 () 1 m to d o ()
m to d o 3 ()

w h ile ( o b je to - > m to d o 1 ( ) )
m t o d o 2 ( m to d o 3 )

D e r iv a d a 1 D e r iv a d a 2 D e r iv a d a 3 T r a t a m ie n to g e n ric o
d e l a s a b s tr a c c io n e s
m to d o 1 () m to d o 1 () m to d o 1 ()
m to d o 2 () m to d o 2 () m to d o 2 ()
m to d o 3 () m to d o 3 () m to d o 3 ()

Figura 15.4: Tratamiento genrico de abstracciones mediante polimorfismo.

Para ampliar el funcionamiento de la aplicacin mediante una nueva abstraccin


debemos:
1. Crear una nueva clase derivada de la abstraccin genrica.
2. Implementar todos los mtodos especficos de la nueva abstraccin.
3. Crear explcitamente instancias de la nueva clase, cuando la aplicacin lo requie-
ra.
Ejemplos de este tipo de abstracciones, en el que una aplicacin puede ser amplia-
da, son prcticamente infinitos; pueden variar desde elementos grficos como mens, ba-
rras de herramientas, tipos de letra o cursores de ratn, hasta abstracciones propias del
problema a resolver.
La limitacin de la programacin anterior reside en la necesidad de parar la ejecu-
cin de una aplicacin, codificar la ampliacin siguiendo los tres pasos descritos, compilarla
y volver a ejecutarla. Mediante la reflectividad estructural y la interaccin ofrecida entre
aplicaciones, esto ya no es necesario.
Si hemos desarrollado una barra de herramientas implementando una interfaz bien
definida que especifique su imagen, dimensiones y el comportamiento esperado a la hora
de pulsar sobre ella, podemos ampliar dinmicamente la funcionalidad de esta aplicacin
sin necesidad de parar su ejecucin siguiendo los siguientes pasos:
1. Implementamos la interfaz con el comportamiento y estructura del nuevo bo-
tn.
2. Mediante otra aplicacin, lo insertamos en la lista de la barra de herramientas.
La aplicacin ser automticamente adaptada en tiempo de ejecucin. Este proceso
puede aplicarse a cualquier abstraccin, incluidas las propias del problema a resolver85.

15.3.2 Gestin de Informacin Desconocida en Fase de Desarrollo


Las aplicaciones informticas gestionan una informacin conocida en fase de desa-
rrollo. Los sistemas gestores de bases de datos son aplicaciones encargadas de mantener

85
Se ha desarrollado un ejemplo demostrativo en la distribucin del prototipo descrito en el apndice B.
En el directorio ControlProcess, se encuentra un sistema de simulacin de control de procesos autom-
ticos en una planta. Cada vez que queramos aadir el control de un nuevo proceso a la planta, aadimos
dinmicamente una implementacin de la interfaz del proceso a la lista de procesos existente. El sistema
reacciona automticamente, distribuyendo su capacidad de cmputo entre todos los sistemas implantados.

241
CAPTULO 15

esta informacin de un modo ntegro, seguro y eficiente. Sin embargo, el esquema de la


informacin a almacenar ha de describirse previamente a la introduccin de la misma.
La utilizacin de un sistema de persistencia de objetos dentro de nuestro entorno
de programacin [Ortn99b] y la caracterstica de reflectividad estructural e introspeccin,
hacen posible que nuestro sistema pueda adaptarse a nueva informacin aparecida en tiem-
po de ejecucin.
A la hora de dar de alta un elemento de la base de datos, puede ser necesario, para
ese objeto en particular, almacenar ms informacin que para el resto sin que los nuevos
campos hayan sido aadidos en tiempo de diseo. Mediante la utilizacin de un interfaz
grfico y haciendo uso de la reflectividad estructural, se podr ampliar la informacin (atri-
butos) para ese objeto en particular; el resto de los objetos no sufrirn este cambio [Yo-
der2001].
El posterior tratamiento de la informacin con determinadas modificaciones se
puede llevar a cabo haciendo uso de la introspeccin de los objetos. Por ejemplo, las con-
sultas se realizarn mediante los atributos comunes, pero la visualizacin y modificacin se
implementar sobre todos los atributos del objeto conocidos dinmicamente.

15.3.3 Patrones de Diseo Adaptables


Al tratarse nuestro sistema de un entorno computacional orientado a objetos, toma
todos los conceptos propios de este tipo de sistemas aadiendo sus caractersticas especfi-
cas. Uno de los conceptos utilizados en el desarrollo de aplicaciones orientadas a objetos es
el Patrn de Diseo [GOF94]: una solucin arquitectnica de diseo para un determinado
tipo de problema. Haciendo uso del concepto de reflectividad, pueden definirse patrones
de diseo orientados a la flexibilidad dinmica de la solucin ofertada.
Lejos de tratar de crear nuevos patrones de diseo en la utilizacin de las caracters-
ticas reflectivas ofertadas por nuestro sistema, analizaremos posibles modificaciones a al-
gn patrn conocido, que lo hagan ms flexible. En concreto estudiaremos el caso del pa-
tn Decorador (Decorator) [GOF94].
El patrn decorador (Decorator) permite aadir nuevas responsabilidades o
funcionalidades a abstracciones existentes. Si tenemos una clase Archivo, con sus
primitivas de tratamiento (abrir, cerrar, leer y escribir), se puede derivar una clase de sta
que, haciendo uso de un agregado del tipo Archivo, pueda ofrecer adicionalmente
servicios de compresin manteniendo su interfaz.
Para ofrecer estos servicios, la aplicacin deber disearse con la siguiente jerarqua
esttica de clases:

242
mbitos de Aplicacin del Sistema

Archivo

abrir()
cerrar()
1
leer()
escribir()

Archivo::escribir( ArchivoComprimido
comprimir(parmetro)) archivo

escribir()
return descomprimir( leer()
Archivo::leer()) comprimir()
descomprimir()

Figura 15.5: Utilizacin del patrn Decorador.

Una vez compilada y ejecutada esta aplicacin, no se podrn aadir nuevas respon-
sabilidades a la abstraccin Archivo si no se modifica su cdigo fuente. Mediante reflecti-
vidad estructural esta adaptacin dinmica es posible substituyendo el objeto por otro que,
haciendo uso del patrn Decorador, implemente su interfaz con responsabilidades aadidas
por ejemplo, el empleo de un buffer.
Haciendo uso de esta substitucin dinmica, puede desarrollarse un decorador ge-
nrico que pueda aadir responsabilidades a cualquier abstraccin, cualquiera que sea su
interfaz. Por ejemplo, podemos disear un decorador que, mediante la invocacin de un
mtodo decorar que reciba como parmetro el objeto a decorar, realice los siguientes
pasos:
1. Cree un atributo con una referencia al parmetro pasado.
2. Vaya analizando todos los mtodos del objeto asociado, creado en s mismo
tantos mtodos como posea, obteniendo as la misma interfaz.
3. Utilice en cada uno de los mtodos la funcionalidad propia del mtodo hom-
logo de su asociado, aadiendo una determinada funcionalidad.
Un ejemplo puede ser la construccin de un objeto que aada funcionalidad de tra-
za, mostrando un mensaje en cada invocacin de los mtodos del objeto asociado.

15.4 Aplicaciones Tolerantes a Fallos


Existen aplicaciones que son implantadas en plataformas susceptibles de poseer un
elevado porcentaje de fallos (por ejemplo, las aplicaciones distribuidas por distintos nodos
de Internet). Del mismo modo, existen aplicaciones crticas que tienen que dar una respues-
ta en tiempo real sin cometer jams un error en dicha respuesta (como un sistema en tiem-
po real de tratamiento mdico).
La validacin y prueba de este tipo de sistemas puede pasar por una fase de ensayo
basado en la simulacin de entornos susceptibles de sufrir fallos. Las caractersticas reflec-
tivas de nuestro sistema pueden ser empleadas para construir este tipo de entornos de si-
mulacin orientados a probar esta clasificacin de aplicaciones. Por un lado se desarrolla la
funcionalidad general de la aplicacin y por otro, haciendo uso de la reflectividad dinmica,

243
CAPTULO 15

se introducen situaciones computacionales simuladoras de fallos para observar la respuesta


del sistema separacin dinmica de incumbencias.
Basndonos en sistemas reales, y a modo de ejemplo, mostraremos distintas aplica-
ciones de nuestro sistema en la simulacin de fallos computacionales:
Comunicaciones susceptibles a fallos. Uno de los ejemplos es el desarrollo de
un entorno reflectivo basado en un MOP, que permite simular fallos en las co-
municaciones mediante la modificacin de la semntica del paso de mensajes
[Killijian98] reflectividad computacional. Permite analizar as, cmo se com-
porta una aplicacin CORBA bajo los contextos simulados, sin necesidad de
modificar el cdigo propio de la aplicacin.
Recuperacin de errores en sistemas concurrentes. Dada la resolucin de un
problema concurrente mediante un conjunto de hilos, se puede idear un sistema
reflectivo tolerante a fallos que haga que cualquier hilo se recupere ante un
error. El objetivo es que todos los hilos concluyan su ejecucin satisfactoria-
mente para resolver el problema global.
En [Kasbekar98], se define un chekpoint como un punto de estabilidad computa-
cional de un hilo. Mediante reflectividad estructural, cuando un hilo alcanza un
checkpoint, se puede salvar su estado en un almacenamiento persistente. El modo
de computar un hilo (la semntica del lenguaje) se modifica mediante reflectivi-
dad computacional de modo que, si sucede un error en ejecucin, se recupera el
estado del checkpoint anterior para volver a intentar computar su cdigo con xi-
to.
Recuperacin ante errores de sistemas complejos. Un sistema complejo que sea
dividido en un conjunto de aplicaciones desplegadas sobre distintos entornos
computacionales, debe analizarse de un modo global. Su tolerancia a los fallos
debe estudiarse teniendo en cuenta cmo se comportara ante el fallo de parte
del sistema.
Los estudios realizados en [Cibele98], aaden modificaciones aleatorias en el es-
tado de los objetos (mediante reflectividad estructural), as como modificaciones
aleatorias de su semntica (reflectividad computacional), simulando distintos ti-
pos de errores en partes del sistema para analizar su comportamiento global.
Para los tres casos presentados, nuestro sistema puede emplearse como un entorno
de simulacin dinmica en el que pueden obtenerse empricamente los grados de tolerancia
a fallos de las aplicaciones, pudiendo incluso ofrecer informes de calidad de stas, sin nece-
sidad de incluir cdigo adicional en la funcionalidad de las aplicaciones.

15.5 Procesamiento de Lenguajes


El hecho de poder conocer y modificar el estado de un sistema computacional,
puede emplearse para facilitar la programacin en sus lenguajes de programacin; tanto
para la depuracin y mantenimiento de las aplicaciones, como para la generacin dinmica
de cdigo y optimizacin en funcin de la propia aplicacin.

15.5.1 Depuracin y Programacin Continua


A la hora de depurar una aplicacin, muchos compiladores aaden cdigo adicional
a su cdigo destino para que pueda ejecutarse por un depurador (debugger). Este proceso

244
mbitos de Aplicacin del Sistema

permite ejecutar la aplicacin paso a paso, conociendo los valores en memoria de las distin-
tas variables. Sin embargo, la introduccin de este cdigo intruso de depuracin hace que la
aplicacin pueda comportarse de distinto modo que aqulla no compilada en modo depu-
racin aplicaciones en tiempo real o multitarea pueden sufrir estas carencias.
La introspeccin es un mecanismo que es utilizado en entornos interpretados para
conocer en todo momento el estado computacional de una aplicacin, sin necesidad de
inyectar en sta cdigo intruso de depuracin. Dinmicamente, cualquier elemento de una
aplicacin puede analizarse y, mediante reflectividad estructural, modificarse su estructura,
estado o comportamiento. Si queremos evaluar dinmicamente cdigo, podemos crearlo,
aadrselo a un objeto y evaluarlo (descosificarlo) para comprobar los resultados de su
computacin; si no es correcto, corregir los errores y repetir el proceso.
La principal ventaja es que estos pasos se pueden llevar a cabo dinmicamente, sin
necesidad de separar dicotmicamente las fases de codificacin (desarrollo) y ejecucin
(pruebas), propias del desarrollo de aplicaciones. Se analiza el funcionamiento de la aplica-
cin, y se modifica y se examinan automticamente la reaccin a los cambios introducidos.
Esta modificacin de los objetos perdura en la aplicacin, no es necesario volver a un en-
torno de desarrollo para salvar cambios y recompilar.

15.5.2 Generacin de Cdigo


Cuando se desarrolla una aplicacin para compilar a distintas plataformas, el modo
en el que se genera y optimiza el cdigo destino es un factor crtico. Cada plataforma tiene
su propio cdigo nativo, y para cada tipo de entorno es necesario modificar el modo en el
que se genera el cdigo destino optimizacin en velocidad, en tamao o en utilizacin de
recursos, son ejemplos reales. La mayora de compiladores tiene un conjunto determinado
de opciones para optimizar el cdigo generado, pero carecen de un mecanismo genrico de
especializacin de ste.
Si se especifican y documentan todos los pasos de la generacin de cdigo de un
compilador, mediante la utilizacin de reflectividad computacional estos pasos podrn mo-
dificarse, y ser posible desarrollar un mecanismo de generacin de cdigo adaptable me-
diante un lenguaje, consiguiendo las siguientes funcionalidades:
1. Generacin de cdigo a cualquier plataforma.
2. Cualquier tipo de optimizacin que el usuario desee expresar mediante la
modificacin reflectiva de los pasos de invocacin al generador de cdigo.
3. Optimizacin en funcin de la aplicacin. La codificacin de la nueva semntica
del generador de cdigo puede utilizar introspeccin para analizar la estructura
de la aplicacin, llevando a cabo optimizaciones especficas para esa aplicacin:
optimizacin de cdigo personalizada a la aplicacin procesada.
Otra tcnica genrica de compilacin ampliamente utilizada en la ejecucin de apli-
caciones en entornos interpretados, es la compilacin bajo demanda. Existen distintas va-
riaciones para obtener mejores tiempos de ejecucin de las aplicaciones generadas sobre
plataformas virtuales:
Compilacin Dinmica (Dynamic Compilation): Se produce una compilacin bajo
demanda de una aplicacin. En lugar de compilar todos los mdulos de una
aplicacin, se compila el primero demandado en la ejecucin del programa y, en
funcin de las invocaciones de ste, se va demandando la generacin de cdigo
de otros mdulos [Chambers92]. El resultado obtenido es que la ejecucin de la

245
CAPTULO 15

aplicacin comienza rpidamente, siendo sta lenta en su evaluacin, y acele-


rndose conforme pasa el tiempo.
Compilacin Dinmica Adaptable (Adaptive Dynamic Compilation) [Hlzle94]: Es-
ta tcnica es una modificacin de la anterior. En tiempo de ejecucin se realizan
estudios probabilsticos de las fracciones de cdigo ms utilizadas (Hot Spot) y,
una vez detectadas, se optimiza su cdigo dinmicamente.
Compiladores Nativos Bajo Demanda (JIT, Just in Time Compilers): Esta es una
variacin de los primeros en la que la generacin de cdigo se produce a la pla-
taforma real especfica utilizada en la ejecucin de la aplicacin [Yellin96]. Esta
tcnica ha sido utilizada en las plataformas comerciales de Java [Sun98] y .NET
[Microsoft2000].
La reflectividad computacional es uno de los mecanismos ms elegantes para im-
plementar un compilador bajo demanda puesto que, sin necesidad de modificar la plata-
forma de interpretacin, es posible compilar a la plataforma nativa los fragmentos de cdi-
go que vayan siendo utilizados. La modificacin de la semntica de creacin de objetos,
carga de clases y paso de mensajes, son computaciones que son adaptadas a la generacin
de cdigo.
Si, utilizando reflectividad computacional, aadimos a la generacin dinmica de
cdigo la posibilidad de modificar el mdulo de generacin de cdigo, como mencionba-
mos al comienzo de este punto, obtendremos un compilador bajo demanda abierto (Open-
JIT) [Matsuoka98]: compilador nativo bajo demanda, configurable para la generacin de
cdigo especfica de plataformas, recursos y aplicaciones, sin restriccin alguna en su ex-
presividad.

15.6 Adaptacin de Lenguajes de Programacin


La reflectividad de lenguaje ofrecida por nuestro sistema computacional reflectivo,
permite adaptar cualquier lenguaje de programacin, ya sea al problema a resolver o a ca-
ractersticas especficas de ste demandadas por el programador.

15.6.1 Adaptacin al Problema


La capacidad de nuestro sistema de modificar las caractersticas de los lenguajes de
programacin seleccionados por el programador, hace que sea posible acercar el lenguaje al
problema, eligiendo el nivel de abstraccin adecuado para modelar un sistema de la forma
ms apropiada, y con una sintaxis y semntica fcilmente legibles.
Uno de los ejemplos tpicos existentes representativos de la carencia de representa-
tividad de lenguajes de programacin, es la solucin de problemas mediante patrones de
diseo. La utilizacin de un patrn de diseo se traduce a mltiples lneas de cdigo y cla-
ses que ocultan y dificultan el entendimiento de la solucin, abordada mediante la utiliza-
cin de un patrn. Esto suele dar lugar a un nmero de errores surgidos en el manteni-
miento de la aplicacin.
Sin perder la representatividad ni la sintaxis existentes del lenguaje de programacin
seleccionado, nuestro sistema permite amoldar ste a un determinado problema a resolver,
previamente a la codificacin de la aplicacin existente.
Un ejemplo de esta utilidad queda patente en la utilizacin de OpenJava [Chiba98]
un sistema con reflectividad de lenguaje en tiempo de compilacin para adaptar el len-

246
mbitos de Aplicacin del Sistema

guaje de programacin Java a la resolucin de problemas, mediante la utilizacin de los


patrones de diseo Adaptador (Adapter) y Visitante (Visitor) [Tatsubori98]. En nuestro sis-
tema, la aplicacin elegira su lenguaje y amoldara ste al problema a resolver vase el
apndice B.

15.6.2 Agregacin de Caractersticas al Lenguaje


Nuestro sistema puede ser empleado para aadir de un modo sencillo nuevas carac-
tersticas a lenguajes de programacin conocidos. Si un determinado programador requiere
facultades no ofrecidas por un lenguaje de programacin, puede adaptar su especificacin
para que las contemple, aumentando as la productividad en el desarrollo de aplicaciones.
En [Kirby98] y [Chiba98b] se desarrollaron sistemas que permiten aadir a Java la
posibilidad de desarrollar implementaciones genricas respecto al tipo, de modo similar a
las plantillas (templates) del lenguaje de programacin C++.

15.7 Sistemas Operativos Adaptables


Del mismo modo que los sistemas operativos basados en microncleo estudiados
en 5.6, la separacin del motor computacional (mquina abstracta) y los servicios a im-
plementar (entorno de programacin), permite adaptar los servicios del sistema operativo a
los requisitos propios de la plataforma seleccionada.
Un paso adicional ms cercano a nuestro sistema, es la implementacin del sistema
operativo Apertos [Yokote92b]: utiliza una mquina abstracta, y el concepto de reflectivi-
dad (un MOP) para conseguir flexibilidad, e identifica un metaobjeto por cada caracterstica
del operativo susceptible de ser adaptada.
Esta misma aproximacin ha sido llevada a cabo en el desarrollo del sistema inte-
gral orientado a objetos Oviedo3 [lvarez96]. Las distintas caractersticas pueden ser ofre-
cidas por un sistema operativo haciendo uso de reflectividad, siendo todas ellas adaptables
dinmicamente:
Planificacin de Hilos: La modificacin de la creacin y sincronizacin de hilos
mediante reflectividad computacional, permite adaptar los planificadores sin
ningn tipo de restriccin [Tajes2000].
Seguridad: Distintos mecanismos y polticas de seguridad pueden implantarse
mediante la adaptacin de la semntica de los lenguajes de programacin a dis-
tintos mecanismos de validacin de usuarios [Daz2000].
Distribucin: Modificando la creacin y eliminacin de objetos, as como el pa-
so de mensajes, se puede desarrollar un sistema de distribucin de objetos
transparente al usuario y adaptable respecto a los distintos parmetros existen-
tes en su intercomunicacin [lvarez2000].
Persistencia: Al igual que para los lenguajes de programacin ( 15.1), esta face-
ta se puede ofrecer por el sistema operativo de un modo flexible [Mart-
nez2001].
Heterogeneidad y Acceso al Medio: El sistema operativo puede ofertar tanto
caractersticas introspectivas, como acceso al medio conocimiento de la plata-
forma fsica existente. De este modo, las aplicaciones podrn desplegarse en en-

247
CAPTULO 15

tornos heterogneos, pudindose conocer en todo momento las caractersticas


de cada uno de ellos.
La consecucin de estos objetivos en el sistema operativo de Oviedo3 es restringida
por la utilizacin de un MOP. Sin embargo, la implantacin de estos servicios en nuestro
sistema se produce de un modo dinmico, no restrictivo (toda semntica puede ser modifi-
cada), con una expresividad elevada (un lenguaje el de la mquina abstracta es empleado
para describir el meta-comportamiento) e independiente del lenguaje. Todo ello se consigue
sin necesidad de modificar en ningn momento la implementacin de la mquina virtual
la codificacin se lleva a cabo en su propio lenguaje, sin dar lugar a distintas versiones del
intrprete.

15.8 Adaptacin y Configuracin de Sistemas


La reflectividad computacional es utilizada genricamente para modificar la semn-
tica de un conjunto de operaciones. Si tomamos como ejemplo un lenguaje de programa-
cin, permite modificar cada una de las primitivas computacionales existentes para dicho
lenguaje. Sin embargo, este proceso puede aplicarse de un modo genrico a cualquier tipo
de aplicacin o sistema computacional.

15.8.1 Gestin y Tratamiento del Conocimiento


Los motores de inferencia utilizados para la implementacin de sistemas de ingenie-
ra del conocimiento se basan en el concepto de regla. Pueden inferir o deducir el conoci-
miento a partir de unos hechos y unas reglas de inferencia. Sin embargo, la expresividad de
la lgica obtenida puede en muchos casos no ser suficiente.
Nuestra plataforma puede utilizarse como mecanismo de tratamiento del conoci-
miento y simulacin de la semntica del lenguaje natural. Mediante introspeccin se puede
analizar dinmicamente las distintas propiedades de un objeto o entidad; utilizando reflecti-
vidad estructural se puede modificar su estructura y comportamiento, as como crear nue-
vas entidades del conocimiento; mediante reflectividad computacional puede modificarse la
semntica de produccin o reduccin de reglas, teniendo en cuenta la utilizacin de una
lgica ms detallada y adaptable al contexto dinmico existente.
Como caso prctico, MetaPRL es un sistema de razonamiento que permite separar
la representacin del conocimiento, de la lgica empleada para inferir ste [Hickey2000]. La
codificacin de un mdulo en MetaPRL viene dado por la representacin de un conoci-
miento ms la especificacin de una lgica mediante la utilizacin de un metalenguaje.

15.8.2 Personalizacin de Aplicaciones


La mayora de los sistemas informticos que desean permitir su personalizacin a
cada uno de los usuarios, permiten modificar de algn modo su funcionalidad. As, es co-
mn que las barras de herramientas, mens o aceleradores de determinadas aplicaciones
sean configurables. Elementos adicionales de configuracin, pueden ser la utilizacin de un
lenguaje de macros o script para automatizar un determinado nmero de tareas mediante la
expresividad de un lenguaje de programacin.
En ocasiones, la personalizacin y configuracin de un sistema debe ser ms flexi-
ble y otorgar una mayor expresividad en la modificacin de su funcionalidad. Para este tipo

248
mbitos de Aplicacin del Sistema

de entornos, la reflectividad otorgada por nuestro sistema puede convertirse en un meca-


nismo enfocado a lograr dicho objetivo.
Un sistema especificar de un modo abierto la semntica de las operaciones suscep-
tibles de ser personalizadas. Mediante un lenguaje de programacin, el usuario podr adap-
tar stas haciendo uso de la reflectividad computacional. La introspeccin ofrecer un me-
canismo para conocer dinmicamente la estructura del sistema. Poniendo como ejemplo un
compilador, la derogacin de las funcionalidades del generador de cdigo puede significar
la traduccin a cualquier tipo de plataforma y la personalizacin en la optimizacin de c-
digo como explicbamos en Procesamiento de Lenguajes, 15.5.
Otro ejemplo es la simulacin de mquinas de estados mediante el tratamiento de la
informacin a travs de eventos y acciones de un grafo representativo del flujo de la infor-
macin [Sturman98]. Mediante un lenguaje se especifica el grafo y, haciendo uso de un
lenguaje de meta-comportamiento, se expresan los eventos y las acciones relativos a cada
arco del grafo en la simulacin.

249
CAPTULO 16:
EVALUACIN DEL SISTEMA

El sistema presentado en esta tesis ser evaluado en funcin de los requisitos esta-
blecidos con anterioridad, en el 2.1. Todos los sistemas presentados y estudiados en esta
memoria han sido evaluados en funcin de estos criterios. Para llevar a cabo la valoracin
de un modo comparativo, evaluaremos de forma paralela un grupo de sistemas reales, adi-
cionalmente al presentado.
Para evaluar el conjunto de sistemas, estableceremos una clasificacin de los requi-
sitos y estudiaremos stos tanto en funcin en esta categorizacin, como de un modo glo-
bal (absoluto). Una vez cuantificadas y representadas las distintas evaluaciones, analizare-
mos los beneficios aportados por nuestro sistema en comparacin con el resto de los
estudiados.

16.1 Comparativa de Sistemas


A la hora de comparar nuestro sistema con otros existentes, hemos seleccionado,
del conjunto global de sistemas estudiados en esta tesis, los ms prximos a satisfacer los
requisitos estipulados. De esta forma, nos centraremos en:
Smalltalk. Plataforma construida mediante el empleo de reflectividad estructural
que define un lenguaje de programacin orientada a objetos puro [Goldberg83].
Self. Refinamiento y simplificacin de la plataforma de Smalltalk, a la que se le
aadi, en el proyecto Merln [Assumpcao93], reflectividad computacional [Un-
gar87].
Java. Plataforma y lenguaje orientado a objetos con caractersticas introspectivas
y de modificacin del paso de mensajes [Kramer96].
MetaXa. Modificacin de la mquina abstracta de Java para aadir un protocolo
de metaobjetos en tiempo de ejecucin [Kleinder96] con este sistema, eva-
luamos las caractersticas de la mayora de los sistemas basados en MOPs, estu-
diados en 7.4.1.
nitrO. Este es el nombre con el que haremos referencia a nuestro sistema.

251
CAPTULO 16

16.2 Criterios de Evaluacin


La evaluacin de los distintos sistemas es bsicamente cualitativa. El objetivo prin-
cipal de esta tesis es la consecucin de una plataforma flexible. Distintos grados de flexibi-
lidad han sido presentados y estudiados; en este momento ser utilizados para evaluar los
sistemas.
El conjunto de criterios es el descrito en el captulo 2. Los clasificaremos y enume-
raremos de la siguiente forma:
I. Criterios de la plataforma de computacin.
A. Sistema computacional multiplataforma. Independiente del hardware y
del sistema operativo en el que se va a implantar.
B. Independencia del lenguaje de programacin. Su diseo no depende un
lenguaje preestablecido.
C. Independiente del problema. La plataforma ha de estar diseada como
una mquina computacional de propsito general.
D. Tamao y semntica computacional reducidos. La heterogeneidad en la
implantacin de la plataforma es ms sencilla cuanto ms reducidas sean
las plataformas.
E. Semntica operacional abierta. Existencia de un protocolo de ampliacin
de primitivas operacionales.
F. Introspeccin y acceso al entorno. La plataforma deber facilitar los pa-
rmetros propios del sistema fsico en el que haya sido implantada.
G. Semntica computacional abierta. Facilidad para modificar la semntica
de la propia plataforma.
H. Localizacin de las implementaciones nativas. La dependencia de la pla-
taforma ha de estar separada de su implementacin, y localizada en un
nico punto.
I. Nivel de abstraccin del modelo de computacin. La eleccin de su mo-
delo computacional requiere que ste sea sencillo, sin prdida de expresi-
vidad, y con una traduccin intuitiva desde la mayora de los lenguajes
existentes.
II. Criterios para la creacin de un entorno de programacin.
A. Extensibilidad. La plataforma podr extender su abstraccin en su pro-
pio lenguaje de programacin.
B. Adaptabilidad. Las abstracciones creadas en el sistema, debern poder
ser adaptadas dinmicamente a requisitos surgidos en tiempo de ejecucin.
C. Identificacin del entorno del entorno de programacin. Cualquier apli-
cacin deber poseer la facultad de conocer los mdulos software implan-
tados localmente.
D. Autodocumentacin real. Todo el software deber ser accesible dinmi-
camente para documentarse a s mismo.
III. Criterios del grado de flexibilidad.
A. Conocimiento dinmico del sistema. El sistema ha de ofrecer introspec-
cin en tiempo de ejecucin.

252
Evaluacin del Sistema

B. Modificacin estructural dinmica. Debern existir primitivas de reflecti-


vidad estructural en tiempo de ejecucin.
C. Modificacin dinmica del comportamiento: reflectividad computacional
en tiempo de ejecucin.
D. Modificacin computacional sin restricciones. Toda la semntica de los
lenguajes de programacin podr ser adaptada, sin restriccin alguna.
E. Modificacin y seleccin dinmica del lenguaje. Reflectividad del lengua-
je aspectos lxicos y sintcticos.
F. Interoperabilidad directa entre aplicaciones. Cualquier aplicacin podr
acceder a otra, independientemente del lenguaje de programacin en el
que haya sido codificada, y sin necesidad de un software intermedio.
IV. Criterios generales del conjunto del sistema.
A. Interaccin con sistemas externos. Cualquier aplicacin del sistema ope-
rativo hospedado, podr acceder al sistema computacional, utilizando un
mecanismo estndar.
B. nico sistema de programacin. Debe ofrecerse transparencia entre los
computadores que posean una mquina virtual, otorgando la ilusin de un
supercomputador formado por ordenadores interconectados.
C. Flexibilidad dinmica no restrictiva. El modo en el que se pueda modifi-
car el sistema deber expresarse sin restriccin alguna: un lenguaje propio,
en lugar de un conjunto limitado de operaciones.

16.3 Evaluacin
La evaluacin del sistema ser equiponderada respecto a los criterios descritos. La
consecucin plena de un objetivo ser ponderada con la unidad; su carencia, con un valor
nulo; los factores intermedios sern cuantificados en la mayora de los casos cualitativamen-
te para conocer una justificacin somera de la evaluacin, consltese 16.4.

Criterios de la Plataforma de Computacin

Criterio Smalltalk Self Java MetaXa nitrO


A.1 1 1 1 1 1
A.2 0 1 0 1
A.3 1 1 1 1 1
A.4 0,025 0,75 0,03 0,03 1
A.5 1 1 1 0 1
A.6 1 0 1 0 1
A.7 0 1 1 1
A.8 1 0 0 1
A.9 1 1

Total 5,525 6,75 6,03 3,53 9

253
CAPTULO 16

Representacin parcial de los criterios propios de la plataforma:

Criterios de Plataformas de
Computacin

9 9
8
7 6,75
6 6,03
5,525
5
4
3,53
3
2
1
0
Plataformas

Smalltalk Self Java MetaXa nitrO

Figura 16.1: Evaluacin de los criterios de la plataforma de computacin.

Criterios requeridos para el desarrollo del entorno de programacin

Criterio Smalltalk Self Java MetaXa nitrO


B.1 1 1 1 1
B.2 1 1 0 1 1
B.3 1 1 1 1 1
B.4 1 1 0 1

Total 4 4 2 3 4
Representacin parcial de los criterios necesarios para el desarrollo de un entorno
de programacin:

254
Evaluacin del Sistema

Criterios de Construccin del Entorno de


Programacin

4 4 4 4

3,5

3 3

2,5

2 2

1,5

0,5

0
Plataformas

Smalltalk Self Java MetaXa nitrO

Figura 16.2: Evaluacin de los criterios de construccin del entorno de programacin.

Criterios concernientes al grado de flexibilidad

Criterio Smalltalk Self Java MetaXa nitrO


C.1 1 1 1 1 1
C.2 1 1 0 1 1
C.3 0 1 1 1
C.4 0 0 0 0 1
C.5 0 0 0 0 1
C.6 1 1 0 0 1

Total 3 4 1,5 3 6
Representacin parcial de los criterios que cuantifican el grado de flexibilidad del
sistema:

255
CAPTULO 16

Criterios de Flexibilidad

6 6

4 4

3 3 3

2
1,5
1

0
Plataformas

Smalltalk Self Java MetaXa nitrO

Figura 16.3: Evaluacin de los criterios de flexibilidad.

Criterios de la Plataforma de Computacin

Criterio Smalltalk Self Java MetaXa nitrO


D.1 0 0 0 1
D.2 0 0 1 0 1
D.3 0 0 0 0 1

Total 0 0 1,5 0 3
Representacin parcial de los criterios generales del sistema:

256
Evaluacin del Sistema

Criterios Generales al Sistema

3 3

2,5

1,5 1,5

0,5

0 0 0 0
Plataformas

Smalltalk Self Java MetaXa nitrO

Figura 16.4: Evaluacin de los criterios generales al sistema.

Evaluacin global de todos los criterios

Grupo de Smalltalk Self Java MetaXa nitrO


Criterios
A 5,525 6,75 6,03 3,53 9
B 4 4 2 3 4
C 3 4 1,5 3 6
D 0 0 1,5 0 3

Total 12,525 14,75 11,03 9,53 22


Representacin global de todos los requisitos del sistema, equiponderando todas las
mediciones:

257
CAPTULO 16

Evaluacin Absoluta de Criterios

22
20

15 14,75
12,525
11,03
10 9,53

0
Plataformas

Smalltalk Self Java MetaXa nitrO

Figura 16.5: Evaluacin de los criterios establecidos, de un modo absoluto.

16.4 Justificacin de las Evaluaciones


A continuacin describiremos, de forma somera, la evaluacin de los distintos crite-
rios seleccionados previamente para cada uno de los sistemas estudiados. Si se desea una
ampliacin de las justificaciones, puede consultarse el captulo 4 para la evaluacin de los
criterios A y D, el captulo 6 para las valoraciones de los puntos B y C, as como el captulo
9 para las justificaciones relativas al sistema nitrO.
I. Evaluacin de los criterios de la plataforma de computacin.
A. Todas las plataformas definidas son abstractas e independientes de su
implementacin y plataforma en la que se implanten.
B. Tanto la mquina de Smalltalk como la modificacin de la plataforma
de Java para MetaXa, poseen fuertes dependencias del lenguaje de pro-
gramacin para el que fueron creadas por ejemplo bloques (Smalltalk) o
eventos de meta-comportamiento (MetaXa).
Java posee un modelo computacional basado en clases, con excepciones,
miembros de clase y clases abstractas: un modelo computacional reutili-
zable pero diseado para un determinado lenguaje de programacin. Por
otro lado, Self ha sido catalogado por determinados autores como la pla-
taforma computacional base para representar cualquier lenguaje orienta-
do a objetos [Wolczko96, Chambers91].
C. Aunque alguna de las plataformas haya sido creada para dar soporte
computacional a un lenguaje de alto nivel, todos los lenguajes son de
propsito general, sin estar orientados a un determinado tipo de proble-
ma predefinido.

258
Evaluacin del Sistema

D. El nmero de primitivas computacionales es 240 para Smalltalk, 8 para


Self, 200 para Java y MetaXa y 6 para nitrO. Normalizando los valores
entre cero y uno, obtenemos la evaluacin mostrada en la tabla.
E. La plataforma de Smalltalk est definida sobre un conjunto de primiti-
vas operacionales que el usuario puede ampliar; Self implementa sus
primitivas operacionales mediante cdigo ensamblador de la plataforma
nativa; Java posee su interfaz de acceso nativo (JNI, Java Native Interfa-
ce) [Sun97c]; MetaXa carece de implementacin nativa; nitrO implemen-
ta estas operaciones con el protocolo de invocacin del objeto Extern.
F. El conocimiento de acceso al sistema puede desarrollarse fcilmente en
Smalltalk y nitrO con la adicin de una primitiva operacional en nitrO,
ubicndola en el objeto System. Java ofrece la implementacin de su
clase System, con las propiedades de la plataforma real. Tanto MetaXa
como Self carece de un mecanismo sencillo para obtener esta informa-
cin.
G. Self (mediante sus regions, reflectors, meta-spaces), MetaXa y nitrO (median-
te su MOPs) permiten modificar determinadas semnticas de su lenguaje
como, por ejemplo, el paso de mensajes. Java, en su versin 2, permite
modificar nicamente el paso de mensajes para cada clase [Sun99], pero
no en su mquina abstracta lo implementa en el lenguaje de alto nivel.
Smalltalk carece de esta posibilidad.
H. La plataforma Smalltalk ubica las operaciones nativas como implemen-
taciones externas, asociadas a un nmero de primitiva. Este mismo pro-
ceso mediante un identificador cadena de caracteres lo desarrolla
nuestra mquina en la invocacin desde el objeto Extern.
La implementacin de los mtodos nativos de Java se enlaza con la carga
de libreras de enlace dinmico, especificando el nombre de stas y sin
estar ubicadas todas en una misma posicin predeterminada.
El cdigo nativo de Self est desarrollado dentro de la implementacin
de la mquina en cdigo ensamblador. MetaXa no permite ampliar sus
primitivas.
I. Smalltalk, Java y MetaXa utilizan un modelo de objetos orientado a re-
presentar, en bajo nivel, las abstracciones de su lenguaje de programa-
cin asociado. Sin embargo, nitrO y Self siguen el modelo basado en
prototipos (captulo 8), capaz de representar las mismas abstracciones,
con la mxima sencillez computacional [Ungar91].
II. Evaluacin de los criterios para la creacin de un entorno de programacin.
A. Todas las plataformas, excepto Java, ofrecen introspeccin y reflectivi-
dad computacional para extender dinmicamente las abstracciones del
sistema. Java permite codificar, mediante introspeccin, de forma adap-
table a requisitos previstos en tiempo de diseo, pero, al no poseer re-
flectividad estructural, no permite extenderse de un modo genrico sin
finalizar su ejecucin.
B. Para poder adaptarse dinmicamente es necesario que la plataforma
permita modificar la estructura reflectividad estructural y aadir com-
portamiento cosificacin en tiempo de ejecucin. A excepcin de Ja-

259
CAPTULO 16

va, que carece de la segunda caracterstica, el resto cumplen los requisi-


tos.
C. Todas las plataformas poseen la introspeccin necesaria conocer los
mdulos software implantados localmente.
D. El tratamiento de la computacin como datos y la reflectividad estruc-
tural, hacen que Smalltalk, Self y nitrO sean plataformas autodocumen-
tadas dinmicamente.
Java, mediante su introspeccin y tratamiento de cdigo fuente, ofrece la
herramienta javadoc que, simulando el objetivo buscado, se limita a
documentar a travs del cdigo compilado no dinmicamente. MetaXa
carece de esta posibilidad.
III. Evaluacin de los criterios del grado de flexibilidad.
A. Todos los sistemas ofrecen introspeccin en tiempo de ejecucin.
B. Todos, excepto Java, permiten modificar dinmicamente las estructuras
de sus objetos.
C. Java ofrece un mecanismo limitado de modifica