All About That Stack: A Unified Treatment of Regions and Control Effects
by Philipp Schuster, Jonathan Immanuel Brachthäuser, and Klaus Ostermann
Technical report. University of Tübingen, Germany, 2021.
Tracking Captured Variables in Types
by Aleksander Boruch-Gruszecki, Jonathan Immanuel Brachthäuser, Edward Lee, Ondrej Lhoták, and Martin Odersky
In CoRR abs/2105.11896, 2021.
Virtual ADTs for Portable Metaprogramming
by Nicolas Stucki, Jonathan Immanuel Brachthäuser, and Martin Odersky
In Proceedings of the 18th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes, pages 36–44. Association for Computing Machinery, 2021.
Multi-Stage Programming with Generative and Analytical Macros
by Nicolas Stucki, Jonathan Immanuel Brachthäuser, and Martin Odersky
In Proceedings of the 20th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences, pages 110–122. Association for Computing Machinery, 2021.
Safer Exceptions for Scala
by Martin Odersky, Aleksander Boruch-Gruszecki, Jonathan Immanuel Brachthäuser, Edward Lee, and Ondřej Lhoták
In Proceedings of the 12th ACM SIGPLAN International Symposium on Scala, pages 1–11. Association for Computing Machinery, 2021.
Representing Monads with Capabilities
by Jonathan Brachthäuser, Aleksander Boruch-Gruszecki, and Martin Odersky
Technical report. Higher-Order Programming with Effects (HOPE), 2021.
Revisiting the Cake Pattern: Scaling "Scalable Component Abstractions"
by Paolo G. Giarusso and Jonathan Immanuel Brachthäuser
Technical report. Talk at Scala Symposium 2016, University of Tübingen, Germany, 2016.
Prioritizing Regression Tests for Desktop and Web-Applications Based on the Execution Frequency of Modified Code
by Matthias Hirzel, Jonathan Immanuel Brachthäuser, and Herbert Klaeren
In Proc. of the Intl. Conference on Principles and Practices of Programming on the Java Platform: Virtual Machines, Languages, and Tools. Association for Computing Machinery, 2016.
Parsing with First-Class Derivatives
by Jonathan Brachthäuser, Tillmann Rendel, and Klaus Ostermann
In Proceedings of the International Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA). ACM Press, 2016.
Modularization of Algorithms on Complex Data Structures: An Encoding of Typesafe Extensible Functional Objects
by Jonathan Immanuel Brachthäuser
Master thesis. University of Marburg, Germany, 2014.
From Object Algebras to Attribute Grammars
by Tillmann Rendel, Jonathan Immanuel Brachthäuser, and Klaus Ostermann
In Proceedings of the 2014 ACM International Conference on Object Oriented Programming Systems Languages & Applications (OOPSLA), pages 377–395. ACM Press, 2014.
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.
Continuous Integration (CI) is a common best practice in software development.
This practice dictates, that among other factors, developers should commit early and often and receive feedback about their work as soon as possible.
In order to be effective in a large scale software development environment and to reap all the benefits that come with it, the CI pipeline has to be designed in a certain way and all stakeholders involved need to be instructed.
Partial type signatures are type signatures allowing wildcards in their definition. These wildcards are placeholders for other types which are inferred at compile-time. By using these wildcards, a programmer is able to annotate parts of a type signature manually and let the typer infer the rest. Therefore partial type signatures allow us to omit potentially long and complex parts of a type annotation while providing more restrictions to the type than without any annotation.
Multiple return values in functions have long been regarded as a powerful feature in programming languages, enabling concise and expressive code. However, not all programming languages support this feature natively. Instead, most languages emulate multiple return values only via tuples. In the case of dynamically typed languages like Common Lisp multiple return values are supported but the dynamic handling may cause headaches: (type-of (values x y z)) is the same as (type-of x). This master thesis delves into designing and implementing multiple return values in the Effekt language. The thesis introduces native support for multiple return values in Effekt, exploring their significance and potential impact on software development.
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.
Together with our collaborators the SE group presents three different papers at this year’s International Conference on Object-Oriented Programming, Systems, Languages and Applications (OOPSLA 2023).
Our paper “A Typed Continuation-Passing Translation for Lexical Effect Handlers” (Philipp Schuster, Jonathan Brachthäuser Head of the SE research groupJonathan Immanuel Brachthäuser, Marius Müller, and Klaus Ostermann) has been accepted for publication at the International Conference on Programming Languages, Design, and Implementation (PLDI 2022).
Our paper Multi-Stage Programming with Generative and Analytical Macros, by Nicolas Stucki, Jonathan Brachthäuser Head of the SE research groupJonathan Immanuel Brachthäuser,
and Martin Odersky was honored with the Best Paper Award at the International Conference on Generative Programming: Concepts & Experiences (GPCE 2021)
