Dataflow languages provide natural support for specifying constraints between objects in dynamic applications, where programs need to react efficiently to changes of their environment. Researchers have long investigat...
详细信息
Dataflow languages provide natural support for specifying constraints between objects in dynamic applications, where programs need to react efficiently to changes of their environment. Researchers have long investigated how to take advantage of dataflow constraints by embedding them into procedural languages. Previous mixed imperative/dataflow systems, however, require syntactic extensions or libraries of ad hoc data types for binding the imperative program to the dataflow solver. In this paper we propose a novel approach that smoothly combines the two paradigms without placing undue burden on the programmer. In our framework, programmers can define ordinary statements of the imperative host language that enforce constraints between objects stored in special memory locations designated as "reactive". Differently from previous approaches, reactive objects can be of any legal type in the host language, including primitive data types, pointers, arrays, and structures. Statements defining constraints are automatically re-executed every time their input memory locations change, letting a program behave like a spreadsheet where the values of some variables depend upon the values of other variables. The constraint solving mechanism is handled transparently by altering the semantics of elementary operations of the host language for reading and modifying objects. We provide a formal semantics and describe a concrete embodiment of our technique into C/C++, showing how to implement it efficiently in conventional platforms using off-the-shelf compilers. We discuss common coding idioms and relevant applications to reactive scenarios, including incremental computation, observer design pattern, and data structure repair. The performance of our implementation is compared to ad hoc problem-specific change propagation algorithms, as well as to language-centric approaches such as self-adjusting computation and subject/observer communication mechanisms, showing that the proposed approa
The proceedings contain 27 papers. The topics discussed include: AspectLTL: an aspect language for LTL specifications;from aspect-oriented requirements models to aspect-oriented business process design models: an iter...
ISBN:
(纸本)9781450305563
The proceedings contain 27 papers. The topics discussed include: AspectLTL: an aspect language for LTL specifications;from aspect-oriented requirements models to aspect-oriented business process design models: an iterative and concern-driven approach for software engineering;compositional type-checking for delta-oriented programming;on the impact of crosscutting concern projection on code measurement;aspect-based dynamic software updating: a model and its empirical evaluation;translucid contracts: expressive specification and modular verification for aspect-oriented interfaces;an aspect-oriented approach for implementing evolutionary computation applications;an exploratory study of code smells in evolving aspect-oriented systems;putting events in context: aspects for event-based distributed programming;making aspects natural: events and composition;and modularity for the changing meaning of changing.
Developing 3D virtual environments requires an advanced level of programming expertise. In many cases, working on such an application involves a wide range of programming activities such as 3D graphics, networking, us...
详细信息
ISBN:
(纸本)9780769544670
Developing 3D virtual environments requires an advanced level of programming expertise. In many cases, working on such an application involves a wide range of programming activities such as 3D graphics, networking, user interfaces and audio programming. At the same time, such applications are usually real time and performance critical. The complexity of developing such an application comes from two sources: first, the programminglanguage used in development with its strengths and also the limitations it imposes. The second is the requirements of the virtual environment itself, with its dynamics and size. Some languages are more suitable than others for any given application domain, but in general once a programminglanguage is selected, the main focus is the application itself and not the language used. This paper presents an approach where a virtual environment (CVE) and its implementationlanguage (Unicon) evolved together over the course of the project development, derived from emerging functional and performance requirements. The Unicon language was improved and new features were added over time to meet new demands and address the complexities that arose at the application level. This approach was combined with developing a framework to build virtual worlds with a social integrated development environment and to populate those worlds with non-player characters.
The proceedings contain 25 papers. The topics discussed include: experiences documenting and preserving software constraints using aspects;ASystemC: an AOP extension for hardware description language;using aspect-orie...
ISBN:
(纸本)9781450305563
The proceedings contain 25 papers. The topics discussed include: experiences documenting and preserving software constraints using aspects;ASystemC: an AOP extension for hardware description language;using aspect-orientation to simplify concurrent programming;flexible, dynamic injection of structured advice using Byteman;the theory and practice of modern modeling languagedesign for model-based software engineering;rulemakers and toolmakers: adaptive object-models as an agile division of labor: ultimate agility: let your users do your work!;the aspect-oriented user requirements notation: aspects, goals, and scenarios;analyzing architectural conformance of layered aspect-oriented systems with ArchE Meter;Hist-Inspect: a tool for history-sensitive detection of code smells;GenArch+: an extensible infrastructure for building framework-based software product lines;and revealing architecturally-relevant flaws in aspectual decompositions.
Event-based programming is an appealing paradigm for developing pervasive systems since events enable the decoupling of interacting components. Unfortunately, many event-based languages and systems have hardwired noti...
详细信息
ISBN:
(纸本)9781450305563
Event-based programming is an appealing paradigm for developing pervasive systems since events enable the decoupling of interacting components. Unfortunately, many event-based languages and systems have hardwired notions of physical or logical time and space. This limits their adaptability and target deployment environments, as pervasive systems rely on inherent interaction and interchanging of different protocols and infrastructures. This paper introduces domain-specific aspects for capturing event context, generalizing beyond the classic time and space dimensions associated with events. Through examples, we demonstrate that our context aspects - conspects for short - modularize the design and implementation of event contexts, enabling code reuse, and making programs portable across infrastructures. We illustrate the benefits of conspects by using them to transparently switch protocols in two pervasive software suites implemented in EventJava: (1) a tornado monitoring system deployed on different architectures ranging from desktop x86 to embedded LEON3, and (2) a mobile social networking suite with protocols for different application scenarios.
The domain of operating systems has often been mentioned as an "ideal candidate" for the application of AOP;fundamental policies we find in these systems, such as synchronization or preemption, seem to be in...
详细信息
ISBN:
(纸本)9781450305563
The domain of operating systems has often been mentioned as an "ideal candidate" for the application of AOP;fundamental policies we find in these systems, such as synchronization or preemption, seem to be inherently cross-cutting in their implementation. Their clear separation into dedicated aspect modules should facilitate better evolvability and - the focus of this paper - configurability. Our experience with applying AOP to the domain of highly configurable embedded operating systems has shown, however, that these advantages can by no means be taken for granted. To reveal maximum configurability of central system policies, aspects and their potential interactions with the system have to be taken into account much earlier, that is, "from the very beginning". We propose the analysis and design process of aspect-aware development, which leads to such an "aspect- friendly" system structure and demonstrate its feasibility on the example of CiAO, an AUTOSAR-OS-compliant operating system that provides configurability of all fundamental system policies by means of AOP.
A software architecture describes the structure of a computing system by specifying software components and their interactions. Mapping a software architecture to an implementation is a well known challenge. A key ele...
详细信息
ISBN:
(纸本)9781450304450
A software architecture describes the structure of a computing system by specifying software components and their interactions. Mapping a software architecture to an implementation is a well known challenge. A key element of this mapping is the architecture's description of the data and control-flow interactions between components. The characterization of these interactions can be rather abstract or very concrete, providing more or less implementation guidance, programming support, and static verification. In this paper, we explore one point in the design space between abstract and concrete component interaction specifications. We introduce a notion of interaction contract that expresses allowed interactions between components, describing both data and control-flow constraints. This declaration is part of the architecture description, allows generation of extensive programming support, and enables various verifications. We instantiate our approach in an architecture description language for Sense/Compute/Control applications, and describe associated compilation and verification strategies.
Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats m...
详细信息
Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats modular program design and concurrency as separate goals, where modularity often suffers. To solve these problems, we are designing a new language that we call Panini. In this paper, we focus on Panini's asynchronous, typed events which reconcile the modularity goal promoted by the implicit invocation design style with the concurrency goal of exposing potential concurrency between the execution of subjects and observers. Since modularity is improved and concurrency is implicit in Panini, programs are easier to reason about and maintain. The language incorporates a static analysis to determine potential conflicts between handlers and a dynamic analysis which uses the conflict information to determine a safe order for handler invocation. This mechanism avoids races and deadlocks entirely, yielding programs with a guaranteed deterministic semantics. To evaluate our languagedesign and implementation we show several examples of its usage as well as an empirical study of program performance. We found that not only is developing and understanding Panini programs significantly easier compared to standard concurrent object-oriented programs, but also performance of Panini programs is comparable to their equivalent hand-tuned versions written using Java's fork-join framework.
暂无评论