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 Taxonomy of Metamodel Hierarchies

In the context of software engineering and model-driven development in particular, metamodeling gains more and more importance. So far, no classifying study of theoretical metamodeling concepts and hierarchy design options has been conducted in order to establish a comprehensive set of interrelated design variables, i.e. a coherent design space. A well-designed metamodeling hierarchy is essential to avoid problems not easily noticeable, like ambiguous classification and the replication of concepts. This study aims at exploring the theoretical foundation and providing a taxonomy or a design space for constructing tailor-made metamodel hierarchies for specific problems areas and domains

Model-based tool support for Tactical Data Links: an experience report from the defence domain

The Tactical Data Link (TDL) allows the exchange of information between cooperating platforms as part of an integrated command and control (C2) system. Information exchange is facilitated by adherence to a complex, message-based protocol defined by document-centric standards. In this paper, we report on a recent body of work investigating migration from a document-centric to a model-centric approach within the context of the TDL domain, motivated by a desire to achieve a positive return on investment. The model-centric approach makes use of the Epsilon technology stack and provides a significant improvement to both the level of abstraction and rigour of the network design. It is checkable by a machine and, by virtue of an MDA-like approach to the separation of domains and model transformation between domains, is open to integration with other models to support more complex workflows, such as by providing the results of interoperability analyses in human-readable domain-specific reports conforming to an accepted standard

CAViT: a Consistency Maintenance Framework based on Transformation Contracts

Design by contract is a software correctness methodology for procedural and object-oriented software. It relies on logical assertions to detect implementation mistakes at run-time or to proof the absence thereof at compile-time. Design by contract has found a new application in model driven engineering, a methodology that aims to manage the complexity of frameworks by relying on models and transformations. A ``transformation contract\u27\u27 is a pair of constraints that together describe the effect of a transformation rule on the set of models contained in its transformation definition: the postcondition describes the model consistency state that the rule can establish provided that its precondition is satisfied. A transformation contract of a rule can be maintained automatically by calling the rule (1) as soon as the invariant corresponding to its postcondition is violated and (2) provided that its precondition is satisfied. Domain specific visual languages can facilitate the implementation of the actual transformation rules since they hide the complexity of graph transformation algorithms and standards for tool interoperability. In this talk, we describe CAViT: a framework that integrates a visual model transformation tool with a design by contract tool by relying on OMG standards such as UML, OCL and MOF

Model-Driven Development of Interactive Multimedia Applications

The development of highly interactive multimedia applications is still a challenging and complex task. In addition to the application logic, multimedia applications typically provide a sophisticated user interface with integrated media objects. As a consequence, the development process involves different experts for software design, user interface design, and media design. There is still a lack of concepts for a systematic development which integrates these aspects. This thesis provides a model-driven development approach addressing this problem. Therefore it introduces the Multimedia Modeling Language (MML), a visual modeling language supporting a design phase in multimedia application development. The language is oriented on well-established software engineering concepts, like UML 2, and integrates concepts from the areas of multimedia development and model-based user interface development. MML allows the generation of code skeletons from the models. Thereby, the core idea is to generate code skeletons which can be directly processed in multimedia authoring tools. In this way, the strengths of both are combined: Authoring tools are used to perform the creative development tasks while models are used to design the overall application structure and to enable a well-coordinated development process. This is demonstrated using the professional authoring tool Adobe Flash. MML is supported by modeling and code generation tools which have been used to validate the approach over several years in various student projects and teaching courses. Additional prototypes have been developed to demonstrate, e.g., the ability to generate code for different target platforms. Finally, it is discussed how models can contribute in general to a better integration of well-structured software development and creative visual design

Hybrid modelling methodology for system design

