基于AOP的跨平台自适配安全构件的研究

为解决传统的安全解决方案移植性和适配性差的问题,提出一种既能运行在不同的系统平台,又能根据系统平台特性以及用户需求在运行时动态自适配的安全构件.论述如何将安全构件划分为构件与方面,如何利用AspectLua脚本语言描述构件与方面的编织关系.安全构件应用了面向方面及面向构件等技术,在"和欣"网络操作系统下开发.     

“和欣”操作系统下建立SCI编程环境的探讨*

脚本语言可以通过“黏合”构件模块形成新的应用程序。通过分析“和欣”操作系统和CAR构件编程模型对面向构件编程的支持,提出了基于CAR构件系统的脚本语言通用适配层SCI,探讨了一种脚本语言与CAR构件自动适配的技术,以实现基于CAR构件的脚本动态编程。结合CAR构件技术与脚本语言,提高应用程序的模块化程度,加速应用程序的开发过程。     

方面化中间件平台全息视图语言——HVL4DCAM*

为满足方面化双核中间件平台DCAM面向按需计算的自适应需求,并支持系统平台的实时重构为目的的中间件计算环境,通过分析现有面向方面体系结构描述语言,提出了一种基于XML的中间件平台全息视图语言——HVL4DCAM。HVL4DCAM可以实时解析运行于平台之上的构件和方面的状态以及它们之间的动态关系,实现了构件和方面的对称性描述,提升方面的可重用性。基于HVL4DCAM描述了运行于DCAM之上的绩效考核系统中的构件及方面的关系,以及它们与DCAM平台的关系,并给出了进一步研究的内容。     

一种基于日志的增量式编织机制

编织效率会严重影响面向方面编程的性能。针对上述情况,将按需编织和编织历史机制相结合,提出一种基于日志的增量式编织机制。使用索引日志、编织历史日志和系统日志3种日志文件,通过改变方面存储结构,定量描述方面状态,计算方面状态改变量,由此实现效率更高的增量式编织。     

动态增量式AOP框架的研究与实现

在研究AOP原理的基础上,提出一种面向aspect的编程框架AODF,采用基于日志技术的增量式编织机制,不仅提高了编织效率,而且基于Bigraph理论的AODF支持方面的动态演化,实现了行为的一致性与相容性。另外,AODF从语言层提供对方面的支持,无需改动语言本身任何结构及特性,而且可以把自行编制的aspect配置为标准组件入库,实现方面的重用。从而使得遗留系统无需变更就可以获得面向方面的扩展。     

基于CAR构件的面向方面编程聚合模型的研究

通过识别、封装和集成不同种类的关注点来构件系统，从而提高系统的适应性、可维护性和重用性。面向方面编程（AOP）技术是目前较好的分离关注点的编程范式。基于CAR构件系统，提出了AOP的动态聚合模型及其实现。与其他系统的静态聚合方法相比，动态聚合所具有的随时聚合、随时拆卸的特点更加有效的提高了系统的适应性和重用性。     

基于Petri网的图标编程系统

为了描述图标间的相互作用和它们的动态行为，作者提出了一个基于Ｐｅｔｒｉ网的图标编程系统。本文首先给出了四类基本图标的形式定义；接着，讨论了该系统各构件的功能并设计了网分析图的生成算法；最后，结合例子说明图标库、知识库、语法库、动态运行库等系统构件在图标编程阶段、可执行代码生成及运行阶段的协同工作过程。该系统原型在ＳＧＩ图形工作站ＵＮＩＸ环境中的运行试验表明：与时态逻辑相比，无论在编程阶段还是程序运     

基于AOP和Web服务的多层分布式系统

把面向方面编程的思想引入到Web服务中,将其横切关注点(日志、事务、权限认证等)实现为方面服务,在系统执行时用编织器在SOAP消息层编织Web服务和方面服务来构建最终系统,并结合面向服务软件体系结构和J2EE的多层架构提出一个基于方面服务和Web服务的软件架构。给出一个应用该软件架构的实例。     

基于类修改和反射的动态方面编织模型

方面编织是系统关注点编织的实现部分,其优劣关系着面向方面软件系统的执行效率、编织粒度、模块化程度。依据方面化构件组装以及按需计算中间件平台需求,提出一种动态方面编织模型——DAWeaver,该模型利用BCEL修改类文件,通过方面容器反射调用方面组件,支持了编织的动态性。最后,给出该模型的原型系统,并对已编织系统作了性能分析。     

