Validating Model-Driven Performance Predictions on Random Software Systems

2010 ◽  
pp. 3-19 ◽  
Author(s):  
Vlastimil Babka ◽  
Petr Tůma ◽  
Lubomír Bulej
Keyword(s):  
Software Systems ◽  
Model Driven ◽  
Performance Predictions

scholarly journals Modelling Software Architecture for Visual Simultaneous Localization and Mapping

Automation ◽  
2021 ◽  
Vol 2 (2) ◽  
pp. 48-61
Author(s):  
Bhavyansh Mishra ◽  
Robert Griffin ◽  
Hakki Erhan Sevil
Keyword(s):  
System Integration ◽  
Ad Hoc ◽  
Simultaneous Localization And Mapping ◽  
Software Systems ◽  
Model Driven ◽  
Performance Improvements ◽  
Software Model ◽  
Localization And Mapping ◽  
Stereo Cameras ◽  
Core Components

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.

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

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.

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

2017 ◽  
pp. 683-720
Author(s):  
Graziano Pravadelli ◽  
Davide Quaglia ◽  
Sara Vinco ◽  
Franco Fummi
Keyword(s):  
Software Systems ◽  
Design Framework ◽  
Model Driven

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

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.

Supporting Model-Driven Development

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.

Pair Modeling

2010 ◽  
pp. 1171-1178 ◽  
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.

Model-Driven Reverse Engineering of Open Source Systems

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.

Model-driven software systems engineering in robotics: Covering the complete life-cycle of a robot

2015 ◽  
Vol 57 (2) ◽  
Author(s):  
Christian Schlegel ◽  
Alex Lotz ◽  
Matthias Lutz ◽  
Dennis Stampfer ◽  
Juan F. Inglés-Romero ◽  
...  
Keyword(s):  
Systems Engineering ◽  
System Integration ◽  
Software Systems ◽  
Model Driven ◽  
Domain Specific ◽  
Complete Life Cycle ◽  
Systems Software ◽  
Model Driven Software Development ◽  
Component Based Software Engineering ◽  
Software Systems Engineering

AbstractRobotic systems are complex, software intensive and heterogeneous composite systems. Software systems engineering and system integration is still a major challenge in robotics. We describe how component based software engineering (CBSE), model-driven software development (MDSD) and domain-specific languages (DSLs) for variability management complement each other in addressing the robotics software challenge. We outline how these approaches pave the way towards a software business ecosystem in robotics. We put a focus onto challenges still being considered as open and worth being addressed next.

A Generic Process for the Design and Generation of Software Product Line Skeleton Architectures

2014 ◽  
Vol 24 (09) ◽  
pp. 1301-1335
Author(s):  
Maria Eugenia Cabello ◽  
Isidro Ramos ◽  
Oscar Alberto Santana ◽  
Saúl Iván Beristain
Keyword(s):  
Software Architecture ◽  
Software Product Line ◽  
Product Line ◽  
Feature Model ◽  
Software Systems ◽  
Reference Architecture ◽  
Product Lines ◽  
Model Driven ◽  
Software Product ◽  
And Behavior

This paper presents a process, a method and a framework for developing families of software systems in a domain. The process is generic (domain-independent) and produces skeleton software architectures as Software Product Lines. The genericity is supported by the metamodels (abstract languages) that are defined in order to describe the Reference Architecture (structure view, behavior view and variability view) of the system domain. A standardized Production Plan takes the Reference Architecture as input and produces the equivalent Skeleton Software Architecture (component-connector view) using a Feature Model configuration (describing the system to be) as output. This Skeleton Software Architecture includes the structure and behavior of the target software product. A framework has been implemented to support the approach. The process is applied, as an example, to the Diagnostic Expert Systems domain. Our approach is based on Model-Driven Engineering techniques and the Software Product Line paradigm. A domain analysis must be done in order to build the Reference Architecture.

scholarly journals Editorial to theme issue on model-driven engineering of component-based software systems

2017 ◽  
Vol 18 (1) ◽  
pp. 7-10 ◽  
Author(s):  
Federico Ciccozzi ◽  
Jan Carlson ◽  
Patrizio Pelliccione ◽  
Massimo Tivoli
Keyword(s):  
Software Systems ◽  
Model Driven Engineering ◽  
Theme Issue ◽  
Model Driven
Sign in / Sign up

Export Citation Format

Share Document