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. https://goo.gl/maps/FYZ3pxNDPi42 Abstract 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 https://leanpub.com/fpmortals |
Title: Elm: Taming the Wild West Web using Functional Programming Speaker: Rupert Smith 9th October 2018, The Outhouse pub, 7pm. Abstract 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. |
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 Abstract 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. |
Who Iain Nicol When 19:30, Tuesday 11th July Where Skyscanner, 15 Lauriston Place Title F# for Profit and Fun Abstract |
Who: Edwin Brady Where: Skyscanner, 15 Lauriston Place When: 7:30pm, Tuesday 9th May, 2017 Title: Type-driven Development with Idris Abstract This talk will be about the book "Type-driven Development with Idris" (https://www.manning.com/books/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. |
Speakers: Prabhat Totoo, Pantazis Deligiannis & Hans-Wolfgang Loidl Title: Haskell vs. F# vs. Scala: High-level Language Features and Parallelism Support * Update: here are the slides from the talk: http://www.slideshare.net/pt114/haskell-vs-f-vs-scala * * And the paper: http://www.macs.hw.ac.uk/~dsg/gph/papers/pdf/fhpc12.pdf * Abstract --- We
will outline a recent study that provides a performance and
programmability comparison of parallel programming support in Haskell,
F# and Scala. Emphasis is given on advanced language features such as
purity, evaluation order, and integration of functional aspects
into imperative and object-oriented languages. The expressive power of
each language is analysed, especially regarding their support
for parallelism. We quantify parallel performance and assess
succinctness and modularity of the code. --- This meetup: Date: 8th May Time: 7pm Location: Outhouse Pub, upstairs |
;; First talk Speaker: Szymon Jachim Title: BAYSICK - an embedded Insane-specific Language for Scala implementing a subset of BASIC Abstract: Scala is considered as one of the candidates for the Next Big Language, while BASIC was the First Programming Language for many of us. This short talk will show you the implementation of BASIC as an internal DSL in Scala. While commercial usefulness of it is dubious, Baysick is a neat example of some of the interesting features of Scala and brings back childhood (8-bit) memories like madeleine cake in Proust's novel. ;; Second talk Speaker: Paul Richards Title: Functions all the way down - An introductory frolic with Church Encodings. |
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 programs. |
Speaker: Jeremy Singer, University of Glasgow Title: Controlling Heap Size in Poly/ML Abstract: Typical theorem-proving workloads on the Poly/ML [1] runtime system may execute for several hours, occupying multi-gigabyte heaps. The heap size may be fixed at execution startup time, or it may be allowed to vary dynamically. To date, runtime heap size growth has been implemented using simple hard-coded heuristics. In this talk, I will argue that a mathematically rigorous approach to heap sizing, based on control theory, is more appropriate. 1 - http://www.polyml.org/FAQ.html |
Two talks: 1. Kenneth MacKenzie. Title: RELEASE: scaling to Erlang to 10,000 cores and beyond. Abstract Erlang is a well-known concurrency-oriented functional programming language which has been used to build large and highly-reliable distributed software systems. However, some difficulties arise on very large platforms; the RELEASE project aims to overcome these and enable Erlang to scale smoothly to systems involving many thousands of cores. I'll give an introduction to the basics of Erlang and then describe some of the scalability challenges that arise on large hardware systems, and how we're attempting to tackle them. No prior knowledge of Erlang will be assumed! http://www.release-project.eu/ 2. Mike Borozdin Title: Functional features in Java 8 Abstract Java 8 has many interesting new features. Undoubtedly, the most exciting one out of them is functional programming. In this talk, we will see practical examples of how functional programming features in Java 8 enable you to write code in a more concise and declarative manner. We will also cover the new functionality that makes it possible – Stream API, lambda expressions, default methods, and so on. |
Who: Edwin Brady When: Tuesday 8th October Title: "State, interaction and side-effecting programs in Idris" Abstract: Idris (http://idris-lang.org) is a general-purpose purely functional programming language with dependent types. In a talk at EdLambda last year, I gave an introduction to the language showing how to implement small functions, prove their correctness, and gave a larger example of a well-typed interpreter for the lambda calculus. In this talk, I will present some recent work on Idris which gives a more practical example of these techniques. I will show how we can use dependent types to implement and reason about side-effecting programs, with a clear and usable API, illustrated using a "Space Invaders" style game. Update: Edwin's slides are: here. |
The November meetup will be given by Andrew Forrest and will be about a prototype of a next generation spreadsheet implemented in Scala. As usual join us at 7pm in the Outhouse. We are still looking for speakers for |
Sam Lindley is giving this month's EdLambda talk on Tuesday 17th at 7pm at The Outhouse pub. It'll be based with Ohad Kammar and Nicolas Oury: "Handlers in action". Sam will probably focus mostly on examples from their Haskell effect handler library, perhaps with some live hacking. Abstract --- Plotkin and Pretnar’s handlers for algebraic effects occupy a sweet spot in the design space of abstractions for effectful computation. By separating effect signatures from their implementation, algebraic effects provide a high degree of modularity, allowing programmers to express effectful programs independently of the concrete interpretation of their effects. A handler is an interpretation of the effects of an algebraic computation. The handler abstraction adapts well to multiple settings: pure or impure, strict or lazy, static types or dynamic types. This is a position paper whose main aim is to popularise the handler abstraction. We give a gentle introduction to its use, a collection of illustrative examples, and a straightforward operational semantics. We describe our Haskell implementation of handlers in detail, outline the ideas behind our OCaml, SML, and Racket implementations, and present experimental results comparing handlers with existing code. |
When: 7pm, 10th December @ Outhouse pub Title: "PouchDB and Second System Syndrome" Abstract --- PouchDB is a full re-implementation of CouchDB in JavaScript, I will talk about why that isn't a completely insane idea, the differences between an Erlang and JS codebase, and some things in between. |
Who: Neil Ghani Title: State Of the Art in Data Types Abstract: I'll give a little overview talk about how data types are handled in functional programming languages and the underlying ideas. I'll take us from the simplest of the data types to the current state of the art and demonstrate the power of the underlying ideas by showing how they cope with whatever we throw at them. If time permits I'll also tell you about "Beheading" which is a lovely construction. When & where: Tuesday 12th November. 7pm at the Outhouse pub. Update: Neil's slides are: here. |
January's meetup will be on the 3rd Tuesday of the month (not the 2nd as normal). The January talk (previously planned for December) will be given by Patrick Maier and will be about his work on distributed-memory parallel Haskell. As usual you can join us from 7pm in the Outhouse. If you are unable to make EdLambda then Patrick will also be presenting at the SPLS on November 11th. We are looking for presenters for February and onwards, so get in touch if you are interested in speaking. |
Who: Edwin Brady When: Tuesday 2nd October, 7pm. Title: Idris - a language with dependent types Abstract --- Idris (http://idris-lang.org) is a general purpose pure functional programming language with dependent types. Dependent types allow types to be predicated on values, meaning that some aspects of a program’s behaviour can be specified precisely in the type, and verified by type checking. Idris syntax is heavily influenced by Haskell, and features include type classes, records, and overloadable syntax. In this talk, I'll give a brief tour of dependently typed programming in Idris, by demonstration. In particular, I will show how Idris can be used to implement verifed domain specific languages. |
Who: Conor McBride When: 7pm, 12th March Where: The Outhouse pub Title: "Totally Live Coprogramming" Abstract --- Total programming is too often characterised by the idea that "programs must eventually stop". But there's another side to totality, in which "coprograms can always go". I'll talk about how to guarantee system properties such as "liveness" and even "fairness" by strong typing disciplines, and show you what I'm talking about with a bit of livecoding (language still to be selected; perhaps language still to be implemented). The alleged Turing incompleteness of total languages will emerge as something of an exaggeration. I'll be frank about the shortcomings of current totality checking disciplines, but guardedly optimistic about current developments in that respect. Update: Conor's slides are: here. |
When: 14th May, 7pm at The Outhouse Speaker: Steven Obua Title: Versioning and Access Control in ProofPeer Abstract -- ProofPeer (http://proofpeer.net) is a system in the making for collaborative theorem proving. It runs on top of Google App Engine and implements its own scalable version control and access control mechanisms. I will talk about these mechanisms which are inspired by Git but result in a (hopefully) drastically simplified experience that is targeted at people interested in theorem proving, e.g. mathematicians. |
When: 10th February, 2015 Who: Simon Fowler, University of Edinburgh Title: Functional Web Programming in Links and F# Functional programming has been shown to be a good fit for web development. The Links functional web programming language developed by Cooper, Lindley, Wadler and Yallop at the University of Edinburgh allows client, server, and database code to be written in a single language, while providing abstractions such as formlets to allow form data to be retrieved in a structured, elegant and type-safe manner. More recently, these ideas have been picked up and expanded upon in IntelliFactory's WebSharper web framework, which embeds many of the concepts in the .NET functional-first language F#. In this talk, I'll take a look at Links and WebSharper, comparing the approaches taken by each. In doing so, I'll explore some of the language features of F# which make the embedding possible, revisit some web abstractions such as Formlets, and talk about some more recent abstractions such as Piglets (yes, Piglets). |
Who: Robert Atkey When: 6th November, 7pm @ The Outhouse pub Title: "Theorems for Free" Abstract --- Static type systems for programming languages have several well-known benefits: the eradication of certain classes of bugs at compile time, the use of types as machine-checked documentation, and the use of types as a high-level design language. A less well-known benefit of static type systems is the automatic derivation of useful properties of programs just from their types. These properties often exploit the uniform behaviour that polymorphic programs have when instantiated at different types. For example, functions that have the (Haskell) type: h : forall a. [a] -> [a] will (nearly (*)) always satisfy the following property: forall types a, b. forall f : a -> b. forall l : [a]. h (map f l) = map f (h l) Intuitively, this property holds because 'h' must "act the same" whether the input type is '[a]' or '[b]'. This kind of property can be used to rewrite programs for optimisation purposes, for example. (*) nearly: this gets more complicated when non-termination and 'seq' are taken into account. This property of the function 'h' can be deduced purely from its type alone, without looking at the actual implementation. Hence, Wadler called these properties "Theorems for Free" [1]. I'll talk about the different kinds of Theorems for Free that one can obtain, and what uses they can be put to. I'll also talk about some recent work [2] that applies the Theorems for Free idea to programs that manipulate geometric data, providing free theorems that state how the behaviour of programs can be invariant under geometric transformations like scaling, rotating and translation. [1] Wadler, P. "Theorems for Free!" http://homepages.inf.ed.ac.uk/wadler/papers/free/free.ps [2] Atkey, R., Johann, P., Kennedy, A.. "Abstraction and Invariance for Algebraically Indexed Types" https://personal.cis.strath.ac.uk/robert.atkey/algebraic-indexed.html |
Who: Sven-Bodo Sholz, SAC do-designer When: Tuesday, 10th July, 7pm at the Outhouse pub What about: Single Assignment C a strict purely functional programming language which design is focused on the needs of numerical applications. Emphasis is laid on efficient support for array processing." [1] Title: Aiming for HP3: High-Productivity, High-Performance, and High-Portability Abstract: As a starting point for discussion, I will present SaC and its auto-sequentialising compiler toolchain. I will present some of the underlying design choices that were guided by the desire to offer programmers with a high-level of programming productivity. Being based on C syntax, SaC offers a completely hardware agnostic programming model with n-dimensional array structures at its heart. This enables abstractions similar to what is available in Matlab. In contrast to Matlab, the toolchain of SaC was always aimed at compilation for high-performance executions. We have employed functional principles in order to facilitate radical program transformations that enable our toolchain to transform algorithm-friendly, hardware-agnostic programs into highly optimised, target-hardware-specific form. For several examples from computational science and from computer vision, we could demonstrate very competitive runtimes on a range of architectures including traditional SMPs and GPGPUs. This performance can be obtained without any manual program adjustments despite the vast differences in the target architectures, making code portability a matter of a compiler switch. |
When: 11th September, 7pm @ The Outhouse pub Title: Riak, What's all the fuss about? Who: Sam Elliot * Update: Here are the slides presented at EdLambda: https://speakerdeck.com/u/lenary/p/riak-whats-all-the-fuss-about * Abstract --- In
this talk, I hope to give an introduction to Riak, a Highly-Available
Distributed Key-Value Store written in Erlang and based on Amazon's
Dynamo Paper. I'll show the original Dynamo concepts, how they have been
applied to Riak, and some of the extra features that have been added to
make Riak more useful to real-world situations. Finally, I'll say
something about why Erlang was the right language to developer Riak in
(as opposed to a higher-level functional language or an imperative
language). |
When Thursday 12th November at 7pm Where Skyscanner's offices, Quartermile One, 15 Lauriston Pl, Edinburgh Who Adam Gundry, Well Typed. Tickets https://www.eventbrite.co.uk/e/adam-gundry-overloaded-record-fields-for-haskell-tickets-19291410127 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 Abstract 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. |
Talk 1: An experience report with Rust Speaker: Bob Atkey Abstract: Rust is a new language being developed by Mozilla, intended for low-level systems programming, and has an interesting linear/region-based type system for managing stack and heap allocated memory without using a garbage collector, and for safe shared-memory concurrency. I will give a short talk on Rust, based on my experience of one whole afternoon of writing one program in it (plus whatever I manage to do before the next EdLambda). Talk 2: Scaling Runtime Systems with Session Types? Speaker: Rob Stewart Abstract: "Programs + communication = systems" (Simon Gay, Glasgow Uni). Simon and others advocate session types as a verification tool to ensure that planned communication between programs is safe, perhaps to ensure that a protocol is obeyed. Verification, OK. But what else? What about performance? For example, can session types inform distributed runtime systems to help minimise communication costs and hence maximise scalability? I will give a very simple, under-researched and almost certainly broken idea of what this might look like. |
Where Skyscanner's offices, 15 Lauriston Place. Map: https://goo.gl/n0GYxG 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. Link: https://glasgowmoocadventures.wordpress.com |