Home > Theses @stoerrle +45 45253757 hsto@dtu.dk

Theses

This page presents ongoing thesis topic projects, and suggests some new topics. Feel free to inquire about them, or base your own topic proposal on these ideas.

Thesis Projects
Below you find a number of past and ongoing thesis projects - and of course open projects. If you think you want to do one of these, fill in this Questionnaire, and visit Harald at 303b.053.
RedCloud Visual Workflow Control

Available!

Extending on Ioannis and Ahmadreza's previous work, this project will provide features that allow easy handling of very large (visual) workflows. This project combines Python hands-on experience with visual styling and interaction design.
Read more >>>
Connaisseur: Analysing Visual Languages

Jeppe Hartmund, expected 2016-08-01
In SE, we use a lot of visual languages: UML, BPMN, ERD, IDEF, ... but are they any good? And, more importantly, can they be made any better? The "Physics of Notations" is a (deficient) theory aout this, and Jeppe aspires to operationalize it as far is it will allow.
NOVA: Refactoring for Prolog

Luai Michlawi and Casper Paulsen, expected 2017-02-15
The NOVA Project provides an IDE for refactoring and documenting large scale Prolog programs. It will be an Eclipse-perspective, based on the popular PDT and the previous contributions by Daniel (see below). This project, however, will extend the refactorings by architecture-scale transformations, and possibly some type inference.
RED-17: Glossaries for RED

Available!

Having a glossary seems unimportant to many students at first, but it is an incredibly powerful tool in structuring a specification and delineating the context and scope of a project. In other words: it is of greate practical importance. However, it is at current less than ideal in RED.

In this project, concepts and features for automating and checking glossaries are to be developed. In particular, there should be a process of crawling existing text fragments (typically in "Description" fields), and creating cross-references (and, indeed, new glossary entries) automatically. Read more >>>
RED-18: UML for RED

Available!

Over time, RED has been equipped with many concepts very similar to UML, while maintaining a clear and lean meta-model. Some concepts and diagrams are still missing though, and the challenge in this project is to add them in a parsimonous and elegant way.

In this project, we are looking to add state machines, interactions, processes, and deployments with their respective concepts and diagrams. Much of the infrastructure is already there, so this is a prime opportunity to exercise meta-modeling. Read more >>>
Diagram Patterns

Available!
Diagrams exhibit patterns of layouts - but exactly which and how often? And can we, somewhow, compute which pattern a diagram exhibits, and how closely it adheres to a given pattern? In this family of projects, empirical work harvesting diagrams can be combined with implementational work (extending MagicWand, to be precise), and conceptual/mathematical work with a touch of machine learning. This project will upgrade the MagicWand tool by Luai that supersedes Magnus' work on the ModelReporter (see below).
NOVA: Refactoring for Prolog

MSc, Daniel Brand, completed 2015-08-13
The NOVA Project will provide an IDE for refactoring and documenting large scale Prolog programs. It will be an Eclipse-perspective, possibly based on the popular PDT - but that is open to technical investigations. NOVA will be showcased on our existing Prolog-libraries that have evolved over the past decade, and are in desperate need of re-engineering, documentation, and some TLC.
RED-16: Tracing, Consistency, and Metrics for RED

Sebastian Dittmann, expected 2017-02-01

One of the most common problems of students is to understand what the quality of a requirements specification is. Some facettes of this notion can be captured in a straightforward objective way: there shall not be spelling mistakes, there shall be tracing links, and so on.

In this project, concepts and features for analysing the quality of requirements specification will be added. The tool shall support users in an interactive way and reduce their workload rather than adding more burden and effort on them.Read more >>>
RED-15: RED Interoperability

Available!

No man is an island, and RED needs connectivity, too! It should allow importing and exporting CSV and XLSX, JSON (from REDO), and common requirements formats like ReqIF. Besides all the down-to-earth file handling questions, the challenge of this project is to make sense of existing data, and "Guess" what they mean so as to transform them and insert them into RED. Read more >>>
RedCloud Visual Model Version Control

