28 research outputs found
Multi-Platform Generative Development of Component & Connector Systems using Model and Code Libraries
Component-based software engineering aims to reduce software development
effort by reusing established components as building blocks of complex systems.
Defining components in general-purpose programming languages restricts their
reuse to platforms supporting these languages and complicates component
composition with implementation details. The vision of model-driven engineering
is to reduce the gap between developer intention and implementation details by
lifting abstract models to primary development artifacts and systematically
transforming these into executable systems. For sufficiently complex systems
the transformation from abstract models to platform-specific implementations
requires augmentation with platform-specific components. We propose a
model-driven mechanism to transform platform-independent logical component &
connector architectures into platform-specific implementations combining model
and code libraries. This mechanism allows to postpone commitment to a specific
platform and thus increases reuse of software architectures and components.Comment: 10 pages, 4 figures, 1 listin
Code Generator Composition for Model-Driven Engineering of Robotics Component & Connector Systems
Engineering software for robotics applications requires multidomain and
application-specific solutions. Model-driven engineering and modeling language
integration provide means for developing specialized, yet reusable models of
robotics software architectures. Code generators transform these platform
independent models into executable code specific to robotic platforms.
Generative software engineering for multidomain applications requires not only
the integration of modeling languages but also the integration of validation
mechanisms and code generators. In this paper we sketch a conceptual model for
code generator composition and show an instantiation of this model in the
MontiArc- Automaton framework. MontiArcAutomaton allows modeling software
architectures as component and connector models with different component
behavior modeling languages. Effective means for code generator integration are
a necessity for the post hoc integration of applicationspecific languages in
model-based robotics software engineering.Comment: 12 pages, 4 figures, In: Proceedings of the 1st International
Workshop on Model-Driven Robot Software Engineering (MORSE 2014), York, Great
Britain, Volume 1319 of CEUR Workshop Proceedings, 201
Integration of Heterogeneous Modeling Languages via Extensible and Composable Language Components
Effective model-driven engineering of complex systems requires to
appropriately describe different specific system aspects. To this end,
efficient integration of different heterogeneous modeling languages is
essential. Modeling language integaration is onerous and requires in-depth
conceptual and technical knowledge and ef- fort. Traditional modeling lanugage
integration approches require language engineers to compose monolithic language
aggregates for a specific task or project. Adapting these aggregates cannot be
to different contexts requires vast effort and makes these hardly reusable.
This contribution presents a method for the engineering of grammar-based
language components that can be independently developed, are syntactically
composable, and ultimately reusable. To this end, it introduces the concepts of
language aggregation, language embed- ding, and language inheritance, as well
as their realization in the language workbench MontiCore. The result is a
generalizable, systematic, and efficient syntax-oriented composition of
languages that allows the agile employment of modeling languages efficiently
tailored for individual software projects.Comment: 12 pages, 11 figures. Proceedings of the 3rd International Conference
on Model-Driven Engineering and Software Development. Angers, Loire Valley,
France, pp. 19-31, 201
Towards Product Lining Model-Driven Development Code Generators
A code generator systematically transforms compact models to detailed code.
Today, code generation is regarded as an integral part of model-driven
development (MDD). Despite its relevance, the development of code generators is
an inherently complex task and common methodologies and architectures are
lacking. Additionally, reuse and extension of existing code generators only
exist on individual parts. A systematic development and reuse based on a code
generator product line is still in its infancy. Thus, the aim of this paper is
to identify the mechanism necessary for a code generator product line by (a)
analyzing the common product line development approach and (b) mapping those to
a code generator specific infrastructure. As a first step towards realizing a
code generator product line infrastructure, we present a component-based
implementation approach based on ideas of variability-aware module systems and
point out further research challenges.Comment: 6 pages, 1 figure, Proceedings of the 3rd International Conference on
Model-Driven Engineering and Software Development, pp. 539-545, Angers,
France, SciTePress, 201