Maged Elaasar

Satellite transport protocol handling bit corruption, handoff and limited connectivity

Being both wireless and mobile, low Earth orbiting (LEO) satellite access networks have a unique set of link errors including bit corruption, handoff, and limited connectivity. Unfortunately, most transport protocols are only designed to handle congestion-related errors common in wired networks. This inability to handle multiple kinds of errors results in severe degradation in effective throughput and energy saving, which are relevant metrics for a wireless and mobile environment. A recent study proposed a new transport protocol for satellites called STP that addresses many of the unique problems of satellite networks. There was, however, no explicit attempt to implement a differentiating error control strategy in that protocol. This paper proposes grafting a new probing mechanism in STP to make it more responsive to the prevailing error conditions in the network. The mechanism works by investing some time and transmission effort to determine the cause of error. This overhead is, however, recouped by handsome gains in both the connections effective throughput and its energy efficiency.

Domain-specific model verification with QVT

Model verification is the process of checking models for known problems (or anti-patterns). We propose a new approach to declaratively specify and automatically detect problems in domain-specific models using QVT (Query/View/Transformation). Problems are specified with QVT-Relations transformations from models where elements involved in problems are identified, to result models where problem occurrences are reported in a structured and concise manner. The approach uses a standard formalism, applies generically to any MOF-based modeling language and has well-defined detection semantics. We apply the approach by defining a catalog of problems for a particular but important kind of models, namely metamodels. We report on a case study where we used the catalog to verify recent revisions of the UML metamodel. We detected many problem occurrences that we analyzed and helped resolve in the (latest) UML 2.4 revision. As a result, the metamodel was found to have improved dramatically by the experts defining it.

Enhanced code generation from UML composite state machines

UML modelling tools provide poor support for composite state machine code generation. Generated code is typically complex and large, especially for composite state machines. Existing approaches either do not handle this case at all or handle it by flattening the composite state machine into a simple one with a combinatorial explosion of states, and excessive generated code. This paper presents a new approach that transforms a composite state machine into an equivalent set of simple state machines before code generation. This avoids the combinatorial explosion and leads to more concise and scalable generated code. We implement our approach in Umple. We report on a case study, comparing our approach to others in terms of code size and scalability.

Integrating Modeling Tools in the Development Lifecycle with OSLC: A Case Study

Models play a central role in a model driven development process. They realize requirements, specify system design, abstract source code, drive test cases, etc. However, for a modeling tool to be most effective, it needs to integrate its data and workflows with other tools in the development lifecycle. This is often problematic as these tools are usually disparate. OSLC is an emerging specification for integrating lifecycle tools using the principles of linked data. In this paper, we describe how OSLC can be used to integrate MOF-based modeling tools with other lifecycle tools. We demonstrate this in a case study involving an EMF-based modeling tool. We show how we made the tool conform to the OSLC specification and discuss how this enabled it to integrate seamlessly with other lifecycle tools to support some key end-to-end development lifecycle workflows.

VPML: an approach to detect design patterns of MOF-based modeling languages

A design pattern is a recurring and well-understood design fragment. In a model-driven engineering methodology, detecting occurrences of design patterns supports the activities of model comprehension and maintenance. With the recent explosion of domain-specific modeling languages, each with its own syntax and semantics, there has been a corresponding explosion in approaches to detecting design patterns that are so much tailored to those many languages that they are difficult to reuse. This makes developing generic analysis tools extremely hard. Such a generic tool is however desirable to reduce the learning curve for pattern designers as they specify patterns for different languages used to model different aspects of a system. In this paper, we propose a unified approach to detecting design patterns of MOF-based modeling languages. MOF is increasingly used to define modeling languages, including UML and BPMN. In our approach, a pattern is modeled with a Visual Pattern Modeling Language and mapped to a corresponding QVT-Relations transformation. Such a transformation runs over an input model where pattern occurrences are to be detected and reports those occurrences in a result model. The approach is prototyped on Eclipse and validated in two large case studies that involve detecting design patterns—specifically a subset of GoF patterns in a UML model and a subset of Control Flow patterns in a BPMN model. Results show that the approach is adequate for modeling complex design patterns for MOF-based modeling languages and detecting their occurrences with high accuracy and performance.

