Rob Deas
Engineer · Writer · Builder of Useful Things
I’ve spent over twenty years building backend systems in Java, Kotlin, and whatever the JVM throws at me next. Somewhere along the way I discovered that explaining things well is just as satisfying as building them.
That’s the thread running through everything I do now: open-source libraries published to Maven Central, technical posts on medium, dev.to and LinkedIn, and side projects that exist partly because I needed them, and partly because writing about them forces me to understand them properly.
My background is a little unusual. I came to software through electronics and physics, picked up database systems along the way, and ended up specialising in the JVM on topics such as concurrency, memory, security, and the unglamorous plumbing that keeps production systems honest. These days I’m particularly interested in the infrastructure and tooling layer around AI/LLM systems, where good engineering communication is genuinely scarce.
I’m currently open to roles where I can do both: build things and help developers understand them.
The Architecture of My Approach
Most software engineers come from computer science. I came in via electronics, physics, and signal processing before working my way up through databases and distributed systems.
That path turned out to be useful. When you’ve spent time thinking about hardware constraints, you develop a different instinct for where abstractions leak. When you’ve modelled data at the schema level, you ask different questions about state. I didn’t plan this curriculum; it just happened to build a fairly unusual mental stack.
It also means I’m genuinely comfortable explaining things across levels. Whether I’m talking to a junior engineer about thread lifecycle or to a CTO about storage trade-offs in a local-first app, I try to find the right layer of abstraction for the person in front of me rather than one that makes me sound impressive.
That’s the skill I most want to keep exercising. Not just building things, but helping people understand them.
The “Working Notebook” Philosophy
I build practical tools that solve real problems. They are often published to Maven Central, documented here, and used on production projects. Sometimes I may want to publish work that doesn’t work perfectly the first time; that’s the point of a notebook. Don’t worry I will warn you if I post something broken.
This site is an explanation of real published software as well as a record of experiments, hard-won lessons, and technical deep dives.
Notable Open Source
| Project | Focus | Stack |
|---|---|---|
| JCoroutines | Structured concurrency for the modern era | Java 21+ / Virtual Threads |
| NotNull4J | Runtime null-safety extending JSpecify at trust boundaries | Java / Maven Central |
| ABCoroutines | Structured concurrency for Kotlin on Java 21 | Kotlin / Virtual Threads |
| VerZanctuary | CLI for safe code snapshots in AI-assisted workflows | Kotlin |
| SheafGate | A pattern for SvelteKit/Bun desktop apps without Electron | SvelteKit / Bun / Go |
| Sandcastle-Auth | Auth server with robust token governance | Spring Boot / Kotlin |
Technical Interests & Expertise
Modern Concurrency
Virtual threads, structured concurrency, Kotlin coroutines
AI/LLM Workflows
Safety tooling and infrastructure around AI-assisted coding
Secure Microservices
Hardened backend architecture with Spring Boot and PostgreSQL
Modern Web
Server-side rendering with htmx/Qute and local-first apps with SvelteKit
Hardware Integration
Automation workflows via microcontrollers and custom firmware
Let’s Connect
I regularly cross-post technical content to Medium, dev.to and LinkedIn, reaching thousands of developers. If you’re hiring for a role that needs deep JVM expertise, open-source credibility, and someone who can articulate complex concepts to a developer audience — I’d love to talk.
Contact Me
My contact details are here: Contact Me