Easy concurrency is one of the main prophesied benefits of the modern functional programming (FP) languages. But the implementation of concurrency differs widely between different FP languages. In this talk, we shall explore the methods and primitives of concurrency across three FP languages: Haskell, Erlang, and Clojure (with core.async).

We shall learn about and compare the trade-offs between

• the green threads and STM channels oriented concurrency of Haskell
• everything-is-a-process and message-passing actor pattern of Erlang
• macro-based CSP transformation of Clojure/core.async

We recently started working on a new Elixir project and had the need for a background processing system.

We decided to build our own background processing system in Elixir.

This talk describes why and how we built our own background processing system in Elixir.

How we use Elixir's GenStage package for adding back-pressure between the producer and consumer stages and how we add support for custom rate-limiting between several pipelines.

DSLs allow us to express our code in verbs and nouns that describe our domain. This helps keeping business logic clean of implementation specific details, and allows for more readable code. Few languages have support for easily defining DSLs, for example macros in clojure/lisp, metaprogramming in ruby, but these techniques are not portable to other languages. Free monads is a way to convert a functor into monads, and allow us to create a structure for our desired computation, which can be interpreted later. This also allows us to decouple the definition of a DSL from its interpretation. In this talk we explore the use of Free monads to easily define DSLs and their interpreters.