Thesis (M.S. in computer science)--Washington State University, August 2006. / Includes bibliographical references (p. 111-115).

Made available in DSpace on 2014-06-12T15:57:56Z (GMT). No. of bitstreams: 2 arquivo3237_1.pdf: 1530844 bytes, checksum: dcdb6221a7c974cbfc9e96c7629001ef (MD5) license.txt: 1748 bytes, checksum: 8a4605be74aa9ea9d79846c1fba20a33 (MD5) Previous issue date: 2010 / Conselho Nacional de Desenvolvimento Científico e Tecnológico / Atualmente, arquitetura baseada em componentes é a abordagem mais utilizada no desenvolvimento de softwares complexos; esta tem como principal objetivo a atribuição dos requisitos da aplicação aos componentes. Uma das técnicas mais difundidas para especificação de requisitos é a utilização de Casos de Uso. Em geral, arquiteturas de software baseadas em componentes resultam em implementações onde o código relativo a um caso de uso está espalhado e entrelaçado em diversos componentes do sistema, caracterizando um crosscutting concern. Isto ocorre porque técnicas tradicionais, como Orientação a Objetos (OO), não oferecem mecanismos que sejam capazes de modularizar este tipo de concern. Recentemente, novas técnicas de modularização como aspectos, mixins e classes virtuais, foram propostas para tentar resolver este problema. Estas técnicas podem ser usadas para agrupar o código relacionado a um único caso de uso em uma nova unidade de modularização. Este trabalho analisa qualitativa e quantitativamente o impacto causado por este tipo de modularização de casos de uso. Nós exploramos duas técnicas baseadas em Orientação a Aspectos (OA): (i) Casos de Uso como Aspectos - onde utilizamos os construtores de AspectJ para isolar todo código relativo à implementação de um caso de uso em um aspecto; e (ii) Casos de Uso como Colaborações Plugáveis - onde usamos os construtores de CaesarJ para modularizar implementações de casos de uso através de uma composição hierárquica de colaborações. Nós executamos dois estudos de casos onde comparamos as implementações OA de casos de uso com sua implementação OO. No processo de avaliação extraímos métricas tradicionais e contemporâneas incluindo coesão, acoplamento e separação de concerns e analisamos modularidade em termos de atributos de qualidade de software como: plugabilidade, rastreabilidade e suporte para desenvolvimento em paralelo. Nossos resultados indicam que modularidade é um conceito relativo e sua análise depende de outros fatores além do sistema alvo, das métricas e da técnica aplicada

Systems created within the aspect-oriented paradigm (AOP) are difficult for programmers to understand fully. AOP suggests moving crosscutting concerns scattered throughout class code into an individual module, known as an aspect. The process of aspect weaving injects the crosscutting concern back into class code at specific locations, known as joinpoints. A side effect of the weaving process is aspect interference-when aspect code creates unexpected results at a joinpoint. Therefore, developing an understanding of locations that could either cause or exhibit aspect interference problems is essential to developing an interference-free AOP system. This study used the interference potential (IP) and interference causality potential (ICP) metrics, and derived a new metric called total interference potential (TIP), to classify areas of potential interference problems. In addition, the project performs a hierarchical agglomerative clustering using the three metrics. Experiments conducted on two AOP systems identified clusters within each program that could cause or exhibit aspect interference problems. Results showed the merit of using clustering analysis as a technique to locate portions of a system to review or alter to prevent interference problems.

在醫療系統中，存取控管是電子病歷安全防護的核心。針對這樣的議題，我們實驗室已經有設計出一種安全的架構，利用最新的程式開發技術，剖面導向程式設計為基礎，設計出一種宣告式電子病歷安全控管的方法。這樣的設計讓安全管理者可以有系統化的控制整個系統的安全存取。但是這樣的架構下，安全規則的變動必須經過好幾道複雜的手續，造成使用上彈性不足。 本研究針對這樣的架構提出幾種改進的方式，使安全規則更動更具有彈性。主要分為兩方面，第一，針對安全規則的變數，設計可以彈性更動的方式，不需要為了更動變數而重複整個安全控管規則產生流程。第二，利用動態載入的功能，提出可以由外部Java程式寫好安全控管規則，在執行時候將該規則載入來判斷，如此對於複雜的安全控管規則也有修改的彈性。希望藉由這樣彈性的設計使我們設計的安全控管架構更能符合實際使用的需求。 / Maintaining proper access control to Electronic Medical Records (EMR) is essential to protecting patients’ privacy. However, the fine-grained and dynamic nature of access control rules for EMR has imposed great challenges on the healthcare information system developers. This thesis presents a dynamically configurable access control mechanism for Web-based EMR systems.It is an enhancement of a previous work in which static aspects are employed to enforce fine-grained access control for EMR. Specifically, we provide two additional kinds of dynamic adjustment mechanism to enhance the static access control aspects, namely dynamic parameters and dynamic constraints. If the scope of dynamic changes is small, dynamic parameters can realize the required changes. Otherwise, dynamic constraints can be used to support replacement of the access control enforcing code while allowing the EMR application running as usual. Consequently, system administrators have a fine range of choices with different trade-offs between flexibility and performance, namely fully static aspects, parameterized aspects using dynamic parameters and fully dynamic aspects using dynamic constraints. We have built a Web-based EMR prototype implementation using AspectJ to demonstrate our approach.

