Mark Hibberd


Chief Technical Architect at Ambiata

Mark Hibberd spends his time working on large-scale data and machine learning problems for Ambiata. Mark takes software development seriously. Valuing correctness and reliability, he is constantly looking to learn tools and techniques to support these goals.

This approach has led to a history of building teams that utilise purely-functional programming techniques to help deliver robust products.


YOW! Lambda Jam 2013 – Greg Davis & Mark Hibberd – Haskell in Production

YOW! Lambda Jam 2013 – Mark Hibberd & Tony Morris – Zippers, Comonads & Data Structures in Scala

YOW! Lambda Jam 2013 – Mark Hibberd – Patterns in Types: A Look at Reader, Writer & State in Scala

YOW! Lambda Jam 2013 – Mark Hibberd / Tony Morris – Argonaut – Purely-Functional JSON in Scala

YOW! Lambda Jam 2014 Brisbane

Tic-Tac-Type: Dependent Types with Idris


Functional programming provides a fundamental basis for reasoning about our programs and building out principled abstractions. However, it is not enough on its own and we also rely on other programming tools to aid in constructing programs correctly and efficiently. An advanced example of such a tool is dependent types; that is, types that depend on values. Dependent types can be used to provide strong guarantees about a program’s behaviour that are difficult or impossible to express with traditional type-systems.

Dependent types are gaining traction in mainstream FP languages such as Haskell (via language extensions) and Scala (via path-dependent sub-typing), but disappointingly, they are still less accessible to everyday programming than they can and should be. To help address this problem, Idris is a new programming language built from the ground up with the explicit goal of having better support for dependent types (as well as a number of other useful tools such as totality checking and tactic based theorem proving).

This talk will step through an end-to-end example in Idris, from fundamentals like building type-safe APIs, and performing IO through to building user interfaces. By the end of the talk we will have identified the strengths of this programming model, the practicalities of using them in Idris (in contrast to Scala and Haskell) and produced a battle-hardened, multi-player, tic-tac-toe game ready for production.

The Art of Incremental Stream Processing


Purely functional, elegant, correct, incremental and composable stream processing that is CPU and memory efficient. This is our (worthy) goal, but where do we start?

This problem space is being extensively explored across a variety of languages and libraries, each with subtly different trade-offs and not-so subtly different APIs and terminology. However, these libraries share common goals, and most share common ancestry from Oleg Kiselyov’s original Iteratee work or its Free Monad based derivatives.

This talk aims to build up an intuition for stream processing in general by first building up the core concepts and language of stream processing, and then grounding those by carefully examining the trade-offs and internals of several productionised implementations. Of particular interest are the pipes and conduits libraries from the Haskell community, and scalaz-stream from the Scala community.

The Art of Incremental Stream Processing


Building on the concepts presented in “The Art of Incremental Stream Processing”, this workshop will step through a series of challenges to build our own set of “pipe-able” unix-like tools as stream processors.

These tools, including: cat, head, tail, grep, nl, cksum, tee and xargs; provide an excellent proving ground for stream processing libraries, and will reinforce understand of the underlying concepts.

Attendees will be provided with a template containing skeleton code with a choice of one of four starting points for the challenges:

  1. pipes
  2. conduit
  3. scalaz-stream
  4. free-form, just follow the specification with what ever technology you want

Along with the skeleton, there will be a series of test cases for each tool that can be used to validate the code, specifically including edge cases for lazy evaluation & early termination.

To get things started, you will need access to a laptop, appropriate development tools for you chosen approach, and a clone of the base repository from:

Language / library specific instructions are available in the repository.

Introduction to Functional Programming


This workshop is targeted toward the conscientious programmer who is looking for a start to the journey of functional programming (FP). Attendees should expect to spend our time together under an intense investigation of the fundamental concepts to the FP thesis.

Central to our goal is to develop the tools and skills to continue exploring the subject independently and with peer support in the future. We will also be overcoming some of the common nomenclature that is often used in this subject, so that attendees are not presented with barriers in their own future investigations.

The goal of this workshop is not specific to any programming language, however, the Haskell programming language will be (proximately) used to achieve our goal.


This workshop will be carefully designed to utilise our short time together to ensure an optimum outcome. Therefore, we request some preparation beforehand.

Please bring a suitable development machine with GHC version 7.6 (or higher) installed. The details of the installation are specific to your host operating system, however, important information can be found at

If there are any troubles achieving this pre-requisite, please email me and I will help you out.