Modeling and Analyzing Web Application with Aspect-Oriented Hierarchical Coloured Petri Nets

Aspect-oriented modeling can uncover potential design faults, yet most existing work fails to achieve both separation and composition in a natural and succinct way. This study presents an aspect-oriented modeling and analysis approach with hierarchical Coloured Petri Nets(HCPN). HCPN has sub-models and well-defined semantics combining a set of submodels. These two characteristics of HCPN are nicely integrated into aspect oriented modeling. Submodels are used to model aspects while the combination mechanism contributes to aspects weaving. Furthermore, the woven aspect oriented HCPN model can be simulated and analyzed by the CPN Tools. A systematic web application case study is conducted. The results show the system original properties are satisfied after weaving aspects and all design flaws are revealed. As such, the approach can support web application design and analysis in an aspect-oriented fashion concisely and effectively.

Context-aware BPEL workflow system using aspect-oriented programming

Business process execution language(BPEL)is a most recognized standard workflow language.However,it is difficult to be used in the ubiquitous system computing environment because it is difficult to describe the context information in the selection of the flow through the branch.To solve this problem,we propose a new BPEL workflow system with context-awareness by using aspect-oriented programming(AOP).This system is composed of a BPEL system module and a weaving module using AOP for context-aware.The BPEL system module generates a BPEL workflow program.And the weaving module converts a context-aware mark-up language(CAML)document to the aspect-oriented program that is applied to context-aware code without modification of the existing BPEL document.We also define a new document form that is called CAML,which provides a context-aware that is not available in BPEL.The system can generate a context-aware workflow program.It is developed in a way that inserts context information using AOP to provide context-aware services.

An Embedded Software Modeling and Process by Using Aspect-Oriented Approach

In recent years, mobile devices have become widespread and refined, and they have offered increased convenience in human life. For these reasons, a variety of embedded systems have been designed. Therefore, improving methods for developing of embedded software systematically has become an important issue. Platform-based design is one example of an embedded-system design method that can reduce the design cost via improving a design’s abstraction level. However, platform-based design lacks precise definitions for platforms and design processes. This paper provides an approach that combines the aspects and platform-based design methods for developing embedded software. The approach is built on platform-based design methodology and uses the separating of concerns (SoC) concept to define the aspects and to reduce the crosscutting concerns in embedded system modeling. For aspect issues, we use the extended UML notation with aspects to describe both the static structure and the dynamic structure of the embedded system. We used an example of a digital photo frame system to demonstrate our approach.

Towards Semantic Mutation Testing of Aspect-Oriented Programs

Aspect-oriented programs have received much attention from software testing researchers. Various testing techniques and approaches have been proposed to tackle issues and challenges when testing aspect-oriented programs including traditional mutation testing. In traditional mutation testing of aspect-oriented programs, mutants are generated by making small changes to the syntax of the aspect-oriented language. Recently, a new approach known as semantic mutation testing has been proposed. This approach mutates the semantics of the language in which the program is written. The mutants generated misunderstandings of the language which are different classes of faults. Aspect-oriented programming presents itself with different properties that can be further explored with respect to semantic mutation testing. This paper describes various possible scenarios that semantic mutation testing strategy might have particular value in testing aspect-oriented programs.

Specifying redundancy tactics as crosscutting concerns using aspect-oriented modeling

Various redundancy tactics can be modeled at the design stage of safety-critical systems thereby providing a set of fault-tolerance guidelines for subsequent development activities. However, existing approaches usually interweave redundancy tactics into the functional models making them complex and cluttered; the maintenance of such models is time-consuming and error-prone. To address this problem, we provide a modeling approach to separate the redundancy tactics from the base functional models using aspect-oriented modeling. More specifically, the conceptual models of the redundancy tactics and their semantic constraints are first defined for deriving the relevant aspects. Subsequently, a UML profile is proposed to specify the tactic aspects followed by mapping these concepts to the corresponding concepts of aspect-oriented modeling based on pre-defined principles. In accordance with our proposed profile, reuse directives are applied to handle the overlap of structural features between redundancy tactics and other kinds of tactic. Based on our tactic aspects and their configured attributes, a weaving algorithm is proposed to associate the tactic aspects with the base functional models. The proposed approach is compared with a traditional tactic modeling approach using two safety-critical systems, revealing that： 1） our approach significantly reduces the number of extra model elements needed in the tactic design stage; 2） our approach can largely avoid the impact of changing of the base functional model as the model evolves.

Aspect-Oriented Modeling and Verification with Finite State Machines

Aspect-oriented programming modularizes crosscutting concerns into aspects with the advice invoked at the specified points of program execution. Aspects can be used in a harmful way that invalidates desired properties and even destroys the conceptual integrity of programs. To assure the quality of an aspect-oriented system, rigorous analysis and design of aspects are highly desirable. In this paper, we present an approach to aspect-oriented modeling and verification with finite state machines. Our approach provides explicit notations （e.g., pointcut, advice and aspect） for capturing crosscutting concerns and incremental modification requirements with respect to class state models. For verification purposes, we compose the aspect models and class models in an aspect-oriented model through a weaving mechanism. Then we transform the woven models and the class models not affected by the aspects into FSP （Finite State Processes）, which are to be checked by the LTSA （Labeled Transition System Analyzer） model checker against the desired system properties. We have applied our approach to the modeling and verification of three aspect-oriented systems. To further evaluate the effectiveness of verification, we created a large number of flawed aspect models and verified them against the system requirements. The results show that the verification has revealed all flawed models. This indicates that our approach is effective in quality assurance of aspect-oriented state models. As such, our approach can be used for model-checking state-based specification of aspect-oriented design and can uncover some system design problems before the system is implemented.

