Conference talks

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.

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.

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.

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.

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

2019

Verified Code Generation from Isabelle/HOL

Doctoral Dissertation

Slides Link

2018

A Verified Compiler from Isabelle/HOL to CakeML

European Symposium on Programming (ESOP, Open Access)

Slides Link

2017

Safer functional programming with F*

Munich Lambda

Link

2016

Translating Scala Programs to Isabelle/HOL

International Joint Conference on Automated Reasoning (IJCAR)

Slides Link

2015

When Types are Not Enough

Scala World


What Haskell can learn from Scala

Haskell eXchange


Semantics-Preserving Simplification of Real-World Firewall Rule Sets

Formal Methods (FM)

Slides Link

2014

Macros vs Types

Northeast Scala Symposium


Typelevel Scala: What does it mean for the language, the ecosystem, the community, and you?

Scala.IO

Recording Link

State of the Typelevel

Scala eXchange (Keynote)


Interactive Simplifier Tracing and Debugging in Isabelle

Intelligent Computer Mathematics (CICM)

Slides Link

The Next 1100 Haskell Programmers

Haskell Symposium

Recording Slides Link

2013

Seven at one blow

Northeast Scala Symposium


Generating Type Class Instances Automatically

Scala Workshop

Slides Link