Aspect oriented programming (AOP) introduces new and powerful modularization constructs. The aspect module is used to encapsulate crosscutting concerns, which otherwise would remain tangled and scattered. The idea of encapsulating crosscutting concerns rapidly expanded to earlier phases in the development cycle, including requirement analysis (aspect oriented requirement engineering, AORE) and design (aspect oriented modeling, AOM). The overall application of aspect orientation concepts is known as aspect oriented software development (AOSD). AOP is not yet a mainstream practice. Particularly AOSD is still in its early stages. This is reflected in the lack of reports of full development cycles using aspect oriented approaches, especially using industrial case studies. Furthermore, the power of aspects comes at the price of new challenges, one of them is that systems built using aspects are more difficult to understand. The crosscutting nature of aspects allows them to alter the behavior of many other modules. As a result, aspects may interact in unintended and unanticipated ways. This problem is known as aspect interactions. In this work we deal with the aspect interaction problem in the context of an industrial domain: slots machines. We perform a complete development cycle of the slot machine software. This is, to the best of our knowledge, the first complete industrial case of study of aspect orientation. Through this experience we discovered the limitations with regard to aspect interactions, of some emblematic aspect oriented approaches for requirement engineering, design and implementation. The contribution of this work is threefold. Firstly, we contribute with the evaluation and extensions to some of AORE and AOM approaches, in order to provide explicit support for aspect interactions in requirement analysis and design phases. We also evaluate the implementation of interactions using a static and a dynamic AOP language, and propose an AspectJ extension that copes with aspect interactions. Secondly, this work is the first report of a complete aspect oriented development cycle of an industrial case study. Thirdly, this work provides a complex case study that presents several business logic crosscutting concerns, which in turn exhibit numerous aspect interactions, that serves as a challenging test bed for upcoming AOSD approaches.

Thesis (M.S.) -- Worcester Polytechnic Institute. / Keywords: conflict; precedence; dependency; feature-oriented programming; object-oriented design; aspect-oriented programming. Includes bibliographical references (p.76-78).

A dynamic program analysis provides essential information during later phases of an application development. It helps with debugging, profiling, performance optimizations or vulnerability detection. Despite that, support for creating custom dynamic analysis tools, especially in the domain of managed languages, is rather limited. In this thesis, we present two systems to help improve application observability on the Java platform. DiSL is a language accompanied with a framework allowing simple and flexible instrumentation for the dynamic program analysis. DiSL provides high level abstractions to enable quick prototyping even for programmers not possessing a knowledge of Java internals. A skilled analysis developer gains full control over the instrumentation process, thus does not have to worry about unwanted allocations or hidden execution overhead. ShadowVM is a platform that provides isolation between the observed application and the analysis environment. To reduce the amount of possible interactions between the analysis and the application, ShadowVM offloads analysis events out of the context of the application. Even though the isolation is the primary focus of the platform, ShadowVM introduces a number of techniques to stay performance comparable and provide a similar programming model as existing...

