Finally got around to reading Domain Modeling Made Functional, Tackle Software Complexity with Domain-Driven Design and F#, by Scott Wlaschin. Book basically covers:
- Domain Driven Design
- How to design with types
- How to implement 1 and 2 in code & refactor it.
There’s other good content leveraging the above like balancing both exceptions vs. Result (e.g errors as values) & Persistence concerns (e.g. database).
My favorite, though, are his translations of OOP concepts to FP ones. This is a huge deal because most DDD (Domain Driven Design) content is heavily biased towards OOP, design patterns, and mutation, none of which is in the FP world. Additionally, despite Java’s & C#’s massive improvements, OOP devs don’t worship types like the FP community does, and sum types & records are perfect for modelling things in DDD style, with the compiler’s help. So having his translations from the OOP world to the FP one helped a lot. He even included Onion/Hexagonal architecture which I loved, omitting the parts that FP devs don’t need.
I’ve been meaning to read “The Blue Book” and “The Red Book”, famous DDD books, for a long time, but my patience of translating OOP things to my world is basically spent, so it was dope to get Scott’s explanation. The topics are vast so everything had external links if you wanted to learn more.
The biggest thing I took away was I am 90% on track. That was a HUGE sigh of relief; 90% of the book I’m either like “Yeah, I know this” or “whoa, cool, so I was doing it like you’re supposed too, rad”. That made me feel good; I don’t use F#, I use TypeScript, but it’s basically the same, just more verbose for unions, and doesn’t have those dope Monad helpers.
The other crazy thing was it was released in 2018. Excluding Continuous Delivery/TDD, everything in the book is just as relevant in today’s world in how I build software, and done the same way, so that was another self-esteem boost knowing the core techniques continue to be evergreen, and language agnostic (well… they _do_ assume your types don’t suck and even in 2025, there are popular languages who’s type systems aren’t that great).
One minor thing, it was hilarious to see DTO’s, Data Transfer Objects, embraced and encouraged. I haven’t used DTO’s or VO’s, ValueObjects, since my OOP days back in like 2011. I get why, and agree, no doubt, but… just funny in that:
- most FP devs I work with have no idea what those are
- most OOP devs under 32 have zero idea what those are, either
Really loved how both relational and NoSQL persistence were covered with raw SQL. Really helped solidify some feelings I’ve had and concerns, and squashed all anxiety after reading. I only have about 2 years of real Postegres and DynamoDB experience, but based on what I read, I was on the right track “thinking with an FP mindset” around persistence, and was missing a major core piece around how to save Unions/Sum Types/Variants, so the examples provided were awesome.
If you don’t know DDD and want to learn it, buy this book.
If you want to learn how to “design with types, first, not tests first”, buy this book.
If you know TypeScript, but aren’t really sure if the types are giving you value in your work, buy this book and see if it doesn’t give you a fresh perspective on how to approach your work.
https://pragprog.com/titles/swdddf/domain-modeling-made-functional