JavaScript Domain-Driven Design : Speed up Your Application Development by Leveraging the Patterns of Domain-Driven Design.

Cover -- Copyright -- Credits -- About the Author -- About the Reviewers -- www.PacktPub.com -- Table of Contents -- Preface -- Chapter 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 -- Chapter 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 -- Chapter 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 -- Chapter 4: Modelling 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 compositionomposition -- Polymorphism without inheritance -- Applying object design to the domain -- Building a system on simple objects -- Summary -- Chapter 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 -- Chapter 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 -- Chapter 7: It Is 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 -- Chapter 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.

Description based on publisher supplied metadata and other sources.

Electronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2024. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.