A Model-Driven Engineering Approach for ROS using Ontological Semantics

This paper presents a novel ontology-driven software engineering approach for the development of industrial robotics control software. It introduces the ReApp architecture that synthesizes model-driven engineering with semantic technologies to facilitate the development and reuse of ROS-based components and applications. In ReApp, we show how different ontological classification systems for hardware, software, and capabilities help developers in discovering suitable software components for their tasks and in applying them correctly. The proposed model-driven tooling enables developers to work at higher abstraction levels and fosters automatic code generation. It is underpinned by ontologies to minimize discontinuities in the development workflow, with an integrated development environment presenting a seamless interface to the user. First results show the viability and synergy of the selected approach when searching for or developing software with reuse in mind.Comment: Presented at DSLRob 2015 (arXiv:1601.00877), Stefan Zander, Georg Heppner, Georg Neugschwandtner, Ramez Awad, Marc Essinger and Nadia Ahmed: A Model-Driven Engineering Approach for ROS using Ontological Semantic

Quality-aware model-driven service engineering

Service engineering and service-oriented architecture as an integration and platform technology is a recent approach to software systems integration. Quality aspects ranging from interoperability to maintainability to performance are of central importance for the integration of heterogeneous, distributed service-based systems. Architecture models can substantially influence quality attributes of the implemented software systems. Besides the benefits of explicit architectures on maintainability and reuse, architectural constraints such as styles, reference architectures and architectural patterns can influence observable software properties such as performance. Empirical performance evaluation is a process of measuring and evaluating the performance of implemented software. We present an approach for addressing the quality of services and service-based systems at the model-level in the context of model-driven service engineering. The focus on architecture-level models is a consequence of the black-box character of services

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

Model based code generation for distributed embedded systems

Embedded systems are becoming increasingly complex and more distributed. Cost and quality requirements necessitate reuse of the functional software components for multiple deployment architectures. An important step is the allocation of software components to hardware. During this process the differences between the hardware and application software architectures must be reconciled. In this paper we discuss an architecture driven approach involving model-based techniques to resolve these differences and integrate hardware and software components. The system architecture serves as the underpinning based on which distributed real-time components can be generated. Generation of various embedded system architectures using the same functional architecture is discussed. The approach leverages the following technologies – IME (Integrated Modeling Environment), the SAE AADL (Architecture Analysis and Design Language), and Ocarina. The approach is illustrated using the electronic throttle control system as a case study

An ontology framework for developing platform-independent knowledge-based engineering systems in the aerospace industry

This paper presents the development of a novel knowledge-based engineering (KBE) framework for implementing platform-independent knowledge-enabled product design systems within the aerospace industry. The aim of the KBE framework is to strengthen the structure, reuse and portability of knowledge consumed within KBE systems in view of supporting the cost-effective and long-term preservation of knowledge within such systems. The proposed KBE framework uses an ontology-based approach for semantic knowledge management and adopts a model-driven architecture style from the software engineering discipline. Its phases are mainly (1) Capture knowledge required for KBE system; (2) Ontology model construct of KBE system; (3) Platform-independent model (PIM) technology selection and implementation and (4) Integration of PIM KBE knowledge with computer-aided design system. A rigorous methodology is employed which is comprised of five qualitative phases namely, requirement analysis for the KBE framework, identifying software and ontological engineering elements, integration of both elements, proof of concept prototype demonstrator and finally experts validation. A case study investigating four primitive three-dimensional geometry shapes is used to quantify the applicability of the KBE framework in the aerospace industry. Additionally, experts within the aerospace and software engineering sector validated the strengths/benefits and limitations of the KBE framework. The major benefits of the developed approach are in the reduction of man-hours required for developing KBE systems within the aerospace industry and the maintainability and abstraction of the knowledge required for developing KBE systems. This approach strengthens knowledge reuse and eliminates platform-specific approaches to developing KBE systems ensuring the preservation of KBE knowledge for the long term

Model driven product line engineering : core asset and process implications

Reuse is at the heart of major improvements in productivity and quality in Software Engineering. Both Model Driven Engineering (MDE) and Software Product Line Engineering (SPLE) are software development paradigms that promote reuse. Specifically, they promote systematic reuse and a departure from craftsmanship towards an industrialization of the software development process. MDE and SPLE have established their benefits separately. Their combination, here called Model Driven Product Line Engineering (MDPLE), gathers together the advantages of both. Nevertheless, this blending requires MDE to be recasted in SPLE terms. This has implications on both the core assets and the software development process. The challenges are twofold: (i) models become central core assets from which products are obtained and (ii) the software development process needs to cater for the changes that SPLE and MDE introduce. This dissertation proposes a solution to the first challenge following a feature oriented approach, with an emphasis on reuse and early detection of inconsistencies. The second part is dedicated to assembly processes, a clear example of the complexity MDPLE introduces in software development processes. This work advocates for a new discipline inside the general software development process, i.e., the Assembly Plan Management, which raises the abstraction level and increases reuse in such processes. Different case studies illustrate the presented ideas.This work was hosted by the University of the Basque Country (Faculty of Computer Sciences). The author enjoyed a doctoral grant from the Basque Goverment under the “Researchers Training Program” during the years 2005 to 2009. The work was was co-supported by the Spanish Ministry of Education, and the European Social Fund under contracts WAPO (TIN2005-05610) and MODELINE (TIN2008-06507-C02-01)

