
Domain Modeling Made Functional
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
You want increased IPSer 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 requirements both elegantly and concisely - often more so than an object-oriented approach. Practical examples in the open-source F# functional language, and examples from familiar business domains, show you how to apply these techniques to build software that is business-focused, flexible, and high quality.
Domain-driven design is a well-established approach to designing software that ensures that domain experts and developers work together effectively to create high-quality software. This book is the first to combine DDD with techniques from statically typed functional programming. This book is perfect for newcomers to DDD or functional programming - all the techniques you need will be introduced and explained.
Model a complex domain accurately using the F# type system, creating compilable code that is also readable documentation---ensuring that the code and design never get out of sync. Encode business rules in the design so that you have "compile-time unit tests," and eliminate many potential bugs by making illegal states unrepresentable. Assemble a series of small, testable functions into a complete use case, and compose these individual scenarios into a large-scale design. Discover why the combination of functional programming and DDD leads naturally to service-oriented and hexagonal architectures. Finally, create a functional domain model that works with traditional databases, NoSQL, and event stores, and safely expose your domain via a website or API.
Solve real problems by focusing on real-world requirements for your software.
What You Need:
The code in this book is designed to be run interactively on Windows, Mac and Linux.You will need a recent version of F# (4.0 or greater), and the appropriate .NET runtime for your platform.Full installation instructions for all platforms at fsharp.org.
More details
Other editions
Additional editions

Person
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.
Content
- Intro
- Domain Modeling Made Functional
- About the Pragmatic Bookshelf
- Table of Contents
- Early praise for Domain Modeling Mad e Functional
- Preface
- Who Is This Book For?
- What's in This Book?
- Other Approaches to Domain Modeling
- Working with the Code in This Book
- Questions or Suggestions?
- Credits
- Acknowledgments
- Pa rt 1 Understanding the Domain
- Chapter 1: Introducing Domain-Driven Design
- The Importance of a Shared Model
- Understanding the Domain Through Business Event s
- Partitioning the Domain into Subdomains
- Creating a Solution Using Bounded Con texts
- Creating a Ubiquitous Language
- Summarizing the Concepts of Domain-Driven Desi gn
- Wrapping Up
- Chapter 2: Understanding the Domain
- Interview with a Domain Expert
- Fighting the Impulse to Do Database-Driven Des ign
- Fighting the Impulse to Do Class-Driven Design
- Documenting the Domain
- Diving Deeper into the Order-Taking Wo rkflow
- Representing Complexity in Our Domain Model
- Wrapping Up
- Chapter 3: A Functional Architecture
- Bounded Contexts as Autonomous Software Compon ents
- Communicating Between Bounded Contexts
- Contracts Between B ounded Contexts
- Workflows Within a Bounded Context
- Code Structure Within a Bounded Context
- Wrapping Up
- What's Next
- Part 2: Modeling the Domain
- Chapter 4: Understanding Types
- Understanding Functions
- Types and Functions
- Composition of Types
- Working with F# Types
- Building a Domain Model by Composing Types
- Modeling Optional Values, Errors, and Collecti ons
- Organizing Types in Files an d Projects
- Wrapping Up
- Chapter 5: Domain Modeling with Types
- Reviewing the Domain Model
- Seeing Patterns in a Domain Model
- Modeling Simple Values
- Modeling Complex Data
- Modeling Workflows with Functions
- A Question of Identity: Value Objects
- A Question of Identity: Entities
- Aggregates
- Putting It All Together
- Wrapping Up
- Chapter 6: Integrity and Consistency in the Domain
- The Integrity of Simple V alues
- Units of Measure
- Enforcing Invariants with the Type System
- Capturing Business Rules in the Type System
- Consistency
- Wrapping Up
- Chapter 7: Modeling Workflows as Pipelines
- The Workflow Input
- Modeling an Order as a Set of States
- State Machines
- Modeling Each Step in the Workflow with Types
- Documenting Effects
- Composing the Workflow fro m the Steps
- Are Dependencies Part of the Design?
- The Complete Pipeline
- Long-Running Workflows
- Wrapping Up
- What's Next
- Part 3: Implementing the Model
- Chapter 8: Understanding Functions
- Functions, Functions, Everywhere
- Functions Are Things
- Total Functions
- Composition
- Wrapping Up
- Chapter 9: Implementation: Composing a Pipeline
- Working with Simple Types
- Using Function Types to Guide the Implementat ion
- Implementing the Validatio n Step
- Implementing the Rest of the Steps
- Composing the Pipeline Steps Together
- Injecting Dependencies
- Testing Dependencies
- The Assembled Pipeline
- Wrapping Up
- Chapter 10: Implementation: Working with Errors
- Using the Result Type to Make Errors Explicit
- Working with Domain Errors
- Chaining Result-Generating Functions
- Using bind and map in Our Pipeline
- Adapting Other Kinds of Functions to the Two- Track Model
- Making Life Easier with Computation Expressio ns
- Monads and More
- Adding the Async Effect
- Wrapping Up
- Chapter 11: Serialization
- Persistence vs. Serialization
- Designing for Serialization
- Connecting the Serialization Code to the Work flow
- A Complete Serialization Example
- How to Translate Domain Types to DTOs
- Wrapping Up
- Chapter 12: Persistence
- Pushing Persistence to the Edges
- Command-Query Separation
- Bounded Contexts Must Own Their Data Storage
- Working with Document Databases
- Working with Relational Databases
- Transactions
- Wrapping Up
- Chapter 13: Evolving a Design and Keeping It Clean
- Change 1: Adding Shipping Charges
- Change 2: Adding Support for VIP Customers
- Change 3: Adding Support for Promotion Codes
- Change 4: Adding a Business Hours Constraint
- Dealing with Additional Requirements Changes
- Wrapping Up
- Wrapping Up the Book
- You May Be Interested In.
System requirements
File format: ePUB
Copy protection: Adobe-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Install the free reader Adobe Digital Editions prior to download (see eBook Help).
- Tablet/smartphone (Android; iOS): Install the free app Adobe Digital Editions or the app PocketBook before downloading (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (not Kindle).
The file format ePub works well for novels and non-fiction books – i.e., „flowing” text without complex layout. On an e-reader or smartphone, line and page breaks automatically adjust to fit the small displays.
This eBook uses Adobe-DRM, a „hard” copy protection. If the necessary requirements are not met, unfortunately you will not be able to open the eBook. You will therefore need to prepare your reading hardware before downloading.
Please note: We strongly recommend that you authorise using your personal Adobe ID after installation of any reading software.
For more information, see our ebook Help page.