This paper proposes language concepts that facilitate the separation of an application into independent reusable building blocks and the integration of pre-build generic software components into applications that have...
详细信息
This paper proposes language concepts that facilitate the separation of an application into independent reusable building blocks and the integration of pre-build generic software components into applications that have been developed by third party vendors. A key element of our approach arc on-demand remodularizations, meaning that the abstractions and vocabulary of an existing code base are translated into the vocabulary understood by a set of components that are connected by a common collaboration interface. This general concept allows us to mix-and-match remodularizations and components on demand.
Many crosscutting mechanisms proposed in the literature offer means to restrain aspects to some dynamically-defined scopes. Dynamically-scoped mechanisms are particularly interesting because of the flexibility, expres...
详细信息
Many crosscutting mechanisms proposed in the literature offer means to restrain aspects to some dynamically-defined scopes. Dynamically-scoped mechanisms are particularly interesting because of the flexibility, expressiveness, and control they give over structural and behavioral changes made by aspects. Since the nature of dynamic scopes as well as the scoping mechanisms themselves greatly vary among proposals, it is relatively complex to compare them. This paper aims at filling this gap by proposing a first characterization of dynamically-scoped crosscutting mechanisms, hence providing a reference frame for comparing different approaches. As a result, this work clarifies some differences between related approaches, suggests possible tracks for further exploration of the design space of such mechanisms, and discusses some issues raised by dynamically-scoped aspects.
This paper presents a model-driven methodology and tool for Embedded Control System (ECS) design. This methodology defines a common metamodel that unifies the design steps and ensures the consistency of models along t...
详细信息
This paper presents a model-driven methodology and tool for Embedded Control System (ECS) design. This methodology defines a common metamodel that unifies the design steps and ensures the consistency of models along the design cycle. It uses an approach based, in one side, on the software components that increase models reusability to face the increasing complexity of ECS; in the other side, on the aspect-oriented paradigm that allows to model transversal real time properties to support models analysis and validation in the earliest steps of the design cycle. Our methodology supports the control and scheduling co-design in order to evaluate the performance and stability of ECS during their design. A tool called MoDEST implements this methodology and provides real-time code generation. It should help designers to choose the best scheduling that preserves the control performance and quality of the designed ECS.
Today's World Wide Web provides the basis for demanding distributed services, such as online-banking, travel reservation, and stock trading - which require high predictability and quality-of-service properties suc...
详细信息
Today's World Wide Web provides the basis for demanding distributed services, such as online-banking, travel reservation, and stock trading - which require high predictability and quality-of-service properties such as security, end-to-end availability, dependability, and real time. The Common Object Request Broker Architecture (CORBA) is a widely-accepted, standardized open system integration framework based on distributed object technologies, which - among others - has been successfully used for implementation of open Web services. CORBA does not explicitly address quality-of-service parameters neither for its communication links nor its end systems. However efforts like the Real-Time CORBA Special interest Group (SIG) at OMG and the "pluggable protocols" proposal will ultimately lead to support of quality-of-service properties for CORBA communication links. Within this paper we are concentrating on design patterns and architectural approaches for fault-tolerant, highly available end systems. Any fault tolerance extension for CORBA components needs to trade off data abstraction and encapsulation against implementation specific knowledge about a component's internal timing behavior, resource usage and interaction patterns. These nan-functional aspects of a component are crucial for the predictable behavior of fault-tolerance mechanisms. However, in contrast to CORBA's interface definition language (IDL), which describes a component's functional interface, there is no general means to describe a component's non-functional properties. We propose the usage of aspect descriptions based on the extended Markup Language (XML) for that purpose. We describe the automatic generation of reliable CORBA services based on aspect information. Our approach relies on a number of building blocks, which provide solutions for service replication, for supervision of a service, for online replacement and for call admission and timely execution. We discuss our implementation of the "Obser
We propose an aspect-oriented programming (AOP) language called aspectual Caml based on a strongly-typed functional language Objective Caml with two AOP mechanisms similar to those in aspectJ language. This paper desc...
详细信息
We propose an aspect-oriented programming (AOP) language called aspectual Caml based on a strongly-typed functional language Objective Caml with two AOP mechanisms similar to those in aspectJ language. This paper describes the design and implementation issues of those AOP mechanisms that give us insights into the interaction between AOP features and common features in strongly-typed functional languages such as type inference, polymorphic types and curried functions. We implemented a prototype compiler of the language and used the language for separating crosscutting concerns in application programs, including for separating descriptions of a type system from compiler descriptions.
The existing techniques for software testing can be used to perform only a particular type of testing, and moreover proficiency is required to write the automation test scripts using these techniques. This paper propo...
详细信息
The existing techniques for software testing can be used to perform only a particular type of testing, and moreover proficiency is required to write the automation test scripts using these techniques. This paper proposes a novel software testing approach using aspect-oriented programming (AOP) that alone suffices for carrying out most of the types of software testing and thus obliterates the need of using distinctive tools for different types of testing. Nevertheless, AOP is a new programming paradigm and not all testers have the proficiency of working with it. Hence, a domain-specific language named Testing aspect Generator Language (TAGL) was developed which has got a very low learning curve. Using TAGL, testers can write the testing code in the form of natural language-like statements. Further, the lexical analyzer and parser, written using lex and yacc, convert the TAGL statements into actual testing code in the form of AOP. The proposed approach was applied for the testing of widely used open source projects and remarkable bugs were detected into them. A detailed comparison as to how our approach is effective than the conventional testing techniques is provided.
The emergence of aspect-oriented programming (AOP) languages has provided software designers with new mechanisms and strategies for decomposing programs into modules and composing modules into systems. What we do not ...
详细信息
The emergence of aspect-oriented programming (AOP) languages has provided software designers with new mechanisms and strategies for decomposing programs into modules and composing modules into systems. What we do not yet fully understand is how best to use such mechanisms consistent with common modularization objectives such as the comprehensibility of programming code, its parallel development, dependability, and ease of change. The main contribution of this work is a new form of information-hiding interface for AOP that we call the crosscut programming interface, or XPI. XPIs abstract crosscutting behaviors and make these abstractions explicit. XPIs can be used, albeit with limited enforcement of interface rules, with existing AOP languages, such as aspectJ. To evaluate our notion of XPIs, we have applied our XPI-based design methodology to a medium-sized network overlay application called Hypercast. A qualitative and quantitative analysis of existing AO design methods and XPI-based design method shows that our approach produces improvements in program comprehensibility, in opportunities for parallel development, and in the ease when code can be developed and changed.
aspect-oriented programming (AOP) is increasingly gaining in popularity. However, the focus of aspect-oriented language research has been mostly on language design issues;efficient implementation techniques have been ...
详细信息
aspect-oriented programming (AOP) is increasingly gaining in popularity. However, the focus of aspect-oriented language research has been mostly on language design issues;efficient implementation techniques have been less popular. As a result, the performance of certain AOP constructs is still poor. This is in particular true for constructs that rely on dynamic properties of the execution (e. g., the cflow construct). In this paper, we present efficient implementation techniques for cflow that exploit direct access to internal structures of the virtual machine running an application, such as the call stack, as well as the integration of these techniques into the just-in-time compiler code generation process. Our results show that AOP has the potential to make programs that need to de. ne control flow-dependent behavior not only more modular but also more efficient. By making means for control flow-dependent behavior part of the language, AOP opens the possibility of applying sophisticated compiler optimizations that are out of reach for application programmers.
Asynchronous programming has been widely adopted in domains such as Web development. This programming style usually uses callback methods, non-blocking operations, allowing high responsive user interactions even if an...
详细信息
Asynchronous programming has been widely adopted in domains such as Web development. This programming style usually uses callback methods, non-blocking operations, allowing high responsive user interactions even if an application works without multi-threading. However, this style requires the uncoupling of a module into two sub-modules at least, which are not intuitively connected by a callback method. The separation of modules spurs the birth of other issues: callback spaghetti and callback hell. This paper proposes a virtual block approach to address the previous two issues. This approach enables a programmer to virtually block a program execution and restart it at arbitrary points in the program. As a result, programmers do not need to uncouple a module even if non-blocking operations are adopted;therefore, callback dependencies disappear. Using aspect-oriented programming, this approach uses aspects to control the execution of a program in an oblivious manner. As a consequence, programmers do not need to be concerned whether pieces of code use blocking or non-blocking operations. We implement a proof-of-concept for this approach, called SyncAS, for Action-Script3. In addition, we apply our proposal to a toy application and conduct experiments to show its modular application, flexibility, and performance.
aspect-oriented programming (AOP) has produced interesting language designs, but also ad hoc semantics that needs clarification. We contribute to this clarification with a calculus that models essential AOP, both simp...
详细信息
aspect-oriented programming (AOP) has produced interesting language designs, but also ad hoc semantics that needs clarification. We contribute to this clarification with a calculus that models essential AOP, both simpler and more general than existing formalizations. In AOP, advice may intercept method invocations, and proceed executes the suspended call. Proceed is an ad hoc mechanism, only usable inside advice bodies. Many pointcut mechanisms, for example, wildcards, also lack regularity. We model proceed using first-class closures, and shift complexity from pointcuts to ordinary object-oriented code. Two well-known pointcut categories, call and execution, are commonly considered similar. We formally expose their differences, and resolve the associated soundness problem. Our calculus includes type ranges, an intuitive and concise alternative to explicit type variables that allows advice to be polymorphic over intercepted methods. We use calculus parameters to cover type safety for a wide design space of other features. Type soundness is verified in Coq.
暂无评论