基于方面构件模型及其组装与实现

将面向方面编程技术融入传统的基于构件开发方法,提出了一种基于方面的构件模型.同时探讨了基于方面构件的组装策略以及利用XML语言描述组装、编织方面化构件的处理逻辑.新的构件模型采用更加模块化的构件实现方式,从传统构件模型中提取出方面元素,很好地解决了传统的基于构件开发方法中构件间关注点横切所导致系统混乱的问题,提高了构件的可复用性以及软件的开发效率.     

Comprehensive aspect weaving for Java

Aspect-oriented programming (AOP) has been successfully applied to application code thanks to techniques such as Java bytecode instrumentation. Unfortunately, with existing AOP frameworks for Java such as AspectJ, aspects cannot be woven into the standard Java class library. This restriction is particularly unfortunate for aspects that would benefit from comprehensive aspect weaving with complete method coverage, such as profiling or debugging aspects. In this article we present MAJOR, a new tool for comprehensive aspect weaving, which ensures that aspects are woven into all classes loaded in a Java Virtual Machine, including those in the standard Java class library. MAJOR includes the pluggable module CARAJillo, which supports efficient access to a complete and customizable calling context representation. We validate our approach with three case studies. Firstly, we weave existing profiling aspects with MAJOR which otherwise would generate incomplete profiles. Secondly, we introduce an aspect for memory leak detection that also benefits from comprehensive weaving. Thirdly, we present an aspect subsuming the functionality of ReCrash, an existing tool based on low-level bytecode instrumentation techniques that generates unit tests to reproduce program failures. Our aspect-based tools are concisely implemented in a few lines of code, and leverage MAJOR and CARAJillo for comprehensive aspect weaving and for efficient access to calling context information.     

Blending design patterns with aspects: A quantitative study

Design patterns often need to be blended (or composed) when they are instantiated in a software system. The composition of design patterns consists of assigning multiple pattern elements into overlapping sets of classes in a software system. Whenever the modularity of each design pattern is not preserved in the source code, their implementation becomes tangled with each other and with the classes’ core responsibilities. As a consequence, the change or removal of each design pattern will be costly or prohibitive as the software system evolves. In fact, composing design patterns is much harder than instantiating them in an isolated manner. Previous studies have found design pattern implementations are naturally crosscutting in object-oriented systems, thereby making it difficult to modularly compose them. Therefore, aspect-oriented programming (AOP) has been pointed out as a natural alternative for modularizing and blending design patterns. However, there is little empirical knowledge on how AOP models influence the composability of widely used design patterns. This paper investigates the influence of using AOP models for composing the Gang-of-Four design patterns. Our study categorizes different forms of pattern composition and studies the benefits and drawbacks of AOP in these contexts. We performed assessments of several pair-wise compositions taken from 3 medium-sized systems implemented in Java and two AOP models, namely, AspectJ and Compose*. We also considered complex situations where more than two patterns involved in each composition, and the patterns were interacting with other aspects implementing other crosscutting concerns of the system. In general, we observed two dominant factors impacting the pattern composability with AOP: (i) the category of the pattern composition, and (ii) the AspectJ idioms used to implement the design patterns taking part in the composition.     

Online reconfiguration of component-based applications in PacoSuite

In this paper, we present an original approach for enabling online reconfiguration of component-based applications. This research fits into our component composition methodology PacoSuite, that makes use of explicit connectors between components, called composition patterns. Both components and composition patterns are documented by making use of a special kind of MSC. We propose an algorithm to check whether a new component can fulfill the role of an old component in a given composition pattern, without the need to revalidate the entire composition all over again. To enable online reconfiguration, we extend the documentation of a component with a new primitive that specifies when a component reaches a safe state. This approach enables to swap a component at run-time, while maintaining a consistent application.     

Safe Composition of Linda-based Components

Component-Based Software Development is an emerging discipline in the field of Software Engineering. When constructing component-based systems, we must be sure that the cooperative behaviour of the components and their interaction will be successful. In this paper, we use Linda to specify the interactive behaviour of software components. To do this, we first introduce a process algebra for Linda, and then we define a compatibility relation providing conditions that ensure safe composition. This relation takes into account the state of a shared tuple space which represents the current execution. Indeed, a Linda-based computation is characterized by the store's evolution, so that the set of tuples included into the store governs each computation step. In this context, the success of the composition of a pair of agents in presence of a suitable store can be useful to condition the acceptance of a given component into an open running system. In order to extend our approach to complex systems, where constructing a system involves more than two components, we propose the use of distributed tuple spaces as the glue to join components.     

