- AI
- Context-Aware AI
Bookshelf.
23 books, most recent first.
A friendly note: the covers here belong to their publishers and authors — all credit and thanks to them. This is just my personal reading log, shared with the polygloter community in the hope it points you to your next great read.
Data Engineering Design Patterns
I'd long wanted a Gang of Four for the data side — a pattern language for the problems you keep re-solving in pipelines and warehouses — and this is the book I picked up to fill that gap. Named, reusable patterns for data engineering practices instead of one-off recipes; exactly what I was after.
ReadMay 2026- Data Engineering
A gift from my former CTO, handed to me after I gave a talk on cloud maturity in paf headoffice. It puts hard data behind what actually makes software delivery fast and stable — and the metrics chapters land differently on the re-read, once you've picked up a few scars of your own. One of the few books I went back to and got more from the second time.
Re-readFeb 2026ReadDec 2022- DevOps
- Software Craft
A former colleague wrote this, and I was one of its technical reviewers — so I read these chapters as drafts long before they were bound, and got to hold one of the very first copies straight off the printing press. There's a real satisfaction in watching ideas you argued over in review settle into a finished book. On the content, it's a practical guide for data engineers to bring modern development techniques to their pipelines — and I enjoyed it as much in the making as in the final product.
ReadJun 2023- Data Engineering
I found this on my employer's bookshelf — free to take — and it's been my first stop for DDD ever since. It distills the ideas down to what you actually need to get going, so when I want a quick refresher on aggregates or bounded contexts, this is what I reach for. When I need to go deeper, I turn to Vernon's fuller Implementing Domain-Driven Design. A great on-ramp, and the one I'd hand a teammate first.
Re-readApr 2023ReadJan 2022- Software Craft
- Domain-Driven Design
iOS 13 Programming Fundamentals with Swift
I picked this up to get started on an iOS app — a learning project more than anything I shipped. Coming from an OOP background, Swift was easy to follow, and the book is a grounded way into the language and the Cocoa runtime. My takeaway: it's worth learning Swift, but I ended up pivoting to more cross-platform languages so the same app could also target Android.
ReadSep 2022- Swift
- iOS
Java Performance: The Definitive Guide
I reached for this when our Docker images started showing performance issues after we migrated to modular Java. It demystifies the JVM and GC tuning with data rather than folklore — exactly what I needed to reason about what was actually happening instead of guessing. A definitive reference I still turn to when the performance of my services need revisit.
ReadDec 2021- Java
- Performance
Implementing Domain-Driven Design
I came to DDD late. I picked this up on a consulting assignment for a banking client where the whole team was already fluent in the concepts, and I needed to catch up fast. The book got me the vocabulary quickly — aggregates, bounded contexts, ubiquitous language, and domain events stopped being buzzwords and became tools I could actually reason with. It's one of the few books I keep coming back to; I've re-read parts of it several times since, usually when designing microservices and trying to get the boundaries right.
Re-readJan 2021Re-readSep 2019ReadJan 2019- Software Craft
- Domain-Driven Design
Real-Life BPMN
I picked this up out of curiosity while mapping out an approval process and integration flow for a paf, land and ship business. My goal was simple: learn the best practices up front so I could avoid the modeling mistakes rather than discover them later. It turned out to be a practical guide rather than a walk through the BPMN spec — it showed me which elements are actually worth using and how to keep diagrams clean enough for a small team to follow without hand-holding. My takeaway: stay consistent — the same conventions across BPMN, network diagrams, and the deployment process.
ReadNov 2020- Process Modeling
My summer vacation read that year, and an easy pick: Sam Newman's Building Microservices had already won me over, and this is the natural next step — where that book covers what microservices are, this one is about how you actually get there from a monolith you already run. A practical, pattern-driven take on decomposition as a gradual journey rather than a big-bang rewrite.
ReadJul 2020- Architecture
- Microservices
Java 9 Modularity
This one has a special place on my shelf — I got it signed by Sander Mak at Devoxx Belgium, back when most of the world was still migrating from Java 7 to 8. I started it on the flight home and was hooked enough to finish the first five chapters before landing, then worked through the rest over the next two weeks. It builds up the Java Platform Module System gradually — the motivation first, then the mechanics — so modules land as a tool for real encapsulation and dependency management rather than just new syntax, and the migration guidance made adopting it in larger projects feel achievable. Modularity felt like a phenomenal upgrade to the language, and this was the book that made it click modularity for me.
Re-readMay 2020ReadNov 2018- Java
The Rust Programming Language
I picked this up when we were integrating a contactless payment terminal into our amusement gaming machines. The learning curve was steep — ownership and borrowing take a while to sink in — but the payoff was real: we built and shipped the devices with code that just worked in production. This is "the book" for a reason; the clearest path into Rust I've found.
ReadMar 2020- Rust
- Systems
Programming Kotlin
I've been a fan of Venkat Subramaniam since catching his opening remarks at conferences, and I'd already read his Functional Programming in Java before I ever met him, so picking up his Kotlin book was an easy call — and it's a great read. His enthusiasm comes through on the page as much as on stage: a pragmatic tour of what makes Kotlin genuinely pleasant to write. Kudos to Venkat — and a real pleasure to have met him personally and even shared a ride with him :)
ReadFeb 2020- Kotlin
Serverless Architectures on AWS
I was new to serverless and Lambda, and picked this up to understand the whole model — not just how to use it, but how it's actually implemented. It gave me a real perspective on the awkward parts, especially batch processing and database connections. The gap at the time was a truly serverless Postgres — without it, the "fully serverless" story never quite closed. Still, a sound early map of building around Lambda and events.
ReadNov 2019- Architecture
- AWS
Refactoring: Improving the Design of Existing Code
A real discovery for me. I'd been a software developer for about four years and still couldn't quite figure out how to write code that stayed maintainable — this is the book that finally gave me the vocabulary and the food for thought I'd been missing. The catalogue of moves is handy, but the deeper lesson is the discipline of writing code that stands the test of time. I recommend it without reservation.
ReadJul 2019- Software Craft
Think Python
I picked this up around the time I realized Java alone wasn't enough — I needed to diversify, and Python was making all the news. It's a great read: I worked through it with real enthusiasm, coding along as I went rather than just reading passively. It teaches you to think like a computer scientist as much as it teaches Python, and that framing stuck with me.
ReadJul 2019- Python
Designing Data-Intensive Applications
A colleague put me onto this in 2018, and it turned out to be one of the most valuable technical books I've read. I came at distributed systems with an RDBMS mindset — normalized schemas, one database — and this reframed all of it: it explains not just how storage, replication, partitioning, and consistency work, but why they're designed that way, and it connected ideas that had always felt unrelated. It's become a book I go back to for reference rather than a one-time read. My takeaway: if you've spent your career on monoliths and relational databases, this is the one that shifts you from designing schemas to designing systems.
ReadNov 2018- Architecture
- Data Engineering
Spring 5 Recipes
We were writing Spring Boot starters for our microservices, and Spring 5 had just landed — I picked this up to stay on the bleeding edge of the framework. It's a dependable problem-solution reference: when I hit a specific need, there was usually a recipe close enough to adapt. Not a cover-to-cover read, but exactly the book to keep near the keyboard while building.
ReadJun 2018- Java
- Spring
Book of Vaadin, Volume 1
I found Vaadin at Devoxx Belgium, right after my team and I had accepted that our experience with Liferay was unpleasant. As backend developers, the pitch — build modern, rich web UIs entirely in Java without living inside a JavaScript framework — landed immediately. Working through the examples I picked up responsive layouts, data binding, and how to structure an app using concepts I already knew, and I could map each one straight onto our own projects. It gave me the confidence to take a Java-first frontend seriously, and looking back it marked the start of a real shift in how I think about frontend development.
ReadApr 2018- Java
- Web Development
I picked this up after being impressed by one of Sam Newman's GOTO Conference talks, and it more than lived up to the hype. It's practical throughout — even-handed about the trade-offs and honest about when microservices aren't the answer. Thoroughly enjoyed it; a must-read before you break anything into micro-services.
ReadMar 2018- Architecture
- Microservices
Data Structures & Algorithms in Java, Sixth Edition
I keep this one around as a refresher — both for keeping my own fundamentals sharp and for mentoring others through the classics. As a Java developer, I appreciated that the implementations are concrete Java rather than pseudocode, so the data structures map straight onto code I'd actually write. My takeaway: a must-have on any programmer's shelf.
Re-readNov 2017Re-readSep 2016ReadDec 2015- Java
- Algorithms
Java 8 in Action
This was my second Manning book after spring in action, and it reinforced why I should keep coming back to manning — a gradual, practical build-up rather than a syntax dump. I picked it up during the lambda hype, wanting to get ahead of the slow migration to Java 8 and actually understand the ideas behind the features, not just use them. When I put it into practice on a greenfield project in 2017, the streams, lambdas, and method references stripped out a lot of boilerplate and made the code read far more naturally. My takeaway: this book helped me write expressive code.
ReadNov 2016- Java
Node.js, MongoDB and AngularJS Web Development
I picked this up when the MEAN stack was all the rage, mostly to understand what it actually was and whether the hype held up. It's a solid full-stack tour — Node, MongoDB, and AngularJS end to end — and it gave me a working picture of how the pieces fit together. Some of the stack has aged since, but as a way to cut through the noise and see the whole thing at once, it did the job.
ReadFeb 2015- Web Development
No books match all of those genres.