Final Conference Schedule is live now!

Functional Conf 2015 Day 1

Fri, Sep 11
08:30

    Registration - 30 mins

09:00
10:00

    Welcome Talk - 15 mins

10:15

    Tea/Coffee - 15 mins

10:30
  • Added to My Schedule
    keyboard_arrow_down
    Ravi Mohan

    Ravi Mohan - Building a General Game Playing Engine with OCaml and Erlang

    schedule  10:30 AM - 12:00 PM place Grand Ballroom 1

    "General Game Playing  is the design of artificial intelligence programs that play more than one game"  Wikipedia [1]

    In other words, one program has to be able to play (and win!) multiple games ( Chess, checkers, Go, Othello etc).

    Summary: This experience report is about my  "Forever Project" [2,3,4] to build such a system in OCaml, and the problems (theoretical and practical) and will include a demo of the program, warts and all.

    Detail: GGP is an active CS research area [5]Annual competitions are held every year where  ggp programs compete against each other[6], playing games which they have never seen before (the rules are supplied as an input file for the system to consume five minutes before the match begins).

    Over the last year, in my non-existent spare time, I've been building a GGP engine to compete in a GGP competition.

    Most such engines are written in Java, C++  etc.. I'm using OCaml for the game playing agent, and Manoj is building the backend in Erlang.

    As mentioned above this is our "Forever Project"  We've made some decent progress.

    Come, see, laugh, jeer!

  • Added to My Schedule
    keyboard_arrow_down
    Brian Lee Troutwine

    Brian Lee Troutwine - Fault-Tolerance on the Cheap: Making Systems That (Probably) Won't Fall Over

    schedule  10:30 - 11:15 AM place Grand Ballroom 2

    Building computer systems that are reliable is hard. The functional programming community has invested a lot of time and energy into up-front-correctness guarantees: types and the like. Unfortunately, absolutely correct software is time-consuming to write and expensive. Fault-tolerant systems achieve system-total reliability by accepting that sub-components will fail and planning for that failure as a first-class concern of the system. As companies embrace the wave of "as-a-service" architectures, failure of sub-systems become a more pressing concern. Using examples from heavy industry, aeronautics and telecom systems, this talk will explore how you can design for fault-tolerance using functional programming techniques, type theory, monitoring, instrumentation and effective team dynamics. 

  • schedule  10:30 AM - 12:00 PM place Esquire

    Organising code as chained combination of data processing steps is a common pattern. Functional programming has made it ubiquitous due to concise lambda notations. But there are wide variations in how these pipelines are implemented. In this talk we will explore important properties of lazy data streams such as: push vs pull, hot vs cold, linear-flows vs graphs, perishable vs reusable, unicast vs multicast, synchronous vs asynchronous back-pressured etc.

    We will then explain "reactive-streams" protocol which guarantees asynchronous back-pressure for push based data streams. We will conclude with a demo using Akka-Streams which is an implementation of this protocol. The demo will involve a) streaming images from server to the browser over websockets, b) transferring large files from one source server to multiple destination servers.

11:30
12:15

    Lunch - 75 mins

