PDF de programación - Programación Orientada a Aspectos

Programación
Orientada a Aspectos



Ing. José Joskowicz

José Joskowicz

Página 1

10/02/2008

El presente trabajo ha sido realizado en el marco de la asignatura “Nuevas Técnicas de Desarrollo
de Software en Ingeniería Telemática”, del Doctorado de Ingeniería Telemática de la Universidad
de Vigo, España.



“Se trata de permitir que los programadores escriban programas que,
en todo lo que sea posible, se parezcan a su diseño”

Adaptado de la página de Gregor Kiczales [1]



Indice


Indice....................................................................................................................... 2
Abstract ................................................................................................................... 3
1.
Introducción...................................................................................................... 3
2. Breve reseña histórica...................................................................................... 4
3. Definición de Aspecto....................................................................................... 4
4.
Implementación de Aspectos ........................................................................... 6
5. Diseño y desarrollo de aplicaciones Orientadas a Aspectos............................ 7
6. Lenguajes orientados a Aspectos .................................................................... 8
6.1. COOL...................................................................................................... 10
6.2. RIDL........................................................................................................ 10
6.3. MALAJ .................................................................................................... 10
6.4. AspectC .................................................................................................. 11
6.5. AspectC++ .............................................................................................. 11
6.6. AspectJ ................................................................................................... 11
7. Ejemplos de aplicación................................................................................... 12
7.1. Código “enredado”: Filtros de imágenes ................................................. 12
7.2. Aspectos de concurrencia: Manejo de colas circulares........................... 13
7.3. Aspectos de “logging”: Protocolo TFTP .................................................. 13
7.4. Aspectos de “timing”: Un sistema de telecomunicaciones ...................... 14
8. Conclusiones.................................................................................................. 14
9. Referencias .................................................................................................... 16



José Joskowicz

Página 2

10/02/2008

Abstract

La “Programación Orientada a Aspectos” es una propuesta reciente que brinda un
mayor grado de abstracción en el desarrollo de software, permitiendo realizar de
manera clara y eficiente una clara “separación de incumbencias”.

El presente trabajo resume los conceptos principales de la Programación
Orientada a Aspectos. Se incluye una introducción al tema, una breve reseña
histórica, las definiciones formales necesarias, la descripción de algunos lenguajes
orientados a aspectos y las características destacables de la implementación y el
diseño de las aplicaciones orientadas a aspectos.


también

1. Introducción

Generalmente, el desarrollo de una aplicación involucra varias tareas que se
deben realizar. Hay tareas que pueden considerarse “principales”, y que son
típicamente detalladas por los usuarios como parte del análisis funcional de
requerimientos. Pero, adicionalmente, existen
tareas que pueden
considerarse “servicios comunes”, generalmente no detalladas en el análisis
funcional. Ejemplos de estos “servicios comunes” pueden ser la necesidad de
generar registros de auditoria (logging), accesos a bases de datos, temas
relacionados con las seguridad, temas relacionados con la concurrencia del
acceso a cierta información, etc. Es habitual que esta clase de “servicios
comunes” deba ser realizada en forma similar pero independiente en diversas
partes del código.

Cada una de estas tareas es considerada una “incumbencia” (“concern”, en
inglés), en el entendido que al código que la implementa le debería “incumbir”
solamente esa tarea. La “separación de incumbencias” es, por lo tanto, deseable
en cualquier desarrollo de software.
Sin embargo, en los lenguajes de programación típicos (ya sea procedurales u
orientados a objetos), es difícil, o imposible, separar claramente las incumbencias
de los “servicios comunes” de las incumbencias “principales”, teniendo como
consecuencia, por lo tanto, que las tareas de los “servicios comunes” queden
dispersas dentro del código de las incumbencias principales. Esto es conocido
como “incumbencias transversales” (“crosscutting concerns”, en inglés).

Como se mencionó anteriormente, las incumbencias son los diferentes temas,
asuntos o aspectos de los que es necesario ocuparse para resolver un problema
determinado. Separando las incumbencias, se disminuye la complejidad a la hora
de tratarlas, y se gana en claridad, adaptabilidad, mantenibilidad, extensibilidad y
reusabilidad.


