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 Brisbane

Argonaut: Purely-Functional JSON in Scala


Argonaut is a purely-functional library for dealing with JSON in Scala. Argonaut utilises advanced functional programming techniques that emphasise correctness and performance without sacrificing convenience. Argonaut provides zippers and lenses for efficient navigation and modification of immutable data structures; type-class based codecs for robust, composable mappings between Scala data structures and JSON; and data-types for accurately capturing the essence of JSON and the errors that can occur.

In this talk we will take a look at general principles for designing robust, purely functional libraries in Scala. We will then be taking a deeper technical dive into the specifics of Argonaut, examining the abstractions it uses, the specifics of how they are applied and why these techniques are invaluable to quality code.

Patterns in Types: A Look at Reader, Writer and State in Scala


Developers are often very good at spotting repetition in their programs at the value level, but for some reason struggle, or are reluctant to apply that same careful analysis at the type level. This talk aims to build up an intuition for spotting when you can factor your types, examining what this gains you and looking at the practicalities for doing so in Scala. For appropriate buzz-word compliance during this talk you will see Scalaz, Monads, Monad transformers, data types and type classes.

Zippers, Comonads and Data Structures in Scala


The term zipper is a colloquial used to describe n-hole (most often, 1-hole) contexts. That is, a data structure that has a hole or pointer focused on a specific element with the ability to efficiently traverse to its neighbouring elements, providing an elegant solution for the need to efficiently traverse and modify immutable data structures. Comonads, the categorical dual of Monads, provide an abstraction for dealing with types that allow extraction. That is, the ability to take a value out of a context; for example, the fact that it is a total operation to extract the head of a non-empty list.

In this talk, we will dive into the implementation of purely-functional data structures in Scala. Exploring zippers, Comonads, and their relationship.

Haskell in Production: 12 Months Building ApiEngine


Web development in Haskell is efficient, contorting, rewarding, frustrating and elegant all at the same time. 12 Months building production quality Haskell has taught many lessons, and in this talk we will discuss the amazing, with the downright painful, and hope to provide a glimpse at what it is like building real software in a purely functional world.

We will look at the Haskell eco-system and tools; Yesod and the other technologies used to build ApiEngine; as well as the social side of Haskell development by looking at what it takes to spin up new developers.

Patterns in Types: A Look at Reader, Writer and State in Scala


Building on the concepts introduced in the ””Patterns in Types”” talk, this Jam will step through a series of challenges where we will build our own Reader, Writer, State transformer stack. The exercises will help train your intuition for spotting patterns, and implementing data-types to capture those patterns. By the end of the Jam you will be able to build your own monadic types and transformers with confidence. To get things started, you will need access to a laptop with a JVM installed, and a clone of the base repository from:

To take part in this Jam a solid understanding of Scala syntax is desirable.

Zippers, Comonads and Data Structures in Scala


Whilst conceptually straight forward, implementing and utilising zippers and comonads can be challenging.

In this workshop we will take a deeper dive into the content presented during the correspondingly titled talk. The workshop will step through implementing specific cases of zippers in Scala, as well as investigating general techniques for deriving zippers.

For those who want to follow along, come armed with a laptop including a JVM and a clone of the repository from: