Domain Modeling Made Functional Tackle Software Complexity with Domain Driven Design and F 1st Edition by Scott Wlaschin ISBN 1680502549 9781680502541

Domain Modeling Made Functional Tackle Software Complexity with Domain Driven Design and F 1st Edition by Scott Wlaschin – Ebook PDF Instant Download/Delivery: 1680502549, 9781680502541
Full download Domain Modeling Made Functional Tackle Software Complexity with Domain Driven Design and F 1st Edition after payment

Product details:

ISBN 10: 1680502549 
ISBN 13: 9781680502541
Author: Scott Wlaschin

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

Domain Modeling Made Functional Tackle Software Complexity with Domain Driven Design and F 1st Table of contents:

Part I. Understanding the Domain
1. Introducing Domain-Driven Design
The Importance of a Shared Model
Understanding the Domain Through Business Events
Partitioning the Domain into Subdomains
Creating a Solution Using Bounded Contexts
Creating a Ubiquitous Language
Summarizing the Concepts of Domain-Driven Design
Wrapping Up
2. Understanding the Domain
Interview with a Domain Expert
Fighting the Impulse to Do Database-Driven Design
Fighting the Impulse to Do Class-Driven Design
Documenting the Domain
Diving Deeper into the Order-Taking Workflow
Representing Complexity in Our Domain Model
Wrapping Up
3. A Functional Architecture
Bounded Contexts as Autonomous Software Components
Communicating Between Bounded Contexts
Contracts Between Bounded Contexts
Workflows Within a Bounded Context
Code Structure Within a Bounded Context
Wrapping Up
What’s Next
Part II. Modeling the Domain
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 Collections
Organizing Types in Files and Projects
Wrapping Up
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
6. Integrity and Consistency in the Domain
The Integrity of Simple Values
Units of Measure
Enforcing Invariants with the Type System
Capturing Business Rules in the Type System
Consistency
Wrapping Up
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 from the Steps
Are Dependencies Part of the Design?
The Complete Pipeline
Long-Running Workflows
Wrapping Up
What’s Next
Part III. Implementing the Model
8. Understanding Functions
Functions, Functions, Everywhere
Functions Are Things
Total Functions
Composition
Wrapping Up
9. Implementation: Composing a Pipeline
Working with Simple Types
Using Function Types to Guide the Implementation
Implementing the Validation Step
Implementing the Rest of the Steps
Composing the Pipeline Steps Together
Injecting Dependencies
Testing Dependencies
The Assembled Pipeline
Wrapping Up
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 Expressions
Monads and More
Adding the Async Effect
Wrapping Up
11. Serialization
Persistence vs. Serialization
Designing for Serialization
Connecting the Serialization Code to the Workflow
A Complete Serialization Example
How to Translate Domain Types to DTOs
Wrapping Up
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
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

People also search for Domain Modeling Made Functional Tackle Software Complexity with Domain Driven Design and F 1st:

    
domain modeling made functional
    
domain modeling made functional pdf
    
domain modeling made functional github
    
domain modeling made functional by scott wlaschin
    
domain modeling made functional pdf github

Tags:

Scott Wlaschin,Domain Modeling,Functional Tackle,Software Complexity,Design