Our next meeting is on Monday 18th June at MadLab’s new venue at PLANT NOMA (Redfern, Dantzic Street, NOMA, M60 0AE).

The meeting starts at 7pm (doors open a little earlier, we aim to start by 7:05pm).

Please register to let us know you’ll be attending.

This month Conor Farrell (@SectoidCmdr) will give us an Introduction to Idris.

Idris is a purely functional language that has a number of interesting features like dependent types and totality checking. It can also be used as a proof assistant, similar to Coq and Agda.

In this talk I’ll cover development using Idris and how you can use types to help you write your code - rather than thinking of types just as things that need to be checked, we can instead see them as a plan for producing a robust program by following the three steps of type, define and refine.

You don’t need any experience with Idris or functional programming as I’ll be starting from the basics, but if you do happen to know Haskell you’ll probably see some similarities!

This event is generously sponsored by Equal Experts, a network of talented, experienced software consultants, specialising in agile delivery. Equal Experts will be providing refreshments, yay! Equal Experts Logo

(Please register to let us know you’ll be coming!)

(And please get in touch if you’d like to talk at a future event: (contact the mailing list or ping @lambdamcr, or speak to us at the event! We’re a very supportive crowd, do let us know if you have any questions!)


So this is very exciting for several reasons: our next meeting is on Monday 21st May at MadLab’s new venue at PLANT NOMA (Redfern, Dantzic Street, NOMA, M60 0AE).

(See MadLab’s announcement for more details.)

We’ll be learning about Audio Synthesis in F# with John Stovin. This is a re-run of his very popular workshop at F# Exchange this year, and should be lots of fun! This meeting is brought to you in collaboration with the Manchester F# User Group.

Planning for the usual 7pm (doors open a little earlier, we aim to start by 7:05pm), but do keep an eye out for any changes, as it’s a slightly new setup.

Please register to let us know you’ll be attending.

In this workshop, John Stovin will show how several features in F# work together make it an ideal platform for creating high-performing real-time applications for a wide variety of application areas. Specifically, John will share with you how reactive event handling and lazy sequences can be used together to create a simple software-based audio synthesizer.

No knowledge of signal processing theory is required. John will start with a simple, non-technical and non-mathematical explanation of the basic concepts of digital signal processing. John will then build on that explanation to show how to design a basic signal flow and processing elements using pure functional elements, and how to make this signal flow interact with external devices in real time.

Functional topics covered will include: Seq & List; Event Handling; Sequence comprehension; Higher-order functions, particularly unfold.

Have you done audio or music work with a functional programming language. Let us know on twitter or at beginning of the session, and we should have time for some show-and-tell at the end of the session!

(Please register to let us know you’ll be coming!)

(And please get in touch if you’d like to talk at a future event: (contact the mailing list or ping @lambdamcr, or speak to us at the event! We’re a very supportive crowd, do let us know if you have any questions!)


We’ll meet on Monday 16th April, 7pm (doors open a little earlier, we aim to start by 7:05pm) at MadLab for a meeting about Real World uses of Functional Programming! Please register to let us know you’ll be attending.

Dan Meyers will be telling us about how his team at the BBC uses Clojure with the Kafka stream processing platform. Dan will be giving us an exclusive sneak preview of the talk he’s had accepted to the Kafka Summit in London later this month. Dan writes:

“In the beginning was PIPs, an API backed by a relational database used to store all the BBC’s programme metadata. But as more clients came, with more requirements and ever more complex queries, it became untenable to build one system able to service them all and maintain performance. Each client wanted a simple interface to be able to ask their specific complex questions, about subjects like availability and scheduling.

“The Programme Metadata team turned to a combination of Kafka and Clojure (a functional, immutable, Lisp dialect) running in AWS to produce multiple pipelines, one per client requirement. This setup turns the normal ETL pipeline on its head, with one homogenous backend and multiple heterogenous outputs. At each level you can see the same pattern repeated, which extends even into the structure of the Clojure code itself. In this talk we’ll go through some of the things we’ve learned, look at how the structure of Clojure mirrors and supports the way Kafka is used, and see how simple commodity microservices can be reused in multiple pipelines to rapidly satisfy new client requirements.”

Do you have a Real World use of functional programming that you’d like to talk about? We’ll have some time after Dan’s talk for you to talk about your project, either as an informal discussion or a 5 minute “lightning talk”! (We may be able to fit in a longer ~20 min talk if that’s preferred.)

Please let me know asap if you’d like to talk (contact the mailing list or ping @lambdamcr) but we may also be able to accept some short talks on the night. (We’re a very supportive crowd, do let us know if you have any questions!)

(Please register to let us know you’ll be coming!)


We’ll meet on Monday 19th March, 7pm (doors open a little earlier, we aim to start by 7:05pm) at MadLab for a meeting about Elm! Please register to let us know you’ll be attending.

Michael Jones who runs the new Elm Manchester meetup, will be showing us how to get started with Elm!

Elm is a friendly language for front-end development that promises ‘no runtime exceptions’. It has a functional approach with a solid type system and a focus on simplicity. Michael will demonstrate how to get going with a basic Elm application and illustrate how some of the features of the language and the compiler lead to a smooth & enjoyable development experience.

We’ll start with a demo and some live-coding. There’ll be plenty of time for discussion, and do bring along your own laptop if you’d like to play along!

(Please register to let us know you’ll be coming!)

Looking forward to seeing old and new faces, we should have some time after the session to chat about what people been playing since we last met. Please shout on the night, or contact the mailing list or ping @lambdamcr to let us know if you have a talk you’d like to give. (We’re a very supportive crowd, do let us know if you have any questions!)


We’ll meet on Monday 19th February, 7pm (doors open a little earlier, we aim to start by 7:05pm) at MadLab for the first meeting of the new year! Please register to let us know you’ll be attending.

Paul Brabban from def_shef in Sheffield will talk us through implementing a classic machine learning algorithm. This is a workshop session, so do bring your laptop to play along if you can! Paul writes:

The algorithm behind the k-nearest neighbour classifier dates back to the early days of computer science. Its simplicity, amongst other properties, make it a great introduction to machine learning algorithms.

In the workshop, you’ll implement a kNN classifier in the functional language of your choice, including training and testing against real data sets using k-fold cross validation. I’ll help anyone who’s having problems, and for FP experts who finish the implementation quickly, there’ll be several suggestions for further exploration.

If any of those terms are new to you, don’t worry! We’ll assume no previous Machine Learning knowledge.

(Please register to let us know you’ll be coming!)

Looking forward to seeing old and new faces, we should have some time after the session to chat about what people been playing since we last met in November. Please shout on the night, or contact the mailing list or ping @lambdamcr to let us know if you have a talk you’d like to give. (We’re a very supportive crowd, do let us know if you have any questions!)


We’ll meet on Monday 20th November, 7pm (doors open a little earlier, we aim to start by 7:10pm) at MadLab for the final meeting of the year! We’ll do a Show and Tell of projects that people have been involved and some Discussion on topics of interest.

We still have space for topics! We’re looking for short talks (5-15 minutes) on any topic of interest to Functional Programmers, and about Any Programming Language. So whether you’re using Monads in Python, doing Internet of Things with Haskell, FRP in Javascript, or an MMORPG in Erlang, feel free to suggest a talk!

  • Paul Brabban (defshef) discussion on “intro to FP” workshop
  • James Fielder “So you’re stuck with Java/C++ and you want to do FP…”
  • Giambattista Pieretti Erlang & Internet of Things, with the Wemos D1 mini (Arduino compatible board)
  • Hakim Cassimally a Clojure macro to make declaring XML data simpler

Really looking forward to seeing what people have been playing with over the year! Please reply to the mailing list or ping @lambdamcr to propose a topic!

(Alternatively, feel free to bring an idea on the night and we may be able to fit you in.)


We’ll meet on Monday 16th October, 7pm (doors open a little earlier, we aim to start by 7:10pm) at MadLab to learn about macros in Clojure.

(We don’t know yet if we’ll be in the main section or the next door FabLab - will be clearly signed and we’ll try to tweet details beforehand!)

Clojure Macros - with great power comes much confusion

Dan Meyers (BBC Programme Metadata, @Carr0t) will go through the basic building blocks of macros and how they differ from functions. He writes:

“Anyone who’s written any Clojure has probably used macros that are in the language core, even if they didn’t realise it, but a lot of people might not have written their own macros.

We’ll go through two examples covering what I see as the major use-cases of macros – logging and code readability. We’ll do this bit by bit to see how they do what they do, and then look at the results of that.”

The talk starts from fairly basic principles and building on that so you don’t need to know Clojure or anything to understand it. A few brief slides at the beginning give you all the info you need to understand what’s going on even if you’ve not really looked at a Lisp-like language before.


Back to School evening

As we reach the end of the Glorious British Summer, it’s time to pick up our new exercise books and pencil cases and learn some new techniques on Javascript (and a bit of Clojure) in the field!

LambdaLounge is pleased to present an evening suitable for all, and especially newcomers to Functional Programming on Monday 18th September at 7pm at MadLab.

A Functional JS Field Guide

Katie Fenn (@katie_fenn) is a software engineer at npm. She works with all aspects of the web, particularly JavaScript, CSS, Node.JS and ops. When not at her desk, she is usually in the pool or on her bike in the Peak District.

JavaScript is a language of two flavours: object-oriented and functional. Some would say functional is JavaScript’s dominant flavour, but only recently have we started exploring its uses fully. I will show how lessons from functional programming takes advantage of JavaScript’s better features, and may even change the future of computing.

In this talk I will introduce the basic ingredients of functional programming and explain why embracing them makes JavaScript easier to work with. It will be aimed at JavaScript developers of all experience levels and backgrounds.

Writing a tile-matching game in Clojure (first steps)

Ever wondered how to write a tile-matching game (like Candy Crush and the earlier Bejeweled)? And how do you even write a game (with graphics, and state, and user interaction!) functionally? Regular speaker and co-organizer Hakim is just starting to explore this process, and will present some of the basics of modelling the game grid, and playing a basic event loop, introducing some important concepts in functional programming.


Hacknight: The Functional Internet of Things

We’re meeting on Monday 17th July at 7pm at MadLab to play with microcontrollers and functional languages! We will have some instructions for very simple projects that you can extend. Alternatively, you are welcome to work on a project of your own, or join other attendees to help them.

After our May talks on IoT we’ll meet to work together on various Internet of Things projects. This will be a Hands On session, so please do bring:

 * laptop
 * any electronics kit you have that you'd like to play with

But don’t worry: we will bring various microcontrollers: ESP8266, Arduino, some BBC micro:bits etc.

We’ll start by getting software installed and things setup, so do feel free to arrive early if you can. Then we’ll do a brief brainstorming exercise, and form into small teams (or work alone if you prepare) on our projects!


The Functional Internet of Things

We’re meeting on Monday 15th May at 7pm at MadLab to talk about how Functional Programming can be used to interact with the Internet of Things.

Firstly, Qambar Raza (@QambarRaza) (BBC), who is starting an exciting project using the ESP8266 IC, Clojure, and Firmata and is blogging all the way up to his talk and demo at LambdaLounge.

Our second confirmed speaker, Spencer Marsden (@spencermarsden) (a creative technologist at the BBC’s consumer technology showcase, the Blue Room) will give an overview of some of the exciting projects and technology he’s worked on.

We can still make time for one or two more speakers! could you get involved?

Perhaps you’ve written some dataflow based code on the Raspberry PI with NodeRED? Or you’ve been experimenting with Haskell and hArduino? Or have you been sneaking Functional concepts into C++ code on a PIC?

Whether you are enthusiastically tinkering on a hobby project, or have used these technologies in a successful enterprise, we’d love to hear from you!

We’re really keen to get a diverse range of speakers, from a wide range of backgrounds and experience, whether you’re a relative newcomer to functional programming, a veteran developer, or an academic, we always provide a warm welcome! See our call for speakers for more details or ping us at @lambdamcr!


Discovering the beauty of recursion and pattern matching

We’re meeting on Monday 20th Mar at 7pm at MadLab where DJ Adams will speak about one of the essential features of functional programming: recursion.

Moving from an imperative mindset across to a more functional one requires some rewiring of your brain. One of the areas where this is particularly noticeable is understanding how iteration is achieved in languages without explicit loop constructs. In this talk, we’ll look at recursion as a fundamental building block, and discover how pattern matching in Haskell, Clojure, Elm, Elixir and even JavaScript is a beautiful thing.

We're meeting on Monday 20th Feb at 7pm at madlab to learn Elixir!
Elixir is a dynamic, functional language with Ruby-like syntax that runs on the Erlang virtual machine. With first class support for concurrency, scalability, fault tolerance and high availability, all courtesy of its Erlang roots, it can be described as the language for today's real time, hyper-connected world.

In this short introduction to Elixir presented by Chi-chi Ekweozor, learn how to use the ubiquitous pipeline operator |> to consume functions as data, pattern matching, modules, lists and other language constructs. Level up and get writing distributed software applications that go beyond the browser on to mobile and the Internet of Things.

** Please note: Hands-on Session **
This is a hands-on session, to follow along please come with a laptop with Elixir pre-installed. There are instructions for installing Elixir and Erlang on most operating systems on the Elixir-lang website.
This month Hakim Cassimally is presenting on Data Structures for Text Editors.   We're meeting on Monday 16th Jan in madlab at the normal time of 7pm.
To support the features that we need as programmers, text editors arrange textual data in rather different ways than we might expect from other text-processing tasks, where we commonly use strings and streams of characters.
We'll first look at some classic text editor data-structures like Lists of lines (vi, Atom), the Gap Buffer (Emacs), and then at purely functional data structures that fit better with functional languages - structures like Piece Tables (Abiword, Bravo), various sorts of tree (the infamous Xanadu, GtkTextBuffer) and Zippers (yi).
I'll be showing a few examples in Clojure, but the approaches are valuable in any language (I've done previous prototypes in Perl, Java, and Haskell!)

This Monday at 7pm Chi-chi Ekweozor is giving a talk on the soft real-time aspects of Elixir/Phoenix and its web sockets implementation (aka Phoenix channels) - which was the main draw for building a real-time Q&A service with it over at And, yes, there will be a live demo!

This Monday at 7pm Alex Weaver is giving a talk on deep learning for functional programmers.
Deep learning has improved on the state of the art in several fields of machine learning, and is beginning to be used in commercial settings. This talk aims to provide a grounding in the core concepts of the topic, explore parallels with functional programming and introduce some promising recent research.
This Monday at 7pm we're pleased to announce we have another talk by Lee Kitching, this time on Property Based Testing a Regex Processor in F# with FsCheck.

Traditional unit testing requires the programmer to manually generate test cases, which are highly specific but give poor coverage of the range of possible inputs.

Property-based testing is used to specify the behaviour of programs and assert the adherence of the implementation to the specification by randomly exploring the input space.

This talk introduces property-based testing FsCheck, an F# port of Quickcheck. The API will be introduced before being demonstrated in development of a simple regular expression engine, and used to check invariants for data structures.
This monday at 7pm Rick Moynihan is talking about Clojure, the functional Lisp for the JVM.

The interactive REPL driven demonstration will try and provide a whistlestop tour of Clojure and its workflow, showcasing unique aspects of the language and its workflows.  Depending on what people want to see, we can touch on topics ranging from macros and meta programming to interacting with Lisp at the REPL, using profilers to diagnose performance issues, tools such as Leiningen, nREPL, Paredit, or CIDER, or the concurrency options available to you such as futures, promises, agents, atoms and the Software Transactional Memory.

Or perhaps any other core language features such as protocols, multimethods, persistent data structures, lazy sequences, transducers, that I can talk about.

I won't be able to cover everything, but I'll try my best to give you a flavour of this practical language.

This month we have another talk from Jaakko Pallari, this time on the Apache Spark platform. 

Spark provides a functional programming interface for building parallel, distributed data processing jobs.  Jaakko will talk about what Spark is and how to set it up, whilst demonstrating examples of developing with Sparqk.
We'll be meeting at 7pm at madlab as normal.
This monday at 7pm we have PLT guru Lee Kitching talking about Pipes.

Pipes is a Haskell library based on a composable push/pull streaming abstraction.

Laziness is crucial for defining reusable algorithms which can be freely composed together, and most modern languages define an abstractions for lazy sequences such as Java 8 Streams and IEnumerable in C#. However laziness is problematic when streams are derived from resources such as file handles which are consumed incrementally and require prompt cleanup since streams hide the nature of the source from the consumer. This presents a risk of resource leaks if clients fail to consume the entire stream, or inefficient use of resources if the problem is avoided by consuming the entire stream eagerly.

This talk describes the abstraction defined by the Pipes library and demonstrates how it can be used to define reusable streaming components.
This month Hakim Cassimally is presenting on why "Haskell is an acceptable Perl".  We're meeting on Monday in madlab at the normal time of 7pm... 

So, Haskell is "an advanced purely-functional programming language" which supports writing "declarative, statically typed code". It may be optimized for academic buzzwords you've never heard of but... is it any good for writing code in the way that you'd write Perl, Python, or Ruby?
What are strong types, and why are we so frightened of them anyway? Can you develop interactively in  Haskell, the way you would in a dynamic language?

Does Haskell have "whipuptitude" (being able to get things done quickly) as well as "manipulexity" (being able to manipulate complex things)? And perhaps most importantly, can writing Haskell be *fun*?
Haskell is founded on decades of the finest mathematical and computer science research.  Perl, quite demonstrably isn't... but why do so many Perl programmers also love Haskell?

Audrey Tang wrote the first prototype for Perl 6, Pugs, in Haskell, and coined the phrase "lambdacamel" for the substantial crossover between the languages.
What does a Perl programmer make of Haskell?  What are the lessons that can be learned (in either direction).  And do the languages have more in common than you might have thought?
This month after a brief hiatus we return at the usual time of 7pm with a talk by DJ Adams entitled:

Learning by Doing: Beginning Clojure by Solving Puzzles.

DJ had this to say about his talk:

"I'm teaching myself Clojure, because awesome. In this talk, I'll relate some of my experiences in trying to discover how natives speak, by tackling puzzles in Project Euler and Advent of Code.  If you're a Clojure beginner too, or even if you're not, this might give you some confidence in taking a similar journey; if you're more experienced, it might be a comedy half hour. Either way it will be fun :-)"

So come and join us for an interesting tour in applying a modern Lisp to classic computing and problems
This month saw Scala developer, Jaakko Pallari, talk about how Free monads are a general way of deriving monads for functor data types.

Besides reducing the boilerplate for creating new monads, they allow customising how the monads are interpreted.

Jakko demonstrated what free monads can be used for in practice, as well as how the free monad itself is structured.

The code examples in Haskell can be applied to other functional programming languages as well.
This month we have Lee Kitching giving us a talk on  Servant, a Haskell DSL for creating HTTP APIs.

We'll be meeting @madlabuk at the usual time of 7pm.

API endpoints in Servant are represented as types which ensures implementations conform to the definition and enables safe routing and automatic client generation.

The talk will cover how to use Servant to create web APIs, and examine some of the features of the Haskell type system which make it possible.

Show and Tell

The lambda lounge this Monday are doing a show and tell.  We'll meet at @madlabuk at 7pm as usual.

It's going to be a pretty informal round table discussion, so bring something along to chat about that you think will be interesting to the Lambda Lounge!

Things you could bring...

- A cool book you've read on Functional Programming or Computer Science

- An interesting paper, you've read on Computer Science, Types, Functional Programming etc...

- A neat algorithm

- An awesome API you've found

- A blog article you've found interesting.

Ideally you should be able to talk about what you've brought for a minute or two.  Feel free to bring as many things as you want to chat about - just try and keep them relevant to computer science and/or PLT

Don't worry if you don't have anything to bring - just come and join the conversations.

This Monday at 7pm, we'll be looking at Split-Apply-Combine a strategy for analysing data: split up the problem, apply a function, and combine the pieces.

Adopting this pattern will free you to focus on the unique aspects of your problem.

The strategy was first described by Hadley Wickham with a implementation he wrote in GNU-R. With roots in Scheme and S, R is a statistical language and computing environment offering both functional programming features (first class functions, higher-order functions, and closures) and support for objects.

Robin Gower, of Infonomics, is a data scientist with many years experience using R and he will be providing us with an overview of the split-apply-combine strategy and some live coded examples.

Application development with Purescript

Join us on the 20th July at 7pm at Madlab, where Becky Conning tells us about her path from Javascript to Purescript.

Becky's team uses Javascript for everything and over time has found the approaches and technologies that were helping them the most have their roots in functional programming.

Purescript is written in and inspired by Haskell. Luckily for us web developers, Purescript modules compile to CommonJS modules making  it surprisingly easy to interface between Javascript and Purescript in both directions.

There are also versions of Purescript in development that compile to Python and C++.

Becky will be sharing her excitement about the possibilities of functional programming for application development with you and we’ll building a small application to help get you motivated.

So whether you’re a Javascript developer, a seasoned functional programmer or just interested in applications come on down and get excited about Purescript and functional programming for applications!

Introducing Rust

This Monday at the usual time of 7pm, Michael Jones will introduce the Rust programming language from Mozilla with an overview of the goals of the project, what has been achieved so far and a focus on some of the functional influences in the language.

Rust is a systems programming language, that is gaining traction.  Its features include an innovative borrow checker, and many zero-cost abstractions to ensure type and memory safety.


Calling all Javascripters!

This Monday we have two talks talking about how to write better Javascript by using functional programming techniques.

Firstly Matthew Cannon will tell us about how the functional features of Javascript and the lodash framework helped deoderise his nodejs code.

This will be followed by Rick Moynihan giving a brief talk and discussion on why Javascripters might want to learn other functional languages.

We’re meeting at the usual time of 7pm @madlabuk, so we’ll see you there!

This month on Monday 16th @7pm we have Claudia Doppioslash talking about the adventures she's been having exploring the Elm programming language.

Elm is a Functional Reactive Programming language that targets the web (Javascript, Html, CSS). Reactive Programming, which has gotten in the mainstream with the Microsoft Rx extensions, is basically a better abstraction for anything that requires interactivity, like GUIs and games.

Some useful features of Elm are a Time Travelling debugger (which is remarkably similar to Bret Victors'), hot code swapping, immutability, Union Types, type inference and of course FRP.

We will be meeting at Madlab as usual.
On Monday February 16th at 7pm we're hosting a series of lightning talks @madlabuk.

The first talk by Michael Jones is on Facebook's React, a Javascript framework for functional DOM manipulation. 

This talk will then segway  nicely into a talk by Andrew Kirkham on the advantages of using React for Clojurescript UI's via either Om or Reagent.

In our third talk Daira Hopwood gives an introduction to the cool things you can do with dependent types and how they can help you write safer code.

We still have room for another lightning talk so if you'd like to talk for ~10-20mins, we'd love to listen!

This Monday @RickMoynihan will be introducing Grafter, an opensource Clojure DSL developed by Swirrl to solve the hard graft of linked data ETL

We'll look at how Clojure's affordances make it a natural language for simplifying the process of cleaning tabular data and converting it into linked graph data and how we're  building an interactive environment for lay users to write purely functional programs.

As usual we'll be meeting at 7pm at Madlab.