The 30th Netherlands Functional Programming Day
On Mon 02 Jan, at 13:55, an email was sent (via bcc) to all registered participants. And another one at 16:52. Check your spam folder if you don’t see it.
The Netherlands Functional Programming Day (a.k.a. FP Dag) is an annual gathering of researchers, students, and practitioners sharing a common interest in functional programming. The day features talks that cover the latest advances in research, teaching and applications in the area of functional programming and (implementation of) functional languages.
Coffee and lunch breaks provide ample opportunity for networking with your colleagues and meeting new people. Experts and newcomers to the field are equally welcome.
Colleagues from neighboring countries are more than welcome to attend; the language of the FP Day is English.
Date and Time: Friday 06 Jan 2023, 09:30 – 18:00
Venue: The morning presentations will take place at TU Eindhoven (Auditorium, CZ 04) and the lunch and afternoon presentations at Sioux Labs (Esp 101, 5633 AA Eindhoven)
TU Eindhoven (campus info) is at a 10-minute walk from Eindhoven Central Train Station. Sioux Labs (map) is at a 6-minute direct non-stop bus connection from TU/e, from the bus stop on J.F. Kennedylaan (exit the bus on the next stop called Tempellaan). [Map with central station, Auditorium, and bus stop on J F Kenndylaan marked – Availability of OV rental bikes at central station – Map with Sioux Labs and Restaurant Surabaya marked]
Registration: Participation is free of charge, but you do need to register, no later than Fri 23 Dec 2022. Lunch and drinks will be provided. (Do note that parking your car at TU/e and riding the bus aren’t free.)
Organizers: Tom Verhoeff (overall & content) and Agnes van den Reek (logistics) at Software Engineering & Technology Group, Dept. Math. & CS, TU Eindhoven, and Duncan Stiphout at Sioux Technologies
Sponsors: Software Engineering & Technology, TU Eindhoven (organization and morning program) and Sioux Technologies (lunch and afternoon program)
Sioux Technologies brings high-tech to life
… and contributes to a society that is healthy, safe, smart, sustainable and more fun. We are a strategic high-tech solutions partner that develops, innovates and assembles complex high-tech systems with advanced Software, Mathware, Electronics and Mechatronics.
As the largest privately-owned tech company in the Netherlands, Sioux is focused on people and building long-term relations. We are continuously developing our 900 bright employees. This way, more fun & value is created, for the employees, the (inter)national customers, Sioux itself and the world around us.
Schedule (see below for overview of presentation titles, download links, and abstracts)
|09:30 – 10:00||Registration at TU Eindhoven, Auditorium, Voorhof (1st floor, red section)|
|10:00 – 11:15||Presentations (academic/educational)|
10:00 Tom Verhoeff
10:25 Jaap van der Woude
10:55 Wouter Swierstra
|11:15 – 11:45||Break|
|11:45 – 12:45||Presentations (academic/educational)|
11:45 Pieter Koopman
12:15 Jaro Reinders
|12:45 – 14:30||Transfer to Sioux Labs and Lunch|
|14:30 – 15:30||Presentations (applied/industrial)|
14:30 Duncan Stiphout
14:45 Koen Rutten
15:05 Victor Miraldo
|15:30 – 16:00||Break|
|16:00 – 17:00||Presentations (applied/industrial)|
16:00 Eric Torreborre
16:35 Edsko de Vries
|17:00 – 17:05||Business Meeting|
|17:05 – 18:00||Drinks and Networking|
|18:30||Dinner at Indonesian Restaurant Surabaya, Kruisstraat 62B|
Dinner: We will end the day with a joint dinner (at your own expense; separate registration is mandatory; max. 45 places available).
FP-Day 2022 was organized in Utrecht: Program.
Mailing list for Functional Programming in the Netherlands: fp-nl
Presentations – Titles and Abstracts
10:00–10:25 – Tom Verhoeff (TU Eindhoven): The calculational birth of applicatives and monads
Monads (and applicatives) are well-known ways to structure functional computations, where two chains of computational paths are separated. One path serves the primary goal, and this remains explicitly visible, while the other path serves auxiliary goals and is encapsulated in the way functions are combined. The latter is accomplished through the bind operator in a monad (>>= in Haskell), or sequential application in an applicative (<*> in Haskell). Often, monads seem to fall from the sky. In the presentation, I will show through the example of decorating binary trees how one can discover a monadic solution by calculation.
10:25–10:55 – Jaap van der Woude (TU Eindhoven): Monad transformations for parameterised inductive types
Monad transformers are abundant in Haskell and appear in other languages too. Many declarations and instances appear in libraries and some proofs are available in the literature. They are mostly based on composition of adjoints and lifting monads to Kleisli or Eilenberg-Moore categories. For parameterised inductive types, like the Free monad, List and Rosetree we propose a different method: the level-wise lifting is taken care of by the Rolling Rule.
10:55–11:15 – Wouter Swierstra (U Utrecht): Calculating data structures
Where do data structures come from? In this talk, we will explore how to systematically derive implementations of one-sided flexible arrays from a simple reference implementation. Using the dependently-typed programming language Agda, each calculation constructs an isomorphicyet more efficient data structure using only a handful of laws relating types and arithmetic. Although these calculations do not generally produce novel data structures they do give insight into how certain data structures arise and how different implementations are related.
11:45–12:15 – Pieter Koopman (RU Nijmegen): Does Task Oriented Programming Reduce IoT Development Grief?
Internet of Things (IoT) software is notoriously complex, conventionally comprising multiple tiers. Traditionally an IoT developer must use multiple programming languages and ensure that the components interoperate correctly. A novel alternative is to use a single tierless language with a compiler that generates the code for each component and ensures their correct interoperation. We report a systematic comparative evaluation of the tierless Task-Oriented Programming (TOP) and the Python-based tiered approach. We show that the TOP approach requires 70% less code and is more reliable. The TOP approach is ported to resource-constrained IoT nodes and preserves the advantages.
12:15–12:45 – Jaro Reinders (TU Delft): Compiling with Effects and Handlers
Compilers transform human readable source languages into machine readable target languages. Traditional compilers are monolithic, which means they are hard to understand and hard to extend. We present our ongoing research into a modular semantics-driven compiler architecture which explores the use of effects and handlers to model the intermediate languages and the transformation passes. We show how this approach can be applied to a minimal compiler for a language with arithmetic and let-bound variables.
14:30–14:45 – Duncan Stiphout (Sioux Technologies): Sioux Technologies brings high-tech to life
Sioux Technologies contributes to a society that is healthy, safe, smart, sustainable and more fun. Our smart people apply the best fitting languages, methodologies and tools in software and mathware to get the job done. In this presentation Duncan will introduce Sioux as host of the FP Day 2023 and he will highlight some interesting projects.
14:45–15:05 – Koen Rutten (Sioux Technologies): Structured matrix operations for high performance embedded optimal control using an embedded domain specific language
We present Warp, a library for working with structured matrices as encountered in optimal control problems. Specifically, we focus on the constraint matrix for Quadratic Programming problems. The limited coupling of actuator constraints, combined with the time-aspect, leads to a constraint matrix built of repeated blocks (a Kronecker product), surrounded by blocks of zeros.
When solving a Quadratic Programming problem, repeated calculations using this matrix need to be performed, which require a significant portion of the time spent by the solver.
Warp provides a functional domain-specific language to specify such matrices, and calculations based on them. Additionally, it can optimize expressions to equivalent, but faster expressions, and evaluate them.
Focusing on embedded performance, Warp is written in C++, and heavily relies on BLAS. In addition, Julia bindings are available for easy experimenting.
15:05–15:30 – Victor Miraldo (Channable): Resolving Metadata Generically
In this talk we go over an industrial example of using Generic1 and a study in software decomposition. In this case, we had to split a large system into two separate components: its pure kernel and the impure interface that needed to resolve all sorts of metadata by querying a database. The challenge here was maintaining backwards compatibility: no datatype could be observably changed! The solution was a type-indexed datatype and some generic programming to avoid a painful amount of code duplication. The conclusion is that we must always design with composition in mind, because decomposition is prohibitively more difficult.
16:00–16:35 – Eric Torreborre (Symbiont): Wire all the things!
This talk shows how a simple idea, building a list of functions and values, can help us design evolving protocols, implement flexible data generation and create modular applications.
16:35–17:00 – Edsko de Vries (Well-Typed): Eliminating thunk leaks once and for all: the nothunks library
Memory leaks in Haskell applications can be notoriously difficult to debug. A large class of memory leaks arise from thunk leaks: when parts of an application’s long lived state remain unevaluated, they might hold on to large amounts of data. Such problems are usually easily solved once isolated; typically it is a matter of using stricter data types. However, finding the problem in the first place can sometimes be fiendishly difficult; a single missing bang somewhere deep down in a data type declaration could be the result of a huge space leak. With the nothunks library we can debug such problems easily; we get immediate and easily interpretable error messages pointing to where the thunk is, and we can check as part of an integrated test suite that such thunks do not arise, and get minimal counter-examples when they do.