Reducing the Complexity of Modeling Large Software Systems

Reducing the Complexity of Modeling Large Software Systems

Jules White (Vanderbilt University, USA), Douglas C. Schmidt (Vanderbilt University, USA), Andrey Nechypurenko (Siemens AG, Germany) and Egon Wuchner (Siemens AG, Germany)
Copyright: © 2009 |Pages: 29
DOI: 10.4018/978-1-59904-699-0.ch012
OnDemand PDF Download:
$37.50

Abstract

Model-driven development is one approach to combating the complexity of designing software intensive systems. A model-driven approach allows designers to use domain notations to specify solutions and domain constraints to ensure that the proposed solutions meet the required objectives. Many domains, however, require models that are either so large or intricately constrained that it is extremely difficult to manually specify a correct solution. This chapter presents an approach to provide that leverages a constraint solver to provide modeling guidance to a domain expert. The chapter presents both a practical framework for transforming models into constraint satisfaction problems and shows how the Command Pattern can be used to integrate a constraint solver into a modeling tool.
Chapter Preview
Top

Introduction

Model-driven development (MDD) (Ledeczi, 2001a; Kent, 2002; Kleppe, Bast, & Warmer, 2003; Selic, 2003) is a promising paradigm for software development that combines high-level visual abstractions—specific to a domain—with constraint checking and code-generation to simplify the development of a large class of systems (Sztipanovits & Karsai, 1997). MDD tools and techniques help improve software quality by automating constraint checking (Sztipanovits & Karsai, 1997). For example, in developing a software system for an automobile, automated constraint checking can be performed by the MDD tool to ensure that components connected by the developer, such as the antilock braking system and wheel RPM sensors, send messages to each other using the correct periodicity. An advantage of model-based constraint checking is that it expands the range of development errors that can be caught at design time rather than during testing.

