Where academia meets innovation

Code Mesh LDN 2019

KEY FACTS

2
days
40+ speakers
4 tutorials
5 themes

What is Code Mesh LDN?

A two-day conference, bringing together users and speakers of different functional programming languages and alternative tech.

In the spirit of learning from one another, it encourages the sharing of innovative ideas, through inspiring projects, top talks, in-depth tutorials and networking opportunities.

Why Code Mesh LDN?

By bringing together users and inventors of different languages and technologies (new and old), speakers will get the opportunity to inspire, to share experience, and to increase insight.

Through presentations and case studies, we aim to raise awareness and extend the knowledge of all participants, mainstream and non-mainstream users alike.

Time	Room 1	Room 2	Room 3
08.00 - 09.00	REGISTRATION
09.00 - 09.15	WELCOME
09.15 - 10.15	Carl Hewitt Keynote: Room 1 Ultraconcurrency is the future of programming
10.15 - 10.35	COFFEE BREAK
10.35 - 11.20	Allison Randal Room 1 Secure isolation in Rust: hypervisors, containers, and the future of composable infrastructure Intermediate	Miles Sabin Room 2 Adding kind-polymorphism to the Scala programming language Intermediate	Carlos Baquero Moreno Room 3 CRDTs: From sequential to concurrent executions Intermediate
11.25 - 12.10	Lars Hupel Room 1 Programmation en Logique (BEGINNER) Beginner	Dragan Djuric Room 2 Interactive GPU programming with ClojureCUDA and ClojureCL Intermediate	Veronica Lopez Room 3 Verifying a distributed system with combinatorial topology Formal verification of distributed systems is hard and expensive. Modern systems rely on tools like observability, extensive testing, and more recenty, chaos engineering. Understanding the maths behind distributed computing, and being able to express systems in terms of algebraic topology and graph theory brings a new possibility of formal verification and a new approach towards solving complex problems and their interconnections. Intermediate
12.10 - 13.40	LUNCH
13.40 - 14.25	Don Syme Room 1 F# code I love Beginner	Dmitry Kandalov Room 2 Coroutines explained Coroutines have received quite a bit of attention recently from language designers with async/await in JavaScript 2017, Python 3.5 new syntax and Kotlin 1.1 coroutines support. Yet there seems to be a lot of confusion about why coroutines exist and how to use them. This session explains what coroutines are, how they differ between programming languages and how to use coroutines for fun and profit. Intermediate	Garrett Smith Room 3 Introduction to AI engineering Intermediate
14.30 - 15.15	Natalia Chechina Room 1 Co-operative robots sharing the load Advanced	Geoffroy Couprie Room 2 Parsing safely, from 500MB/S to 2GB/s Intermediate	Felix Lopez Room 3 Understanding gossip protocols Beginner
15.15 - 15.35	COFFEE BREAK
15.35 - 16.20	Ulf Wiger Room 1 Using Erlang in blockchain development Beginner	Sophia Drossopoulou Room 2 Towards specifications of robustness -- the things that programs do _not_ do Beginner	Arnaud Bailly and Yann Schwartz Room 3 One Log Intermediate
16.25 - 17.10	Heather Miller Room 1 Towards language support for distributed systems Intermediate	Tom Harding Room 2 PureScript spirographs (INTERMEDIATE) Intermediate	Peter Saxton Room 3 Message passing for actors and humans with Raxx Intermediate
17.15 - 17.20	CLOSING NOTES
17.20 - 22.00	#OpenErlang London Party

Time	Room 1	Room 2	Room 3
09.00 - 09.10	WELCOME
09.10 - 10.10		Kathleen Fisher Keynote: Room 2 From quadcopters to helicopters: formal verification for safer vehicles
10.10 - 10.30	COFFEE BREAK
10.30 - 11.15	Jimmy Soni Room 1 The life, times, and thinking of Dr. Claude Shannon, the founder of information theory	Romeu Moura Room 2 Property based tests for the masses Use property based tests to challenge your knowledge of the domain, to create smaller, fewer tests that: test more, are more readable & document the problem. Use them even (specially) in horrible eldritch codebases written in awful languages, use property based tests to ask questions to your codebase. OBJECTIVES Get people to try property based tests in their own codebase monday within 20 minutes Beginner	Teon Banek Room 3 Life of a distributed graph database query Intermediate
11.20 - 12.05	Frieder Nake Room 1 Do calculating machines like drawing? And if so, why? Considerations from media archaeology	Ju Goncalves Room 2 Abstract nonsense Generative art programming requires many computations, such as random number generation and image output. What if we applied category theory to model a declarative, purely functional way of programming artworks? In other words, what if we could generate abstract nonsense with abstract nonsense? Intermediate	Daniil Fedotov Room 3 Implementing Raft in RabbitMQ Intermediate
12.05 - 13.30	LUNCH
13.30 - 14.15	Joe Armstrong and Jeremy Ruston Room 1 Intertwingling the Tiddlywiki with Erlang Ted Nelson, who coined the term "Hypertext" also coined the lesser known word "Intertwingled" - this captures the idea that all there is, is knowledge which is tangled up and linked together in a myriad of complex ways. Beginner	Andrea Dobson Room 2 Ethics in tech: a psychological perspective Why do people behave unethically and what can we do about it? Andrea will do a deep dive into social psychology research on behaviour, ethics and company culture. What are the anti-patterns we should all avoid? Most of the knowledge we have on Conformity and Obedience today come from Psychological experiments done in the 1950s and 1960 What do they mean in today’s society and what impact are they having on the choices we make? And are there things we can do about this?	James Coglan Room 3 Breaking changes Intermediate
14.20 - 15.05	Hillel Wayne Room 1 Designing distributed systems with TLA+ Intermediate	Einar Høst Room 2 A PostScript to Functional Geometry	Duncan Coutts Room 3 Building a Billion Dollar cryptocurrency with Haskell Intermediate
15.05 - 15.25	COFFEE BREAK
15.25 - 16.10	Edwin Brady Room 1 Idris 2: Type-driven development of Idris Intermediate	Kate Carruthers Room 2 Infosec, AI and ethics – new models for a secure future	Maxim Fedorov Room 3 Scaling Erlang cluster to 10,000 nodes Scaling Erlang Cluster Advanced
16.15 - 17.00	Jyothsna Patnam Room 1 Eta: The rise of pure FP on the JVM Pure functional programming has been around for more than 30 years and the benefits are widely known. Yet, it’s industrial adoption has been scanty. In this talk, Jyothsna will discuss the work being done to address this problem via Eta. Intermediate	Ron Pressler Room 2 Finite of sense and infinite of thought: A history of computation, logic and algebra	Yan Cui Room 3 Applying principles of chaos engineering to serverless Intermediate
17.05 - 18.05	Federica Pelzel Keynote: Room 1 Ethics and AI: Identifying and preventing bias in predictive models
18.05 - 18.15	CLOSING NOTES
18.15 - 19.15	LEAVING DRINKS

