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.

Em meados dos anos 90, alguns pesquisadores constataram a existência de certos interesses que, independente da técnica de programação utilizada ou da maneira como o sistema venha a ser decomposto, não se encaixam em módulos individuais, mas ficam espalhados por várias unidades do software (também chamados de interesses transversais). A programação orientada a aspectos (POA) foi concebida como uma proposta de resolução desse problema, a partir do uso de mecanismos que permitem o isolamento dos interesses transversais. Entretanto, por ser uma técnica nova, nesses primeiros anos os pesquisadores preocuparam-se em estabelecer os conceitos e técnicas básicos das linguagens orientadas a aspectos, deixando para uma segunda fase a investigação de outras características do desenvolvimento de programas orientados a aspectos, como métodos de projeto e abordagens de teste. Nesta dissertação é apresentada uma abordagem de teste estrutural para programas orientados a aspectos baseados na linguagem AspectJ, que pode contribuir para o aumento da confiança no software desenvolvido utilizando essa técnica e auxiliar o entendimento das novas construções e comportamentos envolvidos nesses programas. Modelos de fluxo de controle e de dados baseados no código-objeto resultante da compilação/ combinação de programas escritos na linguagem AspectJ são propostos, bem como nove critérios de teste baseados nesses modelos. Uma ferramenta desenvolvida para apoiar o teste estrutural de unidade de programas Java foi estendida para dar apoio aos modelos e critérios propostos nesta dissertação. Além disso, algumas propriedades do teste de integração de programas orientados a aspectos são discutidas teoricamente.

Made available in DSpace on 2016-06-02T19:05:51Z (GMT). No. of bitstreams: 1 3771.pdf: 2012363 bytes, checksum: beac2e75d3e67d4b8d96a9b1c3ce98ef (MD5) Previous issue date: 2011-05-27 / Universidade Federal de Sao Carlos / Aspect-Oriented Programming allows encapsulating the so-called "Crosscutting Concerns (CCC) - software requirements whose implementation is tangled and scattered throughout the functional modules - into new abstractions, such as Aspects, Pointcuts, Advices and Inter-type Declarations. The reengineering of an OO software to an AO is not an easy task due to the existence of different abstractions in these technologies. We develop a set of nine refactorings of annotated OO class models to AO class models. In the context of this work, "annotated class models" are UML class diagrams whose elements (classes, interfaces, attributes and methods) are annotated with stereotypes representing the existing CCC in the application source code. The set of refactorings developed is divided into: i) generic refactorings; and ii) specific refactorings. Three generic refactorings and six specific refactorings to the persistence (which is divided into management and connections, transaction and synchronization) and logging concerns and to the Singleton and Observer design patterns were created. The generic refactorings are responsible for transforming an annotated OO model with indications of CCC into a partial AO model. This model is called partial because it is usually not fully modularized, i.e., there are remaining software elements stereotyped with indications of particular concerns. These refactorings are applicable to any kind of CCC; this is possible, because what is taken into consideration is the scenario in which these concerns appear in the class model. The specific refactorings are responsible for transforming partial AO models into final ones, whose CCC have been fully modularized in aspects. For that, each refactoring has a set of specific steps for modularization of a particular kind of concern. An Eclipse plug-in, called MoBRe was developed to assist the software engineer in the tasks of refactoring application. As a major contribution, the refactorings proposed in this paper allow obtaining well designed AO models. This is so because: i) they provide a step-by-step guide to the modularization of certain CCC and can avoid that software engineers choose inappropriate strategies for modularization of these CCC; and ii) they were prepared based on good design practices recommended by the scientific community. Thus, besides, the models the use of refactorings can lead to generation of better-quality code, for example, free of bad smells. A case study was conducted to assess the applicability of the proposed refactorings in order to compare an AO model generated by them with an AO model obtained from the literature. / Orientação a Aspectos (OA) permite encapsular Interesses Transversais (ITs) - requisitos de software cuja implementação encontra-se entrelaçada e espalhada pelos módulos funcionais - em novas abstrações, tais como, Aspectos, Conjuntos de Junção, Adendos e Declarações Inter-tipo. A reengenharia de um software OO para um OA não é uma atividade trivial em consequência da existência de abstrações diferentes entre as tecnologias envolvidas. Neste trabalho é proposto um conjunto de refatorações que pode ser aplicado sobre modelos de classes OO anotados com indícios de ITs para obtenção de modelos de classes OA. Modelos de classes anotados são diagramas de classes da UML cujos elementos (classes, interfaces, atributos e métodos) são anotados com estereótipos referentes aos ITs existentes no software. O conjunto de refatorações desenvolvido é subdivido em: i) refatorações genéricas; e ii) refatorações específicas. As refatorações genéricas são responsáveis por transformar um modelo OO anotado com indícios de ITs em um modelo OA parcial - modelo cujos ITs existentes não são completamente modularizados. Essas refatorações são aplicáveis a qualquer tipo de IT existente no software, considerando o cenário que esses interesses apresentam no modelo de classes. As refatorações específicas são responsáveis por transformar modelos de classes OA parciais em modelos de classes OA finais - modelos nos quais os ITs foram completamente modularizados em aspectos. Para que isso aconteça, cada refatoração possui um conjunto de passos específicos para modularização de um determinado tipo de interesse. Três refatorações genéricas e seis refatorações específicas foram elaboradas para os interesses de persistência (subdividido em: gerenciamento de conexões, de transações e sincronização), de logging e para os padrões de projeto Singleton e Observer. Um plug-in Eclipse, denominado MoBRe, foi desenvolvido para auxiliar o Engenheiro de Software na tarefa de aplicação das refatorações. Como principal contribuição, a utilização das refatorações propostas neste trabalho pode permitir a obtenção de modelos OA que representam bons projetos arquiteturais, pois: i) fornecem um guia para modularização de determinados ITs, podendo evitar que Engenheiros de Software escolham estratégias inadequadas para modularização; e ii) foram elaboradas com base em boas práticas de projeto OA preconizadas pela comunidade científica. Assim, além dos modelos a utilização das refatorações pode levar à geração de códigos de melhor qualidade, por exemplo, livre da presença de bad smells. Um estudo de caso foi conduzido para verificar a aplicabilidade das refatorações propostas e os modelos OA resultantes foram equivalentes aos modelos obtidos na literatura.

