Previous events

We've been running a multitude of events over the past few years concerned with computer science, programming language theory and new ways of thinking and representing computation.

Below you'll find our event archive covering events we've ran in previous years.
This Monday we have Ric Roberts from the Linked and Open Data company Swirrl talking about graph databases and Linked Data.

We'll be meeting at the normal time of 7pm, but we'll be located in Federation House (2 minutes walk from Madlab) again because of the ongoing Madlab refurbishments.
This month on Monday October 20th at 7pm Lambda Lounge is lucky to host a talk by Daira Hopwood on designing new error handling features in programming languages. 

*NOTE* due to the Madlab refurbishment we have been kindly relocated just 2 minutes down the road at New Art Spaces - Federation House. 

See here for directions.

Error handling is one of the most difficult problems in computer science and in practical programming. Incorrect error handling often leads to security vulnerabilities (such as many of the recent spate of bugs found in TLS implementations), data loss, and user frustration.

In this talk, we’ll first discuss why programs using existing error handling styles and mechanisms (return and status code checking, conditions and restarts, and exceptions) often fail to recover correctly from errors. We argue that this is due to a fundamental conflict between encapsulation and having enough information to recover a consistent state.

Then we explain how this conflict can be solved by providing language support for automatically recovering the state before the call that failed, so that failures cannot cause inconsistency. We also describe how the Ken protocol complements this automatic recovery and extends it to asynchronous and distributed systems.
This Monday at 7pm we're having a debate, is TDD a waste in functional languages?

Brett will also be giving us a lightning talk on cool Erlang tricks to debug production systems.

So you're using a functional language and doing Test Driven
Development?  Maybe you're doing it wrong.

- Perhaps 50% of your time spent programming, coding tests, could be invested in the software itself.

- Perhaps there are better, less expensive and less wasteful methods of finding bugs.

- Perhaps there are better ways to design software than by writing tests.

- Perhaps functional programming makes TDD redundant.

- Perhaps Rick will commit career suicide as he questions the unquestionable.

Come to this Monday's lambda lounge to join the debate.  We're meeting
at the usual time of 7pm at Madlab.

This month, Jan Macháček will explore how Reactive Streams address the challenges of systems that process flows of live data. Learn about the core principles (asynchrony & non-blocking, stream passing over asynchronous boundaries, back pressure) without worrying about any particular language or framework. For clarity & brevity, Jan will be using Akka Streams implementation of Reactive Streams in the code samples.

You will not need any extensive Scala or Akka experience to understand the core principles. Basic knowledge of Scala and Akka will help you understand the code portion of the talk, though the Akka Streams DSL is undestandable to even non-Scala folk.

This Monday's Lambda Lounge see's us finally getting a talk on a language we've been eager to hear about.  Erlang!

This month Brett will be introducing us to Erlang, one of most commercially successful functional languages, which has found its home in robust systems such as telephony switches, Couch DB, Riak and Rabbit MQ.

Erlang was originally developed by Erricson for programming highly fault tolerant systems which have attained an alleged 99.9999999% availability.

Erlang has lots of cool features which set it apart from many other languages including:

- A crash first approach to error handling.
- A virtual machine that allows hot swapping code in production without service disruption.
- A highly concurrent Actor model, supporting millions of concurrent processes on a single machine.
- Pattern matching.
This Monday we're meeting to talk about constraint based programming with core.logic and its support for finite domains. 

James Richardson will be introducing us to the basics, and helping us solve some logic problems.

We'll start at the usual time of 7pm, and be going to 57 Thomas for some drinks afterwards.
Christmas is coming, and rather than holding a formal Lambda Lounge this month, we decided it'd be better to join our fellow madlabbers at their Christmas Party!

The party starts this friday at 18:30 and goes on till late...   Drinks and  snacks will be available, as well as a gaggle of geeks having fun!

Like every year, it'll be great fun... We'll see you there!

For more details see the official Madlab Christmas party page.

Functional programming events will resume as normal in 2014!!

Madlab Christmas Party
This month's Lambda Lounge see's a talk by Alex McLean on the intersection between music and functional programming.  We'll be meeting at madlab at the usual 7pm start time.

Alex is a laptop musician and researcher based in Sheffield, performing as part of Slub and working at the Interdisciplinary Centre for Scientific Research in Music, University of Leeds. Alex is going to talk about his long term project of getting people to dance to code.

Live coders take advantage of dynamic interpreters to improvise live music (and/or video) with sourcecode, using a computer language as a musical environment. A live code edit
is something like changing the design of a machine while it runs, moving cogs and pistons around and adding new ones. Here though the machine is composed of text, describing the functions which the music flows out of. Music is not made by the machine, but by changes to the machine. The musicians editor is projected for the audience so that they see the live coders gestures within their text editor, and if they like, read the code as it is written.

In this talk Alex will show how he live codes in haskell to make music, including how he represents musical patterns as functions of time, interfaces with synthesis software over the OSC protocol, and uses emacs as an interface in musical improvisation. He'll also introduce his new visual editor for Tidal, called Texture.
Building on last months introductory Scala talk by Lee Kitching,where we learnt about the language's functional programming features (first-class functions, ADTs, currying, ...), Ian Murray will be taking things further showing us how to build real-world applications in Scala. 

