Building complex component-based software architectures can lead to subtle assemblage errors. In this paper, we introduce a type-system-based approach to avoid message handling errors when assembling component-based c...
详细信息
ISBN:
(纸本)9781605582672
Building complex component-based software architectures can lead to subtle assemblage errors. In this paper, we introduce a type-system-based approach to avoid message handling errors when assembling component-based communication systems. Such errors are not captured by classical type systems of host programming languages such as Java or ML. Our approach relies on the definition of a small process calculus that captures the operational essence of our target component-based framework for communication systems, and on the definition of a novel type system that combines row types with process types.
Feature-oriented programming (FOP) is a paradigm that incorporates programming language technology, program generation techniques, and stepwise refinement. In their GPCE'07 paper, thaker et a]. suggest the develop...
详细信息
ISBN:
(纸本)9781605582672
Feature-oriented programming (FOP) is a paradigm that incorporates programming language technology, program generation techniques, and stepwise refinement. In their GPCE'07 paper, thaker et a]. suggest the development of a type system for FOP to guarantee safe feature composition, Le, to guarantee the absence of type errors during feature composition. We present such a type system along with a calculus for a simple feature-oriented, Java-like language, called Feature Featherweight Java (FFJ). Furthermore, we explore four extensions of FFJ and how they affect type soundness.
Today’s software engineering practices are aimed at developing single systems. there are attempts to achieve reuse through object- and component-based technologies with two specific goals: to cut development...
ISBN:
(纸本)3540434836
Today̵7;s software engineering practices are aimed at developing single systems. there are attempts to achieve reuse through object- and component-based technologies with two specific goals: to cut development costs, and time-to-market and to improve quality. But current research and practical experience suggest that only moving from the single system engineering to the system-family engineering approach can bring significant progress with respect to these goals [4, 8, 10].
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...
详细信息
ISBN:
(纸本)9781450301541
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.
Software product lines (SPLs) are used to create tailor-made software products by managing and composing reusable assets. Generating a software product from the assets of an SPL is possible statically before runtime o...
详细信息
ISBN:
(纸本)9781605582672
Software product lines (SPLs) are used to create tailor-made software products by managing and composing reusable assets. Generating a software product from the assets of an SPL is possible statically before runtime or dynamically at load-time or runtime. Both approaches have benefits and drawbacks with respect to composition flexibility, performance, and resource consumption. Which type of composition is preferable should be decided by taking the application scenario into account. Current tools and languages, however, force a programmer to decide between static and dynamic composition during development. In this paper, we present an approach that employs code generation to support static and dynamic composition of features of a single code base. We offer an implementation on top of FeatureC++, an extension of the C++ programming language that supports software composition based on features. To simplify dynamic composition and to avoid creation of invalid products we furthermore provide means to (1) validate the correctness of a composition at runtime, (2) automatically instantiate SPLs in case of stand-alone applications, and (3) automatically apply interaction code of crosscutting concerns.
We discuss our experience of using model-based techniques to generate model-based code generators. the central idea behind model-driven development (MDD) is to use suitable models to specify various concerns and trans...
详细信息
ISBN:
(纸本)9781605582672
We discuss our experience of using model-based techniques to generate model-based code generators. the central idea behind model-driven development (MDD) is to use suitable models to specify various concerns and transform these models to a variety of text artifacts. A business product needs to deliver a given business functionality on a wide variety of implementation platforms and architectures thus necessitating multiple sets of code generators. However, there is a considerable commonality across these code generators. In absence of a suitable abstraction for capturing this commonality, there is little or no reuse across these code generators. We present an abstraction for organizing model-based code generators as a hierarchical composition of reusable building blocks. A building block is a localized specification of a concern in terms of a concern-specific meta model, model to model transformation, and model to text transformation. Model-based code generation is a 3-step walk over the composition tree wherein the first step transforms individual concern-specific models into a unified model, the second step transforms the unified model into individual concern-specific text artifacts, and the third step composes these text artifacts.
Developing pervasive computing applications is a difficult task because it requires to deal with a wide range of issues: heterogeneous devices, entity distribution, entity coordination, low-level hardware knowledge......
详细信息
ISBN:
(纸本)9781605584942
Developing pervasive computing applications is a difficult task because it requires to deal with a wide range of issues: heterogeneous devices, entity distribution, entity coordination, low-level hardware knowledge... Besides requiring various areas of expertise, programming such applications involves writing a lot of administrative code to glue technologies together and to interface with both hardware and software components. this paper proposes a generativeprogramming approach to providing programming, execution and simulation support dedicated to the pervasive computing domain. this approach relies on a domain-specific language, named DiaSpec, dedicated to the description of pervasive computing systems. Our generative approach factors out features of distributed systems technologies, making DiaSpec-specified software systems portable. the DiaSpec compiler is implemented and has been used to generate dedicated programming frameworks for a variety of pervasive computing applications, including detailed ones to manage the building of an engineering school.
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...
详细信息
ISBN:
(纸本)9781450301541
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.
component containers are a key part of mainstream component technologies, and play an important role in separating non-functional concerns from the core component logic. this paper addresses two different aspects of c...
详细信息
Background. the goal of generativeprogramming is to replace manual search, adaptation, and assembly of components withthe automatic generation of needed components on demand. generative technology has been in practi...
详细信息
ISBN:
(纸本)3540434836
Background. the goal of generativeprogramming is to replace manual search, adaptation, and assembly of components withthe automatic generation of needed components on demand. generative technology has been in practical use for decades (e.g., compiler development, application generation, automatic configuration management, preprocessing, and meta-programming). However, developing new domain-specific languages (DSLs), application generators, and component generators has been extremely hard, as it requires being knowledgeable and experienced both in language design and compiler development. Recent developments such as XML technologies and template meta-programming revived the interest in generativeprogramming by making it more accessible to developers.
暂无评论