From Ancient Egypt to the Middle Ages humanity lost it's way in the quest to find the philosopher's stone.

While following the recent advance in machine learning one might think that we are running in that same quest again,
only differences this time are that our philosopher's stone is deep learning and the promise is general artificial intelligence instead of immortality.

The current machine learning ecosystem is mainly based on python and pretty much feels like alchemy,
lot of trial and errors, lack of tooling and good engineering practices, ...

Let's take a tour of the current ecosystem and see how can we do better and safer high performance machine learning using Haskell!

We will be spending the day learning the fundamentals of Functional Programming (FP) using the Haskell programming language. The exercise material will be a condensed selection of the NICTA/course which is regularly held in Australia over three days.

This one day session is targeted to experienced industry programmers who are looking to break into Functional Programming and develop the rudimentary skills and techniques that enable continued independent study. A refresher on Haskell syntax will be provided, however, it is highly recommended to practice with the syntax and development tools prior to obtain the best outcome for the day.

You will be required to bring a suitable development machine (portable) for working through the exercises. You will also need to install Glasgow Haskell Compiler (http://www.haskell.org/ghc/) version 7.8 or higher on that machine prior to the day.

In recent years, the impact of functional programming on mainstream languages has grown significantly.

After conquering server applications and distributed systems,
the paradigm is now conquering the fields of web development and data analytics.

So what remains? The land of system programming.

When Mozilla did release the language Rust in 2012,
it did immediately striked interest from functional programming enthusiasts due to it's strong emphasis on safety.

Even though it currently lacks some advanced features like higher kinded types,
it is built with functional programming principles as it's core.

Like a Trojan horse (or the parasite mushroom after the language is named),
Rust looks like the next C on the outside... while it might actually be closer to Haskell on the inside!

Let's take a tour and discover an other side of system programming by learning together how to do functional programming in Rust.

The streaming of data in a purely functional language is a fascinating problem that have been extensively explored over the years.

In this talk we'll first briefly outline historical solutions to the problem and discuss their advantages and disadvantages,
we will then follow with a practical introduction to the great `machines` library from Edward Kmett.

We will see how the library usage compare to other players in the ecosystem (pipes, conduit, ...),
and walk through real world examples giving us a chance to write our own combinators and understand some of the internals.