It will be a high-level tour of common tools, language features, APIs and frameworks. Including SBT, Spray, Akka, Play!, the Cake Pattern and Slick.

As usual we will be kicking off at 7pm at Madlab.

The slides for this talk are now available.
Our next event see's the first of two talks on the Scala Programming Language. 

This coming monday, (16th September) will be an introduction to programming in Scala by Lee Kitching

We will be meeting at the normal time of 7pm.

Scala is a multi-paradigm programming language targeting the JVM, CLR and Javascript. As well as a powerful object system, it has extensive support for functional programming including first-class functions, algebraic data types, pattern matching and immutable data structures. The goal of this talk is to give an introduction to the language, highlight interesting features of its type system and provide a comparison to functional langauges like Haskell and F#.

Lee's talk will be followed by a deeper dive into Scala by Ian Murray on Monday 21st October where we will have a follow on presentation on Scala which will cover some more advanced areas of the language and its API's and tools.
This monday, we'll be meeting at @madlabuk at 7pm and listening to Chris Warburton tell us about an advanced branch of type systems known as dependent types.

Functional programming languages such as Haskell and ML are known for
their powerful type systems which can prevent many common programming
errors. Recently, these type systems have been growing more complex and confusing in order to capture more program properties.

At the same time, a number of languages have emerged which use Dependent Types instead, such as Coq, Agda and Idris. Dependent Types are more powerful than those of ML or Haskell, but are conceptually simpler. Their flexibility captures everything from dynamically-typed scripts up to fully verified systems.

This introductory talk will describe the basics of Dependent Types, work through some examples in the Idris language to incrementally verify more and more properties of a simple algorithm, then discuss the consequences and drawbacks of using dependently typed languages.
This month we'll be meeting at the madlab at the usual time of 7pm.

Having been inspired by Ian Johnson's talk on Arrows, Lambda Lounger, James Richardson went and implemented something in Scala to help understand the core concepts of arrows. 

The process of implementing Monads and Arrows gave an interesting insight into their usage which he'll be sharing at this months Lambda Lounge. 

This talk will work from the ground up, starting with some common (but simplified) programming problems we'll try to pull out some monad implementations.  This will lead us to implement the maybe monad and the state monad.  Next we'll try and generalise monad's into an arrow form before finally getting stuck with implementing monads as arrows in the Kleisli Arrow.

From this talk you'll hopefully get an understanding of the why/what/how of monads as well as a peek into what Scala has to offer the functional programmer.
This monday we'll be meeting at the usual place (Madlab) and time (7pm) to hear Ian Johnson talk about his implementation of a Python DSL using Arrows.

Arrows allow the programmer to abstract and combine computation. Arrows present operators with which pipelines of computation can be constructed. Arrows are related to Monads but allow for more interesting pipelines to be constructed, allow computations with more than one input, and allow, possibly partially, static computation. It has been said that, "If your application works fine with monads, you might as well stick with them. But if you're using a structure that's very like a monad, but isn't one, maybe it's an arrow."

Ian has been working on the MosesCore project, funded by the European Commission 7th Framework Programme. "MosesCore aims to encourage the development and usage of open source machine translation tools. Computational pipelines occur often in machine translation systems and it was deemed necessary to design an easy method to compose and share pipelines and pipeline components. During this work a Python library called Pypeline. was written to support arrows. It defines monadic and arrow types and allows programmer to compose pipelines using helper functions. PCL, on the other hand, is a DSL that supports arrow operators so that programmers may easily construct and share pipelines, or bits of pipelines.

Ian will be taking you through the Pypeline library and, hopefully, you'll pick up what arrows are all about. Then we'll dive into PCL by looking at the packaged examples.
We'll be meeting on the 18th February at the usual time of 7pm for a relatively informal session of show and tell.

Rick will be giving us a taster of the magical world of Logic Programming with Clojure's core.logic.  In this world programs can run both forwards and backwards, with surprising and powerful consequences.

Daniel Silverstone will be talking with us about a Haskell project of his where he's been trying to tie knots in functional data structures, use parser combinators and implement mini imperative Domain Specific Languages.

If you've got something functional you'd like to speak about, or ask advice on; come along, as the Lambda Lounge loves to listen!
This month we'll be continuing the battleships saga from last month.

We'll be pairing up to do some more work on our battleships admirals.

Meeting @madlab at the usual time of 7pm.
Following last months battleship walk through, this month the Lambda Lounge will engage in all out war.  We will be implementing battleship admirals in Clojure, and competing them head to head for complete supremacy of the battleship warzone (server).

We will be meeting at the usual time of 7pm.  Be sure to either pair up or bring a laptop for some head to head coding!  It will help if you can setup a working Clojure environment beforehand.

This month we'll be meeting at number 44 Edge street (Madlab's other building, just next door to Madlab) at the usual time of 7pm.

KaboomSimon Holgate will be talking us through using battleships as a fun and interactive way of learning functional programming with Clojure.  This month he'll be walking us through the setup, and diving into the implementation code.  A future Lambda Lounge will see us compete our battleships head to head.