Compilers for third-generation languages (e.g., Java, C++, or C#) can be viewed as a form of model-driven development (Atkinson & Kuhne, 2003). A compiler takes the third-generation programming language instructions (model), checks the code for errors (e.g., syntactic or semantic mistakes), and then produces implementation artifacts (e.g., assembly, byte, or other executable codes). A compiler helps catch mistakes during the development phrase and automates the translation of the code into an executable form.

Domain-specific Modeling Languages (DSML) (Ledeczi, 2001a) are one approach to MDD that use a language custom designed for the domain to model solutions. A metamodel is developed that describes the semantic type system of the DSML. Model interpreters traverse instances of models that conform to the metamodel and perform simulation, analysis, or code generation. Modelers can use a DSML to more precisely describe a domain solution, because the modeling language is custom designed for the domain.

MDD tools for DSMLs accrue the same advantages as compilers for third-generation languages. Rather than specifying the solution in terms of third-generation programming languages or other implementation-focused terminology, however, MDD allows developers to use notations specific to the domain. With a third-generation programming language approach (such as specifying the solution in C++), high-level information (such as messaging periodicity or memory consumption) is lost. Because a C++ compiler does not understand messaging periodicity (i.e., it is not part of the “domain” of C++ programs) it cannot check that two objects communicate at the correct rate.

With an MDD-based approach, in contrast, DSML developers determine the granularity of the information captured in the model. High-level information like messaging periodicity can be maintained in the solution model and used for error checking. By raising the level of abstraction for expressing design intent, more complex requirements can be checked automatically by the MDD tool and assured at design time rather than testing time (Sztipanovits & Karsai, 1997), as seen in Figure 1. In general, errors caught during the design cycle are much less time consuming to identify and correct than those found during testing (Fagan, 1999).

Figure 1.

Complexity of identifiable errors increases with level of abstraction

As model-based tools and methodologies have developed, however, it has become clear that there are domains where the models are so large and the domain constraints so intricate that it is extremely hard for modelers to handcraft correct or high quality models. In these domains, MDD tools that provide only solution-correctness checking via constraints provide few real benefits over the third-generation programming language approach. Even though higher-level requirements can be captured and enforced, developers must still find ways of manually constructing a model that adheres to these requirements.

Complete Chapter List

Search this Book:
Reset
Table of Contents
Acknowledgment
Pierre F. Tiako
Chapter 1
Alf Inge Wang, Carl-Fredrik Sørensen
This chapter presents a framework for differentiated process support in large software projects. Process support can be differentiated in different... Sample PDF
Differentiated Process Support for Large Software Projects
$37.50
Chapter 2
Holger Giese, Stefan Henkler, Martin Hirsch, Vladimir Rubin, Matthias Tichy
Software has become the driving force in the evolution of many systems, such as embedded systems (especially automotive applications)... Sample PDF
Modeling Techniques for Software-Intensive Systems
$37.50
Chapter 3
Jaroslav Král, Michal Žemlicka
Software intensive systems are systems strongly depending on supporting software. The software is typically large, complex, and it as a rule... Sample PDF
Service Orientation and Software-Intensive Systems
$37.50
Chapter 4
Alf Inge Wang, Carl-Fredrik Sørensen, Hien Nam Le, Heri Ramampiaro, Mads Nygård, Reidar Conradi
This chapter describes a requirement analysis framework that may be used as a tool for developing client-server systems for mobile workers. The... Sample PDF
From Scenarios to Requirements in Mobile Client-Server Systems
$37.50
Chapter 5
Gan Deng, Douglas C. Schmidt, Aniruddha Gokhale, Jeff Gray, Yuehua Lin, Gunther Lenz
This chapter describes our approach to model-driven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the... Sample PDF
Evolution in Model-Driven Software Product-Line Architectures
$37.50
Chapter 6
Ståle Walderhaug, Erlend Stav, Ulrik Johansen, Gøran K. Olsen
This chapter introduces a tracability solution for use in a model-driven software development approach. It argues that a trace model based on a... Sample PDF
Traceability in Model-Driven Software Development
$37.50
Chapter 7
Gerhard Chroust, Erwin Schoitsch
When designing a complex software-intensive system it is unavoidable to make some a-priori basic assumptions about its architecture. We introduce... Sample PDF
Choosing Basic Architectural Alternatives
$37.50
Chapter 8
Rafael Capilla, Margarita Martínez, Francisco Nava, Cristina Muñoz
Virtual reality systems are a kind of complex software systems that need a lot of effort and resources during its development phase. Because rigid... Sample PDF
Architecting Virtual Reality Systems
$37.50
Chapter 9
Kendra M.L. Cooper, Lirong Dai, Renee Steiner, Rym Zalila Mili
This chapter presents a survey of software architecture approaches. It is intended for a broad audience of students, practitioners, and researchers... Sample PDF
A Survey of Software Architecture Approaches
$37.50
Chapter 10
Daniel G. Waddington, Nilabja Roy, Douglas C. Schmidt
As software-intensive systems become larger, more parallel, and more unpredictable the ability to analyze their behavior is increasingly important.... Sample PDF
Dynamic Analysis and Profiling of Multithreaded Systems
$37.50
Chapter 11
James H. Hill, Douglas C. Schmidt, John M. Slaby
This chapter introduces the next generation of system execution modeling tools designed around modeldriven engineering (MDE) coupled with... Sample PDF
Evaluating Quality of Service for Enterprise Distributed Systems
$37.50
Chapter 12
Jules White, Douglas C. Schmidt, Andrey Nechypurenko, Egon Wuchner
Model-driven development is one approach to combating the complexity of designing software intensive systems. A model-driven approach allows... Sample PDF
Reducing the Complexity of Modeling Large Software Systems
$37.50
Chapter 13
Enis Afgan, Purushotham Bangalore, Jeff Gray
Grid computing environments are dynamic and heterogeneous in nature. In order to realize applicationspecific Quality of Service agreements within a... Sample PDF
A Domain-Specific Language for Describing Grid Applications
$37.50
Chapter 14
Jeff Elpern, Sergiu Dascalu
Traditional software engineering methodologies have mostly evolved from the environment of proprietary, large-scale software systems. Here, software... Sample PDF
A Framework for Understanding the Open Source Revolution
$37.50
Chapter 15
Syed Ahsan, Abad Shah
With the proliferation of Web, a tremendous amount of data is available to researchers and scientists in computational sciences, business... Sample PDF
Quality Metrics for Evaluating Data Provenance
$37.50
Chapter 16
Krishnakumar Balasubramanian, Douglas C. Schmidt, Zoltán Molnár, Ákos Lédeczi
With the emergence of commercial-off-the-shelf (COTS) component middleware technologies software system integrators are increasing faced with the... Sample PDF
System Integration Using Model-Driven Engineering
$37.50
About the Contributors