book

Node.js Design Patterns - Second Edition

Name: Node.js Design Patterns - Second Edition
ISBN: 9781785885587

by Mario Casciaro, Luciano Mammino

July 2016

Intermediate to advanced

526 pages

11h 42m

English

Packt Publishing

Read now

Unlock full access

Node.js Design Patterns - Second Edition
Node.js Design Patterns - Second Edition
Credits
About the Authors
Acknowledgments
About the Author
Acknowledgments
About the Reviewers
www.PacktPub.com
eBooks, discount offers, and moreWhy subscribe?
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. Welcome to the Node.js Platform
The Node.js philosophySmall coreSmall modulesSmall surface areaSimplicity and pragmatism
Introduction to Node.js 6 and ES2015
The let and const keywordsThe arrow functionClass syntaxEnhanced object literalsMap and Set collectionsWeakMap and WeakSet collectionsTemplate literalsOther ES2015 features
The reactor pattern
I/O is slowBlocking I/ONon-blocking I/OEvent demultiplexingIntroducing the reactor patternThe non-blocking I/O engine of Node.js-libuvThe recipe for Node.js
Summary
2. Node.js Essential Patterns
The callback patternThe 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 versus exportsThe require function is synchronousThe resolving algorithmThe module cacheCircular dependenciesModule definition patternsNamed exportsExporting a functionExporting a constructorExporting an instanceModifying other modules or the global scope
The observer pattern
The EventEmitter classCreating and using EventEmitterPropagating errorsMaking any object observableSynchronous and asynchronous eventsEventEmitter versus callbacksCombining callbacks and EventEmitter
Summary
3. Asynchronous Control Flow Patterns with Callbacks
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 with 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
Summary
4. Asynchronous Control Flow Patterns with ES2015 and Beyond
PromiseWhat is a promise?Promises/A+ implementationsPromisifying a Node.js style functionSequential executionSequential iterationSequential iteration – the patternParallel executionLimited parallel executionExposing callbacks and promises in public APIs
Generators
The basics of generatorsA 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
Async await using Babel
Installing and running Babel
Comparison
Summary
5. Coding with Streams
Discovering the importance of streamsBuffering versus streamingSpatial efficiencyGzipping using a buffered APIGzipping using streamsTime efficiencyComposability
Getting started with streams
Anatomy of streamsReadable streamsReading from a streamThe non-flowing modeFlowing modeImplementing Readable streamsWritable streamsWriting to a streamBack-pressureImplementing Writable streamsDuplex streamsTransform streamsImplementing Transform streamsConnecting streams using pipesThrough and from for working with streams
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
6. Design Patterns
FactoryA generic interface for creating objectsA mechanism to enforce encapsulationBuilding a simple code profilerComposable factory functionsIn the wild
Revealing constructor
A read-only event emitterIn the wild
Proxy
Techniques for implementing proxiesObject compositionObject augmentationA comparison of the different techniquesCreating a logging Writable streamProxy in the ecosystem – function hooks and AOPES2015 ProxyIn 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 clientMiddleware using generators in Koa
Command
A flexible patternThe task patternA more complex command
Summary
7. 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 DIThe different types of DIPros and cons of DIService 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 DI container
Wiring plugins
Plugins as packagesExtension pointsPlugin-controlled vs application-controlled extensionImplementing a logout pluginUsing hardcoded dependenciesExposing services using a service locatorExposing services using DIExposing services using a DI container
Summary
8. Universal JavaScript for Web Applications
Sharing code with the browserSharing modulesUniversal Module DefinitionCreating an UMD moduleConsiderations on the UMD patternES2015 modules
Introducing Webpack
Exploring the magic of WebpackThe advantages of using WebpackUsing ES2015 with Webpack
Fundamentals of cross-platform development
Runtime code branchingBuild-time code branchingModule swappingDesign patterns for cross-platform development
Introducing React
First React componentJSX, what?!Configuring Webpack to transpile JSXRendering in the browserThe React Router library
Creating a Universal JavaScript app
Creating reusable componentsServer-side renderingUniversal rendering and routingUniversal data retrievalThe API serverProxying requests for the frontendUniversal API clientAsynchronous React componentsThe web server
Summary
9. Advanced Asynchronous 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
Summary
10. 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 ConsulPeer-to-peer load balancingImplementing an HTTP client that can balance requests across multiple servers
Decomposing complex applications
Monolithic architectureThe microservice architectureAn example of 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
11. Messaging and Integration Patterns
Fundamentals of a messaging systemOne-way and request/reply patternsMessage typesCommand MessageEvent MessageDocument MessageAsynchronous 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 fanout/fanin 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

Content preview from Node.js Design Patterns - Second Edition

Comparison

At this point, we should have a better understanding of the options we have to tame the asynchronous nature of JavaScript. Each one of the solutions presented has its own pros and cons. Let's summarize them in the following table:

Solutions

Pros

Cons

Plain JavaScript

Does not require any additional libraries or technology
Offers the best performance
Provides the best level of compatibility with third-party libraries
Allows the creation of ad hoc and more advanced algorithms

Might require extra code and relatively complex algorithms

Async (library)

Simplifies the most common control flow patterns
Is still a callback-based solution
Good performance

Introduces an external dependency
Might still not be enough for advanced ...

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: 9781785885587

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Node.js Design Patterns - Second Edition

by Mario Casciaro, Luciano Mammino

Comparison

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.