9:00am - Noon Silk

Introduction by the Committee

Welcome to Compose :: Melbourne!

9:30am - M.M.T Chakravarty

Keynote - Playing with Graphics and Animations in Haskell

Graphics and animations are not only fun, they are also an effective learning tool. For example, fractal tree structures nicely illustrate recursion, and animations are often more motivating and engaging than examples and exercises spewing out text. In this talk, I will demonstrate graphics and animations in Haskell playgrounds — aka the REPL on steroids. The immediate feedback of playgrounds facilitates an explorative style of programming that is especially attractive for graphics programming.

Graphics, animation, and games programming in Haskell faces a dilemma. We can either use existing frameworks with their highly imperative APIs or we waste a lot of energy trying to re-engineer those rather complex systems from scratch. Or, maybe, we can escape the dilemma. Instead of a Haskell program directly manipulating the mutable object-graph of existing frameworks, we provide an API for purely functional transformations of a Haskell data structure, together with an adaptation layer that transcribes those transformations into edits of the mutable object-graph. I will illustrate this approach by describing the architecture of a Haskell binding to the animation system of Apple’s SpriteKit framework.

About M.M.T Chakravarty

Manuel M T Chakravarty is an Associate Professor at the University of New South Wales. His core research interests are functional programming, novel compiler technology, and high-performance computing. He graduated from the University of Karlsruhe and received a doctoral degree from the Berlin Institute of Technology. His major contributions include work on Haskell’s foreign function interface, the C->Haskell binding generator, the theory and implementation of type families in the Glasgow Haskell Compiler, and the development of multiple systems for data parallel programming of multicore CPUs and GPUs, including Accelerate, Data Parallel Haskell, and Repa.

He is the principal author of the interactive development environment Haskell for Mac and he is excited by the opportunities presented by the Swift programming language. Most importantly, he believes in the fruitful combination of theory and practice.



10:30am - Sharon Holliday

Practical Programming in an Exception Free World

One of the first lessons we are taught in FP is that all functions should be “referentially transparent”. Amongst other implications, this means a function can’t throw an exception. Great in theory, but often, in the real world, we know we can get errors. A file read may fail, data may be missing from our repository, a network error may occur in a remote call, so how do we model this? For those of us that are writing robust, stable production code, surely this makes our life more difficult?

Based on our production Scala code, this talk takes an in depth, practical look beyond how we handle a single function that can return an error, to how we can compose these simple functions into larger functions and whole systems, while avoiding an explosion of complexity. On the way we will visit a number of generic functions available to us through monad and applicative types, and gain an understanding of the power and increased productivity these tools give us. The talk will be a category theory free zone, with examples using Scala and the scalaz library, aiming to show the value of monads in a practical scenario.

About Sharon Holliday

Sharon is a Lead Developer at REA Group where she is currently writing Scala for their production systems. After more than 10 years as a Java software engineer, she undertook brief forays into ruby and javascript, before discovering the joys of Scala and the elegance of FP.

11am - Paul Bone

Plasma Programming Language

Plasma is a very new, pure, strongly-typed programming language that strikes a compromise between imperative and declarative programming. We aim to create a language with the safety guarantees of a typed purely functional language, but that is easier to learn and use. Plasma will feature many conveniences found in both paradigms including: loops, arrays, first class functions and coroutines. Our second goal is to create a language and tools that makes parallel and concurrent programming easy and safe. Plasma will provide useful language features and many abstractions for concurrent and parallel programming.

About Paul Bone

Paul is a talented software engineer interested in declarative programming, programming language implementation, parallelism and concurrency. He completed his Ph.D. in 2013 on Automatic Parallelisation for Mercury, a pure logic / functional language. Paul wants to make declarative programming more accessible for beginners and more powerful for experienced developers, he hopes that Plasma can help to achieve this.

11:30am - Alistair Roche

Datomic in Production

We've been using Datomic in production for nine months now, and this talk is an experience report. Datomic is an immutable database with a logic-programming-based query language. Lots of Clojurists have played with it, but there aren't many in Australia who've dealt with it day-to-day serving real customers.

It's been interesting, and fun, but there have been headaches and pitfalls, and things I wish I'd done differently from the outset of the project.

Things I can cover:

  • How we combine it with DataScript in the browser to share transactional logic and validations
  • What deployment looks like
  • How we make use of its unusual time model to do things that would otherwise require denormalisation
  • Tradeoffs we made initially (and have discovered since) when comparing it to traditional relational DBs
  • How its declarative “pull syntax” makes it easy to hydrate React components
  • Mistakes we made with the DB schema, and how we fixed those (including data migrations)

Alistair has given talks before at MelbJS, MelbJVM, MFUG, clj-melb, Manilla JS and Decompress on a range of topics.

About Alistair Roche