Where academia meets innovation

KEY FACTS

videos-and-slides

Using formal methods to eliminate exploitable bugs /// Kathleen Fisher

Ethics and AI: Identifying and preventing bias in predictive models /// Federica Pelzel

Scaling Erlang cluster to 10,000 nodes /// Maxim Fedorov

Secure isolation in Rust: hypervisors, containers, and the future of composable infrastructure /// Allison Randal

Ethics in Tech: a psychological perspective /// Andrea Dobson

CRDTs: From sequential to concurrent executions /// Carlos Baquero Moreno

Implementing Raft in RabbitMQ /// Daniil Fedotov

Coroutines Explained /// Dmitry Kandalov

F# Code I love /// Don Syme

Interactive GPU programming with ClojureCUDA & ClojureCL /// Dragan Djuric

Building a Billion Dollar Cryptocurrency with Haskell /// Duncan Coutts

Idris 2: Type-driven development of Idris /// Edwin Brady

A PostScript to functional geometry /// Einar Høst

Understanding gossip protocols /// Felix Lopez

Do calculating machines like drawing? And if so, why? Considerations from media archaeology /// Frieder Nake

Introduction to AI engineering /// Garrett Smith

Parsing safely, from 500MB/S to 2GB/s /// Geoffroy Couprie

Towards language support for distributed systems /// Heather Miller

Everything about distributed systems is terrible /// Hillel Wayne

Breaking changes /// James Coglan

Intertwingling the Tiddlywiki with Erlang /// Joe Armstrong and Jeremy Ruston

The life, times & thinking of Dr. Claude Shannon /// Jimmy Soni

Building a Blockchain in Erlang /// Ulf Wiger

Verifying a distributed system with combinatorial topology /// Veronica Lopez

Programmation en Logique /// Lars Hupel

PureScript spirographs /// Tom Harding

Infosec, AI and ethics – new models for a secure future /// Kate Carruthers

One log /// Arnaud Bailly and Yann Schwartz

Applying principles of chaos engineering to serverless /// Yan Cui

Life of a distributed graph database query /// Teon Banek

Abstract nonsense /// Ju Goncalves

Eta: The rise of pure FP on the JVM /// Jyothsna Patnam

Adding kind-polymorphism to the Scala programming language /// Miles Sabin

Co-operative robots sharing the load /// Natalia Chechina

Message passing for actors and humans with Raxx /// Peter Saxton

Property based tests for the masses /// Romeu Moura

Finite of sense and infinite of thought: a history of computation, logic and algebra /// Ron Pressler

Towards specifications of robustness - the things that programs do _not_ do /// Sophia Drossopoulou

THEMES

Concurrency, Multicore & Parallelism

Language

Distributed Systems

The History and the Philosophy of Computer Science

Infrastructure

Our speakers

Kathleen Fisher

Carl Hewitt

Federica Pelzel

Miles Sabin

Kate Carruthers

Don Syme

Frieder Nake

Natalia Chechina

Heather Miller

Garrett Smith

Sophia Drossopoulou

Maxim Fedorov

Ulf Wiger

Allison Randal

Jimmy Soni

Einar Høst

Ju Goncalves

Hillel Wayne

Joe Armstrong

Jeremy Ruston

Veronica Lopez

Peter Saxton

Dmitry Kandalov

Felix Lopez

Andrea Dobson

Edwin Brady

Carlos Baquero Moreno

Teon Banek

Romeu Moura

Daniil Fedotov

Tom Harding

Jyothsna Patnam