Student Project Topics

Bart Cools: P1 - A language for modeling constraints of characteristics in complex heterogeneous systems

Guide
Istvan David
Summary
This project aims to provide system engineers with a textual language for expressing constraints over the system's parameters in form of arithmetic and logical expressions. Your tasks are:

Defining such a language based on a previously developed visual equivalent of it [1] and implementing a supporting IDE with Xtext.
Facilitating the symbolic evaluation of expressions via the SymPy framework [2].
Demonstrating your results through a simple example.

Background

[1] Modeling and Enactment Support for Early Detection of Inconsistencies in Engineering Processes, I. Dávid, B. Meyers, K. Vanherpen, Y. Van Tendeloo, K. Berx, H. Vangheluwe, 2nd International Workshop on Collaborative Modelling in MDE, 2017. [PDF]

[2] SymPy documentation

Bjorn de Nijs: P15 - Domain Specific Language for Indoor Air Quality Analysis in Museums

Summary

The purpose of this project is to apply the techniques learned in the MDE course and design a domain specific language that allows non-experts to analyze the indoor air quality.

Guide: Cláudio Gomes
Background: To be determined with the student.

Joey De Pauw: P16 - Variability Management and Model Transformations

Summary

This project explores the relationship between variability management and model transformations.

Guide: Cláudio Gomes
Background:

Salay, R., Famelis, M., Rubin, J., Di Sandro, A., & Chechik, M. (2014). Lifting model transformations to product lines. In 36th International Conference on Software Engineering - ICSE (pp. 117–128). New York, New York, USA: ACM Press. http://doi.org/10.1145/2568225.2568267
Czarnecki, K. (2005). Overview of Generative Software Development. In Unconventional Programming Paradigms (pp. 326–341). http://doi.org/10.1007/11527800_25
Berger, T., Stănciulescu, Ş., Øgård, O., Haugen, Ø., Larsen, B., & Wąsowski, A. (2014). To connect or not to connect. In 18th Internaltional Conference on Software Product Line - SPLC ’14 (pp. 330–339). New York, New York, USA: ACM Press. http://doi.org/10.1145/2648511.2648549

Jony Van Puymbroeck: P17 - Workflow Languages for Machine Learning

Summary

This project proposes to explore the existing languages for machine learning related workflows.

It consists of identifying the commonalities in the development of a large class of machine learning solutions, and summarize those in the form of a specialized workflow language.

Guide: Cláudio Gomes
Background:

To be determined.

Jonas Vanden Branden: P18 - Analysis of Blockchain Based Applications using Model Transformations

Summary

This project is part of a larger study comparing blockchain applications with traditional database applications. Possible directions are: build a performance model based on queueing networks using model transformations; use model transformations to find optimal parameters for the application based on a performance model.

Guide: Cláudio Gomes
Background:

Yasaweerasinghelage, R., Staples, M., & Weber, I. (2017). Predicting Latency of Blockchain-Based Systems Using Architectural Modelling and Simulation. In International Conference on Software Architecture (ICSA) (pp. 253–256). IEEE. http://doi.org/10.1109/ICSA.2017.22

Tim Leys: P19 - Recommender System for Bug Reports using RETE Networks

Summary

This project aims at exploring how RETE Networks can be used to build a recommender system that can enhance the process of bug reporting.

Guide: Cláudio Gomes
Background:

Bergmann, G., Ökrös, A., Ráth, I., Varró, D., & Varró, G. (2008). Incremental pattern matching in the viatra model transformation system. Proceedings of the Third International Workshop on Graph and Model Transformations - GRaMoT ’08, 25. http://doi.org/10.1145/1402947.1402953
Forgy, C. C. L. (1982). Rete: A fast algorithm for the many pattern/many object pattern match problem. Artificial Intelligence, 19(1982). http://doi.org/10.1016/0004-3702(82)90020-0

Kleidi Ismailaj: P20 - Abstraction and Verification Techniques for Continuous and Hybrid Systems

Summary

This project proposes to explore how Finite State Automata (FSA), and Timed FSA can be used to over-approximate the behavior of continuous and hybrid systems.

The resulting (Timed) FSA can then be used to prove safety properties using model checking techniques with a tool such as UPPAAL.

A potential use case is to ensure that the force exerted by a power window (when closing) on an obstacle is below a certain threshold.

Guide: Cláudio Gomes
Background:

Maler, O., & Batt, G. (2008). Approximating Continuous Systems by Timed Automata. In Formal Methods in Systems Biology (pp. 77–89). Berlin, Heidelberg: Springer Berlin Heidelberg. http://doi.org/10.1007/978-3-540-68413-8_6
Lygeros, J. (2004). Lecture notes on hybrid systems. Department of Electrical and Computer Engineering University of Patras. Retrieved from https://robotics.eecs.berkeley.edu/~sastry/ee291e/lygeros.pdf
Behrmann, G., David, A., & Larsen, K. G. (2006). A Tutorial on Uppaal 4.0.
Denil, J. (2013). Design, Verification and Deployment of Software Intensive Systems - A multiparadigm approach [Section 4]. University of Antwerp.

