Talks

Selected talks

These are talks that I have given multiple times over the years at various conferences. Each of them has a dedicated page with slides and the latest recording. If you want to share a particular talk, I would like to ask you to not link to a recording directly, but rather to the talk's page as linked here.

Functional Mocking
Mocking is an infamous technique from object-oriented programming. The goal is to be able to test stateful systems in small pieces by simulating the behaviour of certain objects. The problem with mocking is that it usually requires heavyweight frameworks and clutters test code. There are countless rants on that topic, but this talk isn't one. Instead, we'll explore the functional approach in Haskell: Designing a small language supporting the desired behaviour, and then writing interpreters which can execute its semantics in various ways. Testing I/O code was never easier.
JS, Rust, Python and the Holy Graal
In the old times, way back, Java used to be the only JVM language. Later on, a few other players entered the field, such as Jython and JRuby. But those were just for scripting, right? It didn’t take long for compiled languages to catch up. With Scala and Kotlin, we have definitely entered the age of polyglot programming on the JVM. The Truffle project – part of GraalVM – is a promising approach to make it easy, efficient, and seamless to run alternative languages on the same VM as Java. This talk will look at the new age of polyglot programming and all the cool things we can do with it.
OptimusPrimeT
Everybody knows monads by now, so a talk about monads would hardly be worthwhile. Let's take it to the next level: monad transformers. You'll learn what they are, how they naturally emerge in your code base and how to make good use of them in Scala – and maybe even how to create your own.
Programmation en Logique
Prolog is one of the most underrated programming languages around; possibly because of its strange syntax and the unusual paradigm. But it is a very nice special-purpose programming language. In this talk, I introduce Prolog’s programming model, showcase some programming domains in which Prolog allows for very concise, elegant programs, and finally describe how it can also be used as a general-purpose tool.
How to test proper{t,l}y
Writing unit tests is pretty much established practice and in addition to that, property testing has caught up on popularity. Most functional languages have one, sometimes even many implementations. But "property testing" has a lot of aspects: randomized or exhaustive, minimization and generalization of counter examples, custom generators and filters, to name a few. Very often, property tests don't exploit all the features of the framework. In this talk, I'll give an overview of the state of the art of property testing and show some common use cases, techniques and pitfalls.
Numeric Programming with Spire
Numeric programming is a notoriously difficult topic. For number crunching, e.g. solving systems of linear equations, we need raw performance. However, using floating-point numbers may lead to inaccurate results. On top of that, as functional programmers, we’d really like to abstract over concrete number types, which is where abstract algebra comes into play. This interplay between abstract and concrete, and the fact that everything needs to run on finite hardware, is what makes good library support necessary for writing fast & correct programs. Spire is such a library in the Typelevel Scala ecosystem. This talk is an introduction to Spire, showcasing the ‘number tower’, real-ish numbers and how to obey the law.
Theorems for Free
In the typed functional programming communities, there is much talk about “reasoning with types”. But rarely is this elaborated into something concrete. Just how can we extract tangible information from types beyond playing mere type tetris? The secret sauce is called parametricity, first described by John C. Reynolds, and later applied to Haskell by Philip Wadler in his seminal paper “Theorems for free!”.

Ausgewählte Vorträge

Diese Vorträge habe ich über die Jahre hinweg auf mehreren Konferenzen gehalten. Jeder Vortrag hat eine eigens angelegte Unterseite, jeweils mit Folien und der jüngsten Aufzeichnung. Wenn du einen bestimmten Talk teilen möchtest, würde ich dich bitten, nicht die Aufzeichnung, sondern die hier verlinkte Unterseite zu verwenden.

Verifikation von Smart Contracts
Smart Contracts sind eine Technologie, mit der man Code auf Blockchains ausführt. Eine Vielzahl von Geschäftsfällen werden inzwischen durch solche Verträge abgebildet. Ethereum ist dafür eine beliebte Plattform. In diesem Vortrag wollen wir uns anschauen, wie man die Qualität des Codes sicherstellen kann.
Lieber ein Typparameter zu viel als einer zu wenig
So gut wie alle modernen Programmiersprachen erlauben es, Routinen zu parametrisieren – über Werte und über Typen. Für Letzteres gibt es verschiedenen Begriffe: "Templates", "Generics" oder aber "Parametric Polymorphism". Diese Begriffe sollen hier einmal geklärt werden. Außerdem lernen wir die Vorteile von Typparametern kennen und warum Type Erasure in Java nicht nur richtig, sondern auch notwendig ist. Schließlich kommen wir auf Philipp Wadlers einflussreichen Artikel "Theorems For Free" zu sprechen, welcher eine Technik beschreibt, mit der wir Aussagen über Programme nur anhand der Typen treffen können.
Das eierlegende Truffleschwein
Damals, ganz früher, da war Java noch die alleinherschende Sprache auf der JVM und konnte tun und lassen, was sie wollte. Später gesellten sich ein paar Skriptsprachen hinzu, wie zum Beispiel Jython und JRuby. Und die neuen kompilierten Sprachen wie Scala und Kotlin haben das Zeitalter der polyglotten Programmierung endgültig eingeläutet. Das zur GraalVM zugehörige Truffle-Projekt verspricht nun, es noch einfacher zu machen, auch eigentlich JVM-fremde Sprachen mit dem Ökosystem zu verzahnen.

Other Talks

This is a partial list of other talks I gave. Only talks with recordings are listed here.