Coming Up
09.10.2018 - Elm: Taming the Wild West Web using Functional Programming, Rupert Smith
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. |
11.09.2018 - From WebAssembly to Native Code via the OCaml Backend
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. |
11.07.2017 - F# for Profit and Fun
Who Iain Nicol When 19:30, Tuesday 11th July Where Skyscanner, 15 Lauriston Place Title F# for Profit and Fun Abstract |
09.05.2017 - Type-driven Development with Idris
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. |
09.02.2016 - Developing a Haskell MOOC
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 |
12.11.2015 - Overloaded record fields for Haskell
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. |
13.10.2015 - optimising & scaling parallel Haskell
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. |
14.07.2015 - Erlang meets Dependent Types
Speaker Sam Elliott. When 14 July, *at SkyScanner's offices at 15 Lauriston Place* Abstract Concurrent programming is notoriously difficult, due to needing to reason Erlang’s existing type system cannot produce particularly strong This is a ticketed event. To get a ticket: https://www.eventbrite.co.uk/e/erlang-meets-dependent-types-with-sam-elliott-tickets-17472346258 |
24.03.2015 - Vectorising the array-based SaC language
Who: Artem Shinkarov Where: The Outhouse at 7pm Title: Automatic data layout transformations enabling SIMD vectorisation Abstract: 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. |
10.02.2015 - Web programming with F#
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). |
1-10 of 36