Category Theory and Model-Driven Engineering: From Formal Semantics to Design Patterns and Beyond

There is a hidden intrigue in the title. CT is one of the most abstract mathematical disciplines, sometimes nicknamed "abstract nonsense". MDE is a recent trend in software development, industrially supported by standards, tools, and the status of a new "silver bullet". Surprisingly, categorical patterns turn out to be directly applicable to mathematical modeling of structures appearing in everyday MDE practice. Model merging, transformation, synchronization, and other important model management scenarios can be seen as executions of categorical specifications. Moreover, the paper aims to elucidate a claim that relationships between CT and MDE are more complex and richer than is normally assumed for "applied mathematics". CT provides a toolbox of design patterns and structural principles of real practical value for MDE. We will present examples of how an elementary categorical arrangement of a model management scenario reveals deficiencies in the architecture of modern tools automating the scenario.Comment: In Proceedings ACCAT 2012, arXiv:1208.430

A component-oriented programming framework for developing embedded mobile robot software using PECOS model

A practical framework for component-based software engineering of embedded real-time systems, particularly for autonomous mobile robot embedded software development using PECOS component model is proposed The main features of this framework are: (1) use graphical representation for components definition and composition; (2) target C language for optimal code generation with small micro-controller; and (3) does not requires run-time support except for real-time kernel. Real-time implementation indicates that, the PECOS component model together with the proposed framework is suitable for resource constrained embedded systems

Avoiding Unnecessary Information Loss: Correct and Efficient Model Synchronization Based on Triple Graph Grammars

Model synchronization, i.e., the task of restoring consistency between two interrelated models after a model change, is a challenging task. Triple Graph Grammars (TGGs) specify model consistency by means of rules that describe how to create consistent pairs of models. These rules can be used to automatically derive further rules, which describe how to propagate changes from one model to the other or how to change one model in such a way that propagation is guaranteed to be possible. Restricting model synchronization to these derived rules, however, may lead to unnecessary deletion and recreation of model elements during change propagation. This is inefficient and may cause unnecessary information loss, i.e., when deleted elements contain information that is not represented in the second model, this information cannot be recovered easily. Short-cut rules have recently been developed to avoid unnecessary information loss by reusing existing model elements. In this paper, we show how to automatically derive (short-cut) repair rules from short-cut rules to propagate changes such that information loss is avoided and model synchronization is accelerated. The key ingredients of our rule-based model synchronization process are these repair rules and an incremental pattern matcher informing about suitable applications of them. We prove the termination and the correctness of this synchronization process and discuss its completeness. As a proof of concept, we have implemented this synchronization process in eMoflon, a state-of-the-art model transformation tool with inherent support of bidirectionality. Our evaluation shows that repair processes based on (short-cut) repair rules have considerably decreased information loss and improved performance compared to former model synchronization processes based on TGGs.Comment: 33 pages, 20 figures, 3 table

Contract Aware Components, 10 years after

The notion of contract aware components has been published roughly ten years ago and is now becoming mainstream in several fields where the usage of software components is seen as critical. The goal of this paper is to survey domains such as Embedded Systems or Service Oriented Architecture where the notion of contract aware components has been influential. For each of these domains we briefly describe what has been done with this idea and we discuss the remaining challenges.Comment: In Proceedings WCSI 2010, arXiv:1010.233

Relating BIP and Reo

Coordination languages simplify design and development of concurrent systems. Particularly, exogenous coordination languages, like BIP and Reo, enable system designers to express the interactions among components in a system explicitly. In this paper we establish a formal relation between BI(P) (i.e., BIP without the priority layer) and Reo, by defining transformations between their semantic models. We show that these transformations preserve all properties expressible in a common semantics. This formal relation comprises the basis for a solid comparison and consolidation of the fundamental coordination concepts behind these two languages. Moreover, this basis offers translations that enable users of either language to benefit from the toolchains of the other.Comment: In Proceedings ICE 2015, arXiv:1508.0459

Multi-model Consistency through Transitive Combination of Binary Transformations

