Suggested topics for individual software projects and/or Bc/Master theses

We offer various topics connected with Internet of Things, virtualization and cloud, embedded and distributed systems, middleware, operating systems, performance engineering, verification and testing, model-driven development, etc. The best is to contact us. We will create a topic specifically to your skills and interests.

Similarly, if you have your own idea that is related to our focus or courses we teach, do not hesitate to contact us too!

To give you an idea about possible topics, you can find several ready-made ones below. They can be also adjusted to your interests.

Low power smart sensor network

The goal is to design and develop a system for collecting data from a set of distributed smart sensors. The sensors communicate with a central station via a low power network (LPWAN), e.g. LORA. The central station processes the collected data, stores them localy and/or remotely (in a cloud). Additionally, the central station can control the sensors.

The sensors can monitor for example temperature/humidity of the air or temperature/humidity of the soil or height of a set of unmanned aerial vehicles or ...

Target: individual software project, Bc. thesis

Contact persons: Tomáš Bureš, Petr Hnětynka

Smart plant pot

The goal is to design and develop a smart plant pot. The required features of the pot are as follows.

  • The pot monitors humidity and temperature of the soil and humidity and temperature of the air.
  • The pot reports measurements to a central storage (cloud).
  • A plant owner monitors current status and history of measurements.
  • The pot sends alerts when temperature/humidity are "out of limits".
  • The limits are set automatically based on the growing plant
    • The user sets a kind of the plant; the pot downloads limits from a cloud
  • Possible extensions
    • Adding an illumination sensor
    • Supporting a set of pots
    • Supporting sharing of the air sensors (i.e., a set of pots on the same window sill shares the air sensors)

Target: individual software project, Bc. thesis

Contact persons: Tomáš Bureš, Petr Hnětynka

Dynamic analysis tool for C#

Dynamic analysis is a popular approach for detecting bugs, runtime checking and other software engineering tasks. The goal of this project is to create a tool that will record certain events, such as field accesses and method calls, during the program execution, and pass them to various analyzer plugins. It should be extensible with custom plugins and also highly configurable (e.g., what information is recorded). Code for recording of events is typically added by instrumentation of the original input program at the compile time. The Roslyn compiler framework may be used for this purpose.

Target: individual software project, Bc. thesis

Contact persons: Pavel Parízek

Digital Asset Management

