Day One - Speakers and Presentations

A crucible allows base metals to be mixed together at high temperatures to form alloys. Medieval alchemists used crucibles to mix an astonishing variety of substances together in the search for new materials. While Alchemy is often derided for its informal approach, early Alchemists paved the wave for modern chemistry, and included Newton and Boyle among their number.

Just as the crucible encouraged an experimental and experiential approach to understanding the world, so too the computer can provide a computational crucible. Code can be mixed and brought to great temperature in the search for greater understanding and new discovery.

Using his own Extempore programming language Andrew will provide a 'live' introduction to sound synthesis, building up the core components of a real-time digital synthesizer on-the-fly 'in the computational crucible'.

When learning a new programming language there is almost always a leap from learning to applying your knowledge. This leap can be quite large when learning Haskell for a number of reasons. One reason is the dramatic difference between Haskell's style of programming compared to more common imperative languages that many learners are more familiar with. As a consequence, a difficulty for those new to Haskell is identifying when and how to apply the concepts they've learned when writing an application. Another is navigating the Haskell ecosystem; including finding packages and understanding how they work. Finally, some newcomers may delay writing their first application, believing they need to be comfortable with more advanced concepts before they can successfully write useful software. This is not the case. While these abstractions are useful, many of Haskell's benefits can be enjoyed while sticking to its more basic abstractions.

By referring to a simple example application, we'll demonstrate how and when to apply some core techniques and abstractions, and alleviate the burden of starting an app from scratch. We'll cover a number of data types, type classes, and techniques, including:

• Effectively using algebraic data types to more precisely model the problem
• Using applicative parsers to read configuration from the command line or files
• Using the Monoid type class to merge layers of configuration. e.g. user values merged with defaults
• Using Maybe in place of null or exceptions to handle missing/optional data
• Using Either in place of exceptions or return codes to handle failures
• Using the Monad type class to sequence computations in a particular context, such as IO

If you've ever been intimidated by the thought of starting a project in Haskell, then this talk will give you a solid place to start. Along the way we'll see that, not only is Haskell a general purpose language that can be used to write everyday applications, but that it brings with it a range of benefits.

Functional programming techniques have been making appearances in JavaScript for some time now. However, functional programming in JavaScript has some disadvantages: JavaScript is verbose, untyped, and lacks powerful forms of abstraction. Unrestricted JavaScript code also makes equational reasoning very difficult. A functional JavaScript programmer must stay sharp at all times to create pure functions that avoid side effects. However, this puts too much cognitive load on the programmer.

PureScript, on the other hand, is a Haskell-inspired statically typed language which aims to address these issues. It features lightweight syntax, which allows developers to write very expressive code which is still clear and readable. It uses a rich type system to support powerful abstractions. It also generates fast, understandable JavaScript code, which is important when interoperating with other JavaScript libraries. PureScript strikes a very practical balance between the theoretical power of purely functional programming and the fast-and-loose programming style of JavaScript.

The idea behind this talk is to encourage developers to build real-world applications using PureScript. I hope to take you through a journey of applying functional patterns to everyday problems so that you can appreciate the simplicity and ideas behind these patterns:

• Algebraic data types and pattern matching
• Row polymorphism and extensible records
• Higher kinded types
• Type classes with functional dependencies
• Higher-rank polymorphism

Since their inception in Haskell, type classes have become a popular feature of modern functional programming. Indeed, key topics in FP often take the form of type classes, such as Monoid and Functor. Many languages developed since Haskell have included type classes in their design, such as Idris and Purescript; or offered facilities capable of simulating type classes, such as Scala's implicits or OCaml's modules.

In this talk we go beyond the basics with type classes. First we'll differentiate between parametric and ad hoc polymorphism, and we'll see why type classes are a compelling solution to the latter. By comparing them to other solutions - Java interfaces and Scala implicits - we'll see the advantages of type classes. In particular, we will focus on why type classes are principled. This section will include examples in Java, Scala, and Haskell.

In order to be principled, there are conditions on the creation of instances: there can be a maximum of one instance for a given type for a given type class, and it must be in one of two allowed places. We will justify this rigidity by discussing instance coherence and its benefits, with examples of incoherence silently causing bugs. We will learn what orphan instances are and why they can be problematic for coherence.