Aspect-oriented programming (AOP) aims to enhance modularity and reusability in software systems by offering an abstraction mechanism to deal with crosscutting concerns. But, in most general-purpose aspect languages aspects have almost unrestricted power, eventually conflicting with these goals. This work presents Effective Aspects: a novel approach to embed the pointcut/advice model of AOP in a statically-typed functional programming language like Haskell; along two main contributions. First, we define a monadic embedding of the full pointcut/advicemodel of AOP. Type soundness is guaranteed by exploiting the underlying type system, in particular phantom types and a new anti-unification type class. In this model aspects are first-class, can be deployed dynamically, and the pointcut language is extensible, therefore combining the flexibility of dynamically-typed aspect languages with the guarantees of a static type system. Monads enable us to directly reason about computational effects both in aspects and base programs using traditional monadic techniques. Using this we extend the notion of Open Modules with effects, and also with protected pointcut interfaces to external advising. These restrictions are enforced statically using the type system. Also, we adapt the techniques of EffectiveAdvice to reason about and enforce control flow properties as well as to control effect interference. We show that the parametricity-based approach to effect interference falls short in the presence of multiple aspects and propose a different approach using monad views, a novel technique for handling the monad stack, developed by Schrijvers and Oliveira. Then, we exploit the properties of our model to enable the modular construction of new semantics for aspect scoping and weaving. Our second contribution builds upon a powerful model to reason about mixin-based composition of effectful components and their interference, based on equational reasoning, parametricity, and algebraic laws about monadic effects. Our contribution is to show how to reason about interference in the presence of unrestricted quantification through pointcuts. We show that global reasoning can be compositional, which is key for the scalability of the approach in the face of large and evolving systems. We prove a general equivalence theorem that is based on a few conditions that can be established, reused, and adapted separately as the system evolves. The theorem is defined for an abstract monadic AOP model; we illustrate its use with a simple version of the model just described. This work brings type-based reasoning about effects for the first time in the pointcut/advice model, in a framework that is expressive, extensible and well-suited for development of robust aspect-oriented systems as well as a research tool for new aspect semantics.

Legacy systems contain critical and complex business code that has been in use for a long time. This code is difficult to understand, maintain, and evolve, in large part due to crosscutting concerns: software system features, such as persistence, logging, and error handling, whose implementation is spread across multiple modules. Aspect-oriented techniques separate crosscutting concerns from the base code, using separate modules called aspects and, thus, simplifying the legacy code. Aspect mining techniques identify aspect candidates so that the legacy code can be refactored into aspects. This study investigated an automated aspect mining method in which a vector-space model clustering approach was used with model-based clustering. The vector-space model clustering approach has been researched for aspect mining using a number of different heuristic clustering methods and producing mixed results. Prior to this study, this model had not been researched with model-based algorithms, even though they have grown in popularity because they lend themselves to statistical analysis and show results that are as good as or better than heuristic clustering methods. This study investigated the effectiveness of model-based clustering for identifying aspects when compared against heuristic methods, such as k-means clustering and agglomerative hierarchical clustering, using six different vector-space models. The study's results indicated that model-based clustering can, in fact, be more effective than heuristic methods and showed good promise for aspect mining. In general, model-based algorithms performed better in not spreading the methods of the concerns across the multiple clusters but did not perform as well in not mixing multiple concerns in the same cluster. Model-based algorithms were also significantly better at partitioning the data such that, given an ordered list of clusters, fewer clusters and methods would need to be analyzed to find all the concerns. In addition, model-based algorithms automatically determined the optimal number of clusters, which was a great advantage over heuristic-based algorithms. Lastly, the study found that the new vector-space models performed better, relative to aspect mining, than previously defined vector-space models.

