We can arrange external supervision for theses and projects related to specific industrial-driven products and projects. In this respect we cooperate with companies such as JetBrains, IBM, Oracle, RedHat, Microsoft, SUSE or SysGo.

Contact the local coordinator for a specific company.

These kind of projects are sometimes initiated by the students (e.g. by having a part time job) and sometimes by our industrial partners (also via the Partnership Programme). We can help you with some of the formal requirements but we expect that in the end students will bring their topics.

Contacts

The following people are responsible for coordinating projects with our industrial partners.

Project ideas

Please, take the list below as an overview of what is possible, not as an exhustive list: many of the projects are closed sourced and cannot be easily shared on our site.

JetBrains

  • Exploring Challenges in Software Testing Tasks
  • Optimise the select expression in Kotlin coroutines
  • Support for the gRPC in Kotlin/Native in kotlinx.rpc
  • Synthetic Dataset Creation for Kotlin Code Completion
  • AI-based Unit Test Generation Improvement
  • AI Completion for IJ Terminal
  • AI Code Completion for Small Languages

SUSE

  • systemd scalability. systemd is PID 1, that means it is a system-wide reaper and a single thread. There are certain operations that require O(n) time, although not in fast-paths, that may cause inconvenient latencies of some necessary tasks (daemon-reload). The goal is to identify non-scaling parts and improve their behavior.

  • Allow for processes to exit in parallel. Mostly to handle very large address space tear down.

  • Simulation of very large memory setup. The simulation would use CXL.mem (or CXL.cache) on QEMU.

  • API call for cheap free userspace allocator. Design an API and implementation for userspace allocator with cheap free (ideally MADV_FREE like) while still allowing to catch use after free bugs. The primary focus is on reducing overhead of page table manipulation.

  • Memory compaction vs zswap. Memory compaction reduces fragmentation, thus making swap less likely. zswap compresses pages, thus making swap consuming less bandwidth. Both, however, do consume additional CPU, thereby increasing latency. It would be interesting to see how these methods compare against normal swap - does the increased latency outweigh the reduced bandwidth and how?

  • Improve memory fragmentation for large block sizes by improving compaction When using large block sizes for I/O, memory fragmentation increases, setting an effective upper limit on the block size we can support. With improved compaction, we should be able to reduce memory fragmentation and support even larger block sizes.

  • NVMe scaling NVMe scaling is always an exciting topic. We just had a report that things really do go down south beyond 4k drives, it would be interesting to see where the actual limits are (10k drives ? 100k drives ? who knows ?) …

  • Network queue steering for NVMe-TCP NVMe goes to great lengths to align I/O with the submitting CPU. That works great for submission, but for completion we’re at the mercy of the network card to do “something”. The idea is to implement receive flow steering to classify incoming network traffic to the correct queue and thus CPU.

  • Verifying the BPF verifier The BPF verifier makes sure unsafe code does not make it into the kernel. But the verifier also needs to be verified. We want to use the CBMC checker to verify some internal functions of the BPF verifier, with integration into BPF tests and run on BPF CI.

SUSE also provides internship opportunities and an access to their Open Build Service for student projects.

Microsoft

Please see the current project and thesis ideas by Karel Zikmund. If you are interested in any of these, contact Karel (read the above page) and get in touch with Pavel Ježek or Tomáš Petříček (especially for F# projects) to discuss local arrangements. We can also come up with other potential topic ideas!

Bachelor thesis (and Individual Software Project) topics

  • Create an IL rewrite library on top of System.Reflection.Metadata.
  • Implement some .NET runtime analyzers and code fixers.
  • Implement some ASP.NET Core analyzers and code fixers
  • F# Compiler - Support ‘without’ for anonymous records

Master thesis topics

  • Prototype WebTransport in .NET Core based on already existing HTTP/3 and QUIC implementations.
  • ⁠Port .NET trimming tool from Cecil API to System.Reflection.Metadata backend. .
  • Create mutation testing for .NET project based on CLR Instrumentation Engine.
  • Create coverage-guided fuzzing for .NET/C#.
  • F# Tooling - Search engine for typed functions by using F# Compiler APIs (aka ‘hoogle for F#’)
  • F# Compiler + Language design - Support for anonymous type-tagged union types
  • F# Compiler - Type Providers - Generate types from other types

SYSGO

  • Porting libraries or software to the PikeOS runtime (Native/POSIX)
    • Python, Apache Kafka, XML libraries
  • Implementing prototypes for handling new hardware features in the kernel
    • Intel CPU tracing, Remote DMA, Power management, RISC-V hypervisor
  • Improvements in verification approaches for critical software
    • Fuzz-testing, testing multi-threaded systems