MSc, Ahmadreza Ranjbartari, expected 2016-06-01

Extending on Ioannis' previous work, Ahmadreza provides the administration and monitoring features that will turn RedCloud into a practical tool that can be used in the classroom to support teaching requirements
Read more >>>
RED-14: REDO

Andreas Toftegaard, completed April 2016

RED is a desktop tool for requirements engineering, based on the Eclipse RCP framework. Manz people like to use their tools online, these days, so it would be good if we could choose whether we want to use RED installed locally, or on the web.

In this project, you will use an existing technology toolstack to cross-compile RED into a web application. One option is to use Google Web Toolkit to create JavaScript, but there are other options to consider, too.Read more >>>
ModelScope 4: ModelScope on the web

available!

ModelScope is a tool to measure and analyse (sets of) models. In order to make it available for other scientists (and, indeed people in industry), it would be great if ModelScope had a web-interface and were available online to the world. This project aspires to create an online version of ModelScope.
Surveyor

available!

When there are many contributions in a research field, organizing the body of knowledge can be difficult. There are two techniques that can help doing just that: Structured Literature Reviews (SLRs), and Systematic Mapping Studies (SMS). However, these techniques are very labor-intensive. So, we want to create the Surveyor tool to automate those steps that can be automated.
Gourmand 4: Gourmand on the web

available!

Gourmand is a tool to harvest models from documents and pictures. In order to make it available for other scientists (and, indeed people in industry), it would be great if Gourmand had a web-interface and were available online to the world. This project aspires to create an online version of Gourmand.
RED-12: Helping RED Users

MSc, Puvishanan Srinavasa, completed 2015-08-13

Available for re-implementation!

Over time, RED has become a very large and powerful tool. The project has evolved from a mere proof-of-concept prototype into a semi-professional software product with a rapidly expanding user base.

One of the things about RED that is less than professional is the stat of its documentation. In fact, there is little more than code comments, a sample project, and an out-of-date on-line help system. In order to help all new users of RED to effectively use its many features and discover new capabilities, different kinds of documentation is required, including the usual manuals and samples, tutorials, step-by-step videos and many more. Puvi's job is to inventarize the documentation we have, identify the most urgent gaps, and fill them with content. If successful, using RED will be a much simpler and more effective experience than now!

Since Puvi's project did not live up to the expectations, this project is available for a second try.Read more >>>
Model Transformations Made Usable: What is Known About Concrete Syntax Model Transformation Languages?

Ivan Vinogradov, Completed 2015-07-25

Usability is a critical non-functional aspect in the development of model transformation languages MTL(s). A popular option for addressing usability concerns in MTL design is the adoption of concrete syntax transformation rules, i.e. rules incorporating the concrete syntax of the source and/or target modeling languages. However, there is currently no overview of the existing uses of concrete syntax in model transformation languages. The goal of this project is to provide such an overview.

In the course of this project, the student will perform a Structured Literature Review (SLR). He will be provided with a review protocol, and his task will be to find all relevant literature, extract the data specified in the protocol, and interpret the data using primarily descriptive methods (e.g. visualizations, tables). The result of the student’s work will be a deeper understanding of the use of concrete syntax in MTLs, representing a genuine research contribution to the Model-Driven Engineering (MDE) community.

This is a "Research Immersion" course project (number 02001, 5 ECTS), main supervisor will be Vlad Acretoaie
OCL Query API (OQAPI)

Available!

The ability to query models effectively is an important aspect of the practical work with models. We have examined many different approaches for this purpose, and one of them is OQAPI. IT has never been fully implemented, though, and since the recent updates to OCL, it is completely out of date. In this project, a new, improved implementation of the API shall be created in OCL using one of the popular OCL tools. This library should be made available as open source code. Some validation experiments with OQAPI should be conducted.
Harvesting Business Processes

MSc, Ivan Petrov Petrov, completed 2015-07-01