O desenvolvimento de aplicações móveis é guiado por uma especial atenção aos requisitos não funcionais (do inglês, NFR - Non Functional Requirements), sendo o principal objetivo proporcionar uma boa experiência ao usuário final. Entretanto, a avaliação de NFRs é ainda uma tarefa manual, não estruturada e que consome muito tempo. Esta dissertação apresenta um estudo de várias abordagens relacionadas à avaliação de desempenho (por exemplo, o uso de aplicações de benchmark) e de NFRs no âmbito de sistemas móveis. No entanto, os benchmarks atuais são genéricos, geralmente, voltados para a plataforma de execução e nem sempre instituem um consenso na classificação de dispositivos. Visando uma melhor avaliação de NFRs e uma classificação de dispositivos com base nas necessidades de aplicações reais, este trabalho propõe um framework para gerar benchmarks orientados às necessidades de cada aplicação e, assim, fornecer uma forma eficiente e eficaz para estimar requisitos não funcionais em sistemas móveis. Essa ferramenta é composta por uma biblioteca de testes parametrizáveis, métricas e uma estrutura para geração rápida de benchmarks orientados à aplicação. O framework foi construído utilizando o paradigma de programação orientada a aspectos para coleta das métricas por fornecer uma maior modularidade e separação de interesses, de modo que a sua evolução, através da adição de outras métricas ou testes, seja facilitada. Para validação da proposta, foram realizados experimentos com cinco aplicações Android reais disponíveis na Play Store, sendo que para cada aplicação foi gerado um benchmark específico cujos resultados foram comparados com os obtidos para as aplicações móveis reais. Os resultados são promissores, mostrando que é possível criar aplicações de teste com comportamento semelhante ao de aplicações reais e, assim, classificar dispositivos com base nas necessidades das aplicações, através da análise das métricas presentes no framework. Essas métricas podem, ainda, orientar o desenvolvedor na otimização de suas aplicações ou ainda na escolha de dispositivos com melhor custo benefício para executar seus aplicativos. / The mobile application development is guided by a special attention to non-functional requirements (NFRs), where a good experience for the end user is the primary goal. However, NFRs evaluation is still a manual, unstructured and time-consuming task. This thesis presents a study of several approaches related to performance and NFR evaluation within mobile systems. Among these approaches is the use of benchmark applications. Currently available benchmarks are generic, usually focused on the execution platform and do not always establish a consensus on the classification of devices. For a better NFRs assessment and classification of devices based on real application needs, this work proposes a framework for generating application-oriented benchmarks for the early estimation of non-functional requirements in mobile systems. This framework is composed of a configurable test library, a set of metrics and an engine the assembling of the test program. The framework uses aspect-oriented programming to collect the metrics of interest. This approach provides increased modularity and separation of concerns, thus facilitating the improvement of the framework itself, by adding other metrics or testing operations. In order to validate the proposed framework we used five application from the Android Play store. For each application, a specific benchmark is generated and executed in different devices. The results are compared to those of the execution of the actual applications in the same devices. Experimental results are promising, showing that it is possible to create test applications with similar behavior to that of real applications and thus classify devices based on the actual application needs, by analyzing the metrics present in the framework. These metrics can also guide the developer in optimizing her applications or in choosing devices with the best trade-off between cost and performance to run a given application.

O desenvolvimento de aplicações móveis é guiado por uma especial atenção aos requisitos não funcionais (do inglês, NFR - Non Functional Requirements), sendo o principal objetivo proporcionar uma boa experiência ao usuário final. Entretanto, a avaliação de NFRs é ainda uma tarefa manual, não estruturada e que consome muito tempo. Esta dissertação apresenta um estudo de várias abordagens relacionadas à avaliação de desempenho (por exemplo, o uso de aplicações de benchmark) e de NFRs no âmbito de sistemas móveis. No entanto, os benchmarks atuais são genéricos, geralmente, voltados para a plataforma de execução e nem sempre instituem um consenso na classificação de dispositivos. Visando uma melhor avaliação de NFRs e uma classificação de dispositivos com base nas necessidades de aplicações reais, este trabalho propõe um framework para gerar benchmarks orientados às necessidades de cada aplicação e, assim, fornecer uma forma eficiente e eficaz para estimar requisitos não funcionais em sistemas móveis. Essa ferramenta é composta por uma biblioteca de testes parametrizáveis, métricas e uma estrutura para geração rápida de benchmarks orientados à aplicação. O framework foi construído utilizando o paradigma de programação orientada a aspectos para coleta das métricas por fornecer uma maior modularidade e separação de interesses, de modo que a sua evolução, através da adição de outras métricas ou testes, seja facilitada. Para validação da proposta, foram realizados experimentos com cinco aplicações Android reais disponíveis na Play Store, sendo que para cada aplicação foi gerado um benchmark específico cujos resultados foram comparados com os obtidos para as aplicações móveis reais. Os resultados são promissores, mostrando que é possível criar aplicações de teste com comportamento semelhante ao de aplicações reais e, assim, classificar dispositivos com base nas necessidades das aplicações, através da análise das métricas presentes no framework. Essas métricas podem, ainda, orientar o desenvolvedor na otimização de suas aplicações ou ainda na escolha de dispositivos com melhor custo benefício para executar seus aplicativos. / The mobile application development is guided by a special attention to non-functional requirements (NFRs), where a good experience for the end user is the primary goal. However, NFRs evaluation is still a manual, unstructured and time-consuming task. This thesis presents a study of several approaches related to performance and NFR evaluation within mobile systems. Among these approaches is the use of benchmark applications. Currently available benchmarks are generic, usually focused on the execution platform and do not always establish a consensus on the classification of devices. For a better NFRs assessment and classification of devices based on real application needs, this work proposes a framework for generating application-oriented benchmarks for the early estimation of non-functional requirements in mobile systems. This framework is composed of a configurable test library, a set of metrics and an engine the assembling of the test program. The framework uses aspect-oriented programming to collect the metrics of interest. This approach provides increased modularity and separation of concerns, thus facilitating the improvement of the framework itself, by adding other metrics or testing operations. In order to validate the proposed framework we used five application from the Android Play store. For each application, a specific benchmark is generated and executed in different devices. The results are compared to those of the execution of the actual applications in the same devices. Experimental results are promising, showing that it is possible to create test applications with similar behavior to that of real applications and thus classify devices based on the actual application needs, by analyzing the metrics present in the framework. These metrics can also guide the developer in optimizing her applications or in choosing devices with the best trade-off between cost and performance to run a given application.