Rys Arkadiusz: P22 - A modeling language for home automation systems with support for temporal reasoning

Summary

Guide: Istvan David
Background:

P2 - A language for modeling performance metrics and KPI of engineering processes (Xtext)

Guide
Istvan David
Summary
Evaluating the performance of engineering or business processes requires well-defined metrics, known as key performance indicators (KPIs), combining lower level metrics into a higher level one, for example: the cost of the process, the utilization of resources, etc. In this project, you'll develop a language for modeling such KPIs and an will provide a framework for evaluating these in processes based on the FTG+PM framework [1]. Your tasks are:

Researching some of the techniques of process cost modeling [2], defining an appropriate language for modeling costs and implementing a supporting IDE with Xtext.
Providing a framework for evaluating KPIs.
Demonstrating your results through a simple example.

Background

[1] Engineering Process Transformation to Manage (In)consistency, I. Dávid, J. Denil, K. Gadeyne, H. Vangheluwe, 1st International Workshop on Collaborative Modelling in MDE, 2016 [PDF]

[2] Process Cost Modeling: Strategic Engineering and Economic Evaluation of Materials Technologies, F. Field, R. Kirchain, R. Roth, JOM (2007) 59: 21. https://doi.org/10.1007/s11837-007-0126-0

P3 - Tool support for process weaving (Sirius or Xtext)

Guide
Istvan David
Summary
Explicit modeling of processes can shed light on the dynamics of engineering and business related workflows, product development or stakeholder interaction. Very often, however, the underlying process is implied by the combination of multiple processes, possibly on different levels of abstraction. In this project you'll develop a modeling language for process weaving. Your work starts from our in-house process modeling tool. [1] Your tasks include:

A language for defining process weaving patterns, along with a framework for deriving the resulting process.
At least one analysis technique for the resulting process based on the compositionality rules of the interwoven processes.
Demonstrating your results through a simple example.

Background

[2] Towards an Aspect Weaving BPEL engine, C. Courbis, A. Finkelstein, Proceedings. 27th International Conference on. IEEE, 2005. [PDF]

P4 - A visual process simulation tool (Sirius)

Guide
Istvan David
Summary
Modeling processes is a key in many engineering and business domains. Appropriate visualizations of the process should be provided not just during the specification phase, but also during the enactment of the process. The FTG+PM framework enables explicit modeling of processes, with the execution semantics provided by model transformations. In this project you'll develop a visualization of FTG+PM conform processes under execution, using the Sirius framework. You'll start from an existing tool developed in [1]. Your tasks include:

Visualization of the process under execution.
Providing controls for process execution.
Demonstrating your results through a simple example.

Background

P5 - A visual modeling language for streaming model transformations (Sirius)

Guide
Istvan David
Summary
Streaming model transformations represent a novel class of transformations to manipulate models whose elements are continuously produced or modified in high volume and with rapid rate of change. Executing streaming transformations requires efficient techniques to recognize activated transformation rules over a live model and a potentially infinite stream of events. In this project, you'll develop a visual modeling language for specifying transformation rules over streams. Your tasks are:

Understanding the concept and underlying techniques of streaming model transformations [1], defining an appropriate visual modeling language [2] [3] for specifying transformation rules and implementing a supporting IDE with Sirius.
Translating your streaming transformation patterns to a suitable model transformation framework.
Demonstrating your results through a simple example.

Background

[1] Foundations for Streaming Model Transformations by Complex Event Processing, I. Dávid, I. Ráth, D. Varró, International Journal on Software and Systems Modeling, pp 1--28, 2016. DOI: 10.1007/s10270-016-0533-1. [Open access pdf].

[2] The "Physics" of Notations: Toward a Scientific Basis for Constructing Visual Notations in Software Engineering, D. L. Moody, IEEE Transactions on Software Engineering, vol. 35, no. 6, pp. 756-779, November/December, 2009.

[3] Maintaining knowledge about temporal intervals, J.F. Allen, Communications of the ACM 26(11) pp.832-843, Nov. 1983. [webpage]

P6 - Optimized process generation from architectural, functional and extra-functional system characteristics

