Final Conference Schedule is live now!

Functional Conf 2015 Day 1

Fri, Sep 11
08:30

    Registration - 30 mins

09:00
  • Added to My Schedule
    keyboard_arrow_down
    Amit Rathore

    Functional Programming and the Battle for Survival

    schedule 09:00 AM - 10:00 AM place Grand Ballroom

    Startups are hot. They're fun. They're exciting, challenging, and romantic. They're also brutal. Only 1 in 20 startups succeed. 

    This talk is about how functional programming gives startups an advantage. Because every advantage is critical, in the fight to survive. And then to scale up, and thrive.

10:00

    Welcome Talk - 15 mins

10:15

    Tea/Coffee - 15 mins

10:30
  • Added to My Schedule
    keyboard_arrow_down
    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

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

    schedule 10:30 AM - 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
  • schedule 11:30 AM - 12:15 PM place Grand Ballroom 2

    Testing business logic quickly becomes tricky, as applications grow and scale. Example based unit and integration tests, and exploratory tests become poor choices to check and verify a large state space. Also such methods are not  well-suited to clearly describe the state space / transitions we want to test. 

    Since we use Clojure to write test suites and tools at Helpshift, we tried experimenting with DSLs to express some of our testing problems. We've found that mini DSLs can indeed become useful to describe and test fairly complicated business logic.

    In this talk I will cover some of the mini-DSL approaches we've tried, demonstrate one of them by example, and discuss the benefits and drawbacks based on current experience.

12:15

    Lunch - 75 mins

01:30
  • Added to My Schedule
    keyboard_arrow_down
    Bernard Duggan

    Achieving High Uptime with Erlang's OTP

    schedule 01:30 PM - 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

    Pure functional programming in your browser and server with PureScript

    schedule 01:30 PM - 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 PM - 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
  • Added to My Schedule
    keyboard_arrow_down
    Louis-Philippe Gauthier

    Building high-performance Erlang clients using Shackle

    schedule 03:15 PM - 04:00 PM place Grand Ballroom 1

    Building performant network (TCP, UDP) clients can be tricky, especially at high concurrency. By giving you a framework for building asynchronous clients, Shackle solves most of this problem for you. Shackle is the result of multiple years of writing Erlang clients for our real-time bidding platform (RTB), AdGear Trader.

  • schedule 03:15 PM - 04:00 PM place Grand Ballroom 2

    From the perspective of one of the few companies in the country using Haskell in production (hasura.io), we will talk about the journey of using Haskell as a programming language to build and maintain real world software.
    From the burden of choosing a language that probably has a single digit number of active developers in the country, to
    the joys of a small team churning out code that just keeps on working.

    We'll go over how we created a team, organized work ("software development practices"), architecting code, tooling up, testing, performance tweaking and finally deploying a Haskell codebase. We hope that Haskell developers with some prior experience will be able to take away
    something new about the Haskell ecosystem, and those interested in just functional programming will see tangible value in how certain features unique to Haskell have an impact.

    Expect a case study, a review of some cutting-edge tools and how to use them, and some Haskell code samples that will make you grunt in geeky approval.

  • Added to My Schedule
    keyboard_arrow_down
    Yeshwanth

    Building a REST API with Scalaz

    schedule 03:15 PM - 04:00 PM place Esquire

    When we were building our cloud orchestration platform, we were looking into writing our API Gateway server in scala and strictly functional because we knew the API is going to be doing lot of heavy lifting and it will be constantly extended. We stumbled upon scalaz, a brilliant library for scala to write functional programs. It was indeed a pleasure for the whole team to write the API since then.

    I will be talking more about how we designed and built the REST API that powers megam cloud platform(megam.io). Developers with scala experience will be able to take away on getting started with scalaz library.

