Coming Up

15.11.2018 - Divide, conquer, choose, ap and alt... et Empera

posted 5 Nov 2018, 11:50 by Ed Lambda

Title: Divide, conquer, choose, ap and alt... et Empera

Speaker: Sam Halliday

When/where: Thursday 15th November, 7pm, St Andrews Brewing Co. Outhouse (The Outhouse pub) Edinburgh.


Automatically derive functionality (i.e. typeclasses) for domain objects (i.e. data types) with a novel approach based on the Haskell typeclassopedia. This talk uses Scalaz, is suitable for any lambda inclined developer, and has potential applications to other FP languages. It is an excerpt from

09.10.2018 - Elm: Taming the Wild West Web using Functional Programming, Rupert Smith

posted 11 Sept 2018, 01:51 by Ed Lambda

Title: Elm: Taming the Wild West Web using Functional Programming
Speaker: Rupert Smith
9th October 2018, The Outhouse pub, 7pm.


Rupert will introduce the Elm programming language, comparing it with other well known FP languages. The strengths of FP will be examined by looking at examples of Elm programs used to build single page applications for the web. There will also be a quick tour of some of the libraries available and the people and businesses involved with Elm.

11.09.2018 - From WebAssembly to Native Code via the OCaml Backend

posted 20 Aug 2018, 10:26 by Ed Lambda

Speaker: Simon Fowler, University of Edinburgh
Location: The Outhouse pub, 7pm, 11th September 2018
Title: cmm_of_wasm: From WebAssembly to Native Code via the OCaml Backend


WebAssembly is a low-level yet platform-independent language designed
to replace JavaScript as a compilation target for web applications.
WebAssembly has been billed as "Neither Assembly, nor just for the
Web", but the main production implementations are JIT compilers
implemented in web browsers. As the WebAssembly specification evolves
to incorporate new features such as garbage collection and threads,
and with plans to support more advanced features such as handlers for
algebraic effects on the horizon, it becomes important to prototype
new features without having to modify complex browser code.

In this talk, I will describe cmm_of_wasm, a feature-complete
ahead-of-time compiler which compiles WebAssembly to native code via
a translation to OCaml's CMM intermediate representation. I will give
a tutorial introduction to WebAssembly, discuss challenges which
arise both due to the design of WebAssembly and the choice of CMM as
a compilation target, and discuss a roadmap for future work.

11.07.2017 - F# for Profit and Fun

posted 4 Jul 2017, 08:55 by Ed Lambda

Who Iain Nicol
When 19:30, Tuesday 11th July
Where Skyscanner, 15 Lauriston Place

Title F# for Profit and Fun


We share some insights, frustrations, and joys, as a professional F# functional programmer in fintech. From a background of C# and Haskell, F# is an interesting proposition. In particular we will explore some killer features such as QuickCheck and code quotations.

09.05.2017 - Type-driven Development with Idris

posted 1 May 2017, 02:38 by Ed Lambda

Who: Edwin Brady
Where: Skyscanner, 15 Lauriston Place
When: 7:30pm, Tuesday 9th May, 2017

Title: Type-driven Development with Idris