Gourmand is already way past its main competitor, but why stop there? Let's make it even better by adding support for other common modelling notations such as BPMN, EPC, and deployment diagrams. This project contains an extensive validation of the capabilities and performance of Gourmand, too, so that we can actually prove its superiority.
RedCloud Visual Model Version Control

MSc, Ioannis Oikonomidis, completed 2015-08-13

Version control has always been a tricky task, and even many CS students have serious trouble with the concepts involved. So how can we ask domain experts to be proficient users of a VCS? And even worse: for models, such as UML and requirements models, there are additional difficulties not encountered in classic version control approaches.

One of the reasons there has been no break-through in this matter so far is that all of the previous attempts took the point of view of the VC system - not that of the user. In this project, we will try to develop a VCS, that focuses on modelers' activities, with a view to making version control of models a whole lot easier.Read more >>>
Model Querying

Available!

MQ-2 is a MagicDraw-plug-in that allows complex model queries expressed in the Visual Model Query Language (VMQL). VMQL is far superior to all popular approaches in terms of generality and usability, as we have shown in many experiments. However, VMQL has evolved, and the performance of MQ2 is not satisfactory. So, we are looking to replace MQ2 by your work: MQ3. The implementation is probably best done as a web-service, and there is very likely opportunity for optimization by running it on a GPU.
LithMod-2: Literate Modeling

Available!

Just like source code, models are much more frequently read than written. But unlike source code, the audience for models is far more diverse and less technically-minded, yet using a CASE tool requires much more expertise than using a text editor. So, models are often delivered in the from of a (printed) document. In the ModelReporter project (see below), we worked on using the built-in reporting facilities of MagicDraw to create nice reports from UML models. This is the right approach if you are heavy on modelling, and not so heavy on text. If you are faced with the opposite situation, ModelReporter is a very heavy-weight tool.

But imagine a LaTeX package or Word macro that allows you to specify a small model fragment inside a text which would be rendered automatically (e.g., like with yUML), or could be extracted into a "proper" modeling tool. Such a tool would be very useful for light-weight modeling - and that is the purpose of this project.
AIDE-5: XAML Code Generation

Available!
AIDE is quite mature at its front-end, but lacks capabilities at its back-end: it currently creates HTML5-mock-ups which are useful for quick prototyping but somewhat restricted in functionality. AIDE can also create XUL-Code, but the heyday of XUL is apparently over. Microsoft uses a very similar format though, XAML, that is present in many MicroSoft products. The goal of this thesis is to complement the old XUL-Cartridge with a much more modern and comprehensive cartridge for modelling and exporting XAML applications. Ideally, there will be an integration with existing MS development tools, most notably VisualStudio.Read more >>>
RED-10: Risks, Releases, Features, and Priorities

MSc, Dany Fhalpotia, expected 2016-02-08
RED is a great tool for teaching, but it lacks some capabilities necessary for actual projects. One of them is the ability to model and deal with priorities. Priorities are needed to plan releases, and are informed not just by business value (see RED-6 below). In this project, concepts like Risk, Release, and ReleasePlan are added. New features include computing the cost/benefit of a single release as well as that of a release plan aggregated over time, risk modelling and impact computation, and connecting risks to goals. Finally, various techniques for prioritization are supported, so that users can chose the method suitable for them.Read more >>>
The Model Observatory

MSc, Ari Björnsson, Ragnar Hardarsson, expected 2016-06-17
In many scientific disciplines, corpora (i.e., sample data sets) play an important role. Corpora can be used to benchmark new and existing approaches, or to Thus, the availability of corpora can be quite vital for the advancement of a scientific discipline. In the case of model based development, there are only two publicly available corpora, both of which are inadequate. At the DTU, we have collected a wealth of UML models that we want to share with the world. To this end, we want to create the "Model Observatory", a web-application to share models. The Model Observatory is supposed to be implemented using PHP/JS with appropriate frameworks (e.g., BOOTSTRAP, jQuery). It will provide a user-friendly discovery interface to a model archive, quite possibly based on Zenodo - but that is to be decided. One particular challenge is the administrative interface, which is designed to minimize the effort to maintain the Model Observatory. Ari and Ragnar will create the MOCCASSIN platform, fill it with existin gmodels, and deploy it to suppor the Model Observatory.
RED-9: Software Architecture Modeling

