book

Node.js Design Patterns

Name: Node.js Design Patterns
Author: Mario Casciaro
ISBN: 9781783287314

by Mario Casciaro

December 2014

Intermediate to advanced

454 pages

10h 45m

English

Packt Publishing

Read now

Unlock full access

Node.js Design Patterns
Table of Contents
Node.js Design Patterns
Credits
About the Author
Acknowledgments
About the Reviewers
www.PacktPub.com
Support files, eBooks, discount offers, and moreWhy subscribe?Free access for Packt account holders
Preface
What this book covers
What you need for this book

Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions
1. Node.js Design Fundamentals
The Node.js philosophySmall coreSmall modulesSmall surface areaSimplicity and pragmatism
The reactor pattern
I/O is slowBlocking I/ONon-blocking I/OEvent demultiplexingThe reactor patternThe non-blocking I/O engine of Node.js – libuvThe recipe for Node.js
The callback pattern
The continuation-passing styleSynchronous continuation-passing styleAsynchronous continuation-passing styleNon continuation-passing style callbacksSynchronous or asynchronous?An unpredictable functionUnleashing ZalgoUsing synchronous APIsDeferred executionNode.js callback conventionsCallbacks come lastError comes firstPropagating errorsUncaught exceptions
The module system and its patterns
The revealing module patternNode.js modules explainedA homemade module loaderDefining a moduleDefining globalsmodule.exports vs exportsrequire is synchronousThe resolving algorithmThe module cacheCyclesModule definition patternsNamed exportsExporting a functionExporting a constructorExporting an instanceModifying other modules or the global scope
The observer pattern
The EventEmitterCreate and use an EventEmitterPropagating errorsMake any object observableSynchronous and asynchronous eventsEventEmitter vs CallbacksCombine callbacks and EventEmitter
Summary
2. Asynchronous Control Flow Patterns
The difficulties of asynchronous programmingCreating a simple web spiderThe callback hell
Using plain JavaScript
Callback disciplineApplying the callback disciplineSequential executionExecuting a known set of tasks in sequenceSequential iterationWeb spider version 2Sequential crawling of linksThe patternParallel executionWeb spider version 3The patternFixing race conditions in the presence of concurrent tasksLimited parallel executionLimiting the concurrencyGlobally limiting the concurrencyQueues to the rescueWeb spider version 4
The async library
Sequential executionSequential execution of a known set of tasksSequential iterationParallel executionLimited parallel execution
Promises
What is a promise?Promises/A+ implementationsPromisifying a Node.js style functionSequential executionSequential iterationSequential iteration – the patternParallel executionLimited parallel execution
Generators
The basicsA simple exampleGenerators as iteratorsPassing values back to a generatorAsynchronous control flow with generatorsGenerator-based control flow using coSequential executionParallel executionLimited parallel executionProducer-consumer patternLimiting the download tasks concurrency
Comparison
Summary
3. Coding with Streams
Discovering the importance of streamsBuffering vs StreamingSpatial efficiencyGzipping using a buffered APIGzipping using streamsTime efficiencyComposability
Getting started with streams
Anatomy of streamsReadable streamsReading from a streamThe non-flowing modeThe flowing modeImplementing Readable streamsWritable streamsWriting to a streamBack-pressureImplementing Writable streamsDuplex streamsTransform streamsImplementing Transform streamsConnecting streams using pipesUseful packages for working with streamsreadable-streamthrough and from
Asynchronous control flow with streams
Sequential executionUnordered parallel executionImplementing an unordered parallel streamImplementing a URL status monitoring applicationUnordered limited parallel executionOrdered parallel execution
Piping patterns
Combining streamsImplementing a combined streamForking streamsImplementing a multiple checksum generatorMerging streamsCreating a tarball from multiple directoriesMultiplexing and demultiplexingBuilding a remote loggerClient side – MultiplexingServer side – demultiplexingRunning the mux/demux applicationMultiplexing and demultiplexing object streams
Summary
4. Design Patterns
FactoryA generic interface for creating objectsA mechanism to enforce encapsulationBuilding a simple code profilerIn the wild
Proxy
Techniques for implementing proxiesObject compositionObject augmentationA comparison of the different techniquesCreating a logging Writable streamProxy in the ecosystem – function hooks and AOPIn the wild
Decorator
Techniques for implementing decoratorsCompositionObject augmentationDecorating a LevelUP databaseIntroducing LevelUP and LevelDBImplementing a LevelUP pluginIn the wild
Adapter
Using LevelUP through the filesystem APIIn the wild
Strategy
Multi-format configuration objectsIn the wild
State
Implementing a basic fail-safe socket
Template
A configuration manager templateIn the wild
Middleware
Middleware in ExpressMiddleware as a patternCreating a middleware framework for ØMQThe Middleware ManagerA middleware to support JSON messagesUsing the ØMQ middleware frameworkThe serverThe client
Command
A flexible patternThe task patternA more complex command
Summary
5. Wiring Modules
Modules and dependenciesThe most common dependency in Node.jsCohesion and CouplingStateful modulesThe Singleton pattern in Node.js
Patterns for wiring modules
Hardcoded dependencyBuilding an authentication server using hardcoded dependenciesThe db moduleThe authService moduleThe authController moduleThe app moduleRunning the authentication serverPros and cons of hardcoded dependenciesDependency injectionRefactoring the authentication server to use dependency injectionThe different types of dependency injectionPros and cons of dependency injectionService locatorRefactoring the authentication server to use a service locatorPros and cons of a service locatorDependency injection containerDeclaring a set of dependencies to a DI containerRefactoring the authentication server to use a DI containerPros and cons of a Dependency Injection container
Wiring plugins
Plugins as packagesExtension pointsPlugin-controlled vs Application-controlled extensionImplementing a logout pluginUsing hardcoded dependenciesExposing services using a service locatorExposing services using dependency injectionExposing services using a dependency injection container
Summary
6. Recipes
Requiring asynchronously initialized modulesCanonical solutionsPreinitialization queuesImplementing a module that initializes asynchronouslyWrapping the module with preinitialization queuesIn the wild
Asynchronous batching and caching
Implementing a server with no caching or batchingAsynchronous request batchingBatching requests in the total sales web serverAsynchronous request cachingCaching requests in the total sales web serverNotes about implementing caching mechanismsBatching and caching with Promises
Running CPU-bound tasks
Solving the subset sum problemInterleaving with setImmediateInterleaving the steps of the subset sum algorithmConsiderations on the interleaving patternUsing multiple processesDelegating the subset sum task to other processesImplementing a process poolCommunicating with a child processCommunicating with the parent processConsiderations on the multiprocess pattern
Sharing code with the browser
Sharing modulesUniversal Module DefinitionCreating an UMD moduleConsiderations on the UMD patternIntroducing BrowserifyExploring the magic of BrowserifyThe advantages of using BrowserifyFundamentals of cross-platform developmentRuntime code branchingBuild-time code branchingDesign patterns for cross-platform developmentSharing business logic and data validation using Backbone ModelsImplementing the shared modelsImplementing the platform-specific codeUsing the isomorphic modelsRunning the application
Summary
7. Scalability and Architectural Patterns
An introduction to application scalingScaling Node.js applicationsThe three dimensions of scalability
Cloning and load balancing
The cluster moduleNotes on the behavior of the cluster moduleBuilding a simple HTTP serverScaling with the cluster moduleResiliency and availability with the cluster moduleZero-downtime restartDealing with stateful communicationsSharing the state across multiple instancesSticky load balancingScaling with a reverse proxyLoad balancing with NginxUsing a Service RegistryImplementing a dynamic load balancer with http-proxy and seaportPeer-to-peer load balancingImplementing an HTTP client that can balance requests across multiple servers
Decomposing complex applications
Monolithic architectureThe Microservice architectureAn example of the Microservice architecturePros and cons of microservicesEvery service is expendableReusability across platforms and languagesA way to scale the applicationThe challenges of microservicesIntegration patterns in a Microservice architectureThe API proxyAPI orchestrationIntegration with a message broker
Summary
8. Messaging and Integration Patterns
Fundamentals of a messaging systemOne-way and request/reply patternsMessage typesAsynchronous messaging and queuesPeer-to-peer or broker-based messaging
Publish/subscribe pattern
Building a minimalist real-time chat applicationImplementing the server sideImplementing the client sideRunning and scaling the chat applicationUsing Redis as a message brokerPeer-to-peer publish/subscribe with ØMQIntroducing ØMQDesigning a peer-to-peer architecture for the chat serverUsing the ØMQ PUB/SUB socketsDurable subscribersIntroducing AMQPDurable subscribers with AMQP and RabbitMQDesigning a history service for the chat applicationImplementing a reliable history service using AMQPIntegrating the chat application with AMQP
Pipelines and task distribution patterns
The ØMQ fan-out/fan-in patternPUSH/PULL socketsBuilding a distributed hashsum cracker with ØMQImplementing the ventilatorImplementing the workerImplementing the sinkRunning the applicationPipelines and competing consumers in AMQPPoint-to-point communications and competing consumersImplementing the hashsum cracker using AMQPImplementing the producerImplementing the workerImplementing the result collectorRunning the application
Request/reply patterns
Correlation identifierImplementing a request/reply abstraction using correlation identifiersAbstracting the requestAbstracting the replyTrying the full request/reply cycleReturn addressImplementing the return address pattern in AMQPImplementing the request abstractionImplementing the reply abstractionImplementing the requestor and the replier
Summary
Index

Content preview from Node.js Design Patterns

Chapter 8. Messaging and Integration Patterns

If scalability is about splitting, systems integration is about rejoining. In the previous chapter, we learned how to distribute an application, fragmenting it across several machines. In order for it to work properly, all those pieces have to communicate in some way, and hence, they have to be integrated.

There are two main techniques to integrate a distributed application: one is to use a shared store as a central coordinator and keeper of all the information, the other one is to use messages to disseminate data, events, and commands across the nodes of the system. This last option is what really makes the difference when scaling distributed systems, and it's also what makes this topic so fascinating ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781783287314

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Node.js Design Patterns

by Mario Casciaro

Chapter 8. Messaging and Integration Patterns

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.