Flexible and efficient profiling with aspect‐oriented programming

Many profilers for virtual execution environments, such as the Java virtual machine (JVM), are implemented with low‐level bytecode instrumentation techniques, which is tedious, error‐prone, and complicates maintenance and extension of the tools. In order to reduce the development time and cost, we promote building profilers for the JVM using high‐level aspect‐oriented programming (AOP). We show that the use of aspects yields concise profilers that are easy to develop, extend, and maintain, because low‐level instrumentation details are hidden from the tool developer. In order to build efficient profilers, we introduce inter‐advice communication, an extension to common AOP languages that enables efficient data passing between advices that are woven into the same method using local variables. We illustrate our approach with two case studies. First, we show that an existing, instrumentation‐based tool for listener latency profiling can be easily recast as an aspect. Second, we present an aspect for comprehensive calling context profiling. In order to reduce profiling overhead, our aspect parallelizes application execution and profile creation, resulting in a speedup of 110% on a machine with more than two cores, compared with a primitive, non‐parallel approach. Copyright © 2011 John Wiley & Sons, Ltd.     

Model and algorithm for efficient verification of high-assurance properties of real-time systems

In this paper, we present a new compositional verification methodology for efficiently verifying high-assurance properties such as reachability and deadlock freedom of real-time systems. In this methodology, each component of real-time systems is initially specified as a timed automaton and it communicates with other components via synchronous and/or asynchronous communication channels. Then, each component is analyzed by a generation of its state-space graph which is formalized as a new state-space representation model called Multiset Labeled Transition Systems (MLTSs). Afterward, the state spaces of the components are hierarchically composed and simplified through a composition algorithm and a set of condensation rules, respectively, to get a condensed state space of the system. The simplified state spaces preserve equivalence with respect to deadlock and reachable states. Such equivalence is assured by our reduction theories called IOT-failure equivalence and IOT-state equivalence. To show the performance of our methodology, we developed a verification tool RT-IOTA and carried out experiments on some benchmarks such as CSMA/CD protocol, a rail-road crossing, an alternating bit-protocol, etc. Specifically, we look at the time taken to generate the statespace, the size of the state space, and the amount of reduction achieved by our condensation rules. The results demonstrate the strength of our new technique in dealing with the state-explosion problem.     

Tactical contract composition for hybrid system component verification

We present an approach for hybrid systems that combines the advantages of component-based modeling (e.g., reduced model complexity) with the advantages of formal verification (e.g., guaranteed contract compliance). Component-based modeling can be used to split large models into multiple component models with local responsibilities to reduce modeling complexity. Yet, this only helps the analysis if verification proceeds one component at a time. In order to benefit from the decomposition of a system into components for both modeling and verification purposes, we prove that the safety of compatible components implies safety of the composed system. We implement our composition theorem as a tactic in the KeYmaera X theorem prover, allowing automatic generation of a KeYmaera X proof for the composite system from proofs for the components without soundness-critical changes to KeYmaera X. Our approach supports component contracts (i.e., input assumptions and output guarantees for each component) that characterize the magnitude and rate of change of values exchanged between components. These contracts can take into account what has changed between two components in a given amount of time since the last exchange of information.     

Using aspect orientation in legacy environments for reverse engineering using dynamic analysis—An industrial experience report

This paper reports on the challenges of using aspect-oriented programming (AOP) to aid in re-engineering a legacy C application. More specifically, we describe how AOP helps in the important reverse engineering step which typically precedes a re-engineering effort. We first present a comparison of the available AOP tools for legacy C code bases, and then argue on our choice of Aspicere, our own AOP implementation for C. Then, we report on Aspicere’s application in reverse engineering a legacy industrial software system and we show how we apply a dynamic analysis to regain insight into the system. AOP is used for instrumenting the system and for gathering the data. This approach works and is conceptually very clean, but comes with a major quid pro quo: integration of AOP tools with the build system proves an important issue. This leads to the question of how to reconcile the notion of modular reasoning within traditional build systems with a programming paradigm which breaks this notion.