PDF de programación - ESTADO DEL ARTE EN LA PROGRAMACIÓN ORIENTADA A ASPECTOS

Departamento de Lenguajes y Sistemas Informáticos

Facultad de Informática y Estadística

Universidad de Sevilla



Avenida de la Reina Mercedes S/n. 41012 SEVILLA

Fax/Tlf: 954557139

Visión General de la Programación

Orientada a Aspectos



Antonia Mª Reina Quintero

Departamento de Lenguajes y Sistemas Informáticos
Universidad de Sevilla



Diciembre, 2000



Visión General de la Programación Orientada a Aspectos



Índice

1. Objetivos del documento...................................................................................................3
2.
Introducción.......................................................................................................................4
3. Un poco de historia............................................................................................................9
4.
¿Qué es un aspecto?.........................................................................................................10
5. Fundamentos de la programación orientada a aspectos...................................................13
6. Tejiendo clases y aspectos...............................................................................................15
7. Estado del Arte en el Diseño de Lenguajes de Aspectos.................................................18
Lenguajes de Aspectos de Propósito General vs. Dominio Específico. ..............................18
Un lenguaje de dominio específico: COOL.........................................................................19
Un lenguaje de propósito general: AspectJ .........................................................................21
Un ejemplo: La gestión de una cola circular ......................................................................24
Una cola circular usando COOL..........................................................................................25
Una cola circular usando AspectJ........................................................................................29
El problema de los lenguajes base.......................................................................................31
8. Los aspectos en el diseño.................................................................................................33
9. Disciplinas relacionadas con POA...................................................................................38
Reflexión y protocolos de metaobjetos................................................................................38
Transformación de programas .............................................................................................38
Programación subjetiva .......................................................................................................38
Conclusiones................................................................................................................39
Listado de Figuras .......................................................................................................40
Referencias ..................................................................................................................41

10.
11.
12.



2

Visión General de la Programación Orientada a Aspectos



1. Objetivos del documento



La ingeniería del software, y en general, la informática es una disciplina que está
en constante evolución. Cada día surgen nuevas técnicas y metodologías que intentan
mejorar la calidad y la eficiencia de los productos software.


En los últimos tiempos ha surgido con fuerza una nueva forma de descomponer
los sistemas: la orientación a aspectos. Este informe trata dar una visión general de la
programación orientada a aspectos, desde sus comienzos, hasta llegar su estado actual.
Se sentarán las bases sobre las que se apoya está tecnología, y se definirán los conceptos
que maneja, sirviendo de presentación a los investigadores que quieran introducirse en
este campo.



3

Visión General de la Programación Orientada a Aspectos


2. Introducción


Si se echa un vistazo a la historia de la ingeniería del software, prestando
particular atención a cómo ha evolucionado, se puede observar que los progresos más
significativos se han obtenido gracias a la aplicación de uno de los principios
fundamentales a la hora de resolver cualquier problema, incluso de la vida cotidiana, la
descomposición de un sistema complejo en partes que sean más fáciles de manejar, es
decir, gracias a la aplicación del dicho popular conocido como ’divide y vencerás’.


En los primeros estadios de desarrollo de los lenguajes de programación se tenía
un código en el que no había separación de conceptos, datos y funcionalidad se
mezclaban sin una línea divisoria clara. A esta etapa se la conoce como la del código
spaghetti, ya que se tenía una maraña entre datos y funcionalidad que recuerda a la que
se forma cuando comemos un plato de esta pasta italiana.


En la siguiente etapa se pasó a aplicar la llamada descomposición funcional, que
pone en práctica el principio de ‘divide y vencerás’ identificando las partes más
manejables como funciones que se definen en el dominio del problema. La principal
ventaja que proporciona esta descomposición es la facilidad de integración de nuevas
funciones, aunque también tiene grandes inconvenientes, como son el hecho de que las
funciones quedan algunas veces poco claras debido a la utilización de datos
compartidos, y el que los datos quedan esparcidos por todo el código, con lo cual,
normalmente el integrar un nuevo tipo de datos implica que se tengan que modificar
varias funciones.


Intentando solventar estas desventajas con respecto a los datos, se dio otro paso
en el desarrollo de los sistemas software. La programación orientada a objetos (POO)
ha supuesto uno de los avances más importantes de los últimos años en la ingeniería del
software para construir sistemas complejos utilizando el principio de descomposición,
ya que el modelo de objetos subyacente se ajusta mejor a los problemas del dominio
real que la descomposición funcional. La ventaja que tiene es que es fácil la integración
de nuevos datos, aunque también quedan las funciones esparcidas por todo el código, y
tiene los inconvenientes de que, con frecuencia, para realizar la integración de nuevas
funciones hay que modificar varios objetos, y de que se produce un enmarañamiento de
los objetos en funciones de alto nivel que involucran a varias clases.


En la Figura 1 se representa mediante un esquema los distintos estadios en la
evolución de los sistemas software. En este esquema se refleja de forma clara la mezcla
de conceptos que se produce en cada una de las etapas de la evolución (etapas
comúnmente conocidas como “generaciones”). Si cada una de las distintas formas que
aparecen dibujadas (triángulo, cuadrado, trapecio, elipse) representa a un tipo de datos
distinto, y cada color o tonalidad representa a una función distinta, se tiene que en la
primera generación de los sistemas software funciones y datos se entremezclaban.



4

Visión General de la Programación Orientada a Aspectos



1ª Generación:
Código espaghetti

2ª y 3ª Generación:
Descomposición
funcional

Sofware = Datos (formas)
+ Funciones (colores)

4ª Generación:
Descomposición en
objetos

Figura 1 Esquema de la evolución de la ingeniería del software



En la segunda y tercera generación se tienen conjuntos de elementos agrupados
por tonalidades, y en cada conjunto conviven distintas formas, lo que nos indica que la
descomposición del sistema se hace en base a las funciones (tonalidades), y que los
datos quedan esparcidos por todos los conjuntos.


En la cuarta generación, sin embargo, esta agrupación se realiza en base a las
formas (datos), pero como se puede observar, en cada conjunto tenemos representadas
distintas funcionalidades (tonalidades), con lo cual éstas también se nos dispersan por
todo el sistema.


Uno de los principales inconvenientes con el que nos encontramos al aplicar
estas descomposiciones ya tradicionales es que muchas veces se tienen ejecuciones
ineficientes debido a que las unidades de descomposición no siempre van acompañadas
de un buen tratamiento de aspectos tales como la gestión de memoria, la coordinación,
la distribución, las restricciones de tiempo real, ...


En el desarrollo de un sistema software además del diseño y la implementación
de la funcionalidad básica, se recogen otros aspectos tales como la sincronización, la
distribución, el manejo de errores, la optimización de la memoria, la gestión de



5

Visión General de la Programación Orientada a Aspectos

seguridad, etc. Mientras que las descomposiciones funcional y orientada a objetos no
nos plantean ningún problema con respecto al diseño y la implementación de la
funcionalidad básica, estas técnicas no se comportan bien con los otros aspectos. Es
decir, que nos encontramos con problemas de programación en los cuales ni las técnicas
funcionales, ni las orientadas a objeto son suficientes para capturar todas las decisiones
de diseño que el programa debe implementar.


Con las descomposiciones tradicionales no se aislan bien estos otros aspectos,
sino que quedan diseminados por todo el sistema enmarañando el código que
implementa la funcionalidad básica, y yendo en contra de la claridad del mismo. Se
puede afirmar entonces que las técnicas tradicionales no soportan bien la separación de
competencias para aspectos distintos de la funcionalidad básica de un sistema, y que
esta situación claramente tiene