Realizing QVT with Graph Rewriting-Based Model Transformation

Model-based development is an increasingly applied method in producing software artifacts that is driven by model transformation. For instance, OMG's Model-Driven Architecture as a model-based approach to software development facilitates the synthesis of application programs from models created using customized, domain-specific model processors. Meta Object Facility 2.0 Query/ Views/ Transformation (QVT) is the OMG's standard for specifying model queries, views, and transformations. Extensive research of graph transformation provides a strong formal background for model transformation. The main contribution of this paper is to show how high-level constraint constructs facilitate to realize transformations specified in QVT with metamodel-based model transformation. As a result we can reuse the graph transformation constructs, and its formal background, which facilitates to make QVT transformations validated

Model-Driven Software Development

Model-Driven Software Development (MDSD) is an emerging technology approach that has potential to revolutionize the software industry. MDSD has the ability to both increase software delivery velocity, while at the same time reduce complexity and reuse software assets. Experts in the field believe that the MDSD approach helps to abstract away the growing interdependencies of enterprise software development by use of sophisticated tools, models, and automatic code generation. Through the use of Unified Modeling Language (UML/UML2) and other related technologies, the models are intricate enough to fully represent a system domain and then generate system code to represent that system. The case study evaluates the key factors of velocity, modeling complexity, code generation, and code completeness. Using both Model-Driven Software Development and so-called traditional methods of development, both techniques were applied against a real-world system for First United Methodist Church Children\u27s Ministry. The two techniques were measured and critiqued for their effect on the software development. Future direction of MDSD and potential impacts are presented

A reusable application framework for context-aware mobile patient monitoring systems

The development of Context-aware Mobile Patient Monitoring Systems (CaMPaMS) using wireless sensors is very complex. To overcome this problem, the Context-aware Mobile Patient Monitoring Framework (CaMPaMF) was introduced as an ideal reuse technique to enhance the overall development quality and overcome the development complexity of CaMPaMS. While a few studies have designed reusable CaMPaMFs, there has not been enough study looking at how to design and evaluate application frameworks based on multiple reusability aspects and multiple reusability evaluation approaches. Furthermore, there also has not been enough study that integrates the identified domain requirements of CaMPaMS. Therefore, the aim of this research is to design a reusable CaMPaMF for CaMPaMS. To achieve this aim, twelve methods were used: literature search, content analysis, concept matrix, feature modelling, use case assortment, domain expert review, model-driven architecture approach, static code analysis, reusability model approach, prototyping, amount of reuse calculation, and software expert review. The primary outcome of this research is a reusable CaMPaMF designed and evaluated to capture reusability from different aspects. CaMPaMF includes a domain model validated by consultant physicians as domain experts, an architectural model, a platform-independent model, a platform-specific model validated by software expert review, and three CaMPaMS prototypes for monitoring patients with hypertension, epilepsy, or diabetes, and multiple reusability evaluation approaches. This research contributes to the body of software engineering knowledge, particularly in the area of design and evaluation of reusable application frameworks. Researchers can use the domain model to enhance the understanding of CaMPaMS domain requirements, thus extend it with new requirements. Developers can also reuse and extend CaMPaMF to develop various CaMPaMS for different diseases. Software industries can also reuse CaMPaMF to reduce the need to consult domain experts and the time required to build CaMPaMS from scratch, thus reducing the development cost and time

Kevoree Modeling Framework (KMF): Efficient modeling techniques for runtime use

The creation of Domain Specific Languages(DSL) counts as one of the main goals in the field of Model-Driven Software Engineering (MDSE). The main purpose of these DSLs is to facilitate the manipulation of domain specific concepts, by providing developers with specific tools for their domain of expertise. A natural approach to create DSLs is to reuse existing modeling standards and tools. In this area, the Eclipse Modeling Framework (EMF) has rapidly become the defacto standard in the MDSE for building Domain Specific Languages (DSL) and tools based on generative techniques. However, the use of EMF generated tools in domains like Internet of Things (IoT), Cloud Computing or Models@Runtime reaches several limitations. In this paper, we identify several properties the generated tools must comply with to be usable in other domains than desktop-based software systems. We then challenge EMF on these properties and describe our approach to overcome the limitations. Our approach, implemented in the Kevoree Modeling Framework (KMF), is finally evaluated according to the identified properties and compared to EMF.Comment: ISBN 978-2-87971-131-7; N° TR-SnT-2014-11 (2014