José Joskowicz

Página 3

10/02/2008

Los conceptos y tecnologías conocidas con el nombre de “Programación
Orientada a Aspectos" (POA) buscan resolver el problema de la “separación de
incumbencias”, de una manera sistemática, clara y eficiente.

POA es conocida también como AOP, por las siglas en ingles “Aspect-Oriented
Programming” o AOSD, por Aspect-Oriented Software Development



2. Breve reseña histórica

El término “separación de incumbencias” fue introducido en la década de 1970,
por Edsger W. Dijkstra [2]. Significa, simplemente, que la resolución de un
problema dado involucra varios aspectos o incumbencias, los que deben ser
identificadas y analizados en forma independiente.

La “Programación Adaptativa” fue el concepto predecesor de la “Programación
Orientada a Aspectos”. Las ideas originales de la “Programación Adaptativa”
fueron introducidas a principio de la década de 1990 por el grupo Demeter [3],
siendo Karl Lieberherr uno de sus ideólogos.

Los conceptos de POA fueron introducidos en 1997 por Gregor Kiezales y su
grupo [4].

Actualmente, si bien hay ya varias implementaciones de lenguajes orientados a
aspectos (como se verá más adelante en éste articulo), el nuevo paradigma aún
continua en desarrollo, y todavía está abierta la investigación hacia varias áreas
que recién están siendo exploradas, como por ejemplo llevar los “aspectos” a las
etapas de diseño.


3. Definición de Aspecto

La definición formal de “Aspecto” ha evolucionado desde su concepción hasta el
momento. Una definición inicial, aunque todavía no se manejaba el término
“aspecto”, fue introducida por Karl Lieberherr en [3]. Adaptando la definición al
término actual:


“Un aspecto es una unidad que se define en términos de información parcial
de otras unidades”


Gregor Kiezales y su grupo brindan una primera definición de “aspecto” en [4]:


“Una propiedad que debe ser implementada es


José Joskowicz

Página 4

10/02/2008

un componente, si puede ser claramente encapsulada dentro de un
procedimiento generalizado (por ejemplo, un objeto, un método, un
procedimiento, una API). Se entiende que un elemento es claramente
encapsulado si está bien localizado, es fácilmente accesible y resulta
sencillo componerlo...

un aspecto, si no puede ser claramente encapsulado en un procedimiento
generalizado. Los aspectos tienden a no ser unidades de la descomposición
funcional del sistema, sino a ser propiedades que afectan la performance o
la semántica de los componentes en forma sistemática...”


La definición actual de aspecto, de Gregor Kiezales de mayo de 1999 es la
siguiente:


“Un aspecto es una unidad modular que se disemina (“cross-cuts”) por la
estructura de otras unidades funcionales.

Los aspectos existen tanto en la etapa de diseño como en la de
implementación. Un aspecto de diseño es una unidad modular del diseño
que se entremezcla en la estructura de otras partes del diseño. Un aspecto
de implementación es una unidad modular del programa que aparece en
otras unidades modulares del programa”.


Se desprende de esta definición, que los aspectos de una aplicación son aquellos
módulos que generan “incumbencias transversales”, es decir, los módulos que
están diseminados por el resto de las unidades funcionales.

Identificando los aspectos, y aplicando las técnicas desarrolladas en la POA es
posible, por lo tanto, realizar adecuadamente la “separación de incumbencias”.

Es de resaltar que la definición de aspecto no hace referencia al tipo de
programación en la que se implemente (orientada a objetos o procedural), por lo
que el concepto, como tal, aplica a ambos.

En una primera instancia puede ser fácil asociar a aspectos los “servicios
comunes”, tal como se detalló en la introducción, incluyendo aspectos de auditoria
(logging), aspectos de seguridad, aspectos de concurrencia, etc. Sin embargo, el
concepto es mucho más genérico. Las herramientas que soportan POA manejan
tanto las