JavaScript Domain-Driven Design电子书

JavaScript Domain-Driven Design

Table of Contents

JavaScript Domain-Driven Design

Credits

About the Author

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Instant updates on new Packt books

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. A Typical JavaScript Project

The core idea of domain-driven design

Managing an orc dungeon

Inside the dungeon

Managing incoming prisoners

The current state of the art

Digital dungeon management

Specification

Tracking available cells

Starting outgoing transfers

Tracking the state of incoming transfers

Initiating incoming transfers

From greenfield to application

The first route and model

Creating the model

The first route and loading the dungeon

Displaying the page

Gluing the application together via express

Moving the application forward

Another look at the problem

Thinking in an MVC web application

Understanding the core problem

Communication is key

The concepts of domain-driven design

It is all about distractions

Focus on the problem at hand

Further reading

Summary

2. Finding the Core Problem

Exploring a problem

Outlining the problem

Tracking knowledge

The medium

Paper programming

So how does such a paper program work?

Not so scary UML

Involving the experts

Finding the gaps

Talking business

Talking about the actors

Identifying the hard problem

Mapping the dependencies

Drawing with code – spiking

Getting started, it's about time

Creating value without creating code

Deciding on the first feature

Summary

3. Setting Up a Project for Domain-driven Design

Structuring a project as we see it

Approachability

Locality of edits

Fitness

Dealing with shared functionality

A shared toolbox

Moving up the dependencies

Testing

Setting up a test environment

Different types of tests and goals

Feature specs

Unit tests

Performance tests

Continuous integration

Managing the build

Why every application needs a build system

Running the tests

Packaging the application

Deploying

Choosing the right system

Isolating the domain

The architecture of modern applications

Hexagonal architecture

Applying the pattern

Plugging in a framework

Summary

4. Modeling the Actors

The shoulders of giants

The Different approaches to development

Introducing mocks

Why and why not to mock

Who is involved in the prisoner transfer?

Different objects and their roles

Naming objects according to the domain

The traps of common names like *Manager

Readability of method names

Objects first

The basics of objects in JavaScript

Inheritance and why you won't need it

Modeling patterns beyond inheritance

The object composition

Polymorphism without inheritance

Applying object design to the domain

Building a system on simple objects

Summary

5. Classification and Implementation

Building a common language

The importance of object classification

Seeing the bigger picture

Value objects

The advantages of value objects

The referential transparency

Objects defined as entities

More on entities

Managing the application's lifecycle

Aggregations

Grouping and interfaces

Services

Associations

Insight during implementation

Recognizing domain patterns

Not everything is an entity

Refactoring all the time towards malleable code

Implementing language guidance

Working with and on the business language

Building context

Separation and shared knowledge

Summary

6. Context Map – The Big Picture

Don't fear the monolith

Service-oriented architecture and microservices

Keeping it all in your head

Recognizing the contexts

Testing in contexts

Integration across boundaries

TDD and testing in production

The different ways to manage contexts

Drawing a context map

The monolithic architecture

A shared kernel

The APIs

The customer and the supplier

Developing a client

The conformist

The anticorruption layer

Isolating the methodologies

Separate ways

Unrelated applications

An open protocol

Sharing knowledge

The publishing language

Creating the documentation

Updating the documentation

Tests are not the only documentation

Summary

7. It's Not All Domain-driven Design

Matching the domain to the problem

Growing into a domain

A good domain for domain-driven design

The power of object-orientation

The object-oriented principles so far

The object-oriented modeling of business domains

The scenarios of pure object-orientation falling short

Influences to keep close

Aspect-oriented programming

Command-query separation

Plain old objects

Domain-specific languages

Creating DSLs

DSLs in domain-driven design

Drawing knowledge

Functional programming

Functional programming and JavaScript

Value objects

Events

Event stores versus entity relational mapping

Further reading

Summary

8. Seeing It All Come Together

The different kinds of JavaScript project

Enhancing the user experience

Single-page applications

Different frameworks and their implications

Rendering on the client side

Using JavaScript server side

The advantages of a controlled environment

Advanced modularization

The different kinds of complexity

Algorithmic complexity

Logical complexity

The business rules

The domains suitable for domain-driven design

Banking applications

Travel applications

The domain prerequisites

Further reading

Summary

Index