Jesper Kjaer, expected 2016-07-01
RED is a requirements engineering tool developed here at DTU, for the RE course (02264). RED offers a broad collection of features relevant to Requirements Engineers, including Use Case modelling, but, critically, lacking modeling capabilities to address software architecture. We are looking to such features into RED, including analysis features which would be a great contribution towards requirements validation.Read more >>>
RED-6: Business Perspective of Requirements

MSc, Johan Paaske Nielsen, completed 15-08-2014
RED covers much of the technicalities of requirements specification, but offers little in terms of assessing the cost and benefit of a (set of) requirements, in other words: the business perspective of requirements. Johan adds such features to RED, including manual and UseCase-Point-based cost estimation (and all the underlying concepts), tabular comparison and cost-based prioritization of requirements, complete with input from Excel for speeding up work-flows.Read more >>>
MagicLink: Translating Simulink Models into UML for Magic Draw

Available!
Much of the academic modelling community focuses on (variants of) UML, but the industrial uptake of technologies and concepts developed in academia is less than enthusiastic. At the same time, there are some (major) domains, where model-based software development is absolutely dominant, yet there, not UML but Simulink is used. Therefore, we try to develop a converter from Simulink into UML models, thus making our developments accessible to the industrial MBSD mainstream.
RED-7: Visual Goal Modelling

MSc, Jeppe Bloch, completed 2015-03-01
RED is a requirements engineering tool developed here at DTU, for the RE course (02264). RED offers a broad collection of features relevant to Requirements Engineers, but it does have two major gaps, too. One of them is the lack of a visual tool for modeling of goals, and system structures. With such a tool, students (and, indeed, practitioners) would be able to create requirements models faster and easier, with better structure and more benefit.Read more >>>
RED-8: Requirements with Reinforced or Controlled Natural Language

Available!
RED is a requirements engineering tool developed here at DTU, for the RE course (02264). RED offers a broad collection of features relevant to Requirements Engineers, but it does have two major gaps, too. One of them is the lack of a tool for using the most powerful of all requirements engineering tools: natural language. While incredibly powerful, natural languages invite errors and vagueness. Style rules and controlled languages can prevent these, but applying them is really hard - for humans. This project would create tools to apply structured, templated, and controlled language rules to texts. Observe that this project requires at least basic literacy in the PROLOG programming language.Read more >>>
AIDE-4: boosting productivity in UI design

MSc, Tobias B. Aagren, completed 2014-08-11
AIDE is a stand-alone GUI prototyping tool. It takes hand-drawn sketches an converts them into HTML5-mockups, allowing you to add rich transitions between UI parts. It also allows the user to create an abstract UI design using XUL-controls and JavaScript-elements, which can be exported as an executable XUL file. AIDE has been under development since 2008, and over 20 students in Innsbruck, Munich, and Lyngby have contributed to it. So, it is no wonder that many small things have been left over. While each of them may seem small and unimportant, together they are a serious impediment to working smoothly with AIDE: with all these small problems and omissions, there is no way students can work with AIDE in a truly productive. So, Tobias is taking care of that, systematically addressing all the issues, and adding some long-wanted features to AIDE.Read more >>>
Schema Evolution Support

MSc, Kasper Sorensen, completed 2014-08-11
Cooperation with Microsoft
Model Reporter: Mixing Prose with Pictures in MagicDraw

