Sessions at FP Days 2013 on Friday 25th October

Your current filters are…

  • How requirements from the Old World make Erlang fit into the New World

    by Robert Virding

    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.

    At 9:00am to 10:15am, Friday 25th October

    Coverage photo

  • Exploring a Legacy Clojure Codebase

    by Jon Neale, Ragnar Dahlén and Thomas G. Kristensen

    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?

    At 10:45am to 11:30am, Friday 25th October

    Coverage photo

  • Functional Agile Architecture

    by Pierluigi Riti

    In this session I will talk about using functional programming for the construction of Software Architectures.

    I'll cover how to use functional programming to create a UML diagram of the architecture, and how to use functional programming to make the architecture more flexible and easy to change.

    I'll present a real case study applied to a web architecture, and show how to use TDD and other agile methodologies for the implementation and proper functioning of the architecture

    At 10:45am to 11:30am, Friday 25th October

  • Functional Embedded Programming on the Raspberry Pi (with Erlang)

    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.

    At 10:45am to 2:45pm, Friday 25th October

    Coverage photo photo

  • Hands-on Haskell Introduction

    by Erik Hesselink and Sebastiaan Visser

    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.

    At 10:45am to 2:45pm, Friday 25th October

  • The Clojure inside SoundCloud

    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.

    At 11:30am to 12:15pm, Friday 25th October

  • Early Warning Indicators in F#

    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:

    • FSYacc/FSLex parser/interpreter/generator for Excel expression handling
    • Computational Expression usage for type-inferred calculations
    • F# integration with proprietary analytics & Excel function library

    At 1:15pm to 2:00pm, Friday 25th October

  • Excel coding errors are destroying world economies and F# (with Tsunami) is here to stop them!

    by Matthew Moloney

    Ever wish you could code Excel with a Functional Programming Language (F#) instead of VBA?

    Excel has over 400M users all over the world from many backgrounds including business, finance, and governments. On average large spreadsheets have over 12 substantial coding errors. A perfect example of this is the Reinhart-Rogoff paper (Growth in the time of Debt) where a trivial coding error helped them make the case for austerity around the world.
    In this presentation I will demonstrate how to prevent such errors while taking advantage of the rest of the .Net ecosystem by bridging the worlds of Excel and .Net with F#.

    I will give rapid fire demonstrations of
    * Big Data;
    * Data Science;
    * Cloud Computing;
    * GPGPU; and
    * Compiling F# Excel UDFs.
    All from within Excel.

    At 1:15pm to 2:00pm, Friday 25th October

  • Hands-on logic programming with core.logic

    by Thomas G. Kristensen

    Moving from OOP to FP often removes complexity, making code easier to write, read and reason about. The paradigm shift has enabled programmers to be more productive, and hopefully it has made people more open to reconsidering the fundamentals of the tools they use to solve problems. The question is: what is the next big paradigm in programming? and how does it relate to FP?

    Logic programming (LP) offers a declarative way of programming. The shift from FP to LP is very similar to the shift from OOP to FP, in that is makes programs more declarative and easier to reason about.

    core.logic is a Clojure library which enables programmers to write logic programs in Clojure by combining principles from both OOP and FP with logic programming. In this hands-on session we are going to help you through understanding the fundamentals of core.logic, and to write your first logic program on your own machine. We assume you have some (but possibly very little) experience with programming Clojure or another Lisp, but no prior knowledge of any logic programming is assumed.

    The goals of the session are to enable you to:
    * Use fundamental tools in logic programming
    * Combine FP, OOP and logic programming in a single codebase
    * Identify which problems are well suited for logic programming, and which are not
    * Solve a set of problems handed out by the end of the session (at your leisure)

    At 1:15pm to 2:45pm, Friday 25th October

  • Functional programming in the computational sciences with lambda.r

    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.

    At 2:00pm to 2:45pm, Friday 25th October

  • Live Coding as Communication

    by Sam Aaron

    The term "programming language" is often used to describe the medium we use to communicate with computers. However, to what extent can we also use programming languages like we use regular language? For example, could we use them to directly share ideas and thoughts with other people? Could programming be as live as a regular conversation? To what extent would such a live programming environment be ripe for mining novel ideas that would not only benefit the computer industry as a whole and yet even support artistic practices?

    This talk will explore these questions in detail emphasising the role and importance of functional languages in this context. What might a programming environment which has sufficient liveness, rapid feedback and tolerance of failure look like? Could we make such an environment live enough to support music performances? What benefits would such a style of programming offer business? Could live programming be beneficial for rapid prototyping, exploring big data sets, and even communicating formal business ideas?

    At 3:15pm to 4:30pm, Friday 25th October

    Coverage photo