Domain Modeling Made Functional: Tackle Software SPlexity with Domain-Driven Design and F# (Pragmatic Programmers)

As a C# programmer, I get very annoyed by the number of "Why use F#?" and "F# vs C#" articles I see that attempt to sell F# by belittling C#, usually incorrectly. The (very) few convincing articles are usually demonstrating trivial tasks that aren't really challenges in either language. I spent a long time totally unconvinced as to the benefits of F#, until I decided to ignore those articles and just try learning it anyway. This book is a game changer. Apart from a very clear explanation of DDD[*], the way he explains the evolution of the types, and the simple translation of the simple language that the domain expert(s) can understand into F# is very powerful. You can see how the code itself becomes the documentation. Whilst I don't see curly braces and "get; set;" in C# as noise (my mind filters them out), I can see how a non-developer would struggle to make sense of a C# class, whereas the F# type is so clear that any non-developer could understand it. The domain model can evolve with the code, documenting itself as it goes along. As for the idea of functional programming vs imperative programming, I'm still not convinced that either has a huge advantage over the other. C# has so many functional features that the lines are becoming increasingly blurred. However, the way he demonstrates splitting the workflow into sections, and piping the output of one into the next is very clear and clean, and his use of section-specific types means you can't really get it wrong. I can see how this approach to coding could drastically reduce the number of bugs. It does lead to a type explosion, but it's probably worth the price, given how simple the types are in the first place. Again, this isn't anything you couldn't do in C#, but it looks a lot cleaner in F#. If you're still looking to be convinced about F#, you should certainly read this book. Even if you aren't, it's probably still worth reading, as the explanation of DDD is excellent[*], and what he says can be applied to C# as well. [*] Caveat, I haven't read any other books on DDD, so can only comment on how I found this one, not how it compares with any others

A well written and well thought out book where you can learn two things at once without feeling overwhelmed or either feeling watered down, although it leans a bit more towards FP than DDD. You won't become an expert in either but you'll definitely have a good theoretical grounding at the end. The book uses a fictitious case study that, while being necessarily simple, is still complex and believable enough to serve its purpose. It also doesn't oversell DDD as a silver bullet/panacea which I appreciated - the rough edges and tradeoffs of the approach (especially when using an explicit FP language) are openly noted. The only negative I have is that while most fundamental F# concepts and syntax are explained quite thoroughly in the first two thirds of the book, in the last third they're suddenly glossed over as if you've magically gone off and learned a whole bunch of things on your own. This is jarring and a bit annoying but overall a minor issue. Highly recommended.

I have a lot of tech books, but tend to dip in and out of them - this one I read cover to cover. The examples are great and I was inspired to use the overall paradigm in a program. The entire concept is great and leads to a very straightforward and robust application. Note: implementation in Java is where I ran into problems - the initial program design was straightforward, but later modifications led to lots of boiler plate because there are (deliberately) no relationships between the objects, everything is achieved by functions that take one type and return another and attributes had to be copied through.

The functional programming paradigm is an excellent match for Domain driven development and this book provides a helpful walkthrough of some of the specific techniques that can be applied to the practice. The opening chapters give a high level grounding in DDD concepts (Event storming, Bounded contexts, Ubiquitous language, etc.) and the following chapters take a deeper dive into implementing them using a functional approach. F# is the author's language of choice and we get to see how flexible it can be in modelling business domain requirements. Neither a thorough guide to DDD nor F# this book nevertheless plays an essential role in demonstrating the utility of the functional programming paradigm to DDD.

Having the code as clear documentation is great. The use of types to differentiate between validated and invalidated email addresses, rather than a boolean isValidated shows how F# helps you approach problems differently. The book is well-written and well-paced. F# won’t be for everybody, but the ideas in this book make it worthwhile reading for non-F# people, such as me. If you are starting a new project, your design would probably benefit from the ideas in this book.

I loved this book! I have been learning F# for around a year and this book really helped me to understand topics that are not well documented elsewhere online (e.g. serialisation and persistence of F# code, using types to drive the domain design etc.). As a C# and JS developer, this book has really opened my eyes to the genuine advantages of Functional Programming and how F# can ensure you write superior, readable, safe and maintainable code. Moreover, it's also helped me to better understand C# Functional language features (e.g. Linq, Higher-Order Functions and Record Types). Thanks to the author for this gem of a book.

Outstanding demonstration of how Domain-Driven Design ideas and strong static typing can lead to wonderfully expressive code. Even if you have no F# experience you will have no difficulty following the examples. In one or two places there was a bit more in-depth discussion of F# syntax than I was interested in, but these can be skipped over without losing any understanding of the ideas being presented, which could be implemented in many different languages.

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.

El libro está muy bien escrito. Es ameno de leer. El escritor ha hecho un gran trabajo clarificando los conceptos para que sean fáciles de digerir. En la primera parte explica qué es el Domain-Driven Design y qué beneficios tiene aplicarlo. En la segunda parte entra más en detalle en el tema y explica cómo modelar la aplicación de ejemplo en F#. Yo no conocía F# antes de comprar el libro pero la puesta en escena del lenguaje es tan clara que me llevo un gran sabor de boca de lo interesante que sería programar en él. Reitero lo increíblemente bien que se explica este hombre. Ya en la tercera parte, se adentra en el código razonando los porqués de la estructuración bajo el paradigma funcional. Personalmente, compré el libro recomendado por un experto en FP y tenía razón al decir que la exposición de cómo estructurar un programa funcional es muy clara en este libro. Además, de regalo te llevas el conocer DDD.

Premettendo che ho sempre programmato ad oggetti e neofita sul DDD, ho trovato il libro molto chiaro, non solo per gli esempi fatti, di facile comprensione, anche per chi non ha mai usato F#, ma anche per come viene trattato l'argomento DDD.

Das Buch eignet sich gut um in die funktionale Programmierung einzusteigen bzw. sich fortzubilden; für mich als Java-Entwickler war es sehr hilfreich zu sehen wie man Probleme zerlegt und organisiert, wenn man nicht mehr objekt-orientiert arbeiten kann (z.B. ohne Seiteneffekte) und daher anders (und IMHO besser) vorgehen muss; er ist einer der wenigen, die ein (für viele OO-Programmierer ganz neues) Thema wirklich verständlich präsentieren kann. Man kann sich Scott Wlaschin und seinen Lehrstil auf Youtube ansehen um einen ersten Eindruck zu verschaffen.

モナドという言葉なしに、モナドの必要性が自然とわかる書き方になっており、関数型言語に詳しくなくても読める。むしろこの本のわかりやすい説明のおかげで関数型言語の理解が深まった。 エヴァンス本よりもわかりやすい実例。よみやすい。(早く和訳本出して欲しい) 値オブジェクトは関数型の型システムの方が実装が楽。型ドリブンに型だけで実装なしに設計できる。 直和型による素直な設計。少しずつ大きくしていける。 関数のパイプラインな設計のおかけで、機能の追加がしやすい。