MSc, Magnus Magnusson, completed 2014-11-28
Most people think that editing models and generating codes are the two most important activities in model based software development - practical experience suggests otherwise, however. One of those frequently forgotten, belittled, and under-appreciated activities is reporting, that is, the conversion of a model into a text document. Such documents are often useful for communicating, reviewing, and using models. Keep in mind, that the intersection between decision makers and technology-savy UML users is small, very small indeed. So Magnus looks into creating a mixture of text and diagrams that makes for good reports from UML models, for understanding and reviewing them, and generally making them accessible for UML-illiterate people.
Red-6: Multi-File Requirement Spcifications

MSc, Ahmed Fikry, completed 2014-08-11
Independently of Peter and Kasper, Ahmad shall reengineer RED such that requirements specifications can be distributed transparently over several files; any number of files, actually. This way, the potential of conflicts should be reduced, and collaboration should go much smoother. Also, Ahmad will provide integration with Peter and Kasper's tool such that users will not be aware of the file server in most cases.
Towards Diagram Understanding

MSc, Nick Baltsen and Henrik Christoffersen, completed 2014-08-27
In their joint thesis, Nick and Henrik will explore the effect of diagram layout quality to modeler's perception of models using physiological measurements such as pupillary dillatation, fixation distribution and so on. The goal is to double check and cross-validate our earlier work that seemed to confirm that the quality of diagram layout does indeed have a significant impact. Which is kind of intuitive, if it weren't for all the other related work that says it hasn't... Nick and Henrik will use an advanced eye-tracking system to study this question. The thesis is co-supervised with Anja Maier, an esteemed colleague from the DTU Management Engineering institute, as we want to generalize our findings to other classes of models and extend them to deal with questions of design communication, too.
RedCloud-1: Diff/Merge for RED Requirements Specifications

BSC, Peter B. Bastian, completed 2015-02-13
RED is a great tool for Requirements Engineering, and has been used with great success in teaching and practical case studies. One of its biggest shortcomings, however, is the lack of groupwork-support, that is, features that allow larger and/or distributed groups to collaborate in the creation and maintenance of requirements specifications. Together with Kasper and Ahmad, Peter tries to develop such tool support. Peter's job is to create a generic diff/merge server to allow integration of alternative versions.
Gourmand: Harvesting Models from Office Documents

MSc, Thomas Rossen and Asger Espersen, completed 2014-05-22
Most models start their lives as informal sketches on a whiteboard, or a napkin. And most models end their live then and there. Some, however, are photographed or drawn more nicely with some computerized drawing tool, continue to live for years, and never get close to a "proper" UML modeling tool. We can't know for sure, of course, but it is estimated that in excess of 95% of all UML models come as drawings, tables, or structured text in Word documents, PowerPoint slides, or Visio drawings (if you're really lucky). The only benefit of such models is communication and documentation. While these are important purposes (possibly the most important ones), it would be useful if we could transform such models into "proper" models, that is, in a format used by modeling tools (e.g., XMI). Since it is expected that the vast majority of all models come in this form (we estimate 90%), it would be good if we had tools to trawl corporate file stores and harvest models from there more or less automatically. Who knows what treasure trove we might find? The Gourmand tool is a greedy bugger and takes what it can, transforms it into UML, and makes it available as XMI-files.
MSE-1: Measuring Models

MSc, Jacob B. Hansen, completed 2014-02-21
Model-Based Software Development (MBSD) is attempting to raise the level of abstraction that developers use when creating software. Many practical questions depend on a size metric for models, e.g., productivity is typically measured as output by time, quality is measured as defects by size, and so on. Unfortunately, there is little research on the topic, and no agreed-upon notion of model size. One of the impediments to progress is the lack of a tool to study alternative size metrics with a view of finding the most suitable one ‐ but now, Jacob builds the ModelScope, a tool for exploring different metrics and visualizations of size-related aspects of models. The ModelScope uses the metaphor of an oscilloscope with probes and channels to study models. As with other projects, there is a precursor to this project, that created insight, but did not lead to a usable tool.
RED-5: Weaving of Model Fragments