Guide
Istvan David
Summary
Explicitly modeled processes are a significant step towards higher productivity. Modeling the process itself, however, is still a labor-intensive and error-prone task. The FTG+PM formalism and its recent extensions [1] enable the modeling the characteristics of the system being developed during the process. These characteristics are currently used in conjunction with the process in order to detect inconsistencies in the design. Investigating system characteristics and their relationships, in turn, enables generating processes which are the most optimal in terms of consistency, transit time, and other extra-functional properties. In this project you'll implement algorithms for process generation, based on architectural, functional and extra-functional characteristics of the system. Your work will be situated within our process modeling framework, built on top of cutting-edge Eclipse technologies. (You will be NOT asked to integrate your work with the framework beyond the necessary minimum.) Your tasks are:

Understanding the FTG+PM framework and its extensions [1].
Providing algorithms for generating process candidates suitable for implementing the system based on its characteristics, starting from design-structure matrices (DSM).
Providing a method for selecting the optimal process w.r.t. one or two KPIs.
Demonstrating your results through a simple example.

Background

[2] Extended dependency modeling for effective and efficient design decision support, K. Berx, H. Karhula, M. Nicolai, D. Maes. (Available on demand.)

P7 - Process scheduling and optimization by constraint solving

Guide
Istvan David
Background

[1] Engineering Process Transformation to Manage (In)consistency, I. Dávid, J. Denil, K. Gadeyne, H. Vangheluwe, 1st International Workshop on Collaborative Modelling in MDE, 2016

[2] Resource-Constrained Project Scheduling: Models, Algorithms, Extensions and Applications, C. Artigues, S. Demassey, E. Neron, ISTE, 2007.

[3] A MiniZinc Tutorial, K. Marriott, P. J. Stuckey [PDF]

P8 - Inconsistency resolution by constraint solving

Guide
Istvan David
Background

[1] Engineering Process Transformation to Manage (In)consistency, I. Dávid, J. Denil, K. Gadeyne, H. Vangheluwe, 1st International Workshop on Collaborative Modelling in MDE, 2016

[2] A MiniZinc Tutorial, K. Marriott, P. J. Stuckey [PDF]

P9 - Enhancing engineering process models with domain-specific knowledge

Guide
Istvan David
Background

[1] Ontology Development 101: A Guide to Creating Your First Ontology, N.F. Noy, D. L. McGuinness, Stanford knowledge systems laboratory technical report KSL-01-05 and Stanford medical informatics technical report SMI-2001-0880

[2] Modeling and Enactment Support for Early Detection of Inconsistencies in Engineering Processes, I. Dávid, B. Meyers, K. Vanherpen, Y. Van Tendeloo, K. Berx, H. Vangheluwe, 2nd International Workshop on Collaborative Modelling in MDE, 2017

P10 - Constraint identification by machine learning (Bayesian reasoning)

Guide
Istvan David
Background

[1] Bayesian Reasoning Over Models, S. J. Herzig, C. J. Paredis. In 11th Workshop on Model-Driven Engineering, Verification and Validation MoDeVVa 2014, pages 69--78, 2014.

P11 - Statechart configuration for FMI co-simulation

Summary

The Functional Mockup Interface (FMI) Standard defines a common interface via which multiple simulation tools (e.g., Simulink, OpenModelica, 20Sim, etc…) can communicate during a simulation, in order to reproduce the behavior of a complex system (e.g., an ABS of a car, or the power window controller).

In these simulations, each tool computes the behavior of a sub-part of the system (the one that the tool is most specialized in modelling), and assumes that external inputs are computed by other simulation tools.

As more and more tools are adhering to the standard (currently, 35 tools and increasing, see references below), it becomes important to explore the many ways in which a model can communicate with its environment i.e., how and where does it get/set its inputs/outputs, and what are the assumptions made by these.

In this project in particular, the student is going to explore different ways of making a statechart communicate with its environment.

A statechart simulation tool called Yakindu can serve as the target for the implementation of these multiple variations.

Ideally, the results of this project would be published, and these would enable the Yakindu (or any other statechart based simulation tool) to quickly adhere to the FMI Standard by selecting which variation is to be used.

Guide: Cláudio Gomes
Background:

Harel, D. (1987). Statecharts: a visual formalism for complex systems. Science of Computer Programming, 8(3), 231–274. http://doi.org/10.1016/0167-6423(87)90035-9
Blockwitz, T., Otter, M., Akesson, J., Arnold, M., Clauss, C., Elmqvist, H., … Viel, A. (2012). Functional Mockup Interface 2.0: The Standard for Tool independent Exchange of Simulation Models. In 9th International Modelica Conference (pp. 173–184). Munich, Germany: Linköping University Electronic Press. http://doi.org/10.3384/ecp12076173

P12 - Detection of Metamodel “Smells” within the Modelverse

Summary

The same language can be described with an infinite number of grammars.

But while they represent the same language, we can often state that one grammar is better than the other, for example in terms of maintainability or error-proneness. In the programming world, "code smells" are used to identify potentially problematic pieces of code which, although possibly perfectly working, might be worth looking at from a maintenance point of view. For (textual) grammars, a taxonomy of smells has been defined, including a (preliminary) smell detector. Grammars and metamodels share many similarities.

