Evolution of software components may lead to compatibility problems, such as incorrect executing results, compilation errors and system crashes. Solving those problems is a big challenge in software engineering. In th...
详细信息
Evolution of software components may lead to compatibility problems, such as incorrect executing results, compilation errors and system crashes. Solving those problems is a big challenge in software engineering. In the past decade, many automatic solutions to address this issue have been proposed. However, all of them rely on extra change information (i.e., the information regarding the changes of the upgraded components). Without such information, none of the existing solutions can work. Therefore, how to fully automatically solve compatibility problems without extra information is still an important open issue. In the current study, I proposed an end-to-end solution to fully automatically adapt incompatible components without resorting to any extra information. It is composed of two parts. The first part is TARP, an AI-planning based automatic refactoring history reconstruction framework. For an upgraded component, TARP can automatically reconstruct the missing refactoring history. The second part is ALTA, an automatic load-time adaptation framework, which can adapt incompatible components on-the-fly according to the refactoring history generated from TARP. Therefore, as an integrated solution with both TARP and ALTA, compatibility problems among application and components can be fully automatically solved to a very large extent. The implementation of ALTA as ALTA*, and TARP as TARP*, were evaluated by conducting five sets of tests. The experimental results show that the TARP* + ALTA* solution can indeed fully automatically fix compatibility problems incurred to large-scale components without any additional information.
In recent years, aspectorientedprogramming (AOP) has become an emerging technology due to its ability to support the separation of concerns in software development. In particular, AOP allows application requirements...
详细信息
In recent years, aspectorientedprogramming (AOP) has become an emerging technology due to its ability to support the separation of concerns in software development. In particular, AOP allows application requirements to be implemented in separated modules while weaving them together without code tangling. However, this feature also raises a concern about the quality and reliability of AOP programs. Most specifically, the AOP programming constructs, such as join point, pointcut, advice, and aspect, can change the dynamic behavior(1) of original base modules and need to be tested thoroughly to ensure the correctness of AOP programs. In this paper, we propose a state-based testing approach for AOP programs. The approach considers the state-based behavior(2) changes introduced by different advices in multiple aspects. A test model is presented to abstract the state-based behavior of AOP program with the consideration of the interactions between the base modules and aspects. Based on the model, test cases can be derived so as to uncover the potential state behavior errors in the AOP programs. In addition, an example is provided to show the effectiveness of the proposed approach.
To successfully compete in the software marketplace, modern mobile applications must run on multiple competing platforms, such as Android, iOS, and Windows Phone. Companies producing mobile applications spend substant...
详细信息
ISBN:
(纸本)9781479902156
To successfully compete in the software marketplace, modern mobile applications must run on multiple competing platforms, such as Android, iOS, and Windows Phone. Companies producing mobile applications spend substantial amounts of time, effort, and money to port applications across platforms. Creating individual program versions for different platforms further exacerbates the maintenance burden. This paper presents Cloud Twin, a novel approach to natively executing the functionality of a mobile application written for another platform. The functionality is accessed by means of dynamic cross-platform replay, in which the source application's execution in the cloud is mimicked natively on the target platform. The reference implementation of Cloud Twin natively emulates the behavior of Android applications on a Windows Phone. Specifically, Cloud Twin transmits, via web sockets, the UI actions performed on the Windows Phone to the cloud server, which then mimics the received actions on the Android emulator. The UI updates on the emulator are efficiently captured by means of aspectorientedprogramming and sent back to be replayed on the Windows Phone. Our case studies with third-party applications indicate that the Cloud Twin approach can become a viable solution to the heterogeneity of the mobile application market.
Debugging is a tedious and costly process that demands a profound understanding of the dynamic behavior of programs. Debugging aspect-oriented software is even more difficult: to implement the semantics of aspects, a,...
详细信息
ISBN:
(纸本)9781595937537
Debugging is a tedious and costly process that demands a profound understanding of the dynamic behavior of programs. Debugging aspect-oriented software is even more difficult: to implement the semantics of aspects, a, number of implicit activities are performed, whose relation to source code is less direct to grasp. We show how omniscient debugging, a technique that consists in recording the activity of a program to later navigate in its history, can be extended to suit the particularities of aspect-oriented software. By enhancing program understandability, improvements to the tooling associated with aspect orientation will encourage the widespread acceptance of this emerging paradigm.
To comprehend programs or to fix a bug, programmers always mentally simulate the program execution by reading the source code. aspect-oriented programming (AOP) increases this mental effort, because it can alter the s...
详细信息
ISBN:
(纸本)9781450318730
To comprehend programs or to fix a bug, programmers always mentally simulate the program execution by reading the source code. aspect-oriented programming (AOP) increases this mental effort, because it can alter the state and the behavior of the base program at a join point to any extent by executing advices. Advices are implicitly invoked in the source code and their compositions at a join point may vary according to the runtime context. They can access and even change the context values of join points. Without appropriate tools, it is difficult to notice the effects of the implicitly executed advices. The goal of my work is to increase the comprehensibility of AO programs by using a graphical tool, that can succinctly visualize the state and behavioral changes at join points.
In recent years, aspectorientedprogramming (AOP) has become an emerging technology due to its ability to support the separation of concerns in software development. In particular, AOP allows application requirements...
详细信息
In recent years, aspectorientedprogramming (AOP) has become an emerging technology due to its ability to support the separation of concerns in software development. In particular, AOP allows application requirements to be implemented in separated modules while weaving them together without code tangling. However, this feature also raises a concern about the quality and reliability of AOP programs. Most specifically, the AOP programming constructs, such as join point, pointcut, advice, and aspect, can change the dynamic behavior(1) of original base modules and need to be tested thoroughly to ensure the correctness of AOP programs. In this paper, we propose a state-based testing approach for AOP programs. The approach considers the state-based behavior(2) changes introduced by different advices in multiple aspects. A test model is presented to abstract the state-based behavior of AOP program with the consideration of the interactions between the base modules and aspects. Based on the model, test cases can be derived so as to uncover the potential state behavior errors in the AOP programs. In addition, an example is provided to show the effectiveness of the proposed approach.
Synchronization is an important problem in the design and development of the software, which has been resolved in the object-orientedprogramming (OOP). However, the implementation of OOP is easy to leads to code-tang...
详细信息
ISBN:
(纸本)9780769534985
Synchronization is an important problem in the design and development of the software, which has been resolved in the object-orientedprogramming (OOP). However, the implementation of OOP is easy to leads to code-tangling and code-scattering between functional properties and crosscutting properties. aspect-oriented programming (AOP) can solve the problem of code-tangling and code-scatterting, and provide a mechanism of the modularization of crosscutting properties. Synchronization, as a typical aspect, is resolved based on AOP in this paper. Taking the classical producer-consumer problem as a case study, this paper identifies the synchronization as a crosscutting concern, modularizes it as an aspect and implements the program with aspectJ. The execution result shows AOP can not only resolve the problem of synchronization, but also gain the effect of modularization better than OOP. Furthermore, compared execution time of AOP program with that of OOP program, the result shows that the execution time of AOP is similar to OOP.
Although it is assumed that the implementation of design by contract is better modularized by means of aspect-oriented (AO) programming, there is no empirical evidence on the effectiveness of AO for modularizing non-t...
详细信息
Although it is assumed that the implementation of design by contract is better modularized by means of aspect-oriented (AO) programming, there is no empirical evidence on the effectiveness of AO for modularizing non-trivial design by contract code in realistic development scenarios. This paper reports a quantitative and qualitative case study that evolves a real-life application to assess various facets of the adequacy of aspects for modularizing the design by contract concern. Our evaluation focused upon a number of system changes that are typically performed during software maintenance tasks. The study was driven by an analysis of fundamental modularity attributes, such as separation of concerns, coupling, conciseness, and change propagation. We have found that AO techniques improved separation of concerns and the design stability between the design by contract code and base application code throughout the development scenarios. However, contradicting the general intuition, the AO versions of the system did not present significant gains regarding four classical size metrics we employed.
The development of computer systems is extremely complex due to real-time, distribution and dynamism requirements. For this reason, whatever the taken precautions, the occurrence of faults is sometimes unavoidable. In...
详细信息
ISBN:
(纸本)9781479904051
The development of computer systems is extremely complex due to real-time, distribution and dynamism requirements. For this reason, whatever the taken precautions, the occurrence of faults is sometimes unavoidable. In this context, we notice the need of techniques ensuring the dependability of real-time distributed dynamically reconfigurable systems. We focus on fault-tolerance, that means avoiding service failures in the presence of faults. In this paper, we have defined a development process for modeling and generating fault tolerance code using aspectorientedprogramming. First, we integrate fault tolerance elements since the modeling step of a system in order to take advantage of features of analysis, proof and verification possible at this stage using AADL and its annex Error Model Annex. Second, we extend an aspectoriented language and adapt it to respect real-time requirements. Finally, we define a code generation process for both functional preoccupations and cross-cutting ones like fault tolerance.
暂无评论