04:15
  • Added to My Schedule
    keyboard_arrow_down
    Nilanjan Raychaudhuri

    You say big data, I say Fast data

    schedule 04:15 PM - 05:00 PM place Grand Ballroom 1
    Nowadays most of the "Big Data" problems are dealing with speed not size. Folks want "Fast Data". Speed is the problem to solve, not size. Most organizations today actually face smaller big data problems that they are trying to address through in-memory cached real-time processing of data. In this presentation we will explore architectures used for solving "Fast Data" problems. 
     
    We will be using Spark Streaming and Scala for code examples.

     

  • schedule 04:15 PM - 05:00 PM place Grand Ballroom 2

    Here's a markdown version of this proposal: https://gist.github.com/ssrihari/1cad915e7ef22ce61b54

    Over the last year and half at Staples SparX, we built a multivariate testing platform as a service. It satisfies an SLA of 10ms at 99.9th percentile, services all of Staples' experimentation from a single machine, is simulation tested, and is written in Clojure.

    We'll give an introduction to the Experimentation domain, design of experiments and our battle in attaining statistical significance with constrained traffic. We will share our experiences in loading and reporting over months of data in Datomic, using Clojure to grow a resilient postgres cluster, using a homegrown jdbc driver, interesting anecdotes, and OLAP solutions with ETL built in Clojure using core.async. Expect to see references to google white papers, latency and network graphs, histograms, comparison tables and an eyeful of clojure code.

  • Added to My Schedule
    keyboard_arrow_down
    Naresha K

    Rethinking HTTP Apps on JVM with Ratpack

    schedule 04:15 PM - 05:00 PM place Esquire

    HTTP application programming model on JVM traditionally has been based on the thread per request model. However increasing scale and complexity of applications are forcing the developers to think in new directions. Ratpack is one of such efforts. Ratpack is a collection of libraries glued with Java 8 and makes use of Netty, Guava and Reactive Streams. Ratpack also provides a Groovy DSL, helping developers to use declarative style.

    In this demo, I will explore the asynchronous programming model leveraged by Ratpack. Composition, immutability, laziness are the core techniques used in building an application, which in fact are the ideas from functional programming. Though Ratpack has a variety of features, my focus for this presentation is asynchronous, reactive and functional aspects of Ratpack.

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
  • schedule 09:00 AM - 10:00 AM place Grand Ballroom

    In this talk, I will talk about our motivation for creating Julia. Julia is a high-level, high-performance dynamic programming language. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library. Julia’s Base library, largely written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for linear algebra, random number generation, signal processing, and string processing. In addition, the Julia developer community is contributing a number of external packages through Julia’s built-in package manager at a rapid pace. This is why Julia is seeing rapid adoption in universities for teaching and research, as well as in businesses.

    I will discuss what makes Julia fast. Julia's ability to combine these levels of performance and productivity in a single language stems from the choice of a number of features that work well with each other:

    1. An expressive parametric type system, allowing optional type annotations;
    2. Multiple dispatch using those types to select implementations;
    3. A dynamic dataflow type inference algorithm allowing types of most expressions to be inferred;
    4. Aggressive code specialization against run-time types;
    5. Metaprogramming;
    6. Just-In-Time compilation using the LLVM compiler framework; and
    7. Careful design of the language and standard library to be amenable to type analysis;

    I will also touch upon how the language design has made it possible to explore many parallel programming models in Julia, completely within the language.

    See: http://www.julialang.org/

10:00

    Important Announcements - 15 mins

10:15

    Tea/Coffee Break - 15 mins

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

    When we think of OO, most people think of modeling THE real world in software by mapping every real world object (nouns) to entities in software. These entities are then modeled using Is-A-Has-A relationship to build complex, polymorphic hierarchies with deep object graphs. State is stored and mutated in-place inside the object to achieve the desired functionality. This paradigm leads to a fairly convoluted design and encourage imperative style of programming.

    Not everyone who has designed large complex systems, think of OO the same way. For instance, people who Test Drive, do not have the luxury of a big-up-front design, instead they focus on small and incremental design. IME, TDD facilities a design that is side-effect free and encourages a declarative style of programming. While decoupling and composing objects in a functional style with the right granularity of abstraction.

    Let's assume we've to build a web commenting and discussion feature (like Disqus). And we've a requirement to implement this as a jQuery Plugin. Can we apply pure functional principles to design this? Or will the design be better if we try a classical OO JS approach? In this live demo, we'll build this plugin from scratch and see how TDD will help us drive an object-functional design to strike a pragmatic balance between the 2 paradigms.

  • Added to My Schedule
    keyboard_arrow_down
    Abhinav Sarkar

    Introduction to Concurrency in Haskell

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

    Haskell is widely known as a functional programming language which is great to write pure (non I/O) code and immutable data structures. But it is not well known that it has a great support for a wide variety of concurrency models too.

    In this talk we shall explore the various concurrency models and primitives supported by Haskell including green threads, mutable variables, channels and software transactional memory. We shall see how the purity, laziness, and the strong type system of Haskell come together, and help write clean and modular concurrent code. We shall explore these by writing a mutli-user chat server with support for private and channel chatting.

     

  • Added to My Schedule
    keyboard_arrow_down

    UnConference

    schedule 10:30 AM - 12:30 PM place Esquire
