[Haskell] Fun in the Afternoon @Facebook, March 12 2014: Schedule

Thu Feb 13 11:08:29 UTC 2014

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.