MODELING METHOD FOR CROSSCUTTING CONCERNS IN CONCURRENT SOFTWARE SYSTEM

A method for modeling crosscutting concerns in the concurrent software system is presented based on the aspect-oriented（A-O） technique and the statechart of unified modeling language （UML）. Modeled with UML statechart diagrams, the primary system functions and corresponding traversal features are enveloped into various orthogonal regions of a composite state. The mutual relationships between orthogonal regions are implied by the orders of broadcast events. Using a modular transition system as a basic computational model, the formalization description of A-O statechart models is proposed. The precise semantics of model elements and modeling procedures is given. The example study indicates that the separation strategy of crosscutting concerns is implemented in the design phase of the concurrent software system with this method. Meanwhile, the software modeling method has advantages of loose coupling, adaptability and traceability.

基于Spring框架的Web Services系统整合与研究

Web Services通过集成第三方Web服务能够提高应用系统开发效率。但是传统的Web Services在开发中存在代码开发效率低、复用性差,而且可扩展性差。应用现在流行的轻量级Spring容器对Web Services进行系统整合,可大大提高开发效率,有效降低开发成本。

An AOP-Based Security Verification Environment for KECCAK Hash Algorithm

Robustness of the electronic cryptographic devices against fault injection attacks is a great concern to ensure security.Due to significant resource constraints,these devices are limited in their capabilities.The increasing complexity of cryptographic devices necessitates the development of a fast simulation environment capable of performing security tests against fault injection attacks.SystemC is a good choice for Electronic System Level(ESL)modeling since it enables models to run at a faster rate.To enable fault injection and detection inside a SystemC cryptographic model,however,the model’s source code must be updated.Without altering the source code,Aspect-Oriented Programming(AOP)may be used to evaluate the robustness of cryptographic models.This might replace conventional cryptanalysis methods in the real world.At the ESL,we discuss a unique technique for simulating security fault attacks on cryptographic systems.The current study presents a fault injection/detection environment for assessing the KECCAK SystemC model’s resistance against fault injection attacks.The approach of injecting faults into KECCAK SystemC model is accomplished via the use of weaving faults in AspectC++based on AOP programming language.We confirm our technique by applying it to two scenarios using a SystemC KECCAK hash algorithm case study:The first concerns discuss the effect of the AOP on fault detection capabilities,while the second concerns discuss the effect of the AOP on simulation time and executable file size.The simulation results demonstrate that this technique is fully capable of evaluating the fault injection resistance of a KECCAK design.They demonstrate that AOP has a negligible effect on simulation time and executable file size.

System Dependence Graph Construction for Aspect Oriented C++

This paper proposes an extended system dependence graph called AspectSDG to represent control and data dependences for AspeetC＋＋ programs, and presents an approach for the construction of AspectSDG. This approach decomposes aspect-oriented programs into three parts： component codes, aspect codes, and weaving codes. It constructs program dependence graphs （PDGs） for each part, and then connects the PDGs at call sites to form the complete AspectSDG. The AspectSDG can deal with advice precedence correctly, and represent the additional dependences caused by aspect codes. Based on this model, we introduce how to compute a static slice of an AspectC＋ ＋ program.

Approach of Separately Applying Unit Testing to AspectJ Program

A unit testing approach for AspectJ programs is proposed to separately test aspect units which have their own states. In the approach, aspects under test are converted to classes before execution of unit testing. In the conversion process, the context information passed through pointcut is transformed into advices, then the advices are converted to class member methods, and conflicts in the conversion result, if any, are resolved finally. The unit testing process consists of generating test cases, executing test cases and checking results.

Runtime Monitoring Composite Web Services Through Stateful Aspect Extension

The execution of composite Web services with WS-BPEL relies on externally autonomous Web services. This implies the need to constantly monitor the running behavior of the involved parties. Moreover, monitoring the execution of composite Web services for particular patterns is critical to enhance the reliability of the processes. In this paper, we propose an aspect-oriented framework as a solution to provide monitoring and recovery support for composite Web services. In particular, this framework includes 1） a stateful aspect based template, where history-based pointcut specifies patterns of interest cannot be violated within a range, while advice specifies the associated recovery action; 2） a tool support for runtime monitoring and recovery based on aspect-oriented execution environment. Our experiments indicate that the proposed monitoring approach incurs minimal overhead and is efficient.

A Script-Based Prototyping Framework to Boost Agile-UX Developments

Prototypes are described as a successful mechanism to incorporate user-experience design （UX） into Agile de- velopments, but their integration into such developments is not exempt from difficulties. Prototypes and final applications are often developed using different tools, which hinders the collaboration between designers and developers and also compli- cates reuse. Moreover, integrating stakeholders such as clients and users into the Agile process of designing, evaluating, and refining a prototype is not straightforward mainly because of its iterative nature. In an attempt to tackle these problems, this work presents the design and implementation of a new framework in which scripting languages are used to code prototyped behaviors. Prototyping is then treated as a separate aspect that coexists and runs together with final functionality. Using this framework communication is enhanced because designers and developers work in parallel on the same software artifact. Prototypes are fully reused and iteratively added with final functionality while prototyped behaviors are removed. They can be also modified on the fly to implement participatory design techniques.