Graphical object-oriented languages can help in creating more maintainable code, while also providing better means to ensure correctness. However, most approaches do not fully support the requirements for model synchronization today and focus only on classical one-way batch-oriented transformations. For bachelor students we offer German lectures and paper- or project-oriented seminars on software modeling and model-driven software engineering. To achieve consistency between meta-models, we describe rule-based mechanisms providing generic solutions for managing overlapping and redundant data. Using this declarative specification formalism, we focus on the efficient execution of the transformation rules and present our approach to achieve an incremental model transformation for synchronization purposes. In this paper, we present the SceBaSy plugin for the Fujaba Real-Time Tool Suite which supports the scenario-based synthesis of the real-time coordination patterns. We propose two design patterns that provide a flexible basis for the integration of different tool data at the meta-model level.

Uploader: Zulkishura
Date Added: 16 April 2015
File Size: 17.51 Mb
Operating Systems: Windows NT/2000/XP/2003/2003/7/8/10 MacOS 10/X
Downloads: 61032
Price: Free* [*Free Regsitration Required]

We therefore propose hybrid components and a related hybrid Statechart extension for the Unified Modeling Language UMLit is to support the design of self-optimizing mechatronic systems by tujaba specification of the necessary flexible reconfiguration fujabq the system as well as of its hybrid subsystems in a modular manner. The current technology is to use block diagrams including discrete blocks with statecharts for the design and verification of such systems. Besides the Real-Time Statecharts the paper describes the currently available tool support and the underlying prin- ciples of the fujaba tool suite generation for the currently supported platform, Real-time Java.

Download & Installation

Additionally, we present our approach for worst case execution times estimation to predict software behavior in the time domain. The deployment restrictions are employed to determine valid deployment scenarios for an application. We present an extension of ROOM that further facilitates service-based design sulte permits the independent validation of components for such a design style.

For the specification of syntactical consistency rules we provide a built-in formalism based on graph grammars. In this paper, we present the modular code synthesis for our modeling approach with Hybrid Components and a related Hybrid Statechart extension for the Fujaba tool suite Modelling Language UML which offers a representation of reconfigurable systems including conventional, non-reconfigurable block diagrams.

Giese, Holger; Tissen, Sergej As today technical systems also become connected to each other using network technology, we no longer only have technical systems which are controlled by an isolated operating software.


However, the current MDA approaches and tools for hard real-time software do not provide this ideal: Fault tolerance techniques as well fujaba tool suite self-repair capabilities usually result in additional system complexity which can even spoil the intended improvement with respect to dependability. Ideally, starting with the platform independent model, the platform specific model serves only as an intermediate artifact which is derived automatically, and will finally result in a set of threads whose implementations guarantee the behavior, specified in the platform independent model.

The consistency management is highly configurable and can be adapted individually to user, project or domain specific demands.

We first report on the current tool support for an approach which addresses this problem by means of a compositional model checking approach for a pattern and component fujaba tool suite UML 2. Story Diagrams in Real-Time Software.

Fujaba – Mathematical software – swMATH

In addition, engineers from different disciplines, namely mechanical, electrical and software engineering, have to cooperate. To achieve consistency between meta-models, we describe rule-based mechanisms providing generic solutions for managing overlapping and redundant data. However, the CASE tool support for service-based architectures and especially later process phases addressed with component and deployment fujaba tool suite is rather limited.

In practice, model transformations are expected to be applicable in different stages of a development process and help to consistently propagate changes between the different involved models which we refer to as model synchronization. The language is especially geared for event-driven transformations of data structures.

This does not adequately support the verification of large systems which improve the system behavior at run-time by means of online reconfiguration of its controllers because the system as whole has to be verified. However, as outlined in this paper the current integration platforms fall short to address the underlying problems of overlapping data models and their consistency when it comes to a tool integration. This paper proposes a syntactic extension and semantic definition of UML Statecharts which provides enough details to synthesize code for hard real-time systems automatically.

At the fujaba tool suite days, Fujaba had a special focus on fujaba tool suite generation from UML diagrams resulting in a visual programming language with a special emphasis on object structure manipulating rules. Development efforts for embedded software must consider the trade-off between fast development, maintainable code, correct as well as high-performance software. We are involved in the development of the Fujaba Real Time Fujaba tool suite Suite for our research for the model-driven development of embedded realtime systems and a Triple-Graph-Grammar based algorithm s for incremental model transformation and synchronization.


We therefore present a pattern-based approach for the design of service-based systems which enables self-managing capabilities by reusing proven fault tolerance techniques in form of Fault Tolerance Patterns. We show how the combination of both concepts permits the compositional validation of the system and thus enables early design validation even for flexible systems.

Instead, support for the correct reconfiguration of the internal structures of the controllers is required. Our approach overcomes those UML specific limitations by firstly proposing a syntactic extension and semantic definition of UML State Machines which provides enough details to synthesize an appropriate platform specific model that can be mapped to code for hard real-time systems automatically. This paper proposes a rigorous component concept based on the notion of UML component diagrams which enables modular composition and decomposition of complex systems with online reconfiguration given by hierarchical hybrid component specifications.

Fujaba – From UML to Java and Back Again

The pattern specification consists of a service-based architectural design and deployment fujaba tool suite in form of UML deployment diagrams for the different architectural services. The composition of these patterns to describe the complete component behavior and the overall system behavior is prescribed by a rigorous syntactic definition which guarantees that the verification of component and system behavior can exploit the results of the verification of individual patterns.

Our approach employs the fjuaba, formal, and bidirectional transformation technique of triple graph grammars. In this paper, we at first identify a number of general requirements for the visual model-driven modeling of software intensive systems which result from the outlined demands.

In this report we therefore review the state of the art fujaba tool suite two related lines of research, namely extensions for expressiveness such as Statecharts as proposed in the field of software fujba to support the description of complex behavior and extensions to specify the explicit temporal behavior for state-based behavior such as Timed Automata.