Finally, practical guidelines will be given for programmers aiming to simulate type classes in other languages, as is popular in the Scala community. These guidelines, when followed with discipline, will allow one to recover many of the benefits of type classes. Examples in this section will be in Scala.

Goal

Attendees will leave knowing the difference between parametric and ad hoc polymorphism, and they will understand why type classes are a principled approach to the latter. Attendees wishing to simulate type classes in a capable language, such as Scala, will leave the talk with practical guidelines helping them to do so.

Recently there have been great advances in the field of biology arising from rapid technological progress, notably in certain areas such as genomics. These technologies have drastically increased the use of computing as part of data processing and analysis. It is now common to use many hours of compute to process biological data in what is known as a *bioinformatics pipeline*.

These bioinformatics pipelines are typically composed of numerous programs and stages coupled together loosely using intermediate files. These pipelines tend to be quite complex and require substantial computational time, hence a good pipeline must be able to manage intermediate files, guarantee rentrability — the ability to re-enter and continue a partially run pipeline — and also provide clear syntax to easily describe and understand pipelines.

This is a problem that resembles the problem of building software artefacts that is common in computer science. Some notable tools are the ubiquitous tool *make*, and more recently *Shake*, a robust build tool implemented as an embedded domain specific language (EDSL) in Haskell. However, bioinformatic pipelines have some unique properties that do not fit well into current build tools...

In this talk & demo, we have a look at some of the low-hanging problems in general aviation and how functional programming can be applied to provide significant improvements in efficiency and air safety. The current solutions to problems such as navigation, traffic/terrain collision avoidance and weight/balance calculations will be demonstrated to the audience, mostly for amusement. More seriously, we will have a look at the legacy that has led to the way things are, and how to improve by applying our programming skills.

We will look at:

• How aviation safety is regulated.
• How aeronautical services are provided to flight operators.
• How aeronautical navigation is conducted and regulated.
• How the weight and balance for a flight is conducted.
• The methods by which aircraft and ground coordinate between each other.

We will see:

• Some real (and basic) data management problems in aviation, that very obviously threaten safety, then solve them, using programming.
• We will see a live demonstration of aeronautical navigation methods, investigate incident reports where lives were lost as a result, and consider how our programming skills can yield improvements, possibly even save lives.
• We will conduct a real weight&balance calculation for a flight, then once hilarity inevitably ensues, we will look at the problems that arise by this method, then solve them using data structures and functional programming. Some of these practical problems are obvious, even to a non-aviator, and the predictable incident reports are the end result.
• Finally, we will have a look at a live demonstration of a software defined radio (SDR), receiving ADS-B transmissions from aircraft (live), an AHRS implementation and GNSS receiver using off-the-shelf, low-cost parts. We will look at why these instruments are helpful to aircraft pilots and interact with that device using the Haskell programming language.

The history of live coding environments isn't new, still most of the current tools we use are static in nature and require long cycles of build/compilation/restart both in development and production, the REPL is one of the most productive environments to get instant feedback and have become the standard for contemporary functional languages.

In this talk we will go through Re-ops, a Clojure based live environment that aims to speed up remote server management, from ad hoc remote operations to metrics collection/reporting up to managing clusters of virtual machines.

Current configuration management tools (Puppet/Chef/Ansible) are custom environments running on top of Ruby/Python that don't interact (for the most part) with the hosting platform, Re-ops on the other hand is native Clojure and can use any library and language facility.

Using function composition, protocols and data structures with a dash of macros we create our own core abstractions, matching the lisp philosophy of extending the language to match our needs while keeping it simple to extend and use.

Re-ops is composed from a number of components:

• Re-core: VM management and tracking (AWS, Digital Ocean, KVM), using async job execution.
• Re-mote, remote operations on systems using SSH and ZeroMQ including data collection, aggregation, dashboarding and scheduling.
• Re-gent, remote agent that uses ZeroMQ and connects back to Re-mote, used for high throughput low latency operations (an alternative to SSH).
• Each can be used separately or combined.

In summary Re-ops offers an alternative for creating infrastructure as code, one in which we can react quickly to a fast changing environment.

Goals:

• To expose listeners to a different way of thinking with regards to operations (Devops).
• To showcase how to design a system that works well as a live environment both in Clojure (the reload workflow) and the general case.
• Explore protocols, functional composition and pipelines as a base for rapidly changing system.
• How to design the system for explorability
• Cover some interesting libraries used within Re-ops
• Compare Puppet/Chef and show how using Clojure really simplify some problems.

