My skills

These are skills that I am confident in using professionally. This includes both theory, as well as practical skills and tools.

3D design

• FreeCAD
• Blender
• Design optimization for FDM, SLA and laser cutting

Computer science

• Algorithms and data structures
• Automata theory
• Compiler design and construction
• Type systems

Data processing and management

• Unix command-line data processing tools
• SQLite
• PostgreSQL
• PostGIS

Programming

• C
• Asm
• Haskell
• HTML
• Julia
• Parallel programming
• Performance engineering, especially of array computations
• SIMD and SWAR
• Testing, especially property-based testing

Technologies

• CNC machining (wood, aluminium)
• Cardano
• FDM
• SLA
• Laser cutting and engraving
• FDM and SLA slicing
• FDM printer maintenance and construction
• SLA printer maintenance
• Nginx
• Prosody
• Linux
• PWAs
• XMPP

Writing

• Grant writing (commercial grants, academic grants)
• Technical writing (code documentation, educational writing on technical topics, standard specifications)

My experience

The following represents projects I have worked on, either individually or as part of a larger team, as well as what skills I developed or used on each. For those projects whose outputs are open source, you can also find links to them.

C

SIMD UTF-8 validator in bytestring

I implemented a SIMD-accelerated UTF-8 validator for the bytestring Haskell library. The implementation had to be both portable and performant across a range of platforms. This included only-SSE x86, SSE-and-AVX x86 and NEON, as well as a non-SIMD fallback. Inline assembly was used to ensure performance regardless of compiler use.

Link: C source

Relevant skills: C, Haskell, SIMD, asm, automata theory, parallel programming, algorithms and data structures

Data processing

Optical reflection project

I processed NASA AOD Terra optical reflection data as part of a PhD project. This required me to convert a combination of several years’ worth of NASA satellite data, combined with regional data from all of New Zealand, to produce CSV files correlating and summarizing both data sets per geographic region.

Relevant skills: PostgreSQL, PostGIS, Julia, parallel processing, performance engineering, Unix command-line data processing tools

Machine learning data preparation

I won competitive funding (via an academic grant) to process a large amount of CSV data, provided by Fisher and Paykel Healthcare, into the ARFF format, as well as an SQLite relational database, using command-line tools and Haskell. I then used WEKA to run various machine learning algorithms on the data, followed by aggregation of the results. Due to my choices in optimization and tooling, I was able to complete work budgeted for 1 month in 1 day, including revisions requested at the end.

Relevant skills: SQLite, parallel processing, performance engineering, grant writing, Unix command-line data processing tools, Haskell

Haskell

Covenant

I won competitive funding from Catalyst Fund 13 to design and build an intermediate, Turner-total, call-by-push-value language, called Covenant. Covenant was designed to serve a similar purpose to LLVM, but for the Cardano ecosystem.

Link: Project on Github

Relevant skills: Haskell, Cardano, compiler design and construction, type systems, grant writing, testing

Plutarch

I helped design, and currently maintain, an eDSL for UPLC scripts called Plutarch. Plutarch is designed to provide both significant type safety by way of its host language (Haskell) while allowing low-level control over performance-sensitive details where needed. I have been Plutarch’s primary maintainer since 2025; prior to this, I was a co-maintainer.

Link: Project on Github

Relevant skills: Haskell, Cardano, compiler design and construction, type systems, grant writing, testing

nonempty-vector

I contributed support for unboxed vectors to the nonempty-vector library.

Link: Project on Github

Relevant skills: Haskell, testing, performance engineering

CIP implementations

I implemented CIP-49, CIP-121, CIP-122 and CIP-123 into Plutus Core. This also required tests and benchmarks to demonstrate correctness and performance.

Link: Project on Github

Relevant skills: Haskell, testing, performance engineering, algorithms and data structures

Bindings for SECP256k1 library

I implemented bindings to SECP256k1 functionality to cardano-base, as part of the work required to implement CIP-49. This also required tests to demonstrate correctness and safety.

Link: Project on Github

Relevant skills: Haskell, C, testing

Manufacturing

I have designed a range of parts, mostly for FDM printing.

Link: Printables

