Towards modeling reconfiguration in hierarchical component architectures

Heinzemann, Christian; Priesterjahn, Claudia; Becker, Steffen

doi:10.1145/2304736.2304742

Cited by 14 publications

(8 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Our approach ensures transactional execution of such adaptations in real-time. This strategy prevents the system to enter unsafe configurations in reconfiguration operations [6], where the system shows incorrect behavior. Again, our process enforces correctness by model checking of the adaptation behavior [8].…”

Section: Methods Overviewmentioning

confidence: 99%

The MechatronicUML method: model-driven software engineering of self-adaptive mechatronic systems

Becker

Dziwok

Gerking

et al. 2014

Companion Proceedings of the 36th International Conference on Software Engineering

Self Cite

View full text Add to dashboard Cite

The software of mechatronic systems interacts with the system's physical environment. In such systems, an incorrect software may cause harm to human life. As a consequence, software engineering methods for developing such software need to enable developers to effectively and efficiently proof their correctness. This is further complicated by additional characteristics of mechatronic systems as selfadaptation and coordination with other systems. In this poster, we present MechatronicUML which is a modeldriven software engineering method that especially considers these characteristics of self-adaptive mechatronic systems.

show abstract

Section: Methods Overviewmentioning

confidence: 99%

The MechatronicUML method: model-driven software engineering of self-adaptive mechatronic systems

Becker

Dziwok

Gerking

et al. 2014

Companion Proceedings of the 36th International Conference on Software Engineering

Self Cite

View full text Add to dashboard Cite

show abstract

“…Verification of the abstract model Inspired by [5], we construct an abstract system model in UPPAAL by using stubs. IHB is implemented on a single target component while the rest of the system is simulated by a parent stub and a number of child stubs.…”

Section: Verificationmentioning

confidence: 99%

“…In extended MECHATRONICUML (EUML) [5] by Heinzemann et al, component reconfiguration can be propagated and executed at different hierarchical levels. Reconfiguration rules can be specified for each component at design time.…”

Section: Related Workmentioning

confidence: 99%

Handling Emergency Mode Switch for Component-Based Systems

Hang

Hansson

2014

2014 21st Asia-Pacific Software Engineering Conference

View full text Add to dashboard Cite

Software reuse is deemed as an effective technique for managing the growing software complexity of large systems. Software complexity can also be reduced by partitioning the system behavior into different modes. Such a multi-mode system is able to dynamically change its behavior by switching between different modes. When a multi-mode system is developed by reusable software components, a crucial issue is how to achieve a seamless composition of multi-mode components and handle mode switch properly. This is the motivation for the Mode Switch Logic (MSL), supporting the development of component-based multi-mode systems by providing mechanisms for mode switch handling. In this paper, MSL is extended and adapted to systems with emergency triggering of mode switches that must be handled with minimal delay. We propose an Immediate Handling with Buffering (IHB) approach to enable the responsive handling of such an emergency event in the presence of other concurrent non-emergency mode switch events. We present a model checking based verification of IHB and illustrate its benefits by an example.

show abstract

“…Simulink is a proprietary software and is not based on a metamodelling standard. There are, however, several research projects during which a grammar and metamodel for the Simulink file format has been reverse-engineered [68,143,3]. These approaches offer a conversion of the Simulink MDT file format into a metamodel-based representation, which can be used for further analysis and transformations.…”

Section: Modelling Languagesmentioning

confidence: 99%

“…8 Finally, for Simulink, a model-based representation has to be chosen, since the native MDL format of simulink is not based on a metamodel. There are however several efforts in literature to represent Simulink models in a metamodel-based way; in our case study, we have chosen the the approach of [68], which uses the conQAT 9 parser for the conversion of MDL files to instances of a Ecore-based Simulink metamodel, and an Xpand model-to-text transformation for the generation of MDL files from these models.…”

Section: Processmentioning

confidence: 99%

Flexible views for view-based model-driven development

Bürger¹

2013

Proceedings of the 18th International Doctoral Symposium on Components and Architecture

View full text Add to dashboard Cite

Modern software development faces growing size and complexity of the systems that are being developed. To cope with this complexity, several languages and modelling formalisms are used during the development of a system in order to describe it from various view points and at multiple levels of abstraction. These languages and modeling formalisms are specific to the domain of the system under development, to the paradigms that are followed, and to the developer tools being used. For example, in a component-based process, the software architecture may be defined using a component metamodel, while class diagrams are used for the object-oriented design of the system; performance and reliability models express the extra-functional properties; program code in a general-purpose programming language defines the execution semantics, and is used for the implementation of the system. Although all these artefacts follow different concepts and formalisms, they express the same system from various view points and can thus be understood as views on the system under development. The entirety of these views can be identified as a complete definition of the system. Although the usage of multiple formalisms offers the advantage that different developers can describe the system from different view points, and in languages and models that are specially designed for this purpose, it introduces the problem of fragmentation of information across heterogeneous artefacts in different formats, concepts, and languages. With increasing complexity of the systems, this makes navigation through the system description difficult for developers and other roles in the development process. Furthermore, since the concepts and formalisms are managed independently, they can share semantic overlaps, so that a piece of information about the system under i Abstract development can be expressed in several ways and contexts. For example, while a component model may be used to express the prescriptive software architecture of a system, the implementation in a general-purpose programming language also determines an implicit architecture of the system, which leads to redundancies in the system descriptions. The independent evolution of these artefacts can lead to inconsistencies, which cannot be identified automatically if the semantic correspondances between the artefacts are not modelled explicitly.View-based software development processes offer two fundamental principles of adressing this problem: While synthetic approaches integrate the information of heterogeneous models to form a complete system description, projective approaches introduce a common formalism in which all view points of the system can be represented, and generate the views from this central model. While the pure synthetic approach suffers from a quadratic increase of interdependencies between the view types, which become very numerous with a growing number of formalisms that have to be supported, the projective approach faces the problem of providing a common formalism that is ab...

show abstract

Towards modeling reconfiguration in hierarchical component architectures

Cited by 14 publications

References 9 publications

The MechatronicUML method: model-driven software engineering of self-adaptive mechatronic systems

The MechatronicUML method: model-driven software engineering of self-adaptive mechatronic systems

Handling Emergency Mode Switch for Component-Based Systems

Flexible views for view-based model-driven development

Contact Info

Product

Resources

About