book

Node.js Design Patterns - Third Edition

Name: Node.js Design Patterns - Third Edition
ISBN: 9781839214110

by Mario Casciaro, Luciano Mammino

July 2020

Intermediate to advanced

664 pages

15h 24m

English

Packt Publishing

Read now

Unlock full access

Preface
What you need for this bookWho this book is forWhat this book coversTo get the most out of this bookGet in touch
The Node.js Platform
The Node.js philosophySmall coreSmall modulesSmall surface areaSimplicity and pragmatismHow Node.js worksI/O is slowBlocking I/ONon-blocking I/OEvent demultiplexingThe reactor patternLibuv, the I/O engine of Node.jsThe recipe for Node.jsJavaScript in Node.jsRun the latest JavaScript with confidenceThe module systemFull access to operating system servicesRunning native codeSummary
The Module System
The need for modulesModule systems in JavaScript and Node.jsThe module system and its patternsThe revealing module patternCommonJS modulesA homemade module loaderDefining a modulemodule.exports versus exportsThe require function is synchronousThe resolving algorithmThe module cacheCircular dependenciesModule definition patternsNamed exportsExporting a functionExporting a classExporting an instanceModifying other modules or the global scopeESM: ECMAScript modulesUsing ESM in Node.jsNamed exports and importsDefault exports and importsMixed exportsModule identifiersAsync importsModule loading in depthLoading phasesRead-only live bindingsCircular dependency resolutionModifying other modulesESM and CommonJS differences and interoperabilityESM runs in strict modeMissing references in ESMInteroperabilitySummary
Callbacks and Events
The Callback patternThe continuation-passing styleSynchronous CPSAsynchronous CPSNon-CPS callbacksSynchronous or asynchronous?An unpredictable functionUnleashing ZalgoUsing synchronous APIsGuaranteeing asynchronicity with deferred executionNode.js callback conventionsThe callback comes lastAny error always comes firstPropagating errorsUncaught exceptionsThe Observer patternThe EventEmitterCreating and using the EventEmitterPropagating errorsMaking any object observableEventEmitter and memory leaksSynchronous and asynchronous eventsEventEmitter versus callbacksCombining callbacks and eventsSummaryExercises
Asynchronous Control Flow Patterns with Callbacks
The difficulties of asynchronous programmingCreating a simple web spiderCallback hellCallback best practices and control flow patternsCallback disciplineApplying the callback disciplineSequential executionExecuting a known set of tasks in sequenceSequential iterationParallel executionWeb spider version 3The patternFixing race conditions with concurrent tasksLimited parallel executionLimiting concurrencyGlobally limiting concurrencyThe async librarySummaryExercises
Asynchronous Control Flow Patterns with Promises and Async/Await
PromisesWhat is a promise?Promises/A+ and thenablesThe promise APICreating a promisePromisificationSequential execution and iterationParallel executionLimited parallel executionImplementing the TaskQueue class with promisesUpdating the web spiderAsync/awaitAsync functions and the await expressionError handling with async/awaitA unified try...catch experienceThe "return" versus "return await" trapSequential execution and iterationAntipattern – using async/await with Array.forEach for serial executionParallel executionLimited parallel executionThe problem with infinite recursive promise resolution chainsSummaryExercises
Coding with Streams
Discovering the importance of streamsBuffering versus streamingSpatial efficiencyGzipping using a buffered APIGzipping using streamsTime efficiencyComposabilityAdding client-side encryptionAdding server-side decryptionGetting started with streamsAnatomy of streamsReadable streamsReading from a streamImplementing Readable streamsWritable streamsWriting to a streamBackpressureImplementing Writable streamsDuplex streamsTransform streamsImplementing Transform streamsFiltering and aggregating data with Transform streamsPassThrough streamsObservabilityLate pipingLazy streamsConnecting streams using pipesPipes and error handlingBetter error handling with pipeline()Asynchronous control flow patterns with streamsSequential executionUnordered parallel executionImplementing an unordered parallel streamImplementing a URL status monitoring applicationUnordered limited parallel executionOrdered parallel executionPiping patternsCombining streamsImplementing a combined streamForking streamsImplementing a multiple checksum generatorMerging streamsMerging text filesMultiplexing and demultiplexingBuilding a remote loggerMultiplexing and demultiplexing object streamsSummaryExercises
Creational Design Patterns
FactoryDecoupling object creation and implementationA mechanism to enforce encapsulationBuilding a simple code profilerIn the wildBuilderImplementing a URL object builderIn the wildRevealing ConstructorBuilding an immutable bufferIn the wildSingletonWiring modulesSingleton dependenciesDependency InjectionSummaryExercises
Structural Design Patterns
ProxyTechniques for implementing proxiesObject compositionObject augmentationThe built-in Proxy objectA comparison of the different proxying techniquesCreating a logging Writable streamChange observer with ProxyIn the wildDecoratorTechniques for implementing decoratorsCompositionObject augmentationDecorating with the Proxy objectDecorating a LevelUP databaseIntroducing LevelUP and LevelDBImplementing a LevelUP pluginIn the wildThe line between proxy and decoratorAdapterUsing LevelUP through the filesystem APIIn the wildSummaryExercises
Behavioral Design Patterns
StrategyMulti-format configuration objectsIn the wildStateImplementing a basic failsafe socketTemplateA configuration manager templateIn the wildIteratorThe iterator protocolThe iterable protocolIterators and iterables as a native JavaScript interfaceGeneratorsGenerators in theoryA simple generator functionControlling a generator iteratorHow to use generators in place of iteratorsAsync iteratorsAsync generatorsAsync iterators and Node.js streamsIn the wildMiddlewareMiddleware in ExpressMiddleware as a patternCreating a middleware framework for ZeroMQThe Middleware ManagerImplementing the middleware to process messagesUsing the ZeroMQ middleware frameworkIn the wildCommandThe Task patternA more complex commandSummaryExercises

