Skip to the content.

Welcome/Summary

I’m a developer based in Sydney Australia. My strongest languages are Haskell, C#, C++, Scala and Rust. I also have experience using Java, Python, Perl and Groovy. In my previous role at the University of Wollongong I also did a lot of work using SQL and PL/SQL on Oracle databases, and some system administration on Sun Solaris systems.

If you think I’d be valuable to your organisation feel free to send me an email at clintonmead@gmail.com or drop me a message on LinkedIn.

Click here to save this page as PDF.

Employment history:

Accenture (April 2022 - ongoing)

Scala/Javascript developer (July 2021 - March 2022)

Sole developer and adminstrator of ThinkCaddie. Scala backend with Javascript frontend, served by AWS EC2 instances and a AWS RDS Postgres database. The Javascript frontend is based on React+Redux, and the Scala backend is using the Play Framework, with a functional programming style used throughout both the backend and frontend. As sole developer and adminstrator I worked throughout the entire stack, and also did the devops work and deployments. I also developed a NixOS based virtual machine configuration designed to get new developers up and running with all build dependencies and editer plugins within minutes.

C# developer - yReceipts/eyos (Feburary 2018 - June 2021)

C# and .NET developer. Particular focus on interfacing with Windows printing and UI development. Large part of my role was developing a generic rules based model for matching products purchased at checkout against a large number of “promotions”, that would trigger on based on a rule and provide some sort of discount or free product to the user. I designed this rule engine in a way that allowed for rules to be nested within rules yet these rules could be resolved in real-time, and promotions even alerted mid-transaction. A significant part of my role here also was to bring functional programming practices where appropriate to a more imperative/object-orientated codebase.

Haskell Programmer - University of New South Wales (April 2017 to September 2017)

Limited term contract funded by a research grant. Work primarily consisted of redeveloping the lexer, parser and type checker for the compiler for the language MCK.

Staffer - Senator Leyonhjelm (Feburary 2016 - December 2016)

Tasks included creating, analysing and adjusting social media advertising campaigns, development on websites using PHP and Wordpress, and analysis of electoral results data.

Application Support - University of Wollongong (2006 - 2015)

Application support and integration development primarily for Blackboard but also Equella. Role included application support, focused on maintaining and enhancing the performance of a clustered system serving 1000+ simutaneous users, both of the front-end, and the back-end and Oracle database. Also work involved maintaining and extending integrations between university systems, which were written mostly in Perl with some shell scripting. Also implemented single-signon protocols between off the shelf products and PL/SQL inhouse products, and developed custom Oracle database hosted hierachical staff permissioning models for the University content management system Equella. I also worked on various data processing tasks for the school of psychology, primarily in C++.

Other skills

Linux

I have ran Linux in some form at home for most of this century, firstly with Red Hat Linux and then moving on to Debian (Potato) in 2000. I have started to experiment with configuring NixOS virtual machines. So I am comfortable with the linux command line and have a reasonable idea of how to administer Linux systems, at least at the home system level.

Marrying Functional and Object Orientated Programming

I have a lot of experience with both functional and object-orientated programming. Most of my functional programming experience is unpaid and most of my object-orientated experience has been professional, but I have also done open source work in both fields also. In particular, I have an interest in how compilers work in both areas, so have somewhat of an understanding of the mechanics of say, a virtual-call vs a typeclass dictionary. Object-orientated and functional programming can be powerful when used together, as their strengths can used for different problems, but they can clash, so through my experience I’ve learnt how to meld whilst minimising friction.

Education:

Bachelor of Mathematics/Bachelor of Computer Science - University of Wollongong (2003 - 2006). A copy of my academic transcript is here.

Github projects:

Below is a non-complete list of my github projects. They are written in both Haskell, Rust and C#.

Haskell:

Fast-mult

Fast-mult is an integer type that intelligently delays multiplications in such a way that multiplications are only performed with similar sized operands, greatly improving the performance of repeated muliplications which produce large integers. Hence it can improve the performance of existing numeric algorithms without changing the algorithms themselves. More details are in fast-mults hackage documentation.

Disjoint-set-stateful

Disjoint-set-stateful is a Haskell implementation of a disjoint-set data structure in the ST monad. It uses mutable unboxed arrays internally so should be quite fast.

Freelude

Freelude is intended to work as a replacement Prelude, generalising concepts such as categories, functors, and even applicatives and monads, so they can be applied to more datatypes, such as sets and unboxed vectors. An overview of Freelude can be found in the main page of it’s hackage documentation. This was presented at the October 2017 FP-Syd meetup.

Indextype

Indextype is a package of a number of type families that can be used to not only select elements from tuples, functions and constructors, but also form constraints such as “this type is a pair”. Freelude uses this package directly. More information on Indextype is best found on it’s hackage page.

Polydata

Polydata allows one to encapulate polymorphic data in a way that it can be passed into functions in a generic way that perserves it polymorphism. More details can be found in the hackage documentation for polydata-core. Polydata also depends on Indextype.

Typed-streams

Typed-streams is an attempt to get C-like performance out of Haskell code which uses higher level concepts like folds, maps, and list like appends. By being more explicit about the way “lists” or “streams” are constructed than the usual list constructor, we can sometimes help GHC compile to C like loops. The typed-streams hackage documentation gives an example of code which using lists runs quite slowly but using typed-streams allows for C-like performance.

Static-closure

Static-closure is an implementation of applicative style serialisable data and arbitary functions, made possible with the StaticPointers extension to GHC. Whilst Distributed-closure is a similar module, Static-closure is more flexible, has less unsafe typecasts in it’s implementation, and includes a Template Haskell approach to deriving instances which eliminates significant boilerplate.

Generic-enum

Generic-enum is a backwards compatable replacement of the standard Haskell Enum class which allows one to directly produce non-list data structures from functions such as enumFrom. This can be useful when one wants to use the standard enum function to generically produce infinite structures, which could loop forever if an intermediate list is created.

Map-classes

Map-classes provides typeclasses for a variety of colletion types, so one can write generic algorithms which work on many implementations of collections without changing code.

Stack-lib

Stack-lib is a wrapper around stack, designed to allow it to be easy to use stack as a library. The longer term goal of this to develop an extension to stack (which I am currently naming “heap”) which allows, for example, building against multiple LTS releases with one command. Also “heap” should be able to create new projects and do much of the tasks which are currently done manually, including creating and adding initial files to a git repository, connecting that repository to github, and adding continuous integration configurations against for example, Travis GI. Finally, releases should be a one command process, with the commit tested against CI, and if successful, uploaded to Hackage and tagged in git, the version number bumped, with the cabal file pointing to the newly tagged release.

Atomic-File-Ops

Atomic-File-Ops has some utility functions for atomically modifying files, such that readers only ever see the before written or after written state, not an intermediate state, as long as they do all their reads from one file handle.

Rust:

Haskell Bits

An ongoing port of Haskell concepts into Rust, including the Functor/Applicative/Monad hierarchy. I did a presentation on this at June 2019 Rust-Syd, but have developed this significantly since then.

C#:

Typeclasses in C#

A proof of concept for a Functor/Applicative/Monad hierarchy in C#, presented at November 2018 FP-Syd.

Battletech Mods

A variety of mods for the game Battletech, using Harmony to patch CLR methods at runtime and reflection to change ingame private data.

Contributions to other projects:

Rank-2-classes

I’ve made a number of contributions to the rank2classes package, which can be seen in my repository fork of grampa. These generally involve defining functors and applicatives over rank-2 types.