Semiformal Assertion-Based Verification of Hardware/Software Systems in a Model-Driven Design Framework

Visual simultaneous localization and mapping (VSLAM) is an essential technique used in areas such as robotics and augmented reality for pose estimation and 3D mapping. Research on VSLAM using both monocular and stereo cameras has grown significantly over the last two decades. There is, therefore, a need for emphasis on a comprehensive review of the evolving architecture of such algorithms in the literature. Although VSLAM algorithm pipelines share similar mathematical backbones, their implementations are individualized and the ad hoc nature of the interfacing between different modules of VSLAM pipelines complicates code reuseability and maintenance. This paper presents a software model for core components of VSLAM implementations and interfaces that govern data flow between them while also attempting to preserve the elements that offer performance improvements over the evolution of VSLAM architectures. The framework presented in this paper employs principles from model-driven engineering (MDE), which are used extensively in the development of large and complicated software systems. The presented VSLAM framework will assist researchers in improving the performance of individual modules of VSLAM while not having to spend time on system integration of those modules into VSLAM pipelines.

Download Full-text

Composition, Separation of Roles and Model-Driven Approaches as Enabler of a Robotics Software Ecosystem

Software Engineering for Robotics ◽

10.1007/978-3-030-66494-7_3 ◽

2020 ◽

pp. 53-108

Author(s):

Christian Schlegel ◽

Alex Lotz ◽

Matthias Lutz ◽

Dennis Stampfer

Keyword(s):

Complex Systems ◽

Open Source ◽

Building Block ◽

Building Blocks ◽

Software Systems ◽

Software Components ◽

Separation Of Concerns ◽

Software Ecosystem ◽

Model Driven ◽

Successful Approach

AbstractSuccessful engineering principles for building software systems rely on the separation of concerns for mastering complexity. However, just working on different concerns of a system in a collaborative way is not good enough for economically feasible tailored solutions. A successful approach for this is the composition of complex systems out of commodity building blocks. These come as is and can be represented as blocks with ports via data sheets. Data sheets are models and allow a proper selection and configuration as well as the prediction of the behavior of a building block in a specific context. This chapter explains how model-driven approaches can be used to support separation of roles and composition for robotics software systems. The models, open-source tools, open-source robotics software components and fully deployable robotics software systems shape a robotics software ecosystem.

Download Full-text

Validating Model-Driven Performance Predictions on Random Software Systems

Research into Practice – Reality and Gaps - Lecture Notes in Computer Science ◽

10.1007/978-3-642-13821-8_3 ◽

2010 ◽

pp. 3-19 ◽

Cited By ~ 1

Author(s):

Vlastimil Babka ◽

Petr Tůma ◽

Lubomír Bulej

Keyword(s):

Software Systems ◽

Model Driven ◽

Performance Predictions

Download Full-text

Tool Based Integration of Requirements Modeling and Validation into Business Process Modeling

Software Design and Development ◽

10.4018/978-1-4666-4301-7.ch016 ◽

2014 ◽

pp. 285-309

Author(s):

Sven Feja ◽

Sören Witt ◽

Andreas Speck

Keyword(s):

Business Process ◽

Process Modeling ◽

Process Models ◽

Software Systems ◽

Functional Requirements ◽

Model Driven ◽

Level Of Abstraction ◽

Textual Representations ◽

Model Driven Software Development ◽

The One

Business process models (BPM) are widely used for specification of software systems, as the basis for model driven software development. Hence, it is crucial to ensure that these BPMs fulfill the requirements they have to comply with. These requirements may originate from various domains. Many may be considered non-functional requirements. They are affecting privacy, security, as well as compliance or economic aspects. In order to avoid error-prone manual checking, automated checking techniques should be applied wherever possible. This requires expressing requirements in a formal manner. The common textual representations for such formal requirements are not well accepted in the modeling domain, since they are settled on a lower level of abstraction, compared to BPMs. In this chapter, the authors present the Business Application Modeler (BAM), which integrates formal requirement specification and automated checking with process modeling. On the one hand BAM supports different notations for process modeling. On the other hand a graphical notation, called G-CTL, for the formal specification of requirements is provided. G-CTL is based on temporal logic, and statements are expressed on the level of abstraction of the graphical process models. Furthermore BAM provides the ability to define selective views on process models. This allows complex domain specific annotations of processes as well as the assignment of responsibilities regarding functional domains. Moreover, BAM integrates into common requirements engineering processes.

Download Full-text

Supporting Model-Driven Development

Computer Systems and Software Engineering ◽

10.4018/978-1-5225-3923-0.ch016 ◽

2017 ◽

pp. 396-432

Author(s):

Rita Suzana Pitangueira Maciel ◽

Ana Patrícia F. Magalhães Mascarenhas ◽

Ramon Araújo Gomes ◽

João Pedro D. B. de Queiroz

Keyword(s):

Software Engineering ◽

Process Models ◽

Software Systems ◽

Model Driven Development ◽

Model Driven ◽

Process Specification ◽

Process Enactment ◽

Support Tools ◽

Important Approach ◽

Engineering Environment

The adoption of Model-Driven Development (MDD) is increasing and it is widely recognized as an important approach for building software systems. In addition to traditional development process models, an MDD process requires the selection of metamodels and mapping rules for the generation of the transformation chain which produces models and application code. However, existing support tools and transformation engines for MDD do not address different kinds of software process activities, such as application modeling and testing, to guide the developers. Furthermore, they do not enable process modeling nor the (semi) automated execution of activities during process enactment. MoDErNE (Model Driven Process-Centered Software Engineering Environment) uses process-centered software engineering environment concepts to improve MDD process specification and enactment by using a metamodeling foundation. This chapter presents model driven development concept issues and the MoDErNE approach and environment. MoDErNE aims to facilitate MDD process specification and enactment.

Download Full-text

Pair Modeling

Encyclopedia of Networked and Virtual Organizations ◽

10.4018/978-1-59904-885-7.ch153 ◽

2010 ◽

pp. 1171-1178 ◽

Cited By ~ 2

Author(s):

Pankaj Kamthan

Keyword(s):

Software Development ◽

Software Process ◽

Software Systems ◽

Model Driven ◽

Model Driven Approach

We model software for a variety of reasons: to assess the viability of or plan software systems to be built, to optimize use of (minimize, or ideally, avoid waste of) resources in response to inevitable changes in business, social, or technological environments, or simply to understand existing software systems. Indeed, as indicated by the model-driven approach to software development (Beydeda, Book, & Gruhn, 2005), models are becoming first-class members of organizations and software process environments that embrace them. The examples of collaboration in implementation of software are well-known (Nosek, 1998; Williams & Kessler, 2003). As models get large and complex, the need for creating them collaboratively in a systematic manner arises, and we propose pair modeling as an approach.

Download Full-text

Model-Driven Reverse Engineering of Open Source Systems

Open Source Technology ◽

10.4018/978-1-4666-7230-7.ch101 ◽

2015 ◽

pp. 1966-1987

Author(s):

Ricardo Perez-Castillo ◽

Mario Piattini

Keyword(s):

Reverse Engineering ◽

System Design ◽

Open Source ◽

Business Processes ◽

Program Comprehension ◽

Software Systems ◽

Design Models ◽

Model Driven ◽

Class Diagrams ◽

Open Source Systems

Open source software systems have poor or inexistent documentation and contributors are often scattered or missing. The reuse-based composition and maintenance of open source software systems therefore implies that program comprehension becomes a critical activity if all the embedded behavior is to be preserved. Program comprehension has traditionally been addressed by reverse engineering techniques which retrieve system design models such as class diagrams. These abstract representations provide a key artifact during migration or evolution. However, this method may retrieve large complex class diagrams which do not ensure a suitable program comprehension. This chapter attempts to improve program comprehension by providing a model-driven reverse engineering technique with which to obtain business processes models that can be used in combination with system design models such as class diagrams. The advantage of this approach is that business processes provide a simple system viewpoint at a higher abstraction level and filter out particular technical details related to source code. The technique is fully developed and tool-supported within an R&D project about global software development in which collaborate two universities and five companies. The automation of the approach facilitates its validation and transference through an industrial case study involving two open source systems.

Download Full-text