01:30
  • Added to My Schedule
    keyboard_arrow_down
    Bernard Duggan

    Bernard Duggan - Achieving High Uptime with Erlang's OTP

    schedule  01:30 - 03:00 PM place Grand Ballroom 1

    Few technical metrics are more closely watched in the world of online service delivery than a system's “uptime”. Response speed, number of concurrent users and data throughput are all forgotten about very quickly when users can't even get onto your system.

    The Erlang language was designed with fault tolerance as a core principle. Fault tolerance describes the ability of a system to keep running in the event of some kind of unexpected problem, without external assistance (in other words, without waking up your sysadmins) and with minimal impact to users. Consider a single monolithic C++ program, handling 10,000 concurrent users all with persistent TCP connections. If one user does something unusual and hits a poorly tested code path, causing a segfault, then 10,000 people see their connection drop. That's (obviously) not fault tolerant. If just that one user's connection dies and everyone else's carries on, that's fault tolerance (and also far preferable!).

    While Erlang's basic features give a degree of fault tolerance, they're not a silver bullet. The share-nothing memory model and ability to separate your system into thousands of isolated threads are extremely useful when building robust systems, but they're a foundation rather than the whole solution.

    The other killer for uptime is rolling out upgrades and fixes. Without some clever infrastructure, sooner or later your customers will see “We're down for scheduled maintenance – come back in 30 minutes”. One solution to this is “hot upgrades” whereby code can be upgraded on the fly with literally no downtime or interruption to ongoing services.

    This tutorial covers Erlang's Open Telephony Platform (which has almost nothing to do with telephony per se) and how it delivers on Erlang's promise of robust, fault tolerant, hot-upgradable software.

  • Added to My Schedule
    keyboard_arrow_down
    Vagmi Mudumbai

    Vagmi Mudumbai - Pure functional programming in your browser and server with PureScript

    schedule  01:30 - 03:00 PM place Grand Ballroom 2

    PureScript is a functional programming language with a very interesting monadic effect system. If you are a developer who targets javascript either on Node.js or on the Browser, PureScript will liberate you from the callback hell and provide a robust type system to reason about your code at compile time.

    In this session we will build a full stack PureScript application targeting both io.js and a react app on the browser.

  • schedule  01:30 - 03:00 PM place Esquire

    Machine learning is more popular than ever because there are several dataset available and we can use several tools at our disposal to learn an insight from this data.

    In this session I shall show how F# can be used for several machine learning tasks and I will be using industry standard APIs

    During this session participants will be solving several machine learning challenges from Kaggle like handwritten digit recognizer (https://www.kaggle.com/c/digit-recognizer)

    During this session participants will write code in F# to solve real challenges like this one

    https://gist.github.com/sudipto80/72e6e56d07110baf4d4d

    and they will get to understand the process of machine learning system design pipeline.

03:00

    Tea/Coffee - 15 mins

03:15
04:15
05:15

    Fish Bowl Style Panel - 105 mins

07:00

    Dinner and Networking - 180 mins

Functional Conf 2015 Day 2

Sat, Sep 12
09:00
10:00

    Important Announcements - 15 mins

10:15

    Tea/Coffee Break - 15 mins

10:30
11:30
  • Added to My Schedule
    keyboard_arrow_down
    Shantanu Kumar

    Shantanu Kumar - Production Clojure: An Experience Report

    schedule  11:30 AM - 12:15 PM place Grand Ballroom 2

    This talk is about our experience of using Clojure in production at Concur for building a SaaS platform.

    To set the perspective, Concur is a 22 years old, USD 8.3 billion enterprise, now a part of SAP. More than 70% of Fortune 500 companies use Concur for travel and expense solutions. Concur's SaaS platform serves 25,000 customers with 25 million users. The Concur SaaS platform was reaching its limits and needed "re-architecting". This talk is about why we chose Clojure at Concur and how we are building one of the world's largest B2B SaaS platforms in Clojure.

    We will discuss the practices we established, experiments we did and the lessons learnt. We have now built a platform that follows open standards, is rigorously tested, tolerates failure and performs well. We will go over how we reached there, how we deployed the code to production and how we monitor those today.

    If you are considering using Clojure in production or even simply interested in Clojure, you may get useful insights to take away from this talk.

12:30

    Lunch - 60 mins

01:30
02:30
03:15

    Tea/Coffee Break - 15 mins

03:30
05:00
  • Added to My Schedule
    keyboard_arrow_down
    Morten Kromberg

    Morten Kromberg - Parallel Programming in Dyalog using Futures and Isolates

    schedule  05:00 - 05:45 PM place Grand Ballroom

    Dyalog is an array first multi-paradigm language based on an APL language kernel. In APL, it is common for the application of primitive functions to arrays of conforming shape to imply a map; the function is applied item-wise to corresponding elements of the arguments, producing a result of the same shape. APL also provides a variety of explicit operators that provide different mappings of user-defined functions, or more generally functional compositions, to multi-dimensional and nested arrays.

    One might expect that such language features would provide a complete framework for parallel programming. In practice, writing programs that can be efficiently executed in parallel on current hardware is extremely difficult, if implicit or explicit maps are the only parallel language feature available and an interpreter or compiler needs to deduce where to introduce the asynchronicity that is required in order to take advantage of the hardware.

    This talk will present Futures and Isolates, and related parallel operators constructed upon them, which were added to Dyalog version 14.0 in 2014. The goal has been to provide explicit forms of deterministic asynchronous execution, designed to be very familiar to APL users, and continue to allow them to view the language as an executable mathematical notation, while taking advantage of parallel hardware that is now readily available.

05:45

    Good Bye - 15 mins