Goodreads helps you keep track of books you want to read.
Start by marking “Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#” as Want to Read:
Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#
Enlarge cover
Rate this book
Clear rating
Open Preview

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

4.54  ·  Rating details ·  373 ratings  ·  60 reviews
You want increased customer satisfaction, faster development cycles, and less wasted work. Domain-driven design (DDD) combined with functional programming is the innovative combo that will get you there. In this pragmatic, down-to-earth guide, you'll see how applying the core principles of functional programming can result in software designs that model real-world requirem ...more
Paperback, 260 pages
Published November 25th 2017 by Pragmatic Bookshelf
More Details... Edit Details

Friend Reviews

To see what your friends thought of this book, please sign up.

Reader Q&A

To ask other readers questions about Domain Modeling Made Functional, please sign up.

Be the first to ask a question about Domain Modeling Made Functional

Community Reviews

Showing 1-30
Average rating 4.54  · 
Rating details
 ·  373 ratings  ·  60 reviews

More filters
Sort order
Start your review of Domain Modeling Made Functional: Tackle Software Complexity with Domain-Driven Design and F#
Mark Seemann
Nov 22, 2018 rated it really liked it
Shelves: software
If you'd like to understand why F# (or statically typed functional programming in general) is useful for everyday 'enterprise' development, then this is the book for you.

You don't have to know F# already. While this isn't an introduction to the F# programming language as such, Scott gives you enough of an introduction that you'll be able to understand what's going on. Instead of using half the book to introduce the language, he shows you just enough, and then he keeps the example code in the boo
Sebastian Gebski
Aug 11, 2017 rated it it was amazing
Based on Beta 1.0 - 2 final chapters still missing.

PragProg doesn't disappoint, but as I've never read any decent book on functional modeling, my initial enthusiasm was rather limited. Additionally, I'm not really keen on F# (as a language) - its OCaml inspiration doesn't impress me, I generally try to avoid F-OO hybrids.

And then, enters Scott Wlaschin. Needless to say, he's not an anonymous person (quite far from that -, but still - this guy has just accompli
Nikolay Hodyunya
Very beginner-friendly exposition of DDD concepts with examples written in F#. Everything begins from scratch so no prerequisites required.
Feb 25, 2019 rated it did not like it
Ok, so there's one were this girl — I knew she have a husband, but also I knew she wasn't fond of the sucker. She was kinda chubby but qute; and also that was the kind of chubby that makes one's breast grow along with the fat percentage. So she invited me home and we fucked. Several times. And it was fine. But it seemed to me like the fact that it happened mattered for here more than enjoyment or our friendship itself.

Now I know how girls feel when guy immediately starts to dress up after he ca
Sergey Shishkin
Mar 16, 2018 rated it really liked it
That's a great book on software design which I would recommend to any developer, no matter of programming language preferences. Scott has a rare ability to explain complex stuff in approachable way through analogies and examples.

I found some code samples quite trivial and mundane for a book, thus 4 stars.
Adrian Bercovici Simon
This review has been hidden because it contains spoilers. To view it, click here.
Pepijn Looije
Dec 28, 2020 rated it it was amazing
Shelves: data
Even without exposure to F#, the code examples are easy to follow. Trivially translatable to Scala, and even to Clojure with a bit of imagination. I constantly refer to this book on my day job (at a big fintech company).
Apr 04, 2018 rated it really liked it
Shelves: learning
Brilliant introduction to Domain-Driven Design, designing with types in F# and "railway-oriented programming".

If you have an interest in any or all of these topics, this book takes an entire feature, from discussing with business stakeholders over designing your code purely on a type level to implementing the actual business logic in a clear cohesive story. It even touches on async/error handling, something a lot of introductory material is very handwavey about and shows how to tackle these conc
Torben Koch
Oct 20, 2018 rated it it was amazing
Scott made a book by basically distilling, rewriting and ordering a lot of the material on his website. And he did good!

There is a fine introduction to DDD and a lot of neat tricks on how to do it in F#.

Downloading the accompanying code will probably make a dent in your admiration for Scott, though. Functional programmers are seemingly in general lazy people and consistently forget the WORM - Write Once, Read Many - aspect of programming.
Apr 18, 2020 rated it it was amazing
I wish I had this book 5 years ago when functional paradigm and F# became part of what I do.

