Functional Programming Madrid

⚠️ Please remember to provide your full name and an identification document (ID card, passport, etc.) in the designated question during registration. You will be required to present this document on the day of the event in order to access the ILab.

We’re excited to kick off the new season of talks after the summer break, and we couldn't imagine a better way to start. We're honored to welcome Oleg Kiselyov, premiering the season with a deep dive into Tagless-Final Style. Don’t miss the chance to learn directly from one of the key figures behind this influential style!

AGENDA.

18:30. Welcome.
18:35. Talk by Oleg: Tagless-final and generating fast streaming or parallel code for data analytics (see abstract below)
19:30. Roundtable and discussion. An open session focused on sharing feedback with Oleg about how we understand and apply (or don’t apply) tagless-final in our daily work
20:00-. Networking (proudly sponsored by Habla Computing).

TITLE. Tagless-final and generating fast streaming or parallel code for data analytics

Abstract. Data analytics -- transforming and querying, grouping, aggregating volumes of data -- is one of many areas that demand both the flexibility and high performance. Chaining up and readjusting processing operations is intuitive -- but also often slow, resource-demanding and hard to parallelize. (Concurrent) state machines offer the highest performance, but are difficult to write correctly and, especially, modify.

In this talk we show, on several realistic examples, how to work around the dilemma: writing intuitive and intuitively correct pipelines and get (very) high performance. The overall idea is basically the old macro processing, but `upside down'. Typically, the base language is very expressive and the macro system/preprocessor is restrictive, idiosyncratic and often `bolted on'. In contrast, we take as a `macro' language a general-purpose language with all its conveniences; it is the `base' language that is bare -- with just the words needed for the problem at hand. As in writing, choosing the right words is hard. There are a few good heuristics however.

Tagless-final is the way to conveniently build the base (or, target) sentences, extend the target language and give its words meaning, often in terms of other, lower target languages -- eventually, C, Wasm or simple subsets of OCaml and Scala.

We show building nested aggregation pipelines -- incrementally and interactively (with REPL and with audience), testing along the way. The completed pipeline may then be compiled to a sequential or parallel C, OCaml or Wasm code. All these backends are represented as a lowest target language, extensible and swappable.