We are looking forward to working with you on your thesis project (in German or English)!
Our group offers a range of open thesis topics in the general area of software engineering or programming languages.
We also welcome your own ideas, especially if they are in scope of our research topics.
If you are interested in pursuing a thesis with our group, please send us an email with the following information:
a brief description of the kind of work you are interested in (e.g. more theoretical, more practical, a programming task, ...)
your level of knowledge of the theory or implementation of programming languages (if any)
a current transcript of your grades
potentially relevant skills you acquired outside of university
The symmetrical properties of the sequent calculus make it an interesting base for functional programming languages. In contrast to the prevalent base lambda calculus, it allows for an equivalent treatment of terms producing information and evaluation contexts. In this thesis, we have constructed and implemented a term language for the sequent calculus, along with its cut-free fragment. We further present a normalization function that evaluates statements to their cut-free form, utilizing cut elimination and hereditary substitution. Thereby, it lends itself as a compiler intermediate language, shifting computation from runtime to compile-time, and optimizing program execution.
Testing is one of the most important methods for ensuring software quality.
However, traditional example-based testing methods have inherent limitations: they are restricted to evaluating individual scenarios,
yet they are often used to justify broader claims than these scenarios can support.
In dieser Bachelorarbeit wird beschrieben wie Bend, eine Programmiersprache, die auf Interaktionskombinatoren basiert und noch in Entwicklung ist, als Backend des Effekt Kompilierers hinzugefügt wird. Bend kompiliert zu HVM, was für Higher-order Virtual Mashine steht. HVM implementiert die von Lafont [5] entworfenen Interaktionskombinatoren. Bend kann einige Lambda-Terme in von Levy [7] definierter optimaler Zeit berechnen und sehr leicht mehrere Berechnungen parallel durchführen. Deshalb hoffen wir mit Bend als Backend die Laufzeit von Effekt in einigen Programmen stark zu reduzieren.
This thesis aims to provide a way to translate classical sequent calculus to the LLVM intermediate representation to utilize the LLVM toolchain and achieve greater performance than compiling directly to machine code. We provide examples of how this translation works, what the resulting optimized version looks like and how and why we implemented a custom memory allocater to suit our needs. We show how to evaluate the resulting programs and how we test the validity of the translation. Finally we benchmark our approach against other programming languages and compare the resulting performance.
Concurrent programs are widely used in practice, but notoriously difficult to get right,
particularly when dealing with the locking and synchronization of shared memory between threads.
However, ensuring correctness becomes even more challenging when individual components,
which may function correctly in isolation, interact with each other.
Software Transactional Memory offers a solution by abstracting over the low-level details of concurrent programming,
providing atomic blocks that enable modular composibility of transactions.
Inference programming - the adaptation of inference algorithms to a particular model or problem - is difficult in languages that do not deal with side effects or do not handle side effects properly due to their nature of relying on effectful computation. In functional programming, monad transformers are the most common approach to control side effects. However, this makes it difficult to customise such algorithms. Effects and effect handlers on the other hand introduce another possibility to deal with programmable inference. This thesis will demonstrates this idea by developing three inference patterns (Metropolis-Hastings, slice sampling and rejection sampling) using the language Effekt. The result is a more user-friendly way to adapt and combine parts of these algorithms
Alle Programmiersprachen besitzen eine gemeinsame Schnittmenge der grundlegenden Abstraktionen. Durch einen Kompiler oder Interpreter werden die Abstraktionen in Maschinencode umgesetzt und dann ausgeführt. Je besser diese Umsetzung optimiert ist, desto performanter ist die Ausführung des Programmes. Im Paper Are-We-Fast-Yet [ 5 ] werden 9 Microbenchmarks entwickelt, welche in moderat komplexen Programmen jeweils bestimmte Bereiche dieser Core Language testen. Die Benchmarks werden in verschiedene Programmiersprachen implementiert und die Ausführung auf Zeit gemessen. Anhand der Ergebnisse lässt sich eine generelle Aussage über die Performanz einer Programmiersprache, beziehungsweise Kompilers/Interpreters machen.
Reactive systems are an important part of everyday programming. Still, the implementations of such reactive systems differ hugely, which has a major impact on the style and reliability of reactive programs. The main approach to implementing reactivity and parallelism in the industry is to use multi-threading. This approach often leads to non-deterministic behavior. Additionally, programming languages often need extra implementations for reactivity and parallelism to support multi-threading. Languages such as Effekt eradicate the need for additional reactive system language support, by implementing algebraic effects. With algebraic effects, it is possible to implement a vast amount of programs, including reactive systems.
In this work, we present Reactive, a library for the programming language Effekt. Reactive uses algebraic effects to implement reactivity and parallelism in direct style. The ability to write programs in direct style leads to more readable code, as it appears to be sequential, while the control flow is handled with algebraic effects. Reactive defines a synchronous execution model, by interleaving waiting parts of the program. The synchronous approach of the library makes decisions over the execution flow of the program deterministic. Parallelism and reactivity are decoupled by using different effects and handlers. With schedulers, Reactive creates the ability to run parts of a program in parallel. Reactive implements different schedulers, which handle the control flow of the program by enforcing rules. Such rules can be the termination of parts of the program when another has already stopped. The awaiting of an event is done by polling an environment in a busy wait loop, which can be interleaved with other parts of the program. Additional to the Effekt implementation, this thesis implements the ability to wait for JavaScript events inside the Effekt language.
Effekt is a functional programming language developed for research on algebraic effects and handlers. Aside from algebraic handlers, Effekt also features side effects in form of mutable state using region-based memory management.
The Effekt compiler has multiple backends, one of which targets the LLVM Intermediate Representation. The LLVM-IR can be compiled to an executable file with many optimization passes on the way.
The LLVM backend of Effekt covers only a subset of Effekt’s features. As part of this thesis, we extend the LLVM backend by support for mutable state.
Most IDEs for Python development follow traditional code analysis approaches that are known to work well for statically-typed languages such as Java or C++. A lot of modern Python code is untyped, and these conservative tools tend to assign the “Any” type for variables that do not have explicit type annotations. However, programmers are usually able to deduce types (and often concrete values) by looking at surrounding code and jumping through function definitions and call sites.
Handling resources, such as files or network sockets, in a language with control (such as exceptions) safely can become difficult. We need to make sure that all memory is eventually
freed and all file handles and sockets are closed; even in the case of an exception.
Viele der Lehrmaterialien welche wir in der Lehre verwenden bestehen aus nicht interaktiven Skripten und Foliensätzen.
Aber viele Inhalte der Informatik eignen sich besonders gut für eine interaktive Präsentation.
Durch eine interaktive Präsentation können auch sehr abstrakte Inhalte greifbar und verständlich gemacht werden.
So wird zum Beispiel häufig auf Animationen und interaktive Graphiken zurückgegriffen, um die Ausführung von Algorithmen zu veranschaulichen.
Good type errors are an important tool to improve programmer productivity.
Ideally, they can help to quickly localize and fix problems and help programmers
to not only better understand the error, but also the underlying program.
Effekt is a novel programming language featuring new ways to modularize software and structure complex control flow.
In particular, it includes lexical effect handlers as well as an advanced type- and effect system.
However, the language is yet lacking a full module system.
Static type systems help to avoid programming errors by indicating to the programmer
at compile time that a value potentially has a wrong type. This way, unsupported
operations (such as dividing two strings or calling a method on a number) are ruled
out before the program is executed.
