Erlang was designed around a set of requirements for telecom systems from the Old World. They were distributed, massively concurrent systems which had to scale with demand, be capable of handling massive peak loads and never fail. These are same problems we are facing today. This talk will describe how Erlang was developed as a language and system to solve them, as the challenges we had in telecoms back then evolved to the challenges we are facing in the Cloud today.
Clojure is a relatively new language, so what will legacy Clojure applications look like, and how will they be to work with? How will you bring a new developer up to speed with your complex ecosystem of Clojure applications? What happens to your code base when you have a number of experienced developers new to Clojure working on it?
At uSwitch, we deployed our first Clojure application in early 2010. Since then, we've been happily leveraging the power of Clojure to solve problems and improve our business. Many different systems and applications have been built, by different developers, at different stages in their Clojure learning journey.
We will quantify how our use of the language has changed throughout that time, and point out the various techniques which have allowed us to avoid a confusing clash of paradigms. Using and presenting the torch analytical library built on top of codeq and datomic we examine a number of “legacy” Clojure systems, and discuss how our patterns of writing code have evolved.
We will explore the experiences of the developers who inherited the large scale, business critical Clojure applications along with the experiences of the developers who originally wrote the system, whilst exposing some of the WTF moments/mistakes we made along the way. Which parts are easy or difficult to understand or reason about, and what are some of the attributes that make it so?
by Omer Kilic
This hands-on session will introduce how to do embedded programming using the Erlang/ALE framework created by Erlang Solutions.
Erlang/ALE is an Actor Library for Embedded for the Erlang programming language targeted initially for the Raspberry Pi. It provides access to the various embedded interfaces (such as GPIO, I2C, SPI, etc) exposed on the Raspberry Pi from Erlang in a way that sits well with the Erlang and functional programming idioms.
Erlang's support for concurrency and functional programming is very well suited for modern embedded systems that consist of many internal and external peripherals (such as sensors and actuators). After this session you will want to learnyousomeerlang.com so that you can do interesting embedded projects with Erlang/ALE.
Most of the session is focused on using Erlang/ALE to do hands-on exercises with a custom extension board for the Raspberry Pi but a brief overview of the embedded ecosystem and what it entails to do embedded programming on devices such as the Raspberry Pi will also be presented.
This is a hands-on session. Please note: To participate in this session you will have to bring a laptop that has an ethernet port. We will provide you with a Raspberry Pi and the extension board for the duration of the session. The extension board is available as open source hardware, so you can build one yourself at home.
There will be a break for lunch part-way through the session.
Haskell is an interesting programming language that is quite different from most other languages. It is purely functional, lazy, has algebraic data types and pattern matching, and a powerful type system. Learning Haskell can make you a better programmer, but it can also be daunting.
We will teach you the basics of Haskell with a combination of presentation and exercises. No prior experience with Haskell is required. We will cover important language features like data types, pattern matching and IO, as well as tools, such as the GHC compiler, the interactive GHCi environment, and cabal.
This is a hands-on session. Before coming, please make sure you have a laptop with the current Haskell platform (http://www.haskell.org/platform/) installed. This is version 2013.2.0.0, which includes GHC 7.6.3.
There is a break part-way through the session for lunch.
by Joseph Wilk
Over the last year Joseph Wilk has been introducing Clojure into SoundCloud. Over this time we have been refining the blue-print for services functioning under high load with a strong focus on fault tolerance. We will explore how we use Clojure at SoundCloud, the power of focusing around the JVM and real examples where Clojure fit and where it failed.
by Stephen Channell
This is a case study of a live F# application for real-time early warning indicators of Liquidity Risk.
EWI used an F# Excel expression parser and computational expressions to generate a Cell network in memory that triggered indicator calculations from market events, that percolated up to RAG status changes.
The EWI model demonstrates features of F# that enabled rapid development:
by Brian Rowe
The computational sciences are still learning the benefits of functional programming. Most users of R are familiar with object-oriented programming but have not been exposed to functional programming.
In this session I discuss why functional programming is important for the computational sciences in terms of modeling, program organisation, and reasoning about the correctness of a program. We will review the mechanics of lambda.r, a package I wrote that enables a functional programming style in the R language.
Using examples based on my work modeling consumer financial transactions, I will discuss when and why I use the various features of lambda.r, including multipart function definitions, guard expressions, type constraints and variables, and attributes in my models.
The session also explores practical uses of the lambda calculus to reason about numerical programs and show the equivalence between various forms. As R supports vectors natively, there are some surprising results that stem from this.
24th–25th October 2013