James Jeffries will also briefly be telling us about the Functional Programming exchange, and some of the interesting developments with GADT's in Haskell, Scala's Lift 3.0, and functional event sourcing.  Some of which he hopes to talk about more formally at a future Lambda Lounge.

We'll be gathering on the 21st January for our first meeting of the new year, to talk about functional data-structures.

Additionally we'll be continuing with personal  projects; such as our Conway's Game of Life implementations from last year.

We will be starting at 7pm @madlabuk as usual.
Meeting at @madlabuk at 7pm, this monday we will be continuing last months code dojo, by hacking on our implementations of Conway's game of life, in your favourite functional language.

The glider pattern found in Conways Game of Life
We will be pair programming, so bring a laptop!
Meeting at the usual time of 7pm @madlabuk, this monday will be the Lambda Lounge's first code dojo, where we look at implementing Conway's Game of Life, in your favourite functional language.

Conway's game of life, shot to fame in the 1970's for showing how astonishing complexity; similar to that shown in nature can arise from a handful of simple deterministic rules.
The glider pattern found in Conways Game of Life
Just like a butterfly flapping its wings, the smallest change to a cell in life can have massive unpredictable effects resulting in chaos within an entirely orderly world. 

Not only does life have a lot to teach us about the nature of reality it has a strong history in theories of computation, with it being provable turing complete.

More importantly however life is fun, and should be a great starter project to learn a functional language such as Haskell or Clojure.

We will be pair programming, so bring a laptop!

Software Transactional Memory

This month's lambda lounge sees Haskell enthusiast and developer Lee Kitching, talking about Haskell's Software Transactional Memory.  We will be meeting at the usual time of 7pm.

The traditional approach to concurrency uses locks to co-ordinate access to shared state. This approach is flawed in a number of ways:

1: It requires a global ordering on lock acquisition to prevent deadlock

2: It is difficult to maintain consistency in the face of errors

3: Lock granularity has a significant impact on scalability.

Transactional memory systems allow accesses to shared memory to be defined within atomic transactions whose effects are isolated from any concurrently executing transactions.
Haskell's STM system leverages the Haskell type system to permit access to shared state only within transactions. It allows transactions to be composed by automatically handling transaction scheduling, isolation, execution and rollback in the event of errors.

The talk will introduce Haskell's STM system, and show how it can be used to greatly simplify some concurrent programming tasks.
James Jeffries will be giving this months talk on F# (F-Sharp).   F# is a functional language that runs on the .NET runtime. Unlike other languages such as Haskell it is not purely functional and also has support for imperative and object oriented programming. F# is open source and has been officially supported in Visual Studio since 2010, but it can also run on the Mono runtime.

This talk will include a brief overview of the syntax,  some basic examples of how to do common functional and object oriented tasks, and demonstrate a more in depth example showing off some of the cooler features and (hopefully) the elegance of F#.

If anyone wants to try out example as we go through then please bring your laptop,  install F# and the F# power pack.

An Introduction to applicative functors in Haskell

This months talk, graciously hosted by Madab @7pm will be given by Ian Murray, and should be a real hit as he hopes to cover some of the core theoretical concepts found in Haskell.

Applicative functors are an abstraction that sit between functors and monads: weaker (hence more widely occurring) than monads, and stronger than functors.

This practical talk will be split into two parts:

1. An introduction to the definition of the Applicative type class.  Will show some examples of Applicative instances to get a feel for it.  And then discuss how it's used; and how it achieves what a Functor can't.

2. Will look at the applicative-style of programming in Haskell, using user input validation as an example of this (including a brief detour to introduce the Monoid type class).

The slides for this talk are available here.
This meeting was on the 28th May featured an introductory talk on Haskell, by Ian Johnson.

Haskell is a purely functional programming language, where side-effects are forbidden by the type-system; and all functions must be pure. 

Haskell's widely regarded as being on the cutting edge of programming language design, with its rigorous Hindley-Milner inferencing type system, lazy evaluation and infamous use of  an obscure branch of abstract nonsense (category theory).

Haskell is best known for it's ability to lock up side effects where they belong, in an IO::Monad; preventing them from polluting your program with pain and non-determinism.The slides for this talk can be downloaded below.


Come join us in a utopian land of parentheses as we take a whistle stop tour of the Clojure programming language.  A powerful modern dialect of Lisp, reloaded for the JVM, CLR and JavaScript VM's to provide a practical and general purpose functional language.

After learning its syntax, semantics and special forms in Clojure's interactive development environment you'll free your mind of mutable thoughts and seek enlightenment with Value Oriented Programming; the secret behind safe and efficient concurrent programming with Clojure.

You'll discover how laziness is a virtue with Clojure's powerful sequence API, learn how to embrace the worlds largest set of open source class libraries with the most native foreign function interface ever defined, and take a look at how in Clojure code is data; allowing you to extend the Compiler and the language to better solve problems in your domain.

By the end of this session, you'll begin to appreciate how you might use Clojure to tackle programming problems with less ceremony, incidental complexity and a greater degree of expressiveness.