This talk will be about the book "Type-driven Development with Idris" (, recently published by Manning, and there will be an opportunity to win a copy.

Idris is a general purpose functional programming language with first-class dependent types, building on state-of-the-art techniques in programming language research. Idris aims to make type-based program verification techniques accessible to programming practitioners while supporting efficient systems programming via an optimising compiler and interaction with external libraries.

In this talk, I'll use a series of examples to show how Idris can be used for verifying realistic and important properties of software, from simple properties such as array bounds checking, to more complex properties of networked and concurrent systems.

09.02.2016 - Developing a Haskell MOOC

posted 22 Jan 2016, 02:46 by Ed Lambda   [ updated 22 Jan 2016, 03:01 ]

Where Skyscanner's offices, 15 Lauriston Place. Map:
When 6:30pm Tuesday 9th February
Who Jeremy Singer, University of Glasgow

Title Developing a Haskell MOOC

The Massive Open Online Course (MOOC) is the latest trend in higher education, exposing university learning and teaching to anyone on the net. At Glasgow, we are developing a MOOC to teach Haskell to non-functional (!) programmers. Our #haskellmooc is due to launch in September 2016. In this talk I will give some background, preview our learning materials and hope to garner feedback from the audience.


12.11.2015 - Overloaded record fields for Haskell

posted 28 Oct 2015, 02:22 by Ed Lambda

When Thursday 12th November at 7pm
Where Skyscanner's offices, Quartermile One, 15 Lauriston Pl, Edinburgh
Who Adam Gundry, Well Typed.

So that Skyscanner know who they should expect entering their building, please get a free ticket from the EventBrite page.

Title Overloaded record fields for Haskell

A long-standing annoyance when using Haskell for large-scale
applications has been its rather limited record system.  In particular,
field names cannot be reused across multiple datatypes, and while the
record update mechanism is very expressive, it does not compose well.
Over the years there have been many proposals for better systems, but no
concrete progress on implementation.

This is the story of how I foolishly set out to "solve the records
problem" over the summer of 2013, and how over two years later I've
still neither quite succeeded nor failed.  I'll explain the new design
as it currently stands, showing how it decomposes into not one but three
separate language extensions, one of which provides interesting new
possibilities for writing programs that have nothing to do with records.
 While it is always dangerous to predict the future, I'll outline what
you can and can't expect to see from this work in the upcoming GHC 8.0.

13.10.2015 - optimising & scaling parallel Haskell

posted 28 Sept 2015, 11:26 by Ed Lambda   [ updated 28 Sept 2015, 11:27 ]

Title Profiling, optimising, parallelising and distributing Haskell code
When Tuesday 13th October.
Where The Outhouse pub, at 7pm.
Speaker Rob Stewart

I'll talk about those rare occasions when you don't just want to write Haskell programs,
but you also want to run them... and as quickly as possible. I'll cover code profiling and
optimisation, and go through the various ways to write parallel, and distributed, Haskell

14.07.2015 - Erlang meets Dependent Types

posted 28 Jun 2015, 12:09 by Ed Lambda   [ updated 28 Jun 2015, 12:10 ]

Speaker Sam Elliott.

When 14 July, *at SkyScanner's offices at 15 Lauriston Place*


Concurrent programming is notoriously difficult, due to needing to reason
not only about the sequential progress of any algorithms, but also about
how information moves between concurrent agents. What if programmers were
able to reason about their concurrent programs and statically verify both
sequential and concurrent guarantees about those programs’ behaviour? That
would likely reduce the number of bugs and defects in concurrent systems.

Erlang’s existing type system cannot produce particularly strong
guarantees, especially not with regards to concurrent systems. In this talk
I will describe work to integrate a dependently-typed language (Idris) with
Erlang, in order to integrate dependently-typed code with Erlang programs.
This work included both a new Idris code generator, and libraries for
reasoning about concurrent Erlang programs, including some OTP behaviours

This is a ticketed event. To get a ticket:

24.03.2015 - Vectorising the array-based SaC language

posted 10 Mar 2015, 04:40 by Ed Lambda

Who: Artem Shinkarov
Where: The Outhouse at 7pm
Title: Automatic data layout transformations enabling SIMD vectorisation

Usually programming languages use a fixed layout for logical data structures
in physical memory.  Such a static mapping often has a negative effect on
usability of vector units.  In the talk we will consider a compiler for a
programming language that allows every data structure in a program to have its
own data layout.

Such an approach comes with a number of challenges.  First, the number of
theoretically possible data layout configurations per program is very large.
We need to choose the one that will lead to the best program
vectorisation.  Secondly, we have to make sure that the chosen configuration
is sound.  Finally, the code we generate has to encode desired vectorisation
preferably in a portable way.

Our solution lies in using types to encode data layouts.  We
use a type system to verify data layout consistency in programs.  Type
inference techniques allow us to solve a data layout reconstruction problem.
We prove that type-implied transformations preserve semantics
of the original programs and we demonstrate significant performance improvements
when targeting SIMD-capable architectures.

1-10 of 37