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
Elm: Taming the Wild West Web using Functional Programming
Description changed:
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.
cmm_of_wasm: From WebAssembly to Native Code via the OCaml Backend
Description changed:
Speaker: Simon Fowler, University of Edinburgh
Location: The Outhouse pub, Edinburgh, 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.
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.
EdLambda meetup: FP meets high performance, vectorising the array language SaC
Description changed:
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.
EdLambda meetup: Functional Web Programming in Links and F#
Description changed:
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. 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.
Google Developer Group Edinburgh - A meetup focused on google technologies. A great place to find out some of the more obscure things that are going on with google products
Joint meeting of the Java User Group and EdLambda at the Outhouse.
Our special guest speaker Jeremy Singer from Glasgow University will give his talk
"Thinking outside the box: Optimizing non-Java JVM languages"
Jeremy will look at functional JVM languages, their use of boxed value types, and how this impacts efficiency. He will also discuss optimisations to OpenJDK that could improve boxed integer allocation and method invocation performance.
We will be in a pub, so there will be drinks and NCR will be providing free pizza.
Joint meeting of the Java User Group and EdLambda at the Outhouse.
Our special guest speaker Jeremy Singer from Glasgow University will give his talk
"Thinking outside the box: Optimizing non-Java JVM languages"
Jeremy will look at functional JVM languages, their use of boxed value types, and how this impacts efficiency. He will also discuss optimisations to OpenJDK that could improve boxed integer allocation and method invocation performance.
We will be in a pub, so there will be beer and NCR will be providing free pizza.
Come chew the fat about cleanweb, tech, sustainability and have a drink or two at this informal meet-up.
Earlier this summer, the first ever European Cleanweb leaders summit took place in Barcelona. Off the back off the summit, there are further plans to connect cleanweb communities. Some of the proposed plans include; an annual global conference and a bi-annual meeting of some leaders in the European space.
To this end we are actively involved in developing an online presence, Cleanweb.eu. We'd love to hear from you if you'd like to participate. Help in the form of design skills would be especially appreciated!
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.
EdLambda short talks: Rusty session typed runtime systems.
Description changed:
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: Outhouse Pub @ 7pm
Who: Miles Gould
Title: CRDTs and LVars
Abstract
---
The CAP theorem for distributed databases ("consistent, available,
partition-tolerant: pick two") and the growth of Big Data have led to a
renewed interest in relaxed standards of consistency for distributed
data. For many applications it's enough to guarantee eventual
consistency between nodes, but designing protocols to ensure this has
proved tricky and error-prone. A neat approach is to build eventual
consistency guarantees into the datatypes themselves using ideas from
the theory of semilattices: this leads to so-called Convergent
Replicated Data Types (CRDTs). These turn out to be closely related to
the notion of LVars, studied by Kuper et al in the context of concurrent
shared-memory Haskell programs.
Overtone is a music programming & synthesis system based on Clojure, a
modern dialect of Lisp. I'll show how you can use it to create a very
simple DSL for live-coding drum loops. I know little about Clojure or
making music, so I apologise in advance for what you will hear.
David Barbour defined an "insane language" to be one where you can ask the
same question over and over again and get a different answer each time.
Overtone and many other live-coding environments for music rely on the fact
that the Lisp family of languages is utterly mad.
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.
The Outhouse pub
12A Broughton Street Lane
Edinburgh
EH1 3LY
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.
Area changed:YesEdited at by jarofgreen