Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F# 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Frequently bought together
Customers who viewed this item also viewed
From the Publisher
From the Preface
Many people think of functional programming as being all about mathematical abstractions and incomprehensible code. In this book, I aim to show that functional programming is in fact an excellent choice for domain modeling, producing designs that are both clear and concise.
This book is for experienced software developers who want to add some new tools to their programming tool belt. You don't need to have prior knowledge of domain-driven design or functional programming in order to read this book. This is an introductory book and all the important concepts will be explained as we need them. You should read this book if:
- You are curious to see how you can model and implement a domain using only types and functions.
- You want a simple introduction to domain-driven design and want to learn how it is different from object-oriented design or database-first design.
- You are an experienced domain-driven design practitioner who wants to learn why DDD is a great fit with functional programming.
- You want to learn about functional programming, but have been put off by too much theory and abstraction.
- You want to see how F# and functional programming can be applied to real-world domains.
About the Author
Scott Wlaschin is an expert on F#, author of the popular F# site fsharpforfunandprofit.com, and a board member of the F# Software Foundation. Known for his non-academic approach to functional programming, Scott is a popular speaker and has given talks at NDC, F# Exchange, DDD Europe, and other conferences around the world.
There was a problem filtering reviews right now. Please try again later.
I had trouble imagining how you could scale F# to a larger "business" project. Very clear descriptions.
The entire book follows a project from design -> implementation using F#. The project is not too simple.
The whole approach really opened my eyes, and I'd like to try something like this on my next project.
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#!
Top international reviews
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
The guy explains so well that some things takeaway immediately. Ch 6, integrity and consistency, put the validation in the private constructor.
Right after reading it I started implementing the ideas of how to work with Domain Experts and how to model the problem.
Extremely practical book, I loved it!
Great introduction to DDD for those who've not had much to do with it.
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.
Man kann sich Scott Wlaschin und seinen Lehrstil auf Youtube ansehen um einen ersten Eindruck zu verschaffen.