-->


Day One - Speakers and Presentations


🔵  Little assumed knowledge
🔵🔵  Moderate assumed knowledge
🔵🔵🔵  Significant assumed knowledge

8:30am
Registration
9:00am Lyndon Maydwell Introduction by the Committee
9:30am Andrew Sorensen Keynote - Sound Synthesis in the Computational Crucible 🔵
10:15am
Break
10:30 Andrew McCluskey Your first Haskell app 🔵
11am Rahul Trikha From JavaScript to PureScript 🔵
11:30am George Wilson Type Class: The Ultimate Ad Hoc 🔵
12pm
Lunch
1pm Justin Bedő BioShake: a Haskell EDSL for bioinformatics pipelines 🔵 🔵
1:30pm Tony Morris FP in Aviation 🔵 🔵
2pm Ronen Narkis Re-ops, a Functional Live-Infrastructure as Code 🔵 🔵
2:30pm
Break
3pm Luke Stephenson Reactive Streams for REA feeders 🔵 🔵
3:30pm Huw Campbell Grenade - Dependently Typed Neural Networks in Haskell 🔵 🔵 🔵
4pm
Break
4:15pm Jurriaan Hage Domain-Specific Type Error Diagnosis in GHC 🔵 🔵 🔵
4:45pm TBA TBA
5:15pm TBA TBA
5:45pm Closing comment

8:30am

Registration

9:00am - Lyndon Maydwell

Introduction by the Committee

Welcome to Compose :: Melbourne!

9:30am - Andrew Sorensen

Keynote - Sound Synthesis in the Computational Crucible

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'.

About Andrew Sorensen

Andrew Sorensen is an artist, a programmer, and a computer scientist. His interests are diverse, but unify under a common theme - the programming language as an interface for real-time dialogue between human, machine, and environment. In exploring these ideas Andrew is as likely to be found hacking code in nightclubs as steering scientific codes on distributed high performance computing clusters. Andrew is well known for creating the programming languages that he uses in live performance to generate audiovisual theatre. He is the author of the Extempore programming language - a systems programming language designed for high-performance 'live' programming.

10:15am

Break

10:30 - Andrew McCluskey

Your first Haskell app

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.

About Andrew McCluskey

Andrew is a functional programming engineer at Data61. Earlier in his career he worked across a range of domains using conventional imperative programming languages, growing more and more frustrated with the difficulties of reasoning in a stateful and often untyped world. After hearing the claims that functional programming offered solutions to these problems, he embarked on learning Clojure - having fond memories of his first year programming course in Scheme. Convinced that FP was a good choice, but being burned by a lack of types, Andrew then switched his focus to Haskell and hasn't looked back since.

11am - Rahul Trikha

From JavaScript to PureScript

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

About Rahul Trikha

Rahul works as a Technical Lead at REA Group building micro services to power their backend systems. He uses Ruby by day and Haskell/PureScript by night. He enjoys learning more about functional patterns and becoming a better dev through applying them in his everyday code.

11:30am - George Wilson

Type Class: The Ultimate Ad Hoc

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.

About George Wilson

George Wilson is an enthusiastic functional programmer at the Queensland Functional Programming Lab, under Data61/CSIRO, located in Brisbane, Australia.

George co-organises the Brisbane Functional Programming Group and enjoys teaching and learning functional programming and related areas of mathematics.

12pm

Lunch

1pm - Justin Bedő

BioShake: a Haskell EDSL for bioinformatics pipelines

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...

About Justin Bedő

Dr Justin Bedő is a researcher at the Walter and Eliza Hall institute. His interests span machine learning, bioinformatics, privacy, and computer science. Justin has researched at several labs and companies: NICTA, IBISC (le laboratoire Informatique, Biologie Intégrative et Systèmes Complexes), and IBM Research Australia.

1:30pm - Tony Morris

FP in Aviation

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.

About Tony Morris

Tony Morris is a software engineer for the Queensland Functional Programming Lab, under Data61/CSIRO, located in Brisbane, Australia. Tony has been deploying functional programming solutions for over 10 years, using the Haskell and Scala programming languages primarily. Tony teaches functional programming at the tertiary level and for professional programmers with a view toward producing a viable commercial result.

Tony takes a fastidious, principled approach to functional programming both when deployed in practice and when in a learning environment to ensure maximum yield from the effort. Tony believes that exploring principles and the following consequences provides a rewarding experience for all involved.

2pm - Ronen Narkis

Re-ops, a Functional Live-Infrastructure as Code

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.

About Ronen Narkis

Ronen Narkis has been a pro coder for more than 12 years across a variety of projects ranging from Devops to Bigdata, using Clojure since 2008 to solve real world problems.

He enjoys expanding his knowledge about security, operating systems, programming languages and any other cool tech he can lay his hands on.

2:30pm

Break

3pm - Luke Stephenson

Reactive Streams for REA feeders

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

And repeat the above until all data is processed.

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.

About Luke Stephenson

Luke Stephenson works as a Lead Developer at REA Group building Scala services to power the consumer facing website. After many years as a Java developer, Luke has enjoyed the transition to Scala and becoming a better dev through many FP learnings.

3:30pm - Huw Campbell

Grenade - Dependently Typed Neural Networks in Haskell

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.

About Huw Campbell

Huw Campbell is a physicist, data scientist, and functional programmer, currently working at Ambiata in Sydney. Coming from an academic background with a PhD in experimental physics, Huw started working as an applied researcher in machine learning in 2014. With Ambiata's broad Haskell experience and mentorship, and a strong interest in functional programming and type systems, Huw decided to apply these principles to machine learning - bringing together these diverse fields.

4pm

Break

4:15pm - Jurriaan Hage

Domain-Specific Type Error Diagnosis in GHC

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.

About Jurriaan Hage

Jurriaan Hage is assistant professor at Utrecht University. His work in programming technology is largely focused on two aspects: the optimisation of functional languages by means of type and effect systems, and type error diagnosis for strongly typed functional languages. He is currently the lead maintainer of the Helium compiler for learning Haskell. You can also talk to him about soft typing dynamic languages, program plagiarism detection and switching classes.

4:45pm - TBA

TBA

5:15pm - TBA

TBA

5:45pm -

Closing comment