Scott Wlaschin - Domain Modeling Made Functional: Tackle Software Complexity With Domain-Driven Design and F#

Copyright 2017 The Pragmatic Programmers, LLC. This book is licensed to the individual who purchased it. We don't copy-protect it because that would limit your ability to use it for your own purposes. Please don't break this trustyou can use this across all of your devices but please do not share this copy with other members of your team, with friends, or via file sharing services. Thanks.

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and The Pragmatic Programmers, LLC was aware of a trademark claim, the designations have been printed in initial capital letters or in all capitals. The Pragmatic Starter Kit, The Pragmatic Programmer, Pragmatic Programming, Pragmatic Bookshelf and the linking g device are trademarks of The Pragmatic Programmers, LLC.

Every precaution was taken in the preparation of this book. However, the publisher assumes no responsibility for errors or omissions, or for damages that may result from the use of information (including program listings) contained herein.

The Pragmatic Bookshelf is an agile publishing company. Were here because we want to improve the lives of developers. We do this by creating timely, practical titles, written by programmers for programmers.

Our Pragmatic courses, workshops, and other products can help you and your team create better software and have more fun. For more information, as well as the latest Pragmatic titles, please visit us at http://pragprog.com.

Our ebooks do not contain any Digital Restrictions Management, and have always been DRM-free. We pioneered the beta book concept, where you can purchase and read a book while its still being written, and provide feedback to the author to help make a better book for everyone. Free resources for all purchasers include source code downloads (if applicable), errata and discussion forums, all available on the book's home page at pragprog.com. Were here to make your life easier.

Want to keep up on our latest titles and announcements, and occasional special offers? Just create an account on pragprog.com (an email address and a password is all it takes) and select the checkbox to receive newsletters. You can also follow us on twitter as @pragprog.

If you buy directly from pragprog.com, you get ebooks in all available formats for one price. You can synch your ebooks amongst all your devices (including iPhone/iPad, Android, laptops, etc.) via Dropbox. You get free updates for the life of the edition. And, of course, you can always come back and re-download your books when needed. Ebooks bought from the Amazon Kindle store are subject to Amazon's polices. Limitations in Amazon's file format may cause ebooks to display differently on different devices. For more information, please see our FAQ at pragprog.com/frequently-asked-questions/ebooks. To learn more about this book and access the free resources, go to https://pragprog.com/book/swdddf, the book's homepage.

Thanks for your continued support,

Andy Hunt
The Pragmatic Programmers

The book youre reading is in beta. This means that we update itfrequently. Here is the list of the major changes that have been madeat each beta release of the book, with the most recent change first.

• The book is content-complete and heading to production.

• Added Chapter 13, .

• Addressed errata.

• Added Chapter 3, .

• Addressed errata.

• Added Chapter 11, .

• Addressed errata.

• Initial release

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 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.

You do not 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.

This book is divided into three parts:

• Understanding the domain
• Modeling the domain
• Implementing the model

Each part builds on the previous one, so its best if you read them in order.

In the first part, Understanding the Domain , well look at the ideas behind Domain-Driven Design, and the importance of having a shared understanding of a domain. Well have a brief look at techniques that help to build this shared understanding, such as event storming, and then well look at decomposing a large domain into smaller components that we can implement and evolve independently.

To be clear, this book is not meant to be a thorough exploration of domain-driven design. Thats a large topic, and there are many excellent books and websites that cover it in detail. Instead, the goal of this book is to introduce you to domain-driven design as a partner to functional domain modeling. We will cover the most important concepts of domain-driven design, of course, but rather than diving deeply into the subject, well stay at a high level and stress two things: (a) the importance of communication with domain experts and other non-technical team members, and (b) the value of a shared domain model based on real-world concepts.

In the second part, Modeling the Domain , well take one workflow from the domain and model it in a functional way. Well see how the functional decomposition of a workflow differs from an object-oriented approach, and well learn how to use types to capture requirements. By the end, we will have written concise code that does double duty: first as readable documentation of the domain, but also as a compilable framework that the rest of the implementation can build upon.

In the third part, Implementing the Model , well take that same modeled workflow and implement it. In the process of doing that, well learn how to use common functional programming techniques such as composition, partial application, and the scary sounding monad.