Alistair Roche is cofounder of BookWell.com.au, a health and beauty bookings platform built entirely on Clojure, ClojureScript and Datomic. He spent three and a half years learning, talking about and proselytising the word of Rich Hickey before putting his money where his mouth is. In his darker moments he wishes he’d spent those three and a half years learning a language with a strong type system. He has a lot of dark moments these days.



1pm - Finlay Thompson

Using Cloud-Haskell to Build a Continuous-Integration Platform for Reproducible Research

Cloud Haskell is a collection of libraries that have brought Erlang style networking patterns to the Haskell language. The libraries bring together the best of Haskell’s strong typing, with an opinionated approach to building distributed applications. I will provide an experience report on how we have used Cloud Haskell, and Haskell in general, to build a continuous integration platform to support the rest of our data science work. The project has been successful in our organisation, and is starting to be used by other partner organisations. I believe that Haskell has helped development by making it easy to refactor, while also being extremely reliable in production. Cloud Haskell has allowed us to scale up to hundreds of compute nodes, and tens of thousands of computations in parallel, without changing any code.

Haskell is now an essential tool at Dragonfly Data Science. I will also discuss our experience with building up Haskell skills across our team, and across a range of projects.

Dragonfly is a data science team that combines research science and software development experience. We are committed to realising the benefits of using reproducible methods for all our work, for ourselves, our clients, and the general community.

About Finlay Thompson

Finlay has a background in mathematics and software engineering, and is technical lead at Dragonfly Data Science. He has been using Haskell for production systems for the last 5 years, but has tinkered with Haskell for longer than he cares to remember.

1:30pm - Lee Naish

Equational Reasoning and Intended Semantics in Functional Programming

A major advantage of functional programming languages is that they allow for analysis and transformation based on 'equational reasoning'; an idea that has deep roots in computing history. In his seminal Turing Award lecture from 1977, John Backus advocated the functional style over traditional 'von Neumann' languages, citing algebraic program manipulation as a major selling point. Similar ideas were further expanded in the Bird-Meertens formalism, fondly known as 'squiggol', yielding an elegant calculus for iterative program construction. The use of simple equational laws is very attractive, even if the presence of 'undefined' values sometimes violate such laws: Danielsson et al. have shown that, in a precise sense, equational reasoning is still justified. In their words, 'fast and loose reasoning is morally correct'.

There are, however, circumstances where programmer intent needs to be taken into account. Programmers routinely make tacit assumptions about what may or may not happen when a program runs, making liberal use of deliberate under-specification. For example, when coding a merge function we typically assume the arguments are sorted lists. The under-specification or "don't care" status of a computation is best seen as a dual to undefinedness. It can manifest itself during debugging, for example, when a programmer is required to judge the correctness of an expression that violates a precondition (such as merge applied to unsorted lists), and therefore has no particular intended meaning.

We argue that, in the context of a 'programmer-intended semantics' which is usually partial, certain kinds of reasoning with equality are inappropriate and that equality should instead be replaced by a partial ordering of values taking "don't care" into account. In our presentation we aim to explain what goes wrong with naive equational reasoning in the presence of under-specification, how it can be adapted to avoid these pitfalls, and the influence on how we think about our code and design programming environments, including tools for testing, debugging and verification.

This is with joint work with Harald Sondergaard and Bernard Pope.

About Lee Naish

Lee has spent much of his life as an academic at Melbourne University, pondering the following question: How can we clarify the relationships between what we want a computer to do (which is in our head), the programs we write (syntactic objects), and what they make a computer do (a sequence of execution states, hopefully ending up with what we wanted)? In late 2013 he quit paid work and was diagnosed with terminal prostate cancer but has continued with research, become a mamil and occasionally still climbs rocks.

2pm - Ben Hutchison

Getting Work Done with the Eff Monad in Scala

This talk introduces the Eff monad via Eff-cats Scala library, and gives a sense of how use it to solve practical programming problems.

The Eff-cats library is an implementation of the Freer monad concept in Scala, developed by Eric Torreborre. It is inspired by Oleg Kiselyov's Haskell paper 'Freer Monads, More Extensible Effects' . Like Monad Transformer stacks and the Free monad, it provides an organising principle for the construction of pure functional programs. It has a number of desirable qualities:

  • Purity: the construction of the program is decoupled from its interpretation
  • Type-safety: Effects such as error handling or asychronicity are visible in the type signatures
  • Flexible effect stacks: the final effect stack members can be varied without unduly affecting local code
  • Performance: scales gracefully, as the program is stored as a Vector of continuations
  • Flexible evaluation: effects interpretation can be reordered without rewriting the program

This talk focuses on what code written using the Eff monad looks and feels like. It covers several common Eff 'effects' including

  • Using Reader effects for dependency injection
  • Using Either effects for error handling
  • State effects for stateful computation

