Enterprise distributed real-time and embedded (DRE) systems are increasingly being developed withthe use of component-based software techniques. Unfortunately, commonly used component middleware platforms provide lim...
详细信息
ISBN:
(纸本)9781450306898
Enterprise distributed real-time and embedded (DRE) systems are increasingly being developed withthe use of component-based software techniques. Unfortunately, commonly used component middleware platforms provide limited support for event-based publish/subscribe (pub/sub) mechanisms that meet both quality-of-service (QoS) and configurability requirements of DRE systems. On the other hand, although pub/sub technologies, such as OMG Data Distribution Service (DDS), support a wide range of QoS settings, the level of abstraction they provide make it hard to configure them due to the significant source-level configuration that must be hard-coded at compile time or tailored at run-time using proprietary, ad hoc configuration logic. Moreover, developers of applications using native pub/sub technologies must write large amounts of boilerplate "glue" code to support run-time configuration of QoS properties, which is tedious and error-prone. this paper describes a novel, generative approach that combines the strengths of QoS-enabled pub/sub middleware withcomponent-based middleware technologies. In particular, this paper describes the design and implementation of DDS4CIAO which addresses a number of inherent and accidental complexities in the DDS4CCM standard. DDS4CIAO simplifies the development, deployment, and configuration of component-based DRE systems that leverage DDS's powerful QoS capabilities by provisioning DDS QoS policy settings and simplifying the development of DDS applications.
A lot of current approaches attempt to enrich software systems with extra-functional properties. these attempts become remarkably important withthe gradual adoption of component-based programming. Typically, extra fu...
详细信息
ISBN:
(纸本)9789898425577
A lot of current approaches attempt to enrich software systems with extra-functional properties. these attempts become remarkably important withthe gradual adoption of component-based programming. Typically, extra functional properties need to be taken into account in the phase of component binding and therefore included in the process of verifying component compatibility. Although a lot of research has been done, practical usage of extra-functional properties is still rather scarce. the main problem could be in a slow adaptability of specialized research models to rapidly changing industrial needs. We have designed a solution to this issue in the form of a modular framework which provides a formally sound yet practical means to declare, assign and evaluate extra-functional properties in the context of component-based applications. One of its strengths is applicability to a variety of industrial as well as research component models. this paper describes the models and algorithms of the framework and introduces a prototype implementation proving the concept.
Software product lines (SPLs) and adaptive systems aim at variability to cope with changing requirements. Variability can be described in terms of features, which are central for development and configuration of SPLs....
详细信息
ISBN:
(纸本)9781450306898
Software product lines (SPLs) and adaptive systems aim at variability to cope with changing requirements. Variability can be described in terms of features, which are central for development and configuration of SPLs. In traditional SPLs, features are bound statically before runtime. By contrast, adaptive systems support feature binding at runtime and are sometimes called dynamic SPLs (DSPLs). DSPLs are usually built from coarse-grained components, which reduces the number of possible application scenarios. To overcome this limitation, we closely integrate static binding of traditional SPLs and runtime adaptation of DSPLs. We achieve this integration by statically generating a tailor-made DSPL from a highly customizable SPL. the generated DSPL provides only the runtime variability required by a particular application scenario and the execution environment. the DSPL supports self-configuration based on coarse-grained modules. We provide a feature-based adaptation mechanism that reduces the effort of computing an optimal configuration at runtime. In a case study, we demonstrate the practicability of our approach and show that a seamless integration of static binding and runtime adaptation reduces the complexity of the adaptation process.
Smooth integration of domain-specific languages into a general purpose host language requires absorbing of domain code written in arbitrary syntax. the integration should cause minimal syntactical and semantic overhea...
详细信息
ISBN:
(纸本)9781450301541
Smooth integration of domain-specific languages into a general purpose host language requires absorbing of domain code written in arbitrary syntax. the integration should cause minimal syntactical and semantic overhead and introduce minimal dependency on external tools. In this paper we discuss a DSL integration technique for the C++ programming language. the solution is based on compile-time parsing of the DSL code. the parser generator is a C++ template metaprogram reimplementation of a runtime Haskell parser generator library. the full parsing phase is executed when the host program is compiled. the library uses only standard C++ language features, thus our solution is highly portable. As a demonstration of the power of this approach, we present a highly efficient and type-safe version of printf and the way it can be constructed using our library. Despite the well known syntactical difficulties of C++ template metaprograms, building embedded languages using our library leads to self-documenting C++ source code.
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.
Software engineering demands generality and abstraction, performance demands specialization and concretization. generativeprogramming can provide both, but developing high-quality program generators takes a large eff...
详细信息
Software engineering demands generality and abstraction, performance demands specialization and concretization. generativeprogramming can provide both, but developing high-quality program generators takes a large effort, even if a multi-stage programming language is used. We present lightweight modular staging, a library-based multi-stage programming approach that breaks withthe tradition of syntactic quasi-quotation and instead uses only types to distinguish between binding times. through extensive use of component technology, lightweight modular staging makes an optimizing compiler framework available at the library level, allowing programmers to tightly integrate domain-specific abstractions and optimizations into the generation process. We argue that lightweight modular staging enables a form of language virtualization, i.e. allows to go from a pure-library embedded language to one that is practically equivalent to a stand-alone implementation with only modest effort.
there is only that much space in the CS curriculum, and there are always new subjects that should be accommodated by the curriculum. For instance, in our community, we would want all graduates to leave university with...
详细信息
there is only that much space in the CS curriculum, and there are always new subjects that should be accommodated by the curriculum. For instance, in our community, we would want all graduates to leave university with a modest background in technical spaces, software languages, and meta-programming;also, with conceptually informed and reasonably timeless skills to efficiently master related programming techniques and technologies. In reality, the curricula of few CS departments meet this expectation. In this talk, I will discuss such curricula-related expectations of our community and the suboptimal situation at CS departments-as I perceive them. More importantly, I will allude to a revision of the CS curriculum that could optimize matters and may stand a chance for mid-term adoption.
Plug-in components are a means for making feature-rich applications customizable. Combined with plug-and-play composition, end users can assemble customized applications without programming. If plug-and-play compositi...
详细信息
Plug-in components are a means for making feature-rich applications customizable. Combined with plug-and-play composition, end users can assemble customized applications without programming. If plug-and-play composition is also dynamic, applications can be reconfigured on the fly to load only components the user needs for his current work. We have created ***, a plug-in framework that supports dynamic plug-and-play composition. the basis for plug-and-play in Plux is the composer which replaces programmatic composition by automatic composition. components just specify their requirements and provisions using metadata. the composer then assembles the components based on that metadata by matching requirements and provisions. When the composer needs to reuse general-purpose components in different parts of an application, the component model requires genericity. the composer depends on metadata that specify which components should be connected and for general-purpose components those metadata need to be different on each reuse. We present an approach for generic plug-ins withcomponent templates and an implementation for Plux. the general-purpose components become templates and the templates get parameterized when they are composed.
this paper deals with embedded systems software and the modification of its architecture and behavior at execution-time. Incautious implementation of these features demands both heavy memory and performance overrun. T...
详细信息
this paper deals with embedded systems software and the modification of its architecture and behavior at execution-time. Incautious implementation of these features demands both heavy memory and performance overrun. To accomplish such software evolution activities in resource-constrained embedded systems, we propose a component-based run-time evolution infrastructure that reconciles richness of evolution alternatives and performance requirements. Our proposal is based on off-site components reifications, which are representations of components that allow us to treat evolution concerns remotely. Hence, the workload to be processed by the embedded device is alleviated. Memory and processor-time resources consumption evaluation on a real-world scenario show the efficiency and pertinence of our approach.
Some limitations of object-oriented mechanisms are known to cause code clones (e. g., extension using inheritance). Novel programming paradigms such as feature-oriented programming (FOP) aim at alleviating these limit...
详细信息
Some limitations of object-oriented mechanisms are known to cause code clones (e. g., extension using inheritance). Novel programming paradigms such as feature-oriented programming (FOP) aim at alleviating these limitations. However, it is an open issue whether FOP is really able to avoid code clones or whether it even facilitates (FOP-related) clones. To address this issue, we conduct an empirical analysis on ten feature-oriented software product lines with respect to code cloning. We found that there is a considerable number of clones in feature-oriented software product lines and that a large fraction of these clones is FOP-related (i.e., caused by limitations of feature-oriented mechanisms). Based on our results, we initiate a discussion on the reasons for FOP-related clones and on how to cope withthem. We show by means of examples how such clones can be removed by applying refactorings.
暂无评论