This talk is a general introduction to ReasonML and ReasonReact. Created by Facebook, ReasonML is a syntax layer and toolchain for OCaml and yet another compile-to-JavaScript, typed language. ReasonReact marries ReasonML's type-safety with the React component model while leveraging the existing ecosystem for developers seeking a better working experience across both web and native apps.

Since its release in March 2017, the ReasonReact syntax has moved quickly. In this brief overview, attendees should gain an understanding of the the language's evolution, the ethos surrounding it and how it might shape development in the future.

This talk introduces Reactive Streams, specifically the Monix implementation and how at REA Group we have used it to solve real problems.

At REA we have many 'feeders' which extract from one data source, perform some processing and transformations before loading into a target system.

Historically these feeders have been built using Java / Scala concurrency primitives (e.g. Future / ExecutionContext). The typical feeder has a very sequential execution model like:

1. Read a batch in parallel from the source system. The reading is done in as a parallel batch because the source system may be slow, e.g. an S3 bucket).
2. Transform the batch
3. Write the batch in parallel to the target system

The very sequential nature means the feeds are not as performant as they could be. The source and target systems were never accessed in parallel. Writing to the target required waiting for the source to read another batch. And the feeder would not read another batch from the source until the target completed.

Also being based on lower level concurrency primitives, the data pipeline is not as easy to visualise from reading the codebase.

Reactive streams allow us to model asynchronous processing pipelines as a data type which can then be executed. The APIs are declarative, as opposed to the legacy solution working with Scala Future and ExecutionContext which resulted in immediate evaluation.

The talk will cover:

• Background into our feeders and legacy implementation
• How the latency involved in that implementation cumulates to affect performance
• Intro to the Monix reactive streams implementation covering the key APIs that we have used
• Demonstrating how the APIs are just data types and that nothing is executed until the observable is consumed and run.
• Code examples for a basic feeder structure
• How the end solution is more performant, but more importantly that the code is more expressive and easy to reason about.

Attendees should leave with a basic understanding of Reactive Streams, and specifically how to get started with the Monix implementation of reactive streams. I'll share a working basic project (not REA production code) which provides a basic 'feeder' structure for attendees to reference and extend upon if they wish.

With its advanced type system, the purely functional language Haskell is extremely well-suited for developing applications based on embedded domain specific languages (EDSL) for domains where the quality of software is critical to success (e.g., the financial sector). To the compiler an EDSL is no different from any other library written in Haskell; to the user of the EDSL, it is a library that allows her to express her solution to a problem in her domain in a syntax (fluency) reminiscent of that of the domain. But one problem continues to plague the end users of EDSLs: whenever a type error occurs, the encoding of the domain inside the host language Haskell leaks out in those error message. And this encoding is exactly what the EDSL developers were trying to hide! In this talk we demonstrate how type error diagnosis can be made domain-specific by type level programming. We have implemented this in the Glasgow Haskell Compiler, the industrial-strength compiler for Haskell. With relatively small modifications to the compiler, we can show huge gains in terms of domain-aware type error messages, and suggestions on how to fix a given type error. Our solution has more advantages: existing EDSLs can be easily wrapped with specialized error diagnosis, the wrapping is invisible to the end user, and the soundness of the type system is guaranteed by the compiler. The abstractions provided by type-level programming allow us to describe and reuse common patterns in type error diagnosis, lowering the entry barrier for DSL authors.

The talk will consist of an explanation and demonstration of what our technology, as implemented in our branch of GHC, allows EDSL developers to do.

Deep learning and deep neural networks are currently fields of great interest and excitement, due to their impressive results in supervised and unsupervised machine learning tasks across a broad range of fields including computer vision, speech recognition, and games such as Go.

In this talk, I'll talk about my recent explorations in using type level and purely functional programming techniques applied to deep learning and neural networks. We'll run over deep neural networks theory, their common architectures, and their various use cases to obtain an appreciation for the depth of the field. I'll then show how the use of modern Haskell programming allows for these networks to be expressed at the type level, providing not only extreme concision, but also compile time safety, functional reasoning and composition, as well as pretty good runtime performance with a high degree of confidence in their correctness.