Spelling suggestions: "subject:"aspect ariented erogramming"" "subject:"aspect ariented cprogramming""
71 |
Preserving the separation of concerns while composing aspects with reflective AOPMarot, Antoine 07 October 2011 (has links)
Aspect-oriented programming (AOP) is a programming paradigm to localize and modularize the concerns that tend to be tangled and scattered across traditional programming modules, like functions or classes. Such concerns are known as crosscutting concerns and aspect-oriented languages propose to encapsulate them in modules called aspects. Because each crosscutting concern implemented in an aspect is separated from the other concerns, AOP improves reusability, readability, and maintainability of code.<p><p>While it improves separation of concerns, AOP suffers from well-known composition issues. Aspects developed in isolation may indeed interact with each other in ways that were not expected by the programmers and therefore lead to a program that does not meet its requirements. Without appropriate tools, undesired aspect interactions must be identified by reading code in order to gain global knowledge of the program and understand where and how aspects interact. Then, if the aspect language does not offer the needed support, these interactions must be resolved by invasively changing the code of the conflicting aspects to make them work together. Neither one of these solutions are acceptable since global knowledge as well as invasive and composition-specific modifications are exactly what separation of concerns seeks to avoid.<p><p>In this dissertation we show that the existing approaches to compose aspects are not entirely satisfying either with respect to separation of concerns. These approaches either rely on global knowledge and invasive modifications, which is problematic, or lack genericity and/or expressivity, which means that code reading/code modification may still be required for the aspect interactions they cannot handle.<p><p>To properly detect and resolve aspect interactions we propose a novel approach that is based on AOP itself. Since aspect composition is a concern that, by definition, crosscuts the aspects, it indeed makes sense to expect that a technique to improve the separation of crosscutting concerns such as AOP is well-suited for the task. The resulting mechanism is based on reflection principles and is called reflective AOP. <p><p>The main difference between "regular" AOP and reflective AOP lies in the parts of the system they address. While traditional AOP aims at modularizing the concerns that crosscut the base system, reflective AOP offers the possibility to handle the concerns that crosscut the aspects themselves. This is achieved by incorporating new kinds of joinpoints, pointcuts and advice into the aspect language. These new elements, which form what we call a meta joinpoint model, are dedicated to the aspect level and enable programmers to reason about and act upon the semantics of aspects at runtime. As validated on numerous examples of aspect composition, having a well-designed and principled meta joinpoint model makes it possible to deal with both the detection and the resolution of composition issues in a way that preserves the separation of concerns principle. These examples are illustrated using Phase, our prototype reflective AOP language. / Doctorat en Sciences / info:eu-repo/semantics/nonPublished
|
72 |
Securely Handling Inter-Application Connection CredentialsLieberman, Gary 01 January 2012 (has links)
The utilization of application-to-application (A2A) credentials within interpretive language scripts and application code has long been a security risk. The quandaries being how to protect and secure the credentials handled in the main body of code and avoid exploitation from rogue programmers, system administrators and other users with
authorized high levels of privilege.
Researchers report that A2A credentials cannot be protected and that there is no way to reduce the risk of the inevitable successful attack and subsequent exploit. Therefore, research efforts to date have primarily been focused on mitigating the impact of the attack rather than finding ways to reduce the attack surface.
The work contained herein successfully addresses this serious cross-cutting concern and proves that it is in fact possible to significantly reduce the risk of attack. This reduction of risk was accomplished through implementing a method of credential obfuscation which applied advice with concerns utilizing a composition filter. The filter modified messages containing the credentials as they were sent from the interpretive language script to the remote data store.
The modification extracted credentials from a secure password vault and inserted them into the message being sent to the remote data store. This modification moved the handling of the credentials from the main body of code to a secure library and out of the reach of attackers with authorized high levels of privilege. The relocation of the credential handling code lines significantly reduced the attack surface and the overall risk of attack.
|
73 |
A semantics for aspects by compositional translationSanjabi, Sam Bakhtiar January 2008 (has links)
We analyse the semantics of aspect-oriented extensions to functional languages by presenting compositional translations of these primitives into languages with traditional notions of state and control. As a first step, we examine an existing semantic description of aspects which allows the labelling of program points. We show that a restriction of these semantics to aspects which do not preempt the execution of code can be fully abstractly translated into a functional calculus with higher order references, but that removing this restriction requires a notion of exception handling to be added to the target language in order to yield a sound semantics. Next, we proceed to show that abandoning the labelling technique, and consequently relaxing the so-called ``obliviousness'' property of aspectual languages, allows preemptive aspects to be included in the general references model without the need for exceptions. This means that the game model of general references is inherited by the aspect calculus. The net result is a clean semantic description of aspect-orientation, which mirrors recently published techniques for their implementation, and thereby provides theoretical justification for these systems. The practical validity of our semantics is demonstrated by implementing extensions to the basic calculus in Standard ML, and showing how a number of useful aspect-oriented features can be expressed using general references alone. Our theoretical methodology closely follows the proof structure that often appears in the game semantics literature, and therefore provides an operational perspective on notions such as ``bad variables'' and factorisation theorems.
|
74 |
Uma contribuição para o teste baseado em defeitos de software orientado a aspectos / A contribution to the fault-based testing of aspect-orientd softwareFerrari, Fabiano Cutigi 16 December 2010 (has links)
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
|
75 |
Framework para estimar requisitos não funcionais em aplicações móveis / A framework for non-functional requirements estimation in mobile applicationsFernandes, Thiago Soares January 2015 (has links)
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.
|
76 |
Performance Studies of Fault-Tolerant MiddlewareSzentiványi, Diana January 2005 (has links)
Today’s software engineering and application development trend is to take advantage of reusable software. Much effort is directed towards easing the task of developing complex, distributed, network based applications with reusable components. To ease the task of the distributed systems’ developers, one can use middleware, i.e. a software layer between the operating system and the application, which handles distribution transparently. A crucial feature of distributed server applications is high availability. This implies that they must be able to continue activity even in presence of crashes. Embedding fault tolerance mechanisms in the middleware on top of which the application is running, offers the potential to reduce application code size thereby reducing developer effort. Also, outage times due to server crashes can be reduced, as failover is taken care of automatically by middleware. However, a trade-off is involved: during periods with no failures, as information has to be collected for the automatic failover, client requests are serviced with higher latency. To characterize the real benefits of middleware, this trade-off needs to be studied. Unfortunately, to this date, few trade-off studies involving middleware that supports fault tolerance with application to realistic cases have been conducted. The contributions of the thesis are twofold: (1) insights based on empirical studies and (2) a theoretical analysis of components in a middleware equipped with fault tolerance mechanisms. In connection with part (1) the thesis describes detailed implementation of two platforms based on CORBA (Common Object Request Broker Architecture) with fault tolerance capabilities: one built by following the FT-CORBA standard, where only application failures are taken care of, and a second obtained by implementing an algorithm that ensures uniform treatment of infrastructure and application failures. Based on empirical studies of the availability/performance trade-off, several insights were gained, including the benefits and drawbacks of the two infrastructures. The studies were performed using a realistic (telecommunication) applicationset up to run on top of both extended middleware platforms. Further, the thesis proposes a technique to improve performance in the FT-CORBA based middleware by exploiting application knowledge; to enrich application code with fault tolerance mechanisms we use aspect-oriented programming. In connection with part (2) the thesis models elements of an FT-CORBA like architecture mathematically, in particular by using queuing theory. The model is then used to study the relation between different parameters. This provides the means to configure one middleware parameter, namely the checkpointing interval, leading to maximal availability or minimal response time.
|
77 |
Model-based Code Generation For The High Level Architecture FederatesAdak, Bulent Mehmet 01 December 2007 (has links) (PDF)
We tackle the problem of automated code generation for a High Level Architecture (HLA)-
compliant federate application, given a model of the federation architecture including the
federate&rsquo / s behavior model. The behavior model is based on Live Sequence Charts (LSCs),
adopted as the behavioral specification formalism in the Federation Architecture Metamodel
(FAMM). The FAMM is constructed conforming to metaGME, the meta-metamodel offered
by Generic Modeling Environment (GME). FAMM serves as a formal language for
describing federation architectures. We present a code generator that generates Java/AspectJ
code directly from a federation architecture model. An objective is to help verify a federation
architecture by testing it early in the development lifecycle. Another objective is to help
developers construct complete federate applications. Our approach to achieve these
objectives is aspect-oriented in that the code generated from the LSC in conjunction with the
Federation Object Model (FOM) serves as the base code on which the computation logic is
weaved as an aspect.
|
78 |
Modularizing Crosscutting Concerns in SoftwareSaigal, Nalin 01 January 2011 (has links)
Code modularization provides benefits throughout the software life cycle; however, the presence of crosscutting concerns (CCCs) in software hinders its complete modularization. Traditional modularization techniques work well under the assumption that code being modularized is functionally orthogonal to the rest of the code; as a result, software engineers try to separate code segments that are orthogonal in their functionality into distinct modules. However, in practice, software does not decompose neatly into modules with distinct, orthogonal functionality. In this thesis, we investigate the modularization of CCCs in software using two different techniques.
Firstly, we discuss IVCon, a GUI-based tool that provides a novel approach to the modularization of CCCs. We have designed IVCon to capture the multi-concern nature of code. IVCon enables users to create, examine, and modify their code in two different views, the woven view and the unwoven view. The woven view displays program code in colors that indicate which CCCs various code segments implement, while the unwoven view displays code in two panels, one showing the core of the program and the other showing all the code implementing each concern in an isolated module. IVCon aims to provide an easy-to-use interface for conveniently creating, examining, and modifying code in, and translating between, the woven and unwoven views.
Secondly, we discuss LoPSiL, which is a location-based policy-specification language. LoPSiL is Turing-complete and provides users with language constructs that enable them to manipulate location information; hence, LoPSiL can be used to specify and enforce generic policies that might involve location-based constraints. We have implemented a LoPSiL compiler using AspectJ, and we observe and discuss how the use of traditional units of modularization---aspects in this case---help modularize functionally orthogonal CCCs such as security and auditing.
|
79 |
Investigation, Improvement and Development of Aspect-Oriented Design Patterns / Aspektinio projektavimo šablonų tyrimas, tobulinimas ir kūrimasVaira, Žilvinas 26 April 2012 (has links)
Software systems are permanently changed in order to meet new requirements and to adapt them to permanently changing technology. Design modularity decouples design concerns that probably can be changed and in this way facilitates further system changes. Unfortunately, some design concerns, called crosscutting concerns, cannot be modularized using traditional modularization methods and techniques. Modularization of crosscutting concerns is the research subject of the new emerging software engineering paradigm, aspect-oriented analysis and design. However, this paradigm is still not enough mature. It is still unknown, which design patterns developed in the object-oriented paradigm can be adapted for aspect-oriented paradigm and how to transform them from one paradigm to another in a systematic way. Despite the fact that some attempts have been done to solve this problem, the proposed solutions only eliminate crosscutting concerns in object-oriented design patterns, but do not generate pure aspect-oriented patterns. The thesis defines the class of object-oriented design patterns which can be transformed into pure aspect-oriented ones, proposes a systematic procedure for such transformation and investigates properties of resulting patterns from the viewpoint of their applicability in the design of aspect-oriented domain frameworks. This is the main contribution of the research work. The case study methodology has been used for the experimental research of the properties of... [to full text] / Programų sistemos yra dažnai keičiamos, siekiant jas pritaikyti prie pasikeitusių reikalavimų ir dėl nuolat kintančių technologijų. Modulinė sistemos architektūra įgalina nepriklausomus dalykinius turinius realizuoti nepriklausomais ar nedaug vienas nuo kito priklausomais moduliais, kuriuos galima keisti nepriklausomai vienas nuo kito. Tačiau esamomis priemonėmis galima atskirti ne visus turinius. Kai kurie dalykiniai turiniai yra susipynę tarpusavyje ir jų negalima realizuoti savarankiškais moduliais. Šiai problemai spręsti buvo pasiūlyta nauja programų sistemų inžinerijos paradigma – aspektinė paradigma. Tačiau sistemų projektavimo technologija joje kol kas dar nėra pakankamai brandi. Vis dar nėra žinoma, kuriuos objektinio projektavimo šablonus galima panaudoti aspektinėje paradigmoje ir kaip juos transformuoti, keliant iš vienos paradigmos į kitą. Nors keliuose darbuose yra parodoma, kaip objektinių šablonų realizacijas perrašyti aspektinėmis programavimo kalbomis, nė viename iš jų šablonų transformavimo klausimai nebuvo nagrinėti sistemiškai. Šioje disertacijoje nagrinėjami grynieji aspektinio projektavimo šablonai, kurie buvo transformuoti iš objektinių projektavimo šablonų, apibrėžiama sistemiška tokio transformavimo procedūra ir analizuojamas tokių šablonų taikymas aspektiniams dalykiniams karkasams projektuoti. Atskiro atvejo analizės tyrimo metodas disertacijoje yra naudojamas, siekiant išsiaiškinti, kokį poveikį grynieji aspektiniai šablonai padaro aspektinių... [toliau žr. visą tekstą]
|
80 |
Aspektinio projektavimo šablonų tyrimas, tobulinimas ir kūrimas / Investigation, Improvement and Development of Aspect-Oriented Design PatternsVaira, Žilvinas 26 April 2012 (has links)
Programų sistemos yra dažnai keičiamos, siekiant jas pritaikyti prie pasikeitusių reikalavimų ir dėl nuolat kintančių technologijų. Modulinė sistemos architektūra įgalina nepriklausomus dalykinius turinius realizuoti nepriklausomais ar nedaug vienas nuo kito priklausomais moduliais, kuriuos galima keisti nepriklausomai vienas nuo kito. Tačiau esamomis priemonėmis galima atskirti ne visus turinius. Kai kurie dalykiniai turiniai yra susipynę tarpusavyje ir jų negalima realizuoti savarankiškais moduliais. Šiai problemai spręsti buvo pasiūlyta nauja programų sistemų inžinerijos paradigma – aspektinė paradigma. Tačiau sistemų projektavimo technologija joje kol kas dar nėra pakankamai brandi. Vis dar nėra žinoma, kuriuos objektinio projektavimo šablonus galima panaudoti aspektinėje paradigmoje ir kaip juos transformuoti, keliant iš vienos paradigmos į kitą. Nors keliuose darbuose yra parodoma, kaip objektinių šablonų realizacijas perrašyti aspektinėmis programavimo kalbomis, nė viename iš jų šablonų transformavimo klausimai nebuvo nagrinėti sistemiškai. Šioje disertacijoje nagrinėjami grynieji aspektinio projektavimo šablonai, kurie buvo transformuoti iš objektinių projektavimo šablonų, apibrėžiama sistemiška tokio transformavimo procedūra ir analizuojamas tokių šablonų taikymas aspektiniams dalykiniams karkasams projektuoti. Atskiro atvejo analizės tyrimo metodas disertacijoje yra naudojamas, siekiant išsiaiškinti, kokį poveikį grynieji aspektiniai šablonai padaro aspektinių... [toliau žr. visą tekstą] / Software systems are permanently changed in order to meet new requirements and to adapt them to permanently changing technology. Design modularity decouples design concerns that probably can be changed and in this way facilitates further system changes. Unfortunately, some design concerns, called crosscutting concerns, cannot be modularized using traditional modularization methods and techniques. Modularization of crosscutting concerns is the research subject of the new emerging software engineering paradigm, aspect-oriented analysis and design. However, this paradigm is still not enough mature. It is still unknown, which design patterns developed in the object-oriented paradigm can be adapted for aspect-oriented paradigm and how to transform them from one paradigm to another in a systematic way. Despite the fact that some attempts have been done to solve this problem, the proposed solutions only eliminate crosscutting concerns in object-oriented design patterns, but do not generate pure aspect-oriented patterns. The thesis defines the class of object-oriented design patterns which can be transformed into pure aspect-oriented ones, proposes a systematic procedure for such transformation and investigates properties of resulting patterns from the viewpoint of their applicability in the design of aspect-oriented domain frameworks. This is the main contribution of the research work. The case study methodology has been used for the experimental research of the properties of... [to full text]
|
Page generated in 0.1146 seconds