Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#

I'm surprised that I haven't written a review of this book years ago. I read it, cover to cover, about three years ago but then got sidetracked on a Kotlin project. Coming back to F#, I re-read this book and, again, found such valuable guidance on doing things the right way. Mr. Wlaschin puts forth, step by step, how to deal with every aspect of high quality design and implementation, from types to functions to dealing with errors to serialization and data persistence. Buy this book and your coding will improve.

This is a very good book. It delivers what it promises. If you want to go "functional", if you want to learn F# - this is the book for you. You won't find better. By the way, why you want to "go functional"? To write a better code? You don't have to go all-functional for that. And even if you want to go functional, why F#? why not Haskell? Why not Scala? Questions such as "Why you want to go functional?" are completely outside of the scope of the book. Which is, again, as promised. Let's say you want to "go functional" because you don't know how to solve the persistence problem with the OOP (object-oriented-paradigm). It's a very good concern and very good thinking of yours. Because the data persistence is the actual problem. The fact, which author of the book might not be aware of. He advises to "push persistence to the boundaries of the DDD (domain-driven-design) model". And this is a very good advice, very solid advice. I agree with that 100%. Still, DDD, in my humble opinion, is actually called to solve the persistence problem, not some other unknown or implicit problem. You can create a very good data model in any programming language using any programming paradigm if you don't worry about data persistence. But in case you are not aware that the problem exists, why F#? Why functional?

If you have watched a few of Scott Wlaschin's talks at NDC many of the concepts are familiar, but the book takes you through the entire journey. Love it!

Just as the title says, this book shows how to do domain-driven design using only the functional features of F#. It turns out that functional programming fits DDD better than object-oriented programming, and while F# is not a perfect functional language, it's easily the best on the .Net platform. The book is clear, carefully organized, and should be perfectly accessible to the F# newcomer. Experienced F# programmers who are new to DDD will see how powerful this approach is.

Scott's book starts off w/analysis, not coding. This is an underdiscussed stage of process development. It leads naturally into the design/coding parts. He shows how the concepts are captured in each department of a business, and how to bridge them successfully in a single system. It permits the local concepts to be silos, but finds a way to carry them across in a way that isn't too tight (requiring cooperative evolution) nor too weak (causing subversion of the interfaces). Scott is an excellent F# explainer. He frames useful, believable examples in ways that show off the special qualities of F#. Lots of devs will think they don't need F# and can port the ideas to their platform. They should really try F# before dismissing it, though; the benefits are real (concise, bug-resistant, easier for non-devs to read). It can be ring-fenced in a part of the product (e.g. "the business logic") if the other system parts must be coded otherwise. Read his blog on F#!

One of the best books I've read in a while. Scott takes a step by step approach to explain Domain Driven Design (DDD) and its implementation in a functional way using F#. DDD is fantastic for building applications for businesses. Combined with the power of functional programming, Scott reflects how this approach can be used to build truly scalable and evolving models.

This is a gem of a book! I learned “the best bits” of requirements gathering, domain driven design, type driven design, hexagonal architecture, functional programming, monads, and oh right — F#! Clearly, I learned more than I bargained for... and that’s a great thing.

I resisted buying this book for a bit because I thought I could find most of this information at F# for Fun and Profit, a website the author maintains. While you can find much of this information there, it's a bit fragmented, as that site is really geared towards getting people on-boarded to F#, in general, especially when coming from an OOP background such as C#. It's great content, but this book really takes that content and uses a different example to illustrate how DDD is "done" in functional programming, specifically with F#. If you're a fan of Scott Wlaschin and of F# for Fun and Profit, you won't be sorry to pick up this book if you're looking to take your FP skills no the next level after coming from an OOP background. Thanks for the book, Scott!