Universal JavaScript for Web Applications
Sharing code with the browserJavaScript modules in a cross-platform contextModule bundlersHow a module bundler worksUsing webpackFundamentals of cross-platform developmentRuntime code branchingChallenges of runtime code branchingBuild-time code branchingModule swappingDesign patterns for cross-platform developmentA brief introduction to ReactHello ReactAlternatives to react.createElementStateful componentsCreating a Universal JavaScript appFrontend-only appServer-side renderingAsynchronous data retrievalUniversal data retrievalTwo-pass renderingAsync pagesImplementing async pagesSummaryExercises
Advanced Recipes
Dealing with asynchronously initialized componentsThe issue with asynchronously initialized componentsLocal initialization checkDelayed startupPre-initialization queuesIn the wildAsynchronous request batching and cachingWhat's asynchronous request batching?Optimal asynchronous request cachingAn API server without caching or batchingBatching and caching with promisesBatching requests in the total sales web serverCaching requests in the total sales web serverNotes about implementing caching mechanismsCanceling asynchronous operationsA basic recipe for creating cancelable functionsWrapping asynchronous invocationsCancelable async functions with generatorsRunning CPU-bound tasksSolving the subset sum problemInterleaving with setImmediateInterleaving the steps of the subset sum algorithmConsiderations on the interleaving approachUsing external processesDelegating the subset sum task to an external processConsiderations for the multi-process approachUsing worker threadsRunning the subset sum task in a worker threadRunning CPU-bound tasks in productionSummaryExercises
Scalability and Architectural Patterns
An introduction to application scalingScaling Node.js applicationsThe three dimensions of scalabilityCloning and load balancingThe 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 NginxDynamic horizontal scalingUsing a service registryImplementing a dynamic load balancer with http-proxy and ConsulPeer-to-peer load balancingImplementing an HTTP client that can balance requests across multiple serversScaling applications using containersWhat is a container?Creating and running a container with DockerWhat is Kubernetes?Deploying and scaling an application on KubernetesDecomposing complex applicationsMonolithic architectureThe microservice architectureAn example of a microservice architectureMicroservices – advantages and disadvantagesIntegration patterns in a microservice architectureThe API proxyAPI orchestrationIntegration with a message brokerSummaryExercises
Messaging and Integration Patterns
Fundamentals of a messaging systemOne way versus request/reply patternsMessage typesCommand MessagesEvent MessagesDocument MessagesAsynchronous messaging, queues, and streamsPeer-to-peer or broker-based messagingPublish/Subscribe patternBuilding a minimalist real-time chat applicationImplementing the server sideImplementing the client sideRunning and scaling the chat applicationUsing Redis as a simple message brokerPeer-to-peer Publish/Subscribe with ZeroMQIntroducing ZeroMQDesigning a peer-to-peer architecture for the chat serverUsing the ZeroMQ PUB/SUB socketsReliable message delivery with queuesIntroducing AMQPDurable subscribers with AMQP and RabbitMQReliable messaging with streamsCharacteristics of a streaming platformStreams versus message queuesImplementing the chat application using Redis StreamsTask distribution patternsThe ZeroMQ Fanout/Fanin patternPUSH/PULL socketsBuilding a distributed hashsum cracker with ZeroMQPipelines and competing consumers in AMQPPoint-to-point communications and competing consumersImplementing the hashsum cracker using AMQPDistributing tasks with Redis StreamsRedis consumer groupsImplementing the hashsum cracker using Redis StreamsRequest/Reply patternsCorrelation IdentifierImplementing a request/reply abstraction using correlation identifiersReturn addressImplementing the Return Address pattern in AMQPSummaryExercises
Other Books You May Enjoy
Index

Content preview from Node.js Design Patterns - Third Edition

5 Asynchronous Control Flow Patterns with Promises and Async/Await

Callbacks are the low-level building blocks of asynchronous programming in Node.js, but they are far from being developer-friendly. In fact, in the last chapter, we learned techniques to implement different control flow constructs using callbacks, and we can say that they are quite complex and verbose compared to the (low) level of complexity of the tasks they try to accomplish. In particular, serial execution flow, which is the predominant control flow structure in most of the code we write, can easily lead an untrained developer to write code affected by the callback hell problem. On top of that, even if properly implemented, a serial execution flow seems needlessly complicated ...

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

The Complete Node.js Developer Course (3rd Edition)

Publisher Resources

ISBN: 9781839214110

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Node.js Design Patterns - Third Edition

by Mario Casciaro, Luciano Mammino

5

Asynchronous Control Flow Patterns with Promises and Async/Await

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.