Em meados dos anos 90, alguns pesquisadores constataram a existência de certos interesses que, independente da técnica de programação utilizada ou da maneira como o sistema venha a ser decomposto, não se encaixam em módulos individuais, mas ficam espalhados por várias unidades do software (também chamados de interesses transversais). A programação orientada a aspectos (POA) foi concebida como uma proposta de resolução desse problema, a partir do uso de mecanismos que permitem o isolamento dos interesses transversais. Entretanto, por ser uma técnica nova, nesses primeiros anos os pesquisadores preocuparam-se em estabelecer os conceitos e técnicas básicos das linguagens orientadas a aspectos, deixando para uma segunda fase a investigação de outras características do desenvolvimento de programas orientados a aspectos, como métodos de projeto e abordagens de teste. Nesta dissertação é apresentada uma abordagem de teste estrutural para programas orientados a aspectos baseados na linguagem AspectJ, que pode contribuir para o aumento da confiança no software desenvolvido utilizando essa técnica e auxiliar o entendimento das novas construções e comportamentos envolvidos nesses programas. Modelos de fluxo de controle e de dados baseados no código-objeto resultante da compilação/ combinação de programas escritos na linguagem AspectJ são propostos, bem como nove critérios de teste baseados nesses modelos. Uma ferramenta desenvolvida para apoiar o teste estrutural de unidade de programas Java foi estendida para dar apoio aos modelos e critérios propostos nesta dissertação. Além disso, algumas propriedades do teste de integração de programas orientados a aspectos são discutidas teoricamente.

Pour profiter des nombreux matériels actuellement, les logiciels s'exécutant sur des téléphones mobiles doivent devenir sensibles au contexte, c'est-à-dire, qu'ils doivent surveiller les événements provenant de leur environnement et réagir en conséquence. Nous considérons que ces logiciels peuvent bénéficier d'une approche basée sur les Lignes de Produits Logiciels (LPL). Les LPLs sont définies pour exploiter les points communs par la définition d'éléments réutilisables. Néanmoins, les LPLs ne prennent pas en compte les modifications à l'exécution des applications. Cette thèse propose une ligne de produits logiciels dynamique (LPLD) qui étend une LPL classique en fournissant des mécanismes pour adapter les produits à l'exécution. Notre objectif principal est d'unifier les adaptations à la conception et à l'exécution en utilisant des artefacts logiciels de haut niveau. Concrètement, nous introduisons un modèle de variabilité et un modèle de composition pour modulariser les produits sous forme de modèles d'aspect. Chaque modèle d'aspect a trois parties : l'architecture, les modifications, et le point de coupe. Ensuite, nous proposons deux processus de dérivation du produit : un pour la conception que vise à construire un produit, et un pour l'exécution que vise à adapter un produit. Ce travail de recherche s'est déroulé dans le cadre du projet FUI CAPPUCINO. Nous avons défini une LPLD pour une étude de cas de vente d'un hypermarché sensible au contexte. Le scénario démontre les avantages de notre approche et, en particulier, l'unification réalisée par les modèles d'aspect utilisés à la fois à la conception et à l'exécution.

