I had an incredible response to the call for talks for Fun @Facebook, thanks to everyone who offered a talk! The schedule and abstracts are below. As you can see, I've kept the slots short (25 minutes) in order to fit in 9 talks and 2 breaks. Time will be tight, but it should be good Fun. More details about logistics to follow. Schedule: March 12 ================== 12.00-1.00 grab some lunch nearby, then head to Facebook London ------------ 1.00 José Pedro Magalhães: Chordify: Advanced Functional Programming for Fun and Profit 1.25 Dominic Orchard: Fun with indexed monads 1.50 Patrick Chilton and Niklas Hambuchen: Brain reading with Hemokit 2.15-2.45 BREAK ------------ 2.45 Claudio Russo: Tabular: A DSL for Probabilistic Inference from Excel 3.10 Duncan Coutts: Binary serialisation: better, stronger, faster 3.35 Ben Ford: Haskell in production 4.00-4.30 BREAK ------------ 4.30 Tarmo Uustalu: Update monads, or how you always wanted to combine reading and writing 4.55 Dominic Steinitz: Automatic Differentiation: A Criminally Underused Tool? 5.20 Maceij Pirog: FizzBuzz in Haskell by Embedding a Domain-Specific Language 5.45 END (pub + food) Abstracts ========= José Pedro Magalhães Chordify: Advanced Functional Programming for Fun and Profit Abstract Functional programming, especially when using advanced techniques such as GADTs, type functions, and kind polymorphism, is not only fun; it can also be profitable. In this talk I'll describe my experience in using advanced functional programming in Haskell within Chordify, a web startup that brings chord recognition to the masses. ------------- Dominic Orchard Fun with indexed monads Monads are well established as an abstraction technique for programming with effects of various kinds. At the type-level, monads present a black-box view of effects: for some notion of effect, a computation is either effectful or not. This contrasts with the richer information provided by effect systems. Various work has unified monads and effect systems, both syntactically (Wadler & Thiemann, 2003) and semantically (Katsumata, 2014). In this talk, I show how to program with "indexed monads" in Haskell which semantically unify monads and effects, where a monadic type constructor is indexed by a monoid of effect information. A number of examples are shown, including verifying finite-element computations in scientific computing using indexed monads. This is joint work with Tomas Petricek, Andrew Rice, and Alan Mycroft. ------------- Patrick Chilton and Niklas Hambuchen Brain reading with Hemokit We present our Haskell driver for the Emotiv EEG and how you can use it to control your computer with your brain. We might discuss good and bad experiences in binding-writing and might try to abuse the audience to solve our problems. ------------- Claudio Russo Tabular: A DSL for Probabilistic Inference from Excel Joint work with: Andy Gordon, Thore Graepel, Nicolas Rolland, Johannes Borgström, John Guiver, Marcin Szymczak Tabular is a probabilistic functional language embedded in Excel. Tabular brings the power of machine learning to data enthusiasts - the large class of end users who wish to model and learn from their data, who have some knowledge of probability distributions and data schemas, but who are not necessarily professional developers. Tabular is an Excel plugin that provides a much simpler, interactive interface to the underlying Infer.NET inference engine. Tabular helps the data enthusiast model and visualize their data. Tabular automatically suggests a model from the data schema, allows the enthusiast to edit and refine the model, infers model parameters from data and predicts missing values, and visualizes the results using Excel's standard features. The ability to query for missing values provides a uniform interface to a wide variety of tasks, including classification, clustering, recommendation, and ranking. Tabular is based on probabilistic programming technology, which enables a wide range of machine learning algorithms to be constructed based on a probabilistic model. A unique feature is that Tabular models are simply succinct annotations on the relational schema of the Excel data model. The talk will give an overview and demo of the language in action. ------------- Duncan Coutts Binary serialisation: better, stronger, faster This talk is about a new implementation of binary serialisation for Haskell's 'binary' package. It is faster -- much faster -- and produces smaller binary output, but just as importantly it provides a story for versioning and migration and the ability to view the binary data without a schema. We will look at the binary format of the current binary (and cereal) packages and see why it makes developers nervous and excludes potential uses. We will describe some of the qualities that we want from a serialisation format, the particular format choice that we have settled on and how we can implement versioning/migration. We will also look at the performance side of things: why the existing binary serialisation packages are not as fast as they could be and at the key tricks -- high level and low level -- in the new implementation. There will be quite a bit of GHC-core code diving and discussion of evaluation and runtime issues. Some of these optimisation tricks or analysis techniques may be useful in your own projects, and should give you a renewed appreciation for GHC's capabilities. ------------- Ben Ford Haskell in Production Fynder is a start up building a platform for discovering and booking services across multiple different industries. This talk will be about how we tackle the problem and how we've built a development, testing and deployment environment around Haskell as the core language. ------------- Tarmo Uustalu Update monads, or how you always wanted to combine reading and writing Did it ever trouble you that, despite feeling a bit like it, state monads fail to be a common generalization of reader and writer monads? I will introduce you to update monads, a true generalization of reader and writer monads that is moreover as canonical as it gets. An update monad is given by a set (of states), a monoid (of updates) and an action of the monoid on the set (defining the effect of every update on every state). Update monads are exactly the compatible compositions of reader and writer monads, which are in a bijection with distributive laws between reader and writer monads. State monads are canonically related to those update monads where the monoid of updates is the free monoid on the overwrite semigroup structure on the set of states. Update monads do not just have a clean theoretical motivation; embracing many natural examples, they are also a practical abstraction. A finer dependently-typed variation of the concept has every state coming with its own set of enabled updates. This is joint work with Danel Ahman, University of Edinburgh. ------------- Dominic Steinitz Automatic Differentiation: A Criminally Underused Tool? Artificial Neural Networks (ANNs) are a well-established Machine Learning (ML) technique. Traditionally, training ANNs is done using a technique called backpropogation. It turns out that this is just a specialised version of Reverse Automatic Differentiation (RAD) and steepest descent. This talk explains the theory behind RAD and develops an implementation in Haskell of Forward Automatic Differentiation (FAD) with a brief application to another ML technique: regression. ------------- Maceij Pirog FizzBuzz in Haskell by Embedding a Domain-Specific Language The FizzBuzz problem is simple but not trivial, which makes it a popular puzzle during job interviews for software developers. The conundrum lies in a peculiar but not unusual control-flow scenario: the default action is executed only if some previous actions were not executed. In this tutorial we ask if we can accomplish this without having to check the conditions for the previous actions twice; in other words, if we can make the control flow follow the information flow without loosing modularity. And the contest is for beauty of the code. We deliver a rather non-standard, and a bit tongue-in-cheek solution. First, we design a drastically simple domain-specific language (DSL), which we call, after the three commands of the language, Skip-Halt-Print. For each natural number n, we devise a Skip-Halt-Print program that solves FizzBuzz for n. Then, we implement this in Haskell, and through a couple of simple transformations we obtain the final program. The corollary is a reminder of the importance of higher-order functions in every functional programmer s toolbox.