Whatever the system you’re working on it can probably be thought of as a living organism. You nourish it, extend it, add new abilities and inevitably it will depend on external factors to operate properly.

It’s not uncommon for systems to have multiple dependencies on external services. This communication sometimes goes both ways – as well as being asynchronous a lot of the time – and appropriate actions should be taken when certain ‘events’ happen.

The way in which these ‘events’ are handled can be the difference between a clean, easy to reason about codebase and a tangled mess. Who never got stuck in callback hell?

Functional Reactive Programming provides better abstractions in such scenarios.

It models your system’s behaviors as streams of values that change over time. In a functional setting, this allows streams to be filtered, mapped over, sampled, reduced and composed in a number of ways much like you compose pure functions.

In this talk you’ll learn what’s in it for you: how you can use FRP, what’s its sweet spot as well as what tools are available to you.

Make sure you bring a laptop with a working Clojure development environment. By that I mean at least two things:

• Leiningen 2.x: https://github.com/technomancy/leiningen
• Your favourite Clojure editor: Emacs, vim, La Clojure (IntelliJ plugin), Counterclockwiste (Eclipse plugin) or any other editors you like

The complexity of web applications grows exponentially with time. Managing so much state in a modern single-page web application is challenging and difficult to reason about. Frameworks such as AngularJS and Backbone take some of that pain away at the expense of better abstractions and tight coupling between templates and display logic.

Facebook created React in an effort to mitigate this issue. It recognises how powerful the abstractions in functional programming are and let’s you write components which are simply functions from state to DOM sub-trees.

In this talk we’ll look at React through Om, a Clojurescript binding that further improves React’s performance by leveraging immutable data structures.

Games have traditionally been developed in an imperative fashion due to their stateful nature. But what if we could leverage the benefits of pure functional programming in such a setting?

This Code Jam aims to guide attendees through the process of writing a game in Elm, a purely functional language that compiles to Javascript.

Elm is based on Functional Reactive Programming (FRP), a programming paradigm for declaratively building interactive applications.

By the end of this code jam attendees will have enough knowledge of both Elm and FRP and how they can be used to model mutable state in a purely functional way as well as resources to dig in deeper.

PREREQUISITES

I’ve created a docker image to allow attendees to follow the workshop without an internet connection. Instructions are here: https://github.com/leonardoborges/elm-workshop-ylj2015