在醫療系統中，存取控管是電子病歷安全防護的核心。針對這樣的議題，我們實驗室已經有設計出一種安全的架構，利用最新的程式開發技術，剖面導向程式設計為基礎，設計出一種宣告式電子病歷安全控管的方法。這樣的設計讓安全管理者可以有系統化的控制整個系統的安全存取。但是這樣的架構下，安全規則的變動必須經過好幾道複雜的手續，造成使用上彈性不足。 本研究針對這樣的架構提出幾種改進的方式，使安全規則更動更具有彈性。主要分為兩方面，第一，針對安全規則的變數，設計可以彈性更動的方式，不需要為了更動變數而重複整個安全控管規則產生流程。第二，利用動態載入的功能，提出可以由外部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 design (AOSD) enables better and more complete separation of concerns in software-intensive systems. By extracting aspect code and relegating crosscutting functionality to aspects, software engineers can improve the maintainability of their code by reducing code tangling and coupling of code concerns. Further, the number of software defects has been shown to correlate with the number of non- encapsulated nonfunctional crosscutting concerns in a system. Aspect-mining is a technique that uses data mining techniques to identify existing aspects in legacy code. Unfortunately, there is a lack of suitably-documented test data for aspect- mining research and none that is fully representative of large-scale legacy systems. Using a new technique called concern seeding--based on the decades-old concept of error seeding--a tool called AspectAssay (akin to the radioimmunoassay test in medicine) was developed. The concern seeding technique allows researchers to seed existing legacy code with nonfunctional crosscutting concerns of known type, location, and quantity, thus greatly increasing the pool of available test data for aspect mining research. Nine seeding test cases were run on a medium-sized codebase using the AspectAssay tool. Each test case seeded a different concern type (data validation, tracing, and observer) and attempted to achieve target values for each of three metrics: 0.95 degree of scattering across methods (DOSM), 0.95 degree of scattering across classes (DOSC), and 10 concern instances. The results were manually verified for their accuracy in producing concerns with known properties (i.e., type, location, quantity, and scattering). The resulting code compiled without errors and was functionally identical to the original. The achieved metrics averaged better than 99.9% of their target values. Following the small tests, each of the three previously mentioned concern types was seeded with a wide range of target metric values on each of two codebases--one medium-sized and one large codebase. The tool targeted DOSM and DOSC values in the range 0.01 to 1.00. The tool also attempted to reach target number of concern instances from 1 to 100. Each of these 1,800 test cases was attempted ten times (18,000 total trials). Where mathematically feasible (as permitted by scattering formulas), the tests tended to produce code that closely matched target metric values. Each trial's result was expressed as a percentage of its target value. There were 903 test cases that averaged at least 0.90 of their targets. For each test case's ten trials, the standard deviation of those trials' percentages of their targets was calculated. There was an average standard deviation in all the trials of 0.0169. For the 808 seed attempts that averaged at least 0.95 of their targets, the average standard deviation across the ten trials for a particular target was only 0.0022. The tight grouping of trials for their test cases suggests a high repeatability for the AspectAssay technique and tool. The concern seeding technique opens the door for expansion of aspect mining research. Until now, such research has focused on small, well-documented legacy programs. Concern seeding has proved viable for producing code that is functionally identical to the original and contains concerns with known properties. The process is repeatable and precise across multiple seeding attempts and also accurate for many ranges of target metric values. Just like error seeding is useful in identifying indigenous errors in programs, concern seeding could also prove useful in estimating indigenous nonfunctional crosscutting concerns, thus introducing a new method for evaluating the performance of aspect mining algorithms.

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.