I am a PhD student at the Software Technology Group at TU Darmstadt. I’m mainly interested in User Experience Design and User Research. My aim is to support the work of my colleagues by offering qualitative and quantitative insights into how their research fares when applied to real-world use cases.

My current research deals with how the principles of Local-first software can be applied to human-facing applications, and the technical as well as usability challenges associated with doing so. For that I’m designing and evaluating prototype apps. I’m especially curious about creating collaborative tools that are seamless and convenient to use, without sacrificing user agency or privacy.

Open Theses

  • Improving Usability of Web API Documentation by Generating Specification-Compliant Usage Examples

    Generate synthetic usage examples for poorly-documented web APIs, validate and test examples for relevance/correctness, and evaluate with user studies.B.Sc.M.Sc.User StudyWeb APIsDXMore info

    TL;DR: Generate synthetic usage examples for poorly-documented web APIs, leveraging existing docs/examples/similar APIs, validate & test examples for relevance and correctness; evaluate via user studies

    Key Points:

    • Scope: B.Sc. / M.Sc. thesis
    • Language: English
    • Areas: Research, Implementation (no constraints), Evaluation (User Study)

    The Problem

    Web APIs are ubiquitous in modern software, but the quality of available documentation for each API varies wildly. Without adequate documentation, making proper use of an API becomes challenging, error-prone, and inefficient. In many cases, documentation is (at most) generated from the actual implementation, which only reveals available endpoints, accepted parameters, and similar properties. This often results in web API documentation providing little to no usage examples. The teams or individuals maintaining those APIs and their accompanying documentation don’t always have the time and resources to manually add relevant usage examples and guides. At the same time, proper usage examples can significantly enhance developer performance and are therefore a critical part of the documentation.

    The Idea

    Investigate ways to generate synthetic usage examples for specific web APIs. These usage examples could be based on existing documentation, usage examples from existing implementations, or examples from similar web APIs, among others. Generated usage examples are validated against the API’s specification, checked for relevance, and (if possible) tested via end-to-end testing. Results should be evaluated, ideally through a study involving human developers. The initial focus should be on web APIs of popular Open Source / FOSS projects with poor API documentation.

    Envisioned Results

    In the end, there should be two main results. Firstly, requirements or “best practices” for web API examples have been investigated and codified where possible, using existing research, among other resources. Secondly, an enriched documentation has been created for at least one web API. “Enriched” means that several real-world examples have been added that aid with actual usage of the API, based on the discovered requirements. Ideally, these examples should cover a given use case, spanning all individual steps of that use case, specifically any interactions with the API. All examples should be successfully executable against a specific version of the API. Finally, these results should be evaluated, ideally through a study involving human developers.

    Qualifications

    • Required:
      • Experience with using web APIs programmatically
      • Experience with creating (developer) documentation
    • Optional but useful:
      • Interest in Open Source projects
      • Experience with API testing
      • Familiarity with NLP methods
      • Experience with or knowledge about running user studies

    References & Further Reading

  • Improving Conflict Handling for Source Code Collaboration by Employing an AST-CRDT

    Explore CRDT-based collaboration using AST-based change tracking for source code to reduce merge workload and improve conflict handling.B.Sc.M.Sc.ASTsCRDTsDXMore info

    TL;DR: Combine CRDTs with ASTs; handle source code changes by diffing ASTs and applying changes as AST transformations; improve quality of conflict resolution and reduce manual merge workload

    Key Points:

    • Scope: B.Sc. / M.Sc. thesis
    • Language: English
    • Areas: Research, Implementation (AST management ideally in Python, otherwise no constraints), Evaluation (Practicality, Performance)

    The Problem

    Collaborating on source code is generally done through git, which employs text-based merge strategies. These don’t consider the structure of programs, which can lead to syntax errors, semantic errors (bugs), or fragmentation of code blocks. Additionally, merge conflicts are often avoided by developers since they are tedious to resolve. While the git model is obviously popular and working well, there is potential to improve the developer experience (DX) and assist with merge conflict resolution.

    The Idea

    Instead of applying changes to a program by diffing text, we could instead use the program’s AST (abstract syntax tree) to ensure any changes are semantically sound and stay grouped together in all cases. By combining ASTs with CRDTs (conflict-free replicated data types), we can introduce the needed collaboration capabilities into such a system, an approach proven to be fundamentally possible. For concurrent changes, conflicts must still be considered, so we need to create tooling to handle conflicts in ASTs. Here again, CRDTs already offer support for handling conflict resolution, and could be extended to cover this specific use case. Further challenges might arise in translating edits to the source code into changes to the AST, and vice versa. Additional interesting aspects to consider are modelling code comments and discussions, and “cross-client compatibility”, i.e. allowing people to use regular source code editing via git and this AST-based approach at the same time.

    Envisioned Results

    In the end, there should be a way to sync changes to the source code of a program via a custom CRDT that models the program’s AST. Conflicts should be handled properly without causing syntax errors or broken ASTs. Any changes must converge across all replicas. The source code of programs to sync may be constrained to a single source file.
    The CRDT should be useable to collaborate across multiple replicas, either through a custom frontend with built-in editor, or by using a daemon / file watcher that picks up changes made to files.
    Ideally, any comments in the source code should be persisted and synced along with the program logic.

    Qualifications

    • Required:
      • Fundamental understanding of ASTs
      • Solid familiarity and experience with Git-based workflows
    • Optional but useful:
      • Familiarity with CRDTs
      • Familiarity with distributed systems
      • Familiarity with parsing ASTs, e.g. in Python or Java
      • Knowledge of Git merge strategies

    References & Further Reading

Short Biography

whenwhat
since 2025Ph.D. Student, Software Technology, TU Darmstadt
2025M.Sc., Computer Science, TU Darmstadt

Publications