An aspect-oriented programming-based approach to the development of software components for fault detection in automatic measurement systems is proposed. Faults are handled by means of specific software units, the &qu...
详细信息
An aspect-oriented programming-based approach to the development of software components for fault detection in automatic measurement systems is proposed. Faults are handled by means of specific software units, the "aspects", in order to better modularize issues transversal to several components. As a case study, this approach was applied to the design of the fault detection software inside a flexible framework for magnetic measurements, developed at the European Organization for Nuclear Research (CERN). Experimental results of software modularity and performance measurements for comparing aspect- and objectoriented solutions in rotating coils tests on superconducting magnets are reported. (C) 2009 Elsevier B.V. All rights reserved.
aspect-oriented programming (AOP) is a maturing technique that requires a good comprehension of which types of mistakes programmers make during the development of applications. Unfortunately, the lack of such knowledg...
详细信息
aspect-oriented programming (AOP) is a maturing technique that requires a good comprehension of which types of mistakes programmers make during the development of applications. Unfortunately, the lack of such knowledge seems to represent one of the reasons for the cautious adoption of AOP in real software development projects. This paper reports on the results of a series of experiments whose main goal is to analyze and catalogue code pitfalls that are likely to lead programmers to make mistakes in AOP refactoring. Each experiment consists of a task that requires the aspectization of a crosscutting concern in one object-oriented application. Eight rounds of the experiment provided us with data of 98 AOP implementations from four crosscutting concerns in four different applications. Each participant of the experiment produced one implementation. Based on the analysis of these implementations, we (i) document six categories of recurring mistakes made by programmers, (ii) correlate these mistakes with the programmer expertise in object-orientedprogramming, years of software development, and pair programming, and (iii) derive a catalogue of code pitfalls which are likely to lead programmers to make the documented mistakes. We apply significance tests in order to statistically evaluate our results. We also present a prototype tool to warn programmers of the code pitfalls during refactoring activities. (C) 2016 Elsevier B.V. All rights reserved.
Rapid system modelling and early evaluation of design characterisation are central to design space exploration. SystemC is used widely for system-level modelling, but it lacks the semantics to capture power consumptio...
详细信息
Rapid system modelling and early evaluation of design characterisation are central to design space exploration. SystemC is used widely for system-level modelling, but it lacks the semantics to capture power consumption. The article presents a novel high-level power estimation methodology based on SystemC and aspect-oriented programming (AOP). Using a composite pattern, our methodology is applicable to the power estimation of a complex system. The proposed strategies support macro-models with multiple features. The experimental results are illustrated with case studies.
The development of applications for high-performance embedded systems is a long and error-prone process because in addition to the required functionality, developers must consider various and often conflicting nonfunc...
详细信息
The development of applications for high-performance embedded systems is a long and error-prone process because in addition to the required functionality, developers must consider various and often conflicting nonfunctional requirements such as performance and/or energy efficiency. The complexity of this process is further exacerbated by the multitude of target architectures and mapping tools. This article describes LARA, an aspect-oriented programming language that allows programmers to convey domain-specific knowledge and nonfunctional requirements to a toolchain composed of source-to-source transformers, compiler optimizers, and mapping/synthesis tools. LARA is sufficiently flexible to target different tools and host languages while also allowing the specification of compilation strategies to enable efficient generation of software code and hardware cores (using hardware description languages) for hybrid target architectures - a unique feature to the best of our knowledge not found in any other aspect-oriented programming language. A key feature of LARA is its ability to deal with different models of join points, actions, and attributes. In this article, we describe the LARA approach and evaluate its impact on code instrumentation and analysis and on selecting critical code sections to be migrated to hardware accelerators for two embedded applications from industry. Copyright (c) 2014 John Wiley & Sons, Ltd.
Extensible programming languages and their compilers are experimental systems that use highly modular specifications of languages and language extensions in order to allow a variety of language features to be easily i...
详细信息
Extensible programming languages and their compilers are experimental systems that use highly modular specifications of languages and language extensions in order to allow a variety of language features to be easily imported, by the programmer, into his or her programming environment. Our framework for extensible languages is based on higher-order attribute grammars extended with a mechanism called "forwarding" that mimics a simple rewriting process. Forwarding is designed such that no additional attribute definitions need to be written when combining a "host" language with language extensions (specified as attribute grammars), thus allowing for the modular composition of language features. This means that programmers can remain unaware of the underlying attribute grammars when building customized languages by importing language extensions. This paper shows how aspects and the aspect weaving process from aspect-oriented programming can be specified as a modular language extension and imported into an extensible host language. This paper also illustrates how an extensible compiler framework exposes its underlying semantic analyses and how this can provide a convenient arena in which researchers can explore new aspect-oriented language features. (c) 2007 Elsevier B.V. All rights reserved.
Threat evaluation is a vital process for any defense system, and it consists of a series of calculation and evaluation based on the inferred capabilities and intents of the targets that aim to give damage to defended ...
详细信息
Threat evaluation is a vital process for any defense system, and it consists of a series of calculation and evaluation based on the inferred capabilities and intents of the targets that aim to give damage to defended assets. Target evaluation is proceeded in a wargame and the aim is to compare weapon target pairs according to a set of criteria. The target evaluation cycle is repeated anytime a new detection is received and when any change happens in the target currently detected. The whole process consists of a set of tasks that are shared between Command and Control units and the tasks require different responsibilities. Each task is succeeded by a specific behavior that is represented as a reasonably ordered set of actions. The task sharing is organized by taking the C2 architectures into account. In this paper, an agent-based command and control entity, which is in charge of target evaluation and giving engagement decision, is designed and it is situated in an air defense simulation environment. The study aims to propose an agent design in military decision-making domain, bringing analytic methods with the first-order logic together, and combine aspect orientation with agent design. The study also improves dynamic aspect management in agent programming using the relation concept.
aspect-oriented programming (AOP), which allows for modularizing concerns that normally cause crosscutting in object oriented (OO) systems, has effectively solved the problem that the Object-orientedprogramming (OOP)...
详细信息
ISBN:
(纸本)9780769535579
aspect-oriented programming (AOP), which allows for modularizing concerns that normally cause crosscutting in object oriented (OO) systems, has effectively solved the problem that the Object-orientedprogramming (OOP) has encountered such as the scattered codes and tangled codes resulting from the cross-cutting concerns. At present, the AOP paradigm has expanded to all the lifecycle of the software development, as a result, aspect-oriented Software Development (AOSD) is becoming a new technique, which has an important step of modeling the aspects. Modeling aspects is a hot topic these days, however, there is no uniform modeling technique to support this new method. Since the Unified Modeling Language (UML) is an extensible modeling language to facilitate domain specific modeling. At this paper, we use the extension mechanisms provided by the UML to model the aspects of a system to improve the stations of AOP in the software development.
In aspect-oriented programming (AOP) languages, advice evaluation is usually considered as part of the base program evaluation. This is also the case for certain pointcuts, such as if pointcuts in aspectJ, or simply a...
详细信息
In aspect-oriented programming (AOP) languages, advice evaluation is usually considered as part of the base program evaluation. This is also the case for certain pointcuts, such as if pointcuts in aspectJ, or simply all pointcuts in higher-order aspect languages like aspectScheme. While viewing aspects as part of base level computation clearly distinguishes AOP from reflection, it also comes at a price: because aspects observe base level computation, evaluating pointcuts and advice at the base level can trigger infinite regression. To avoid these pitfalls, aspect languages propose ad-hoc mechanisms, which increase the complexity for programmers while being insufficient in many cases. After shedding light on the many facets of the issue, this paper proposes to clarify the situation by introducing levels of execution in the programming language, thereby allowing aspects to observe and run at specific, possibly different, levels. We adopt a defensive default that avoids infinite regression, and gives advanced programmers the means to override this default using level-shifting operators. We then study execution levels both in practice and in theory. First, we study the relevance of the issues addressed by execution levels in existing aspect-oriented programs. We then formalize the semantics of execution levels and prove that the default semantics is indeed free of a certain form of infinite regression, which we call aspect loops. Finally, we report on existing implementations of execution levels for aspect-oriented extensions of Scheme, JavaScript and Java, discussing their implementation techniques and current applications. (C) 2013 Elsevier B.V. All rights reserved.
The languages defined by the standard IEC 6-1131 for Programmable Logic Controllers (PLCs), have both benefits and drawbacks compared to object-orientedprogramming languages. For example, the current programming appr...
详细信息
The languages defined by the standard IEC 6-1131 for Programmable Logic Controllers (PLCs), have both benefits and drawbacks compared to object-orientedprogramming languages. For example, the current programming approach is good for maintaining the system, since it is easy to program and comprehend for a plant floor personal with limited programming experience. The main drawbacks are reusability, code dependability and flexibility. This paper proposes an aspect-oriented programming (AOP) approach as an alternative solution, which can keep the benefits and eliminate the drawbacks. AOP is an emerging programming methodology in computer science, which helps the programmer by separating different crosscutting concerns in the program. These crosscutting concerns and tangled behavior are especially important issues in PLC programming, which makes AOP a suitable approach. The paper describes how to adapt the AOP methodology into PLC program development and how it can benefit the control design process.
An aspect-oriented programming (AOP) based approach is proposed to perform context-aware service composition on the fly. It realises context-aware composition by semantically weaving context into Web service compositi...
详细信息
An aspect-oriented programming (AOP) based approach is proposed to perform context-aware service composition on the fly. It realises context-aware composition by semantically weaving context into Web service composition. The context weaver algorithm is implemented and illustrated. The proposed semantic weaving allows Web services to be composed as the context changes. (C) 2010 Elsevier B.V. All rights reserved.
暂无评论