Idris & Dependent Types Developer — Provably-Correct Software

I am a formal-methods developer who writes software in Idris, where the type system carries a proof that the code does what its specification says. Instead of hoping tests catch every edge case, I encode invariants directly into dependent types, so whole classes of bugs become impossible to compile. My work sits at the boundary between programming and mathematics: I design types that describe the shape of correct data, express pre- and post-conditions as first-class values, and let the type checker act as a tireless proof assistant. If you have a critical piece of logic — a protocol, a parser, a state machine, a financial calculation — that simply cannot be allowed to go wrong, this is exactly the kind of guarantee I deliver.

My approach is type-driven development in the truest sense: I start from a precise specification, sketch the types, and grow the implementation with holes that the compiler helps me fill, refining until the proof obligations are discharged. I write totality-checked functions, indexed data structures, and machine-checked proofs about their behaviour, and I document the reasoning so your team can maintain and trust it. Beyond Idris itself I bring a broader background in functional programming and formal verification, which lets me choose the right level of rigour for the budget — full proofs where they pay off, lightweight typed guarantees elsewhere. I also enjoy research prototypes: exploring a new type-level idea, encoding a domain in a proof-oriented style, and turning an academic result into something runnable.

Whether you need a verified core embedded in a larger system, a formal model of a tricky algorithm, or a mentor to bring dependent types into your codebase, I work carefully, explain every step, and hand over code whose correctness you can actually read off the types.

— Idris implementation with dependent and indexed types
— Type-driven development from formal specifications
— Machine-checked proofs and totality-checked functions
— Verified parsers, protocols and state machines
— Formal modelling of algorithms and domain logic
— Research prototypes and type-level experiments
— Code review, mentoring and dependent-types training