Aspect-Oriented Software Development (AOSD) is a new approach that addresses limitations inherent in conventional programming, especially the principle of separation of concerns by emphasizing the encapsulation and modularization of crosscutting concerns through a new abstraction, the "aspect." Aspect-oriented programming is an emerging AOSD programming paradigm that focuses on the modularization of concerns as appropriate for the host language and providing a mechanism for describing concerns that crosscut each other by congealing into a single textual structure behavior that conventional programming would otherwise distribute throughout the code. AspectJ is the most widely used aspect-oriented programming language to date and provides an extension of the Java language that includes several new concepts and constructs that differ from those in procedural and object-oriented programs. These include join points, pointcuts, advice, inter-type declarations, introduction and aspects. In AspectJ, as well as other aspect-oriented programming languages, "aspects" package pointcuts and advice into functional units in much the same way that object-oriented programming uses classes to package fields and methods into cohesive units but they offer a unique set of problems. Software inspections are considered a software engineering "best practice" for ensuring quality, but the introduction of new aspect-oriented programming language mechanisms drives the need for them to be tailored in a similar manner to how they were tailored to support object-oriented programs and the procedural programs. The identification of faults unique to aspect-oriented programming allowed for the design of an aspect fault model and the associated software inspection checklists criteria that provide a description of the typical faults associated with aspects and the clues that aid in betraying their presence. The proposed methodology for this research entailed a mixed methods approach based on a combination of descriptive and exploratory research methodologies using a normative case study. The proposed methodology resulted in the development of an understanding of the AspectJ primitive pointcut construct, identification of the typical faults associated with this construct and the subsequent development of a fault model, a set of programming rules and tailored software inspection checklist. A case study was conducted comparing defects detected by an inspection checklist tailored for AspectJ with one that was not tailored. The results of the case study demonstrated using software inspection checklists not tailored would result in many faults unique to aspect-oriented programming going undetected.

Doctor en Ciencias, Mención Computación / It is inevitable that some concerns crosscut a sizable application, resulting in code scattering and tangling. This issue is particularly severe for security-related concerns: it is difficult to be confident about the security of an application when the implementation of its security related concerns is scattered all over the code and tangled with other concerns, making global reasoning about security precarious. In this thesis work, we consider the case of access control, a cornerstone of every security architecture, which turns out to be a crosscutting concern with a non-modular implementation based on runtime stack inspection in mainstream languages such as Java and C#. We make use of aspect orientation for the modular definition of access control. More precisely, we design and implement access control, including the advanced features associated to it, in a modular way. We demonstrate that this modular implementation is secure, even in the presence of untrusted aspects. A modular implementation alleviates maintenance and evolution issues produced by the crosscutting nature of access control, and, more importantly, paves the way to global reasoning about access control.

La programmation orientée aspect (AOP) vise à améliorer la modularité et la réutilisation des couches logiciels en proposant un mécanisme d’abstraction pour faire face aux préoccupations transversales. Cependant, dans la plupart des langages d’aspects généralistes, les aspects ont un pouvoir presque illimité, rentrant éventuellement en conflit avec ces objectifs. Dans ce travail, nous présentons Effective Aspects : une nouvelle approche pour incorporer le modèle pointcut/advice de l’AOP dans un langage de programmation fonctionnel statiquement typé comme Haskell. Notre travail comprend deux contributions principales. Premièrement, nous définissons un plongement monadique du modèle pointcut/advice complet de l’AOP. La correction du typage est garantie par l’exploitation du système de type sous-jacent, en particulier les types fantômes et une nouvelle classe de type pour faire de l’anti-unification de types. Dans ce modèle, les aspects sont de première classe, peuvent être déployés de façon dynamique, et le langage de pointcuts est extensible, combinant donc la flexibilité des langages d’aspect typés dynamiquement avec les garanties d’un système de type statique. Les monades nous permettent de raisonner directement sur les effets du calcul à la fois dans les aspects et les programmes de base en utilisant des techniques monadiques traditionnelle. Avec ce système, nous étendons la notion de “open modules” avec des effets, et aussi avec les interfaces de pointcut protégés à l’extérieur d’un advice. Ces restrictions sont appliquées statiquement par le système de type. Aussi, nous adaptons les techniques de EffectiveAdvice afin de raisonner sur des propriétés du flot de contrôle. En outre, nous montrons comment contrôler l’interférence des effets en utilisant l’approche fondée sur la paramétricité de EffectiveAdvice. Nous montrons que cette approche n’est pas satisfaisante en présence de multiples aspects et proposons une approche différente en utilisant des vues monadiques, une nouvelle technique pour le traitement de la pile monadique, développée par Schrijvers et Oliveira. Ensuite, nous exploitons les propriétés de notre modèle pour permettre la construction modulaire de nouvelles sémantiques pour la portée d’aspects et le tissage. Notre deuxième contribution s’appuie sur un modèle puissant pour raisonner sur la composition de mixins avec effets et leur interférence, fondée sur un raisonnement équationnelle, paramétrique, et les lois algébriques sur les effets monadiques. Notre contribution est de montrer comment raisonner sur l’interférence en présence de quantification sans restriction pour les pointcuts. Nous montrons que le raisonnement global peut être compositionnelle, ce qui est essentiel pour le passage à l’échelle de l’approche face aux évolutions de grands systèmes. / Aspect-oriented programming (AOP) aims to enhance modularity and reusability in software systems by offering an abstraction mechanism to deal with crosscutting concerns. But, in most general-purpose aspect languages aspects have almost unrestricted power, eventually conflicting with these goals. This work presents Effective Aspects: a novel approach to embed the pointcut/advice model of AOP in a statically-typed functional programming language like Haskell; along two main contributions. First, we define a monadic embedding of the full pointcut/advicemodel of AOP. Type soundness is guaranteed by exploiting the underlying type system, in particular phantom types and a new anti-unification type class. In this model aspects are first-class, can be deployed dynamically, and the pointcut language is extensible, therefore combining the flexibility of dynamically-typed aspect languages with the guarantees of a static type system. Monads enable us to directly reason about computational effects both in aspects and base programs using traditional monadic techniques. Using this we extend the notion of Open Modules with effects, and also with protected pointcut interfaces to external advising. These restrictions are enforced statically using the type system. Also, we adapt the techniques of EffectiveAdvice to reason about and enforce control flow properties as well as to control effect interference. We show that the parametricity-based approach to effect interference falls short in the presence of multiple aspects and propose a different approach using monad views, a novel technique for handling the monad stack, developed by Schrijvers and Oliveira. Then, we exploit the properties of our model to enable the modular construction of new semantics for aspect scoping and weaving. Our second contribution builds upon a powerful model to reason about mixin-based composition of effectful components and their interference, based on equational reasoning, parametricity, and algebraic laws about monadic effects. Our contribution is to show how to reason about interference in the presence of unrestricted quantification through pointcuts. We show that global reasoning can be compositional, which is key for the scalability of the approach in the face of large and evolving systems. We prove a general equivalence theorem that is based on a few conditions that can be established, reused, and adapted separately as the system evolves. The theorem is defined for an abstract monadic AOP model; we illustrate its use with a simple version of the model just described. This work brings type-based reasoning about effects for the first time in the pointcut/advice model, in a framework that is expressive, extensible and well-suited for development of robust aspect-oriented systems as well as a research tool for new aspect semantics.