A Programação Orientada a Aspectos (POA) é uma técnica contemporânea de desenvolvimento de software fortemente baseada no princípio da separação de interesses. Ela tem como objetivo tratar de problemas de modularização de software por meio da introdução do aspecto como uma nova unidade de implementação que encapsula comportamento relacionado aos interesses transversais do software. A despeito dos benefícios que podem ser alcançados com o uso da POA, seus mecanismos de implementação representam novas potenciais fontes de defeitos que devem ser tratados durante a fase de teste de software. Nesse contexto, o teste de mutação consiste em um critério de seleção de testes baseado em defeitos que tem sido bastante investigado para demonstrar a ausência de defeitos pré-especifiados no software. Acredita-se que o teste de mutação seja uma ferramenta adequada para lidar com as particularidades de técnicas de programação contemporâneas como a POA. Entretanto, até o presente momento, as poucas iniciativas para adaptar o teste de mutação para o contexto de programas orientados a aspectos (OA) apresentam cobertura limitada em relação aos tipos de defeitos simulados, ou ainda requerem adequado apoio automatizado e avaliações. Esta tese visa a mitigar essas limitações por meio da definição de uma abordagem abrangente de teste de mutação para programas OA escritos na linguagem AspectJ. A tese inicia como uma investigação da propensão a defeitos de programas OA e define uma taxonomia de defeitos para tais programas. A taxonomia inclui uma variedade de tipos de defeitos e serviu como base para a definição de um conjunto de operadores de mutação para programas OA. Suporte automatizado para a aplicação dos operadores também foi disponibilizado. Uma série de estudos quantitativos mostra que a taxonomia de defeitos proposta é suficiente para classificar defeitos encontrados em vários sistemas OA. Os estudos também mostram que os operadores de mutação propostos são capazes de simular defeitos que podem não ser relevados por conjuntos de teste pré-existentes, não derivados para cobrir mutantes. Além disso, observou-se que o esforço requerido para evoluir tais conjuntos de teste de forma a torná-los adequados para os requisitos gerados pelos operadores / Aspect-Oriented Programming (AOP) is a contemporary software development technique that strongly relies on the Separation of Concerns principle. It aims to tackle software modularisation problems by introducing the aspect as a new implementation unit to encapsulate behaviour required to realise the so-called crosscutting concerns. Despite the benefits that may be achieved with AOP, its implementation mechanisms represent new potential sources of faults that should be handled during the testing phase. In this context, mutation testing is a widely investigated fault-based test selection criterion that can help to demonstrate the absence of prespecified faults in the software. It is believed to be an adequate tool to deal with testing-related specificities of contemporary programming techniques such as AOP. However, to date, the few initiatives for customising the mutation testing for aspect-oriented (AO) programs show either limited coverage with respect to the types of simulated faults, or a need for both adequate tool support and proper evaluation. This thesis tackles these limitations by defining a comprehensive mutation-based testing approach for AO programs written in the AspectJ language. It starts with a fault-proneness investigation in order to define a fault taxonomy for AO software. Such taxonomy encompasses a range of fault types and underlay the definition of a set of mutation operators for AO programs. Automated tool support is also provided. A series of quantitative studies show that the proposed fault taxonomy is able to categorise faults identified from several available AO systems. Moreover, the studies show that the mutation operators are able to simulate faults that may not be revealed by pre-existing, non-mutation-based test suites. Furthermore, the effort required to augment the test suites to provide adequate coverage of mutants does not tend to overwhelm the testers. This provides evidence of the feasibility of the proposed approach and represents a step towards the practical fault-based testing of AO programs