In this project, you will apply this taxonomy to metamodelling. You will port applicable "smells" to the metamodelling domain (for simple Class Diagrams), and create a smell detector based on model transformations, which annotate the metamodel, in the Modelverse.

Guide: Yentl Van Tendeloo
Background:

Mats Stijlaart and Vadim Zaytsev. 2017. Towards a taxonomy of grammar smells. In Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering (SLE 2017). ACM, New York, NY, USA, 43-54. DOI: https://doi.org/10.1145/3136014.3136035
Yentl Van Tendeloo and Hans Vangheluwe. The Modelverse: a Tool for Multi-Paradigm Modelling and Simulation. In Proceedings of the 2017 Winter Simulation Conference, 2017 (accepted).

P13 - Formalization and Verification of the FMI Standard using UPPAAL

Summary

Since the simulation tools are independent of one another, there must exist an orchestrator which communicates with the tools. When the tools run their simulations in parallel, the orchestrator must make sure that the tools pause at the right simulated times, so that the values exchanges have the same timestamp.

Parallel orchestration algorithms can implement sophisticated mechanisms (e.g., the use of extrapolations functions to present long pauses of fast simulation tools) and their correctness should be formally verified.

In this project, the student is going to use a model checker to formally verify the behavior of a parallel orchestration algorithm (the concrete algorithm is to be determined yet).

The results of this project can be published and will help the rapidly growing number of companies using co-simulation to formally check that their algorithms are correct.

Guide: Cláudio Gomes
Background:

Gheorghe, L., Bouchhima, F., Nicolescu, G., & Boucheneb, H. (2007). A Formalization of Global Simulation Models for Continuous/Discrete Systems. In Proceedings of the 2007 Summer Computer Simulation Conference (pp. 559–566). San Diego, CA, USA: Society for Computer Simulation International.
Behrmann, G., David, A., & Larsen, K. G. (2006). A Tutorial on Uppaal 4.0.
Blockwitz, T., Otter, M., Akesson, J., Arnold, M., Clauss, C., Elmqvist, H., … Viel, A. (2012). Functional Mockup Interface 2.0: The Standard for Tool independent Exchange of Simulation Models. In 9th International Modelica Conference (pp. 173–184). Munich, Germany: Linköping University Electronic Press. http://doi.org/10.3384/ecp12076173

P14 - Concrete syntax icon definition language for explicitly modelled concrete syntax

Summary

Every language consists of an abstract and concrete syntax. Explicitly modelling the concrete syntax mapping has many advantages. Nonetheless, the current approach to this is non-trivial to define. In this project, you will create a concrete syntax icon definition language, based on a specific perceptualization format. From this DSL, a mapping to the actual perceptualization activity is automatically generated. Additionally, this icon definition language will be used for bootstrapping. All of this done in the Modelverse.

Guide: Yentl Van Tendeloo
Background:

Yentl Van Tendeloo, Simon Van Mierlo, Bart Meyers, and Hans Vangheluwe. Concrete Syntax: A Multi-paradigm Modelling Approach. In Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering (SLE), pages 182-193, 2017. DOI: 10.1145/3136014.3136017
Yentl Van Tendeloo and Hans Vangheluwe. The Modelverse: a Tool for Multi-Paradigm Modelling and Simulation. In Proceedings of the 2017 Winter Simulation Conference, 2017 (accepted).

P21 - Model Sonification

Summary

The prevalent way of concrete syntax definition, is through the

rendering with graphical primitives such as rectangles, circles, text,

and lines. Some models, however are better perceptualized in a different

manner. An example is the use of plotting or sonification. With model

sonification, a model is perceptualized not visually, but auditively:

the model is "played" as if it were audio. Some metamodels, such as that

for a music sheet, are ideally perceptualized in multiple ways:

graphically (for editing) and auditively (for evaluation). In this

project, you will use an existing concrete syntax infrastructure in the

Modelverse to reason about and implement model sonification.

Guide: Yentl Van Tendeloo
Background:

Yentl Van Tendeloo, Simon Van Mierlo, Bart Meyers, and Hans Vangheluwe. Concrete Syntax: A Multi-paradigm Modelling Approach. In Proceedings of the 10th ACM SIGPLAN International Conference on Software Language Engineering (SLE), pages 182-193, 2017. DOI: 10.1145/3136014.3136017
Vasco Sousa and Eugene Syriani. 2015. An Expeditious Approach to Modeling IDE Interaction Design. In Joint Proceedings of the 3rd International Workshop on the Globalization Of Modeling Languages and the 9th International Workshop on Multi-Paradigm Modeling. 52– 61