Diagram definition: a case study with the UML class diagram

The abstract syntax of a graphical modeling language is typically defined with a metamodel while its concrete syntax (diagram) is informally defined with text and figures. Recently, the Object Management Group (OMG) released a beta specification, called Diagram Definition (DD), to formally define both the interchange syntax and the graphical syntax of diagrams. In this paper, we validate DD by using it to define a subset of the UML class diagram. Specifically, we define the interchange syntax with a MOF-based metamodel and the graphical syntax with a QVT mapping to a graphics metamodel. We then run an experiment where we interchange and render an example diagram. We highlight various design decisions and discuss challenges of using DD in practice. Finally, we conclude that DD is a sound approach for formally defining diagrams that is expected to facilitate the interchange and the consistent rendering of diagrams between tools.

A systematic identification of consistency rules for UML diagrams

Abstract UML diagrams describe different views of one software. These diagrams strongly depend on each other and must therefore be consistent with one another, since inconsistencies between diagrams may be a source of faults during software development activities that rely on these diagrams. It is therefore paramount that consistency rules be defined and that inconsistencies be detected, analyzed and fixed. The relevant literature shows that authors typically define their own consistency rules, sometimes defining the same rules and sometimes defining rules that are already in the UML standard. The reason might be that no consolidated set of rules that are relevant by authors can be found to date. The aim of our research is to provide an up to date, consolidated set of UML consistency rules and obtain a detailed overview of the current research in this area. We therefore followed a systematic procedure in order to collect from literature up to March 2017 and analyze UML consistency rules. We then consolidated a set of 119 UML consistency rules (avoiding redundant definitions or definitions already in the UML standard), which can be used as an important reference for UML-based software development activities, for teaching UML-based software development, and for further research.

UML diagram synthesis techniques: a systematic mapping study

Context: UML software development relies on different types of UML diagrams, which must be consistent with one another. UML Synthesis techniques suggest to generate diagram(s) from other diagram(s), thereby implicitly suggesting that input and output diagrams of the synthesis process be consistent with one another. Objective: Our aim is to provide a comprehensive summary of UML synthesis techniques as they have been described in the literature to date to then collect UML consistency rules, which can then be used to verify UML models. Method: We performed a Systematic Mapping Study by following well-known guidelines. We selected 14 studies by means of a search with seven search engines executed until January, 2018. Results: Researchers have not frequently published papers concerning UML synthesis techniques since 2004. We present a set of 47 UML consistency rules collected from the different synthesis techniques analyzed. Conclusion: Although UML diagrams synthesis doesn’t seem to be an active line of research, it is relevant since synthesis techniques rely on enforcing diagram consistency, which is an active line of research. We collected consistency rules which can be used to check UML models, specifically to verify if the diagrams of a model are consistent with one another.

Modeling Meets Programming: A Comparative Study in Model Driven Engineering Action Languages

Modeling and programming have often been considered two different activities. While this may be true when modeling is primarily meant for human communication and early design explorations, it is not the case when modeling is meant for execution. Some approaches have been specifically developed to address this latter case with variable successes. In this paper, we discuss two such approaches, namely ALF and Umple. ALF has evolved from the modeling community to provide a textual syntax for an executable subset of UML called Foundation UML (fUML). Umple has evolved from the academic community to introduce the abstractions of modeling into programing languages. We compare both approaches, highlight their critical differences, and discuss their contribution to the evolution of model oriented programming languages.

Systematic generation of standard compliant tool support of diagrammatic modeling languages

In the Model-Driven Engineering community, the abstract syntax of modeling languages is usually defined and implemented using metamodeling techniques. However, it is not the case for the concrete syntax of graphical modeling languages. Indeed, this concern is mostly specified by informal means. This practice leaves considerable leeway in the implementation and raises several standards compliance issues. Hence, toolsmiths can only rely on their interpretation of the standard and lack of systematic way to build conforming tool support. In this context, a first normative specification of the concrete syntax of UML 2.5 has been recently released using Diagram Definition. In this paper, we propose an approach that uses those formal specifications to systematically generate modeling language tool support that guarantees compliance to standard notation. We assess the approach on a subset of the UML class diagram implemented within the open-source Papyrus tool.