L’utilisation de concepts avancés de programmation concurrente permet de dépasser les inconvénients de l’utilisation de techniques de bas niveau à base de verrous ou de moniteurs. Elle augmente le niveau d’abstraction, libérant les programmeurs d’applications concurrentes d’une focalisation excessive sur des détails. Cependant, avec les approches actuelles, la logique nécessaire à la mise en place de schémas de coordinations complexes est fragmentée en plusieurs points de l’application sous forme de« join patterns », de notifications et de la logique applicative qui crée implicitement des dépendances entre les canaux de communication et donc, indirectement, les « join patterns » (qui définissent ces canaux). Nous présentons JEScala, un langage qui capture les schémas de coordination (d’une application concurrente) d’une manière plus expressive et modulaire, en s’appuyant sur l’intégration fine d’un système d’évènements avancé et des « join patterns ». Nous implémentons des automates finis à partir de « joins » à l’aide de JEScala et introduisons un langage dédié à la définition de ces automates finis permettant d’en obtenir des implémentations plus efficaces. Nous validons notre approche avec des études de cas et évaluons l’efficacité de son exécution. Nous comparons la performance de trois implémentations d’un automate fini. Nous validons enfin l’idée d’un moniteur d’évènements en créant un programme JEScala concurrent à partir d’un découpage d’un programme séquentiel. / The advanced concurrency abstractions provided by the Join calculus overcome the drawbacks of low-level techniques such as locks and monitors. They rise the level of abstraction, freeing programmers that implement concurrent applications from the burden of concentrating on low-level details. However, with current approaches the coordination logic involved incomplex coordination schemas is fragmented into several pieces including join patterns, data emissions triggered in different places of the application, and the application logic that implicitly creates dependencies among channels, hence indirectly among join patterns. We present JEScala, a language that captures coordination schemas in a more expressive and modular way by leveraging a seamless integration of an advanced event system with join abstractions. We implement Joins-based state machines using JEScala and introduce a domain specific language for finite state machines that make faster alternative implementations possible. We validate our approach with case studies and we provide a first performance assessment. We compare the performance of three different implementations of a finite state machine. Finally, we validate the idea of constructing a concurrent JEScala program by using the parts of a sequential Event-Based program in combination with an event monitor, a component that synchronizes handling of multiple events.

No description available.

No description available.

存取控管是電子病歷 (Electronic Medical Records, EMR)安全防護的核心課題。為了因應醫病關係的變動及確保病患隱私，EMR的存取控管必須滿足動態和細緻化這兩大需求。但這樣的需求並不容易實現，因為負責存取控管的程式碼具有橫跨 (cross-cutting)的特性，必須嵌入到應用系統的各個模組，很容易與應用邏輯發生夾雜不清的現象。礙於現有的程式機制和開發工具對於這樣的安全需求無法提供有效的支援，因此本研究將以剖面導向程式設計 (Aspect Oriented Programming，AOP)技術為基礎，設計一個宣告式EMR安全控管方法，。 在我們的方法中，安全控管邏輯將從EMR系統的核心抽離，並且匯集到單一的剖面 (Aspect)模組，使原有的系統更加模組化 (modularity)。此外，利用我們開發的存取控管程式碼產生器，安全管理者可以藉由宣告組態檔的方式產生EMR的存取控管程式碼。如此一來，安全管理者不僅可以容易地掌握全局、減少分散管理可能造成的疏失，更可以大幅減少維護EMR存取安全所需的時間及成本。 / This paper presents an aspect-oriented approach to providing adaptable access control framework for Electronic Medical Records (EMR) on Web-based platform. In our scheme, access control logic is decoupled from the core of application and collected into separate aspect modules which are automatically synthesized from access control rules in XML format and properly designed aspect templates. The generated aspect modules will then be compiled and integrated into the underlying application using standard aspect tools. At runtime, these aspect codes will be executed to enforce the required access control without any runtime interpretation overhead. Future changes of access control rules can also be effectively realized through these mechanisms without actual coding. This will not only improve the system’s modularity but also make the task of enforcing comprehensive access control more adaptable.