Even though we are all introduced to functional principles in school (without calling it functional, we just called it math) and later (I'm sure some even earlier) in Excel, it is not easy to isolate the afterwards acquired procedural and object oriented thinking. At that moment one has to reserve an innocent place in one's brain to fully embrace the functional paradigm without carrying the old habits al
Ian Tuomi
Sep 16, 2020 rated it really liked it
I got a lot out of the first half of the book where the essence of ddd is distilled very cleanly from a functional point of view. I consider many of these viewpoints as close to canon as it gets in software development. Outstanding 5/5

The second half was a mix of strict functional programming strategies like making pure pipelines by composing meticulously typed function inputs and outputs to match each other (I am not a fan of this approach. While satisfying and beautiful, I find it difficult to
Gregor Riegler
Jun 16, 2020 rated it it was amazing
Shelves: recommendations
This Book explains the thought process of Software Design using the Functional Paradigm very well.
It's not about the language F#, it's about the paradigm. I do not use F#, nor am i'm planning to.
Still, the book had a lot of value to me.

A key learning is how to take advantage of Types to achieve a better Domain Model.
For me, a OO Guy digging into FP, it was a mind opener.
It teached me how to think in workflows, how to compose and streamline testable functions, how to inject dependencies using p
Mar 04, 2019 rated it really liked it  ·  review of another edition
This is a fantastic introduction to both DDD and Functional Programming in a very accessible book. Being grounded in a very concrete and coherent example it's really easy to relate to the ideas presented in the book.
If there is anything I felt lacking from the book, it would be a little more examples of tests and driving implementation with tests alongside driving it with the type system.
Yannick Grenzinger
Apr 06, 2020 rated it it was amazing
Surely one of the best book how to implement the tactical part of DDD in a functional way.
Totally practical, avoiding Category Theory, and giving a lot of knowledge about how tu use functional programming and types to implement a very robust domain.
Jonathan Stiansen
Nov 06, 2020 rated it it was amazing
I think it was clear, solid, and well thought out. I learned a model of organizing software architecture, using types as state machines, and allowing them to be driven from your domain and those types driving your computation.
Feb 08, 2020 rated it really liked it
Awesome book for anyone interested in domain modelling!
Feb 13, 2020 rated it it was amazing
Shelves: technical, 2019
Great read on how to architect your code and make your code easy to understand, use, and change all while make it hard to introduce bugs.
Jun 09, 2017 rated it really liked it
This is an introductory book and does not cover more advanced functional programming topics, nor does it cover Domain-driven Design (DDD) in detail (see Eric Evans' Domain-Driven Design: Tackling Complexity in the Heart of Software and Vaughn Vernon's Implementing Domain-Driven Design), but it does a good job of explaining how functional programming is a great fit for DDD with clear use of examples.

The author does a good job of starting with simple but naive approaches to software design problem
May 24, 2019 rated it it was amazing
Shelves: 2019
It is a good intro book on doing DDD functional way. To a degree, it's covering the same topic as "Functional and Reactive Domain Modeling" by Debasish Ghosh. But it's significantly shorter and with more evident emphasis on types driven development.
While Ghosh's book is about "i learned about FP, now I want to understand how to write business applications in this style", this one is more about "I know how to do DDD, how can I do it in fp style? But please no category theory this time"

It's a shor
Tomi Turtiainen
May 20, 2019 rated it it was amazing
This book is just great! It gives a great introduction to DDD and then moves on to show how you can do domain modeling with functional programming. Although the examples are in F#, the book focuses more on explaining and showing functional programming concepts you can use to tackle complexity. I can highly recommend this to anyone who is interested in doing functional programming in complex domains.
May 14, 2021 rated it liked it
A solid introduction to functional programming, but not without flaws

In this book, Scott Wlaschin walks us through an imaginary software design project and demonstrates how we can apply functional programming paradigms, as well as the particular capabilities of the F# programming language, to tackling large application development through domain-driven design (DDD).

Some highlights of the book that felt particularly important to me:

* Wlaschin lays out the fundamentals of Domain-Driven Development
Damian Zydek
Oct 31, 2020 rated it it was amazing
Shelves: computer-science
This book teaches by an example. The author took an examplary project done with a functional programming approach and described three phrases from it (Analysis, Design, Implementation).

Part I - Analysis - Discovering Domain (general knowledge).
For me, it is the best chapter of all.
The author starts with the event storming session for discovering events, commands, and subdomains in problem space. After this, he creates a solution space with bounded contexts and relationships within them (contex
Marcos C. Santos
Jan 25, 2021 rated it really liked it
It's a good reading for people interested on learning about Domain Driven Design using real world business applications.
Really well written book, its first two parts are extremely beginner friendly, but the last (and most important part) not as much. The last section of the book assumes you're already familiar with some of F# syntax and constructors, although, one can easily follow up the book until it's end without knowing it.
Sometimes I felt like it missed showing up the entire view of the pr
Aug 09, 2020 rated it it was amazing
Shelves: 2020
This book walks you through the key concepts of Domain Driven Design in a practical and easy to grok manner. Examples are well crafted and do not require expertise of F# (I read it with a little knowledge of a similar language, Kotlin). It helped me learn the "why" behind functional patterns.

The journey starts with identifying the Vocabulary for a Domain (ubiquitous language) using Event Storming. Next modeling with Types is covered. Workflows are represented with Functions along with the Types.
Aaron Cruz
Aug 25, 2020 rated it it was amazing
Really fantastic book. It has made me completely change some fundamental ways I design software.

The book uses F# in the design implementations, a language that I have never used, though I have some years of functional programming experience. It isn't an intro to F# but either because of its simplicity or the author's incredible teaching ability, everything makes sense. You don't need any background in the language.

I really can't say enough good things about this book. Highly recommended.
Keith Nicholas
Feb 22, 2021 rated it it was ok
Maybe the book was over hyped by various people, but I found the book disappointing. The discussion on DDD was pretty good, The discussion around types and algebraic types for modelling the domain is pretty good, but the actual F# didn't seem that good and a lot of the design choices seemed very rigid. If you have a reasonable understanding of functional programming, you can download the code for the book off the prag prog website and check it out for yourself. Luckily I got this book through th ...more
Gábor László Hajba
Oct 23, 2017 rated it it was amazing
Shelves: computer-science
I liked the book because it brought the domain concepts and functional programming using F# together in a well-designed way.

I suggest reading this book if you are interested in implementing DDD. Regardless of the language because the principles described here can be applied in any programming language -- you just have to think a bit more if your choice doesn't support FP -- and such a language is rare to find nowadays.
Tiantang Sun
Feb 22, 2018 rated it it was amazing
I am a little half way through the book but don't think I will change my review when I finish. It's simply super! Coming from an OO background, it's mind-blowing for me to see how to do things in a functional way and how to design things differently.
I think this is a must read for anyone who wants to start DDD and F#. Of course it's intended to be a relatively beginning book but it's just the right level of depth for me.
I do hope the author would write a more in depth book about DDD and F#!
Erich Oswald
Dec 09, 2019 rated it really liked it
A great introduction with actionable recipes for getting from requirements to a functional domain model.

The introduction to functional programming concepts is oriented towards real beginners. I could have used something like that a few years ago. Now it wasn't really necessary anymore.

Things I would have liked: additional material about effect-oriented approaches (using monad transformers or effect rotation as in ZIO).
Bart Sokol
Aug 22, 2018 rated it really liked it
If you're familiar with Scott's work (his website, presentations etc.) then you'll find some things in the book a little bit repetitive, but otherwise, it's a great read. It shows how nicely the principles of domain-driven design fit into the functional paradigm and how powerful type system can help you to model the domain and quickly find any potential issues. ...more
« previous 1 next »
There are no discussion topics on this book yet. Be the first to start one »

Readers also enjoyed

  • Designing Data-Intensive Applications
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • The Pragmatic Programmer: From Journeyman to Master
  • Clean Architecture
  • Clean Code: A Handbook of Agile Software Craftsmanship
  • Patterns Principles and Practices of Domain Driven Design
  • Refactoring: Improving the Design of Existing Code
  • Fundamentals of Software Architecture: An Engineering Approach
  • Accelerate: Building and Scaling High-Performing Technology Organizations
  • Implementing Domain-Driven Design
  • Building Microservices: Designing Fine-Grained Systems
  • Team Topologies: Organizing Business and Technology Teams for Fast Flow
  • Code Complete
  • Domain-Driven Design Distilled
  • A Philosophy of Software Design
  • Test-Driven Development: By Example
  • Effective Java
  • Growing Object-Oriented Software, Guided by Tests
See similar books…

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »

Related Articles

  Here at Goodreads, we've noticed that a funny thing tends to happen when we start talking about audiobooks: The same few titles get...
10 likes · 2 comments