Below you'll find our event archive covering events we've ran in previous years.
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.
*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.
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 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.
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.
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!!
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.
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.
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.
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.
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.
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.
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.
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!
We'll be pairing up to do some more work on our battleships admirals.
Meeting @madlab at the usual time of 7pm.
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.
Simon 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.
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.
We will be pair programming, so bring a laptop!
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.
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 MemoryThis 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.
An Introduction to applicative functors 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.
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.
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.