A programação orientada a aspectos é uma abordagem que utiliza conceitos da separação de interesses para modularizar o software de maneira mais adequada. Com o surgimento dessa abordagem vieram também novos desafios, dentre eles o teste de programas orientados a aspectos. Duas estratégias de ordenação de classes e aspectos para apoiar o teste de integração orientado a aspectos são propostas nesta tese. As estratégias de ordenação tem o objetivo de diminuir o custo da atividade de teste por meio da diminuição do número de stubs implementados durante o teste de integração. As estratégias utilizam um modelo de dependências aspectuais e um modelo que descreve dependências entre classes e aspectos denominado AORD (Aspect and Oriented Relation Diagram) também propostos neste trabalho. Tanto o modelo de dependências aspectuais como o AORD foram elaborados a partir da sintaxe e semântica da linguagem AspectJ. Para apoiar as estratégias de ordenação, idealmente aplicadas durante a fase de projeto, um processo de mapeamento de modelos de projeto que usam as notações UML e MATA para o AORD é proposto neste trabalho. O processo de mapeamento é composto de regras que mostram como mapear dependências advindas da programação orientada a objetos e também da programação orientada a aspectos. Como uma forma de validação das estratégias de ordenação, do modelo de dependências aspectuais e do AORD, um estudo exploratório de caracterização com três sistemas implementados em AspectJ foi conduzido. Durante o estudo foram coletadas amostras de casos de implementação de stubs e drivers de teste. Os casos de implementação foram analisados e classificados. A partir dessa análise e classificação, um catálogo de stubs e drivers de teste é apresentado / Aspect-oriented programming is an approach that uses principles of separation of concerns to improve the sofware modularization. Testing of aspect-oriented programs is a new challenge related to this approach. Two aspects and classes test order strategies to support integration testing of aspect-oriented programs are proposed in this thesis. The objective of these strategies is to reduce the cost of testing activities through the minimization of the number of implemented stubs during integration test. An aspectual dependency model and a diagram which describes dependencies among classes and aspects called AORD (Aspect and Object Relation Diagram) used by the ordering strategies are also proposed. The aspectual dependency model and the AORD were defined considering the syntax constructions and the semantics of AspectJ. As the proposed estrategies should be applied in design phase of software development, a process to map a desing model using UML and MATA notations into a AORD is proposed in order to support the ordering strategies. The mapping process is composed by rules that show how to map both aspect and object-oriented dependencies. A characterization exploratory study using three systems implemented with AspectJ was conducted to validate the ordering strategies, the aspectual dependency model and the AORD. Interesting samples of stubs implementations were collected during the study conduction. The stubs were analyzed and classified. Based on these analysis and classification a catalog of stubs and drivers is presented