John McCarthy (Inventor of Lisp) says "PROGRAMMING, you're doing it completely wrong!"
"The tools we use have a profound (and devious!) influence on our thinking habits, and, therefore, on our thinking abilities."
- Edsger Dijkstra

"The problem with object-oriented languages is the implicit environment that they carry around with them. You wanted a banana but what you got was a gorilla holding the banana and the entire jungle." 
Joe Armstrong

"...any new class is itself an island; unusable by any existing code written by anyone, anywhere. So consider throwing the baby out with the bath water."- Rich Hickey
"Lisp has jokingly been called 'the most intelligent way to misuse a computer'. I think that description is a great compliment because it transmits the full flavor of liberation: it has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts."
- Edsger Dijkstra

Join the renaissance!

There are dozens of functional programming languages, and they can be as different from each other as Ruby and Cobol; however as a family they tend to:
Emphasise the application and composition of functions, over the imperative mutation of state. Consequently functional programs are shorter and easier to reason about.

Prefer pure values over mutable objects. Values never change, so programs using values are safer and easier to reason about.

Treat functions as first-class values
, allowing them to be passed as arguments and returned from functions. Higher order functions such as these enable powerful new abstractions.
Focus on the primacy of data, rather than hiding it behind unwieldly classes.

Manage side effects more cleanly meaning less state and fewer bugs.  

Be thread safe by default, without having to resort to locks which fail to compose.

Be a proving ground for awesome features
. Garbage Collection, Closures, Continuations, Monads, Expression orientation, Lexical Scope, and Software Transactional Memories all made it into functional languages years before they were mainstream.  What are you still missing?
Functional programming is not only on the cutting edge of computer science research, but it's being adopted by a leaner generation of startups who are innovating faster than their competitors.

A new generation of functional languages like F#Scala and Clojure, are giving developers the ability to run functional languages on the runtime environment of their choice (.Net, JVM or Javascript), whilst traditional functional languages like Haskell, Scheme, Erlang and O-Caml continue to develop the state of the art in type systems, language features, compilers, and fault tolerant systems.

Come to a meeting

The Lambda Lounge is proud to be one of @madlabuk's regular groups.

They provide us and others with a vibrant community space to make interesting stuff.  They're a place for geeks, artists, designers, illustrators, hackers, functional programmerstinkerers, innovators and idle dreamers.
They're also an autonomous R&D laboratory and a release valve for Manchester's creative communities.  But most of all, they're really cool friends!

We meet regularly, for talks and practical sessions.  Meetings are usually on the third Monday of the month at 7pm, though for practical reasons this is not always possible.  So it is best to check here and keep an eye on our Google Group for announcements.


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.

About us

The λ lounge meets monthly to talk about and popularise new ways of thinking about computation.  Frequent topics include, functional programming, type systems, programming language design and aspects of computer science.

We are programming language agnostic, but have traditionally focused on exploring functional programming, though we are open to hosting more diverse talks on computer science topics.

We were born from the Manchester Clojure Dojo, when we decided there would be more demand for a broader group focusing on functional programming in general.  We asked politely and took the name from the American revolutionaries, of the orignal Lambda Lounge in St Louis.  Our logo was designed by the incredibly talented @hltn.
Photograph of our first meeting
@RickMoynihan introducing @SimonHolgate's talk on ClojureScript at the first Manchester Lambda Lounge. 

Come along...

to a meeting and join our Google Group!

Join our Google Group, and participate in Manchester's premiere (it's easy when you're the only one) Functional Programming community.

Joining the Google Group is the best way to stay informed on our future meetings, follow up with people after our events, and to help us plan future meetings.

Want to talk?

If you want to talk then there's a good chance the Lambda Lounge will want to listen!

Our main focus is on functional programming, esoteric languages & computer science, however we're a diverse group so if you want to talk the chances are we'll want to listen!

You can submit ideas for talks, either through the form on the right or our Google Group.

e.g. Haskell Curry
e.g. Monads are simples!
e.g. as they're just Monoids in the category of endofunctors...

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.