The goal is to design and develop a digital asset management system (a digital asset is almost anything, i.e., a document, photo, video). The required features of the system are as follows.

  • user-friendly and extensible hierarchical tagging (meta-data), automated tagging
  • enterprise search plus possibility to edit the search results
  • versioning, backup, archiving of assets
  • supporting basic workflows and roles, possibility to monitor a status of assets
    • e.g., receiving documents from a local drive — automated tagging — asset approving — updating/validating tags/metadata
  • Probably developed as an extension to Pydio (http://pydio.com)
    • web-based application (PHP)

Target: software project (4-5 team members)

Contact person: Tomáš Bureš

A Tool for Systematic Literature Reviews

The goal is to design and develop a tool supporting systematic literature reviews (SLR). The required features of the tool are as follows.

  • automated download and categorization of scientific documents (papers, articles,...)
  • support for different
    • review protocols
    • types of documents
    • sources
    • categorization criteria
    • automated analyzes
  • a workflow for a manual concurrent annotation of documents by multiple users
  • a connection to Zotero (http://zotero.org/)
    • storing and searching documents

Target: software project (4-5 team members)

Contact person: Petr Hnětynka

An extension of JetBrains MPS

The goal is to extend the JetBrains MPS platform to support additional programming languages and implement new features, extensions, plug-ins.

Target: software project (4-5 team members)

Contact person: Pavel Parízek

Memory demand optimization of fixpoint algorithm for PHP analysis

Static analysis of programs is a common technique to verify software properties. It is can be tuned to be either fast or precise, but not both. Since the imprecision in terms of a high number of false-positive warnings makes it impossible to be used in the development process, the time and memory demands of the analyser have to be lowered by means of efficient algorithms and optimizations. The goal of the thesis is to design and implement an optimization of the fixpoint computation exploiting the fact that it is sufficient to store the program state just for one program point for each cycle. The states of other cycle points can be computed on demand (when needed in subsequent phases of the analysis), which can even save some time. The implementation context is the PHP analysis framework.

Contact person: Jan Kofroň

Assignment in SIS...

Integration of Weverca into CI server

Weverca is a static analyser for finding security bugs in PHP applications. The core application is written in C#, however, there is a Java wrapper used in an Eclipse plugin, and a web interface in PHP as well. Jenkins is the leading open source automation server. Built with Java, it provides hundreds of plugins to support building, testing, deploying and automation for virtually any project. The goal is to intergrate Weverca into Jenkins. This involves adjusting the Weverca output format to be parsable by the Jenkins framework and creating a Jenkins plugin interfacing with Weverca. Otherwise, Weverca will be used as a black-box.

Contact person: Jan Kofroň

Implement debugging support for the WALA static analysis library

Implementing static analyses using libraries such as WALA is difficult because there is very little debugging support. Developers typically use logging of plain text messages at many places in their implementation of a static analysis. A log message contains, for example, (1) the source code location corresponding to the current node in a control-flow graph and (2) a complete snapshot of the current data-flow information associated with the node. Messages are printed on the standard output or written into a log file. Log files generated in this way can be too large for manual inspection by a developer who needs to find the root cause of some error. The goal of this work is to design and implement debugging support for the static analysis library WALA. An important part of the solution would be an API for monitoring the static analysis during its run and notifying registered listeners about specific events on demand. Relevant events could be, for example, application of the transfer function defined for a specific bytecode instruction and update of the data-flow information for a particular node in the control-flow graph. The proposed debugging API should also allow developers to inspect the data flow values associated with nodes in the control-flow graph at specific points during the analysis computation. One of the main benefits for the developers of custom static analyses would be that the implementation does not have to contain so much code for printing log messages anymore.

Contact person: Pavel Parízek

Assignment in SIS...

Dealing with the state explosion problem in test case generation using model checkers

One of the well-known techniques for model-based test generation exploits the capability of model checkers to return counterexamples upon property violations. However, this approach is not always optimal in practice due to the required time and memory, or even not feasible due to the state explosion problem of model checking. A way to mitigate these limitations consists in decomposing (exploiting variables dependency) a system model into suitable subsystem models. Tests are built for the single subsystems and combined in order to obtain a test for the whole system. The aim of the thesis is to automatize the approach for specifications of the NuSMV model checker. Starting from a test goal, the variables involved in the test goal must be identified. Then, dependencies among variables and strongly connected components of variables must be found. Given the partition of the variables in strongly connected components, different (smaller) NuSMV models must be obtained. Finally, sequences must be derived from the models and combined to obtain a test for the whole system.

Contact person: Paolo Arcaini

Assignment in SIS...

Dynamic Paired Application Profiling

The goal of this assignment is to develop a tool and a method for identifying performance regressions in the runtime environment (Java Virtual Machine, Just-In-Time Compiler) as opposed to regressions in applications themselves.

  • The same application would be run under different versions of the runtime environment
  • Selected (possibly random) methods would be dynamically instrumented in both copies
  • Measurement comparison would reveal performance differences

Contact persons: Petr Tůma

Profiling in Limited Execution Context

When profiling applications, we can pick methods that are either close to the root or close to the leaves of the call tree.

  • Functions high in the call tree
    • Are called less frequently, take a long time to complete, have large code
    • It is difficult to identify reasons for performance regressions in such methods
  • Functions low in the call tree
    • Are called from too many other locations
    • Performance regressions are easily recognized but not clear what caller is impacted
The goal of this assignment is to develop an instrumentation approach capable of measuring a method only in a particular call path, or even only on a particular object instance.

Contact persons: Petr Tůma

Modern JVM Benchmark Suite

Java Virtual Machine can execute a spectrum of languages supported by modern dynamic compilers (C, R, JS, Ruby and so on). The goal of the assignment is to build a suite of benchmarks to support further virtual machine and compiler development.

  • The benchmarks should be selected from a range of practical workloads
  • The assignment should examine major workload features and estimate workload space coverage
  • Compiler optimizations triggered by individual workloads should be included in the coverage metrics

Contact persons: Petr Tůma

Regression Benchmark Visualization Console

Build a regression benchmark visualization console that will provide interactive access to measurement data from the Graal regression benchmarking project.

Contact persons: Petr Tůma

DiSL Session Support

DiSL is a bytecode instrumentation framework utilizing a domain-specific language for instrumentation hosted in Java. One of the important features of DiSL is that it retains Java as the language for both the inserted code as well as code that controls the instrumentation process. To avoid perturbation to the observed program due to the use of Java during instrumentation, DiSL performs instrumentation in an isolated process, the DiSL server. The goal of the project is to design a proper instrumentation service with support for instrumentation sessions. This will allow a client to supply the instrumentation server with all the information necessary to fulfill its instrumentation requests (as opposed to configuring a server for a specific task) for the duration of an instrumentation session.

Target: individual software project, bachelor thesis

Contact person: Lubomír Bulej

Combined DiSL Instrumentation and ShadowVM Analysis Server

DiSL is a bytecode instrumentation framework utilizing a domain-specific language for instrumentation hosted in Java. ShadowVM is a server for executing dynamic analyses driven by events emitted by the observed program in a separate VM. Experience has shown that these two (separate) servers would benefit from operating in the same address space, sharing data of instrumented classes to provide better support for both instrumentation-time and analysis-time reflection. This requires merging the two servers, merging the client parts of each of the servers, and designing a new, efficient, communication protocol between the client and the server parts.

Target: master thesis (potentially an extension of the DiSL Session Support project)

Contact person: Lubomír Bulej

Modular Weaver for DiSL

DiSL is a bytecode instrumentation framework utilizing a domain-specific language for instrumentation hosted in Java. At the heart of DiSL is a weaver which inserts user-defined snippets of Java code into the base program. The existing weaver in the DiSL framework is rather monolithic, hindering maintenance and development of new features. The goal of the project is to modularize the DiSL weaver into multiple self-contained transformations that are applied on the Java bytecode in a predefined order.

Target: individual software project, bachelor thesis

Contact person: Lubomír Bulej

Modularization of Dynamic Analyses

Dynamic program analysis tools based on code instrumentation serve many important software engineering tasks. However, constructing new analysis tools is difficult, because existing frameworks offer little or no support to the programmer beyond the incidental task of instrumentation. The goal of this project is to develop an extension of the DiSL instrumentation framework that would support composing dynamic analyses in a modular fashion so that tasks related to maintenance of analysis state could be separated and reused.

Target: master thesis (potentially an extension of the Modular Weaver for DiSL project)

Contact person: Lubomír Bulej

(Foundations of) Smart Collaborative Disassembler

The goal is to build an advanced disassembler that could be used in a collaborative fashion, i.e., with multiple users disassembling the same binary at the same time. The project should lay foundation for supporting multiple processors and binary formats, but is only required to provide support for one or two. Besides collaborative disassembly, the main focus would be designing an internal representation that would enable static analysis, limited symbolic execution, and also allow the user to reorganize and move instructions between basic blocks within the confines of the data flow graph.

Target: software project (4-5 team members)

Contact person: Lubomír Bulej

Logo of Faculty of Mathematics and Physics
  • Phone: +420 951 554 267, +420 951 554 236
  • Email: info<at-sign>d3s.mff.cuni.cz
  •  
  • How to find us?
Modified on 2017-10-10