11:30
  • Added to My Schedule
    keyboard_arrow_down
    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
  • schedule 01:30 PM - 02:15 PM place Grand Ballroom 1

    If you thought Monads are a mystery, then this demonstration would show you how to evolve your code towards a Monad without knowing about it. This demo will neither go into any Category Theory nor begin with monadic laws.  Instead, we will start with typical code that you see in your daily life as a developer, attempt to DRY (Don't Repeat Yourself) it up and eventually use Monad to remove duplication and verbosity. You'll also see how Monads make your code more declarative and succinct by sequencing the steps in your domain logic.

    Also, we know in Java8 Checked Exceptions + λ == Pain!  To be more precise, we will evolve a Try (exception handling monad) which is missing in Java8, similar to one found in Scala.  Finally, map back Try to the 3 monad laws.

  • Added to My Schedule
    keyboard_arrow_down
    Shashi Gowda

    Escher.jl - Functional Reactive Web without compiling to JavaScript

    schedule 01:30 PM - 02:15 PM place Grand Ballroom 2

    Escher.jl is a Julia package designed to give anyone the power to create sophisticated web-based UIs that are driven by data on server and inputs from the user. Escher is based on the principles of denotative programming - denotations of UI components (called Virtual DOM nodes) are handed off to the browser to be rendered. The result is a framework that abstracts the capabilities of CSS, JavaScript and HTML elements into a single consistent library. Interaction in Escher is done via Reactive.jl - a port of Elm's signal library. In this talk I will explain the inner workings of this Signal library, and of Escher and show how all the pieces fit together to form a convenient functional framework for full-stack web development.

  • Added to My Schedule
    keyboard_arrow_down

    UnConference

    schedule 01:30 PM - 03:15 PM place Esquire
02:30
  • Added to My Schedule
    keyboard_arrow_down
    Srihari Sriraman

    Carnatic music synthesis in Clojure

    schedule 02:30 PM - 03:15 PM place Grand Ballroom 1

    Here's a markdown version of this proposal: https://gist.github.com/ssrihari/b25ddda331ec220663de

    I'm building a carnatic music (south indian classical music) synthesizer using Clojure and Overtone. Here's the library I'm building.

    Carnatic music is different fundamentally in the movements of pitch ('Gamakams'), and needs to be modelled differently than most MIDI music out there today. The library now, can understand prescriptive carnatic music notation, build finer abstractions from that, and play back a not-so-terrible synth version with a plethora of configurable inputs.

    The concept of 'Gamakam' (the transitions between notes) is central, so I'll go into it's guts and show how the library piggybacks on recent work on PASR (pitch-attack-sustain-release) and Dual-PASR ('stage' and 'dance' PASR components) transcriptions. I'll also put forth a path I see for fully synthetic carnatic music based on machine learning 'Ragams' (melodic modes).

    I'll give a detailed demo of the synthetic music on the repl through the talk, and do a live voice vs synth comparison in the end.

  • Added to My Schedule
    keyboard_arrow_down
    Rudraksh MK

    A(n) (un)comfortable introduction to Hy

    schedule 02:30 PM - 03:15 PM place Grand Ballroom 2

    This talk is an introduction of sorts to Hy, a Lisp dialect embedded in Python. We'll explore the semantic designs of Hy from a Lisp programmer's perspective, and we'll look at how Hy gives you the best of Lisp-style functional programming, with the ability to hook into Python's ecosystem.

03:15

    Tea/Coffee Break - 15 mins

03:30
  • schedule 03:30 PM - 05:00 PM place Grand Ballroom

    In Indian classical music, we have Jugalbandi, where two lead musicians or vocalist engage in a playful competition. There is jugalbandi between Flutist and a Percussionist (say using Tabla as the instrument). Compositions rendered by flutist will be heard by the percussionist and will replay the same notes, but now on Tabla and vice-versa is also possible.

    In a similar way, we will perform Code Jugalbandi to see how the solution looks using different programming languages and paradigms.

    During the session, conference attendees will take turns at coding the same problem using different languages and paradigms. There would be multiple such attempts by different participants during the Jugalbandi.

05:00
  • Added to My Schedule
    keyboard_arrow_down
    Morten Kromberg

    Parallel Programming in Dyalog using Futures and Isolates

    schedule 05:00 PM - 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