It will also demonstrate some challenges that arise when using Eff and how to tackle them:

  • Adding new effects to an existing program
  • Mixing Eff-based and non-Eff modules together

About Ben Hutchison

Ben Hutchison works as Lead Developer of the Consumer Data team at REA Group in Melbourne. He has coordinated the Melbourne Scala user group the past 7 years. Ben maintains and/or contributes to a number of open source Scala projects. His particular engineering interests include strong static typing, Scala in the browser client, applying functional programming & type-classes, and the redemption of relational databases.



3:00pm - George Wilson

The Extended Functor Family

Functors are ubiquitous in modern strongly-typed functional programming. Every Haskell beginner will come across them as one of the first typeclasses introduced. Stronger structures such as Applicative and Monad often steal the spotlight, but there are many structures related to the humble Functor that go unnoticed. The goal of this talk is to show off and give an intuition for some of these other structures: contravariant functors, bifunctors, and profunctors. With some of these making their way into Haskell’s standard library recently, now is a perfect time to be introduced to or brush up on these concepts. Code examples will use Haskell, but these techniques extend to any language with typeclasses or a similar mechanism, such as Scala’s implicits.

About George Wilson

George Wilson is an enthusiastic functional programmer from Brisbane. George engineers web services at Ephox by day, and waxes poetic about lenses and all things Haskell at Brisbane Functional Programming Group by night.

3:30pm - Kris Jenkins

Types All The Way Down

In web development, a great deal of effort is spent on consistency. The frontend, backend and database must all agree on a data-model, and if they don't, the system crashes spectacularly.

The default solutions are either to invest heavily in hand-written integration tests, or use JavaScript everywhere. Neither of these are ideal. However there is a compelling alternative - use the same types everywhere.

By reusing strong, static types across tiers, we can make guarantees about the consistency of the entire system, and dramatically lower the cost of change.

We present one approach that uses Haskell data types to drive a both a PostgreSQL database schema and a frontend system written in Elm. With one set of types to rule them all, whole system consistency is automatic and reliable, and the cost of changing types - and hence evolving the whole system's data model - is dramatically reduced.

About Kris Jenkins

Kris Jenkins is a successful startup cofounder, turned freelance functional programmer, and open-source enthusiast. He mostly works building user interfaces in ClojureScript & Elm, improving the world one project at a time.



4:15pm - Brian McKenna

Productionisation of Functional Optics

Manipulating immutable data structures can involve laborious pattern-matching and copying. Functional optics such as isos, lenses, prisms, traversals and folds help us compose data manipulations. Manipulations can include getting, setting or modifying.

This presentation will show examples of optics used in production business applications. It will start with PureScript's 'pure profunctor lenses' library, then move on to examples in the Haskell, Scala and Java optics libraries, acknowledging the increasing compromises of each.

About Brian McKenna

Brian uses and teaches functional programming with Scala, Haskell, PureScript and Java for Atlassian. Functional optics are the most useful thing he has invested time in learning over the past few years.

4:45pm - Sean Seefried

The Joy of Refactoring with Strong, Static Types

Fans of strongly statically typed languages will tout the benefits of their type system such as: mistakes are detected earlier, types serve as a form of machine-checked documentation, increased run-time efficiency, and so on. But a point that is sometimes missed is that types make refactoring your code much easier. This is important since maintaining a program is a huge part of its life cycle!

In this talk I will refactor two small programs live. One will be written in Haskell, which has a strong static type system, and the other in Ruby, which has a dynamic type system and somewhat 'loose'. The programs will be written to be as close in functionality and structure as possible. I will then propose a change to the API of the programs for which a refactor will be required. I will then demonstrate the markedly different experience that a somewhat error prone developer will have when refactoring the two programs.

About Sean Seefried

Sean has been interested in functional programming since 2001. He is attracted to both their elegance and safety and believes that they are helping push forward the frontier of programming.

5:15pm - Magdalena Cassel & Aaron Edwards

Functional Eyes: Applying Functional Principles in Other Paradigms

In consulting, freelancing, or even in-house work, we may not always be able to choose the language we work in. Magdalena and Aaron both spent a year working in Clojure before moving on to other projects in a variety of Object-Oriented languages. By applying the principles of functional programming in these other contexts, we were able to write cleaner, more efficient, more testable code. We will discuss the ways in which our experience in FP has informed our design choices in other paradigms.

About Magdalena Cassel & Aaron Edwards

Magdalena's favorite part of being a consultant is learning a totally new stack for each project. She enjoys cross-pollinating patterns and practices across different languages and paradigms.

Aaron has been a consultant for about 3 years for ThoughtWorks. He enjoys learning the languages used at new clients and drawing on this knowledge to help create elegant solutions to problems.

5:45pm - Lyndon Maydwell

Closing Comment


Walk Out