In the face of rapid development in information technology coupled with a growing dynamism in global markets, manufacturing systems have to be re-constructed for short term or long term goal. Such innovations promise to lead to a new competitive stage, which typically involve design of function, information and behaviour of systems. In order to design the system, simulation has often been chosen. However, simulation has proved limited and fails to aid design of such a complex systems because of consuming much computing time and cost, especially when modelling larger systems. Thus, there is a need to seek a new approach, in a way that results in simulating such a large manufacturing system with less demand on computing time and cost. This study researches into a hybrid modelling approach to minimise these limitations. It includes proposing a hybrid modelling methodology and developing a hybrid modelling tool. The methodology integrates simulation and metamodelling techniques. The metamodel employed in the study possesses, not only characteristics of conventional metamodels in terms of representing relationships in quantity, but also in time lapse. This is the originality of the study and the significant distinction between this research and application of metamodelling in conventional ways. The hybrid modelling tool is developed to support and demonstrate the identified hybrid methodology. LISP has been used as the software language for the hybrid modelling tool. The result of this work concludes that the hybrid modelling approach is capable of simulating a complex manufacturing system with less demands on the computer. The work reported in this thesis has been carried out in conjunction with the EPSRC research project, Hierarchical Manufacturing System Modelling (HMSM) (GR/F96549), to produce an Integrated Design and Modelling Methodology (IDEM). The project was initially a collaborative research program including Loughborough University of Technology (LUT), Morris Crane Ltd., of Loughborough and GEC Large Machine, of Rugby. The experience of these collaborators has proved most valuable in supporting the research, and have provided a cross section of views and comments. The research reported in this thesis is set in the context of the HMSM Research group at Loughborough

Development of service-oriented architectures using model-driven development : a mapping study

Context: Model-Driven Development (MDD) and Service-Oriented Architecture (SOA) are two challenging research areas in software engineering. MDD is about improving software development whilst SOA is a service-based conceptual development style, therefore investigating the available proposals in the literature to use MDD when developing SOA may be insightful. However, no studies have been found with this purpose. Objective: This work aims at assessing the state of the art in MDD for SOA systems. It mainly focuses on: what are the characteristics of MDD approaches that support SOA; what types of SOA are supported; how do they handle non-functional requirements. Method: We conducted a mapping study following a rigorous protocol. We identified the representative set of venues that should be included in the study. We applied a search string over the set of selected venues. As result, 129 papers were selected and analysed (both frequency analysis and correlation analysis) with respect to the defined classification criteria derived from the research questions. Threats to validity were identified and mitigated whenever possible. Results: The analysis allows us to answer the research questions. We highlight: (1) predominance of papers from Europe and written by researchers only; (2) predominance of top-down transformation in software development activities; (3) inexistence of consolidated methods; (4) significant percentage of works without tool support; (5) SOA systems and service compositions more targeted than single services and SOA enterprise systems; (6) limited use of metamodels; (7) very limited use of NFRs; and (8) limited application in real cases. Conclusion: This mapping study does not just provide the state of the art in the topic, but also identifies several issues that deserve investigation in the future, for instance the need of methods for activities other than software development (e.g., migration) or the need of conducting more real case studies.Peer ReviewedPostprint (author's final draft

Action semantics of unified modeling language

The Uni ed Modeling Language or UML, as a visual and general purpose modeling language, has been around for more than a decade, gaining increasingly wide application and becoming the de-facto industrial standard for modeling software systems. However, the dynamic semantics of UML behaviours are only described in natural languages. Speci cation in natural languages inevitably involves vagueness, lacks reasonability and discourages mechanical language implementation. Such semi-formality of UML causes wide concern for researchers, including us. The formal semantics of UML demands more readability and extensibility due to its fast evolution and a wider range of users. Therefore we adopt Action Semantics (AS), mainly created by Peter Mosses, to formalize the dynamic semantics of UML, because AS can satisfy these needs advantageously compared to other frameworks. Instead of de ning UML directly, we design an action language, called ALx, and use it as the intermediary between a typical executable UML and its action semantics. ALx is highly heterogeneous, combining the features of Object Oriented Programming Languages, Object Query Languages, Model Description Languages and more complex behaviours like state machines. Adopting AS to formalize such a heterogeneous language is in turn of signi cance in exploring the adequacy and applicability of AS. In order to give assurance of the validity of the action semantics of ALx, a prototype ALx-to-Java translator is implemented, underpinned by our formal semantic description of the action language and using the Model Driven Approach (MDA). We argue that MDA is a feasible way of implementing this source-to-source language translator because the cornerstone of MDA, UML, is adequate to specify the static aspect of programming languages, and MDA provides executable transformation languages to model mapping rules between languages. We also construct a translator using a commonly-used conventional approach, in i which a tool is employed to generate the lexical scanner and the parser, and then other components including the type checker, symbol table constructor, intermediate representation producer and code generator, are coded manually. Then we compare the conventional approach with the MDA. The result shows that MDA has advantages over the conventional method in the aspect of code quality but is inferior to the latter in terms of system performance