Relevant skills: FDM, SLA, FDM and SLA slicing, FreeCAD, Blender, design optimization for FDM, design optimization for SLA, FDM printer maintenance, SLA printer maintenance

Self-hosting

I self-host several services, as well as two PWAs (see the Web section for details), as well as this site. I use the following technologies and systems.

Relevant skills: Nginx, Prosody, Linux, PWAs, XMPP, HTML

Standards

I produced several reviewed standards documents for Cardano Improvement Proposals (or CIPs). In all cases, I was responsible for writing the original proposal, then amending it after review. All of the CIPs listed here were accepted.

I also implemented support for these CIPs into Plutus Core. The specifics are listed in the Haskell section.

• CIP-49. Specifies builtins to perform signature verification over the SECP256k1 curve, for both Schnorr and ECDSA signatures.
• CIP-121. Defines rules about conversions between builtin Integers and builtin ByteStrings, with support for different choices of endianness and padding requirements.
• CIP-122. Specifies the behaviour of logical operations (such as AND, OR, XOR and NOT), as well as bit indexing conventions, for builtin ByteStrings.
• CIP-123. Specifies the behaviour of certain bitwise operations (shifts, rotation, population count, find first set bit) for builtin ByteStrings.

Relevant skills: Technical writing, Haskell, Cardano, performance engineering

Web

I have written two PWAs, which I also host on my own hardware:

• CNC Doctor, a tool to help calculate feeds and speeds for CNC machines.
• Simotor, a tool to calculate available torque to a stepper motor given a voltage, current and motor parameters.

Relevant skills: HTML, PWAs, CNC machining, FDM printer maintenance and construction, Linux, Nginx

Writing

I have written several blog posts on a range of topics, mostly, but not entirely, related to Haskell. These are currently hosted by MLabs, where I previously worked:

• Patterns and Paradoxes: The Logic of Pattern Synonyms. Explains the use, and benefit, of pattern synonyms and view patterns, in the context of a four-valued logic implementation.
• Performance, pull arrays and Plut{arch, us}. Describes pull arrays and their benefits, demonstrating their improvements in the context of UPLC performance.
• Fast Findings with SWAR and the FFI: The Good, the Bad, and the Inefficient. Compares the performance of SWAR techniques and the FFI in Haskell, focusing around the specific problem of string matching within a region, rather than the entire haystack.
• Our Performance is massiv: Getting the Most Out of Your Hardware in Haskell. Describes the use of the massiv library to get high performance out of arrays using CPU parallelism, in the context of cellular automata.
• First Know Thyself: Understanding String Matching Performance With ASCII. Examines several string matching algorithm implementations in Haskell, ranging from naive to BNDM. Also considers the practical performance of each implementation and the reasons behind it.
• From Term to Script: How PlutusType Drives Plutarch. A detailed description of the role of PlutusType within the Plutarch eDSL, drawing parallels to Monad from Haskell. Also describes how to produce instances of this type class, including using helpers provided by Plutarch.
• The ‘A’ is for ‘Accelerated’: Checking ASCII with SWAR. Describes the use of SWAR techniques in Haskell to speed up validation, as well as the magnitude of the performance improvements SWAR techniques can obtain.
• Quasiquoting for Fun, Profit, Expressions and Patterns. Explains quasiquoting in Haskell in terms of its capabilities, and discusses suitable situations for use of quasiquoting over alternatives.
• How Covenant Will Deliver You to the Promised Land (of Scripts). Describes the proposal for the Covenant project, and explains its benefit to the Cardano ecosystem as a universal target for tooling, similar to LLVM or Wasm.
• Queenside Castling on Cardano: Bitwise Operations for Better Solutions and Improved Plutus Scripts. Describes CIP-122 and CIP-123 operations and how they can be applied to improve an n-queens solver (a UPLC benchmark) using rank-select dictionaries in combination with a technique from Qiu. The performance difference is also measured and explained.
• Mastering QuickCheck: Advanced yet Practical Techniques for Property-Based Testing. A practical tutorial in the use of QuickCheck’s more advanced features to test a compile-time-sized implementation of pull arrays. This describes the techniques, how they are useful, and shows their ability to find bugs and counter-examples.

Relevant skills: Technical writing, performance engineering, Haskell, SIMD, SWAR, C, Cardano, algorithms and data structures