Softwaresysteme werden häufig durch eine Vielzahl an Modellen beschrieben, von denen jedes unterschiedliche Systemeigenschaften abbildet. Diese Modelle können geteilte Informationen enthalten, was zu redundanten Beschreibungen und Abhängigkeiten zwischen den Modellen führt. Damit die Systembeschreibung korrekt ist, müssen alle geteilten Informationen zueinander konsistent beschrieben sein. Die Weiterentwicklung eines Modells kann zu Inkonsistenzen mit anderen Modellen des gleichen Systems führen. Deshalb ist es wichtig einen Mechanismus zur Konsistenzwiederherstellung anzuwenden, nachdem Änderungen erfolgt sind. Manuelle Konsistenzwiederherstellung ist fehleranfallig und zeitaufwändig, weshalb eine automatisierte Konsistenzwiederherstellung notwendig ist. Viele existierende Ansätze nutzen binäre Transformationen, um Konsistenz zwischen zwei Modellen wiederherzustellen, jedoch werden Systeme im Allgemeinen durch mehr als zwei Modelle beschrieben. Um Konsistenzerhaltung für mehrere Modelle mit binären Transformationen zu erreichen, müssen diese durch transitive Ausführung kombiniert werden. In dieser Masterarbeit untersuchen wir die transitive Kombination von binären Transformationen und welche Probleme mit ihr einhergehen. Wir entwickeln einen Katalog aus sechs Fehlerpotentialen, die zu Konsistenzfehlern führen können. Das Wissen über diese Fehlerpotentiale kann den Transformationsentwickler über mögliche Probleme beim Kombinieren von Transformationen informieren. Eines der Fehlerpotentiale entsteht als Folge der Topologie des Transformationsnetzwerks und der benutzten Modelltypen, und kann nur durch Topologieänderungen vermieden werden. Ein weiteres Fehlerpotential entsteht, wenn die kombinierten Transformationen versuchen zueinander widersprüchliche Konsistenzregeln zu erfüllen. Dies kann nur durch Anpassung der Konsistenzregeln behoben werden. Beide Fehlerpotentiale sind fallabhängig und können nicht behoben werden, ohne zu wissen, welche Transformationen kombiniert werden. Zusätzlich wurden zwei Implementierungsmuster entworfen, um zwei weitere Fehlerpotentiale zu verhindern. Sie können auf die einzelnen Transformationsdefinitionen angewendet werden, unabhängig davon welche Transformationen letztendlich kombiniert werden. Für die zwei übrigen Fehlerpotentiale wurden noch keine generellen Lösungen gefunden. Wir evaluieren die Ergebnisse mit einer Fallstudie, bestehend aus zwei voneinander unabhängig entwickelten binären Transformationen zwischen einem komponentenbasierten Softwarearchitekturmodell, einem UML Klassendiagramm und der dazugehörigen Java-Implementierung. Alle gefundenen Fehler konnten einem der Fehlerpotentiale zugewiesen werden, was auf die Vollständigkeit des Fehlerkatalogs hindeutet. Die entwickelten Implementierungsmuster konnten alle Fehler beheben, die dem Fehlerpotential zugeordnet wurden, für das sie entworfen wurden, was 70% aller gefundenen Fehler ausgemacht hat. Dies zeigt, dass die Implementierungsmuster tatsächlich anwendbar sind und Fehler verhindern können

Towards Consistency Management for a Business-Driven Development of SOA

The usage of the Service Oriented Architecture (SOA) along with the Business Process Management has emerged as a valuable solution for the complex (business process driven) system engineering. With a Model Driven Engineering where the business process models drive the supporting service component architectures, less effort is gone into the Business/IT alignment during the initial development activities, and the IT developers can rapidly proceed with the SOA implementation. However, the difference between the design principles of the emerging domainspecific languages imposes serious challenges in the following re-design phases. Moreover, enabling evolutions on the business process models while keeping them synchronized with the underlying software architecture models is of high relevance to the key elements of any Business Driven Development (BDD). Given a business process update, this paper introduces an incremental model transformation approach that propagates this update to the related service component configurations. It, therefore, supports the change propagation among heterogenous domainspecific languages, e.g., the BPMN and the SCA. As a major contribution, our approach makes model transformation more tractable to reconfigure system architecture without disrupting its structural consistency. We propose a synchronizer that provides the BPMN-to-SCA model synchronization with the help of the conditional graph rewriting