MSc, Sanam Ali, completed 2014-03-24
One of the really unique features of RED is its ability to add small fragments of visual models to individual requirements. This way, it is easy to validate both the requirement and the resulting model (fragment). Also, this allows to generate an initial UML analysis/domain model representing the requirements, and, conversely, trace back from the domain model into the original requirements. These features only really bear fruit when the weaving of these fragments into a comprehensive (draft) model is automated. RED does have such a weave tool, but lacks several important features and qualities. So Sanam explores how to improve the existing features, and conducts a case study in their usage, examining just what their contribution is, and what benefit we can expect in a large scale application.Read more >>>
RED-4: Reengineering of an Eclipse RCP Application

MSc, Maciej Kucharek, completed 10/2013
RED is a requirements engineering tool developed here at DTU, for the RE course (02264). Over time, its structure has deteriorated ("architectural erosion"), which makes it very difficult to maintain this tool, or to add new, exciting features by other students, and this was the experience Maciej made when trying to add a diff/merge feature. So he decided to embark on a full-blown reengineering project.Read more >>>
FIT-3

MSc, Alexander Egorov, completed 10/2013
FIT is a web-based tool that facilitates formal ("Fagan-style") software inspections. By allowing collaboration over the web, FIT makes it easier for students to work together on a project. Since the inspection technique is applicable to any kind of artefact, it can be applied at any stage of the software development life cycle. Balancing cost and benefit, this is a strong point for using inspections on requirements documents. Previous attempts to create a tool for this purpose (i.e., FIT-1 have resulted in a far better understanding of the tool requirements, but the resulting tool had serious safety issues that made it impossible to use the tool for practical purposes. So, Alexander decided to give it another shot, with a different, exciting technology: Ruby on Rails.Read more >>>
FIT-1

MSc, Rita Petrolyte, completed 10/2011
Formal ("Fagan-style") software inspections are proven to be effective to discover bugs at any stage of a software development project, yet they are not in widespread use. Partly, this is due to the administrative effort involved in running such inspections. The FIT project aims at reducing this overhead to make inspections more practical.
In 2011, Rita analysed this problem, studied the market of tools supporting inspections, and created a first prototype tool based on PHP and JavaScript. This project allowed us to study design alternatives, and conduct some field tests. This has resulted in a far better understanding of the tool requirements, but we also discovered that there were serious safety issues that made it impossible to use the tool for practical purposes. Read more >>>
MSE-1: Measuring the size of Models

MSc, Panagiotis Tsakos, completed 1/2013
An economic angle on software engineering practices requires a way of quantifying the entities we are dealing with - in the case of model based software development, that would be models. The mkost basic of metrics is of course size. However, there is little research on (or, in fact, consensus about) what a good size metric for models might be. Panagiotis' job was to create a tool that would allow us to experiment with a variety of size metrics, to study this problem.
RED 1+2: Tool Support for Requirements Specifications

MSc, Anders Friis and Jakob Kragelund, completed 4/2011
In their thesis, Anders and Jakob created the first version of RED, providing the infrastructure and a set of basic features.
RED 3: Scenarios for Requirements Specifications

MSc, Johan Flod, completed 2/2013
Scenarios are part of many design techniques, including use cases and personas, both of which are used in course 02264. Johan tried to extend RED with scenarios described by structured text. Such scenarios would be executable interactively, thus facilitating the development and validation of scenarios.
MQ-2: An interpreter for VMQL

MSc, Radu-Vlad Acretoaie, completed 8/2012
The Visual Model Query Language (VMQL) is an attempt to provide a visual interface for models, suitable for people without technical knowledge in complex model querying facilities. An initial implementation showed the viability of the notation, but it was implemented in the "wrong" way, hard-coded. Vlad's project was to evaluate, whether it would be possible to implement it the right way, that is, based on a similarity-matching of model and query.
AIDE-3: Interaction Design for Gesture-Based Interfaces

MSc, Thomas Dehn, completed 6/2010
In his thesis, Thomas tried to extend AIDE with features for designing gesture- and touch based interfaces.