Node.js Web Development - Third Edition

Table of Contents

Node.js Web Development Third Edition

Credits

About the Author

About the Reviewer

www.PacktPub.com

eBooks, discount offers, and more

Why 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 code

Errata

Piracy

Questions

1. About Node.js

The capabilities of Node.js

Server-side JavaScript

Why should you use Node.js?

Popularity

JavaScript at all levels of the stack

Leveraging Google's investment in V8

Leaner asynchronous event-driven model

Microservice architecture

The Node.js is stronger for having survived a major schism and hostile fork

Performance and utilization

Is Node.js a cancerous scalability disaster?

Server utilization, the bottom line, and green web hosting

Node.js, the microservice architecture, and easily testable systems

Node.js and the Twelve-Factor app model

Summary

2. Setting up Node.js

System requirements

Installing Node.js using package managers

Installing on Mac OS X with MacPorts

Installing on Mac OS X with Homebrew

Installing on Linux, *BSD, or Windows from package management systems

Installing the Node.js distribution from nodejs.org

Installing from source on POSIX-like systems

Installing prerequisites

Native code modules and node-gyp

Installing developer tools on Mac OS X

Installing from source for all POSIX-like systems

Installing development instances with nvm

Node.js versions policy and what to use

Running and testing commands

Node.js's command-line tools

Running a simple script with Node.js

Launching a server with Node.js

NPM – the Node.js package manager

Node.js and ECMAScript 6 (ES-2015, ES-2016, and so on)

Using Babel to use experimental JavaScript features

Summary

3. Node.js Modules

Defining a module

Node.js module format

File modules

Demonstrating module-level encapsulation

Directories as modules

Node.js's algorithm for require (module)

Module identifiers and path names

An example application directory structure

npm – the Node.js package management system

The npm package format

Finding npm packages

Other npm commands

Installing an npm package

Initializing a new npm package

Maintaining package dependencies with npm

Fixing bugs by updating package dependencies

Declaring Node.js version compatibility

Updating outdated packages you've installed

Installing packages from outside the npm repository

Publishing an npm package

Package version numbers

A quick note about CommonJS

Summary

4. HTTP Servers and Clients – A Web Application's First Steps

Sending and receiving events with EventEmitters

The EventEmitter theory

HTTP server applications

ES-2015 multiline and template strings

HTTP Sniffer – listening to the HTTP conversation

Web application frameworks

Getting started with Express

Walking through the default Express application

The Express middleware

Middleware and request paths

Error handling

Calculating the Fibonacci sequence with an Express application

Computationally intensive code and the Node.js event loop

Algorithmic refactoring

Making HTTP Client requests

Calling a REST backend service from an Express application

Implementing a simple REST server with Express

Refactoring the Fibonacci application for REST

Some RESTful modules and frameworks

Summary

5. Your First Express Application

ES-2015 Promises and Express router functions

Promises and error handling

Flattening our asynchronous code

Additional tools

Express and the MVC paradigm

Creating the Notes application

Your first Notes model

The Notes home page

Adding a new note – create

Viewing notes – read

Editing an existing note – update

Deleting notes – destroy

Theming your Express application

Scaling up – running multiple Notes instances

Summary

6. Implementing the Mobile-First Paradigm

Problem – the Notes app isn't mobile friendly

Mobile-first paradigm

Using Twitter Bootstrap on the Notes application

Setting it up

Adding Bootstrap to application templates

Mobile-first design for the Notes application

Laying the Bootstrap grid foundation

Improving the notes list on the front page

Breadcrumbs for the page header

Cleaning up the add/edit note form

Building a customized Bootstrap

Bootstrap customizers

Summary

7. Data Storage and Retrieval

Data storage and asynchronous code

Logging

Request logging with Morgan

Debugging messages

Capturing stdout and stderr

Uncaught exceptions

Storing notes in the filesystem

Storing notes with the LevelUP data store

Storing notes in SQL with SQLite3

SQLite3 database scheme

SQLite3 model code

Running Notes with SQLite3

Storing notes the ORM way with Sequelize

Sequelize model for the Notes application

Configuring a Sequelize database connection

Running the Notes application with Sequelize

Storing notes in MongoDB

MongoDB model for the Notes application

Running the Notes application with MongoDB

Summary

8. Multiuser Authentication the Microservice Way

Creating a user information microservice

User information model

A REST server for user information

Scripts to test and administer the User Authentication server

Login support for the Notes application

Accessing the user authentication REST API

Login and logout routing functions

Login/logout changes to app.js

Login/logout changes in routes/index.js

Login/logout changes required in routes/notes.js

View template changes supporting login/logout

Running the Notes application with user authentication

Twitter login support for the Notes application

Registering an application with Twitter

Implementing TwitterStrategy

The Notes application stack

Summary

9. Dynamic Interaction between Client and Server with Socket.IO

Introducing Socket.IO

Initializing Socket.IO with Express

Real time updates on the Notes home page

The Notes model as an EventEmitter class

Real-time changes in the Notes home page

Changing the home page template

Running Notes with real-time home page updates

Real-time action while viewing notes

Changing the note view template for real-time action

Running Notes with real-time updates while viewing a note

Inter-user chat and commenting for Notes

Data model for storing messages

Adding messages to the Notes router

Changing the note view template for messages

Using a Modal window to compose messages

Sending, displaying, and deleting messages

Running Notes and passing messages

Other applications of Modal windows

Summary

10. Deploying Node.js Applications

Notes application architecture

Traditional Linux Node.js service deployment

Prerequisite – provisioning the databases

Installing Node.js on Ubuntu

Setting up Notes and User Authentication on the server

Setting up PM2 to manage Node.js processes

Twitter support for the hosted Notes app

Node.js microservice deployment with Docker

Installing Docker on your laptop

Starting Docker using Docker Toolbox and Docker Machine

Starting Docker with Docker for Windows/Mac

Kicking the tires of Docker

Creating the AuthNet for the User Authentication service

MySQL for the Authentication service

Dockerizing the Authentication service

Putting Authnet together

Creating FrontNet for the Notes application

MySQL for the Notes application

Dockerizing the Notes application

Putting FrontNet together

Configuring remote access on Docker for Windows or Mac

Configuring remote access in VirtualBox on Docker toolbox

Exploring the Docker Toolbox VirtualBoxMachine

Controlling the location of MySQL data volumes

Deploying to the cloud with Docker compose

Docker compose files

Running the Notes application with Docker Compose

Deploying to cloud hosting with Docker Compose

Summary

11. Unit Testing

Testing asynchronous code

Assert – the simplest testing methodology

Testing a model

Mocha and Chai­ the chosen test tools

Notes model test suite

Configuring and running tests

More tests for the Notes model

Testing database models

Using Docker to manage test database servers

Docker Compose to orchestrate test infrastructure

Package.json scripts for Dockerized test infrastructure

Executing tests under Docker Compose

Testing REST backend services

Frontend headless browser testing with CasperJS

Setup

Improving testability in Notes UI

CasperJS test script for Notes

Running the UI test with CasperJS

Summary

Index

Node.js Web Development Third Edition

Node.js Web Development Third Edition

Copyright © 2016 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

First published: August 2011

Second published: July 2013

Third edition: June 2016

Production reference: 1220616

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham B3 2PB, UK.

ISBN 978-1-78588-150-3

www.packtpub.com

Credits

Author

David Herron

Reviewer

Nicholas Duffy

Commissioning Editor

Amarabha Banerjee

Acquisition Editor

Larissa Pinto

Content Development Editor

Samantha Gonsalves

Technical Editor

Vivek Pala

Copy Editor

Pranjali Chury

Project Coordinator

Sanchita Mandal

Proofreader

Safis Editing

Indexer

Mariammal Chettiyar

Graphics

Disha Haria

Production Coordinator

Manu Joseph

Cover Work

Manu Joseph

About the Author

David Herron has worked as a software engineer in Silicon Valley for over 20 years. This includes companies both tiny and large. He has worked on a wide variety of projects, from an X.400 e-mail server and client application to assisting with the launch of the OpenJDK project (open source Java rocks), to Yahoo's Node.js application-hosting platform (Mojito and Manhattan), and applications to monitor solar power array performance.

While a staff engineer at Sun Microsystems, David worked as the architect of the Java SE Quality Engineering team where he focused on test automation tools, including co-developing the AWT Robot class. He was involved in open source activities related to Java, including the OpenJDK project.

Before Sun, he worked for VXtreme on software which eventually became Windows Media Player when Microsoft bought the company. At Mainsoft, David worked on a library that allowed developers to recompile Windows applications on Unix, and then participated in porting Internet Explorer to Unix. At The Wollongong Group, he worked on both e-mail client and server software and was part of several IETF working groups improving e-mail-related protocols.

David is interested in electric vehicles, world energy supplies, climate change, and environmental issues, and he is a co-founder of Transition Silicon Valley. As an online journalist, he writes about electric cars and other green technology on LongTailPipe.com after having written for PlugInCars.com. He runs a large electric vehicle discussion website on VisForVoltage.org, and he blogs about other topics, including Node.js, Drupal, and Doctor Who on DavidHerron.com. Using Node.js, he developed a Content Management System that produces static HTML websites or EPUB3 eBooks, AkashaCMS (akashacms.com).

There are many people I am grateful to.

I wish to thank my mother, Evelyn, for, well everything; my father, Jim; my sister, Patti; and my brother, Ken. What would life be without all of you?

I wish to thank my girlfriend, Maggie, for being there and encouraging me, her belief in me, her wisdom, and humor. May we have many more years of this.

I wish to thank Dr. Ken Kubota of the University of Kentucky for believing in me and giving me my first job in computing. It was six years of learning not just the art of computer system maintenance, but so much more.

I wish to thank my former employers, University of Kentucky Mathematical Sciences Department, The Wollongong Group, MainSoft, VXtreme, Sun Microsystems, Yahoo!, Recargo, Laplace Systems, and all the people I worked with in each company.

I am grateful to Ryan Dahl, the creator of Node.js, and the current Node.js core team members. They have the rare combination of wisdom and vision needed to create such a joy-filled fluid software development platform. Some platforms are just plain hard to work with, but not this one.

About the Reviewer

Nicholas Duffy has had a wide-ranging career, holding positions from analyst to business intelligence architect, to software engineer, and even golf professional. He has a passion for all things data and software engineering, specializing in data warehouse architecture, Python, and Node.js. He is a frequent contributor to open source projects and is, unfortunately, also a lifelong New York Mets fan.

You can read more about Nicholas' interests on this blog at https://medium.com/@duffn or contact him via GitHub at @duffn.

I'd like to thank my wife, Anne, and boys, Jack and Chuck, for their never ending support in whatever endeavor.

www.PacktPub.com

eBooks, discount offers, and more

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.

https://www2.packtpub.com/books/subscription/packtlib

Do you need instant solutions to your IT questions? PacktLib is Packt's online digital book library. Here, you can search, access, and read Packt's entire library of books.

Why subscribe?

Fully searchable across every book published by Packt

Copy and paste, print, and bookmark content

On demand and accessible via a web browser

Preface

Welcome to the world of software development on the Node.js platform. This is an up-and-coming software platform that liberates JavaScript from the web browser, allowing us to reuse our JavaScript skills for general software development on a large range of systems. It runs atop the ultra-fast JavaScript engine at the heart of Google's Chrome browser, V8, and adds a fast and robust library of asynchronous network I/O modules. The Node.js community have developed a dizzyingly large body of third-party modules for nearly every conceivable purpose. While the primary focus of Node.js is high performance highly-scalable web applications, it is seeing widespread use in Internet of Things (IoT) applications, microservice development, asset build workflow for frontend engineers, and even in desktop applications like the Atom editor.

Microservices are one of the brightest ideas in computing today, and Node.js is right there as one of the best platforms for microservice development. This is doubly true when combined with Docker.

In just a few years, Node.js has gone from being a brand new will anyone adopt it technology to a major force in software development. It is now widely used in companies big and small, and the MEAN Stack (MongoDB, Express, AngularJS, and Node.js) has become a leading application model.

The Node.js platform was developed by Ryan Dahl in 2009 after a couple years of experimenting with web server component development in Ruby and other languages. His goal was to create an event-oriented system with a low-overhead architecture. This led Dahl toward an asynchronous single-thread system, as opposed to a more traditional thread-based architecture.

This model was chosen for simplicity, under the theory that threaded systems are notoriously difficult to develop and debug for lower overhead and for speed. Node.js's goal is to provide an easy way to build scalable network servers. The design is similar to, and influenced by, other systems, such as Event Machine (Ruby) and the Twisted framework (Python).

JavaScript was chosen as the language because anonymous functions and other language elements provide an excellent base to implement asynchronous computation. Event handler functions are often coded in-line as anonymous functions. The Node.js runtime is ingeniously designed to support asynchronous I/O operations.

Now that ECMA Script 2016 is on the scene, new features, such as arrow functions and Promises, are coming to JavaScript engines, including Node.js. These powerful new capabilities will change JavaScript programming for the better. We now have a path toward taming some of the difficulties with asynchronous coding. The Promise object gives us a way to organize asynchronously-executed procedures in a semi-linear sequence, rather than the pyramid-shaped structures of callback functions.

The result is a platform that allows developers to not only succinctly write code of great power but to have a lot of fun while doing so.

Having JavaScript on both the server and the client (browser) lets us implement a vision dating back to the earliest days of the World Wide Web. Java's proponents first showed us dynamic stuff, powered by Java, running inside a web page. With Java on both client and server side, developers were supposed to reach nirvana. Java did not achieve success promoted by Sun Microsystems. Instead, it is JavaScript that is quickly advancing to implement that vision in a big way.

With Node.js, we have JavaScript on both the client and the server. While this probably won't help developers reach nirvana, our work is made much easier. We can use common code, common data structures, and more team members speak the same code language.

This book, Node.js Web Development, Third Edition, focuses on building web applications using Node.js. We assume that you have some knowledge of JavaScript and maybe even have server-side development experience. We will take a tour through the important concepts in order to understand Node.js programming.

To do so, we'll develop several applications, including a Note-taking application that will take several chapters to implement data storage with several database engines, user authentication, including OAuth2 against Twitter, real-time communications between users, and server deployment, including Docker. Along the way, we'll explore leading application development best practices, distributing heavy workloads to backend servers, and implementing REST microservices for multitiered architectures.

What this book covers

Chapter 1, About Node.js, introduces you to the Node.js platform. It covers its uses, the technological architecture choices in Node.js, its history, the history of server-side JavaScript, and why JavaScript should be liberated from the browser.

Chapter 2, Setting up Node.js, goes over setting up a Node.js developer environment. This includes installing Node.js on Windows, Mac OS X, and Linux, the command-line tools using ECMA Script 2015 features in Node.js, and the npm package management system.

Chapter 3, Node.js Modules, explores the module as the unit of modularity of Node.js applications. We dive deep into understanding and developing Node.js modules and using npm to maintain our dependency list.

Chapter 4, HTTP Servers and Clients – A Web Applications First Steps, starts exploring web development with Node.js. We develop several small webserver and client applications in Node.js. We use the Fibonacci algorithm to explore the effects of heavy-weight long-running computations on a Node.js application, as well as several mitigation strategies. This gives us our first exposure to REST-based service development.

Chapter 5, Your First Express Application, begins several chapters of developing a note-taking application. The first step is getting a basic application running.

Chapter 6, Implementing the Mobile-First Paradigm, uses the Bootstrap framework to implement responsive web design. Supporting mobile devices from the outset is a driving paradigm in modern software development.

Chapter 7, Data Storage and Retrieval, ensures that we don't lose our notes when restarting the application. We explore several database engines, and a method to make it easy to switch between them at will.

Chapter 8, Multiuser Authentication the Microservice Way, adds user authentication to the note-taking application. It can be used by both logged in and anonymous users with different capabilities for each. Authentication is supported against both a local user registry and using OAuth2 against Twitter.

Chapter 9, Dynamic Interaction between Client and Server with Socket.IO, lets our users talk to each other in real time. JavaScript code will be written in both browser and server, with Socket.IO providing the plumbing needed for real-time event exchange. Users will see notes change as they're edited by other users, or they will read and write notes that others can see.

Chapter 10, Deploying Node.js Applications, helps us understand Node.js application deployment. We look at both traditional Linux service deployment using an /etc/init script and using Docker to easily deploy an infrastructure of two databases and two Node.js services.

Chapter 11, Unit Testing, takes a look at three test development models: Unit Testing, REST testing, and functional testing. In addition to the Mocha and Chai frameworks, we use CasperJS to run automated tests in a headless browser component. Docker is used to facilitate test infrastructure deployment.

What you need for this book

The basic requirement is to install Node.js and to have a programmer-oriented text editor. We will show you how to install everything that you need, all of which is open source software, easily downloaded from the web. The most important tool is the one between your ears.

The examples here were tested using Node.js v5.x and ECMA Script 2015 features are widely used.

Some chapters require the database engines, MySQL and MongoDB.

While Node.js supports cross-platform software development, some of the third-party modules require compilation from source code. This means that one must have C/C++ compiler tools and Python installed. The details are covered in Chapter 2, Setting up Node.js.

While this book is about developing web applications, it does not require you to have a web server. Node.js provides its own web server stack.

Who this book is for

This book is written for any software engineer who wants the adventure that comes with a new software platform embodying a new programming paradigm.

Server-side engineers may find the concepts behind Node.js refreshing, giving you a different perspective on web application development. JavaScript is a powerful language, and Node.js's asynchronous nature plays to its strengths.

Developers experienced with JavaScript in the browser may find it fun to bring that knowledge to new territory.

We assume that you already know how to write software and have an understanding of modern programming languages such as JavaScript.

Conventions

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: The implementation of this is in views/pageHeader.ejs.

A block of code is set as follows:

router.get('/auth/twitter/callback',

passport.authenticate('twitter', { successRedirect: '/',

            failureRedirect: '/users/login' }));

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

btn btn-primary href=/users/login>Log in btn btn-primary href=/users/auth/twitter>15px src=/images/twitter-brand-logos/TwitterLogo_white.png/>Log in with Twitter

<% } %>

Any command-line input or output is written as follows:

$ npm start

New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: You now have both Log Out and ADD Note buttons.

Note

Warnings or important notes appear in a box like this.

Tip

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail <[email protected]>, and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for this book from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

You can download the code files by following these steps:

Log in or register to our website using your e-mail address and password.

Hover the mouse pointer on the SUPPORT tab at the top.

Click on Code Downloads & Errata.

Enter the name of the book in the Search box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on Code Download.

You can also download the code files by clicking on the Code Files button on the book's webpage at the Packt Publishing website. This page can be accessed by entering the book's name in the Search box. Please note that you need to be logged in to your Packt account.

WinRAR / 7-Zip for Windows

Zipeg / iZip / UnRarX for Mac

7-Zip / PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Node.js-Web-Development-Third-Edition We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books—maybe a mistake in the text or the code—we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.

Piracy

Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at <[email protected]> with a link to the suspected pirated material.

We appreciate your help in protecting our authors and our ability to bring you valuable content.

Questions

If you have a problem with any aspect of this book, you can contact us at <[email protected]>, and we will do our best to address the problem.

Chapter 1. About Node.js

Node.js is an exciting new platform for developing web applications, application servers, any sort of network server or client, and general purpose programming. It is designed for extreme scalability in networked applications through an ingenious combination of server-side JavaScript, asynchronous I/O, asynchronous programming, built around JavaScript anonymous functions, and a single execution thread event-driven architecture.

While only a few years old, Node.js has quickly grown in prominence to where it's playing a significant role. Companies, small and large, are using it for large-scale and small-scale projects. PayPal, for example, has converted many services from Java to Node.js.

The Node.js model is very different from common application server platforms using threads. The claim is that with the single-thread event-driven architecture, memory footprint is low, throughput is high, the latency profile under load is better, and the programming model is simpler. The Node.js platform is in a phase of rapid growth, and many are seeing it as a compelling alternative to the traditional Java, PHP, Python, Ruby on Rails, and so on, approach to building web applications.

At its heart, it is a standalone JavaScript engine with extensions making it suitable for general purpose programming and with a clear focus on application server development. Even though we're comparing Node.js to application server platforms, it is not an application server. Instead, Node.js is a programming runtime akin to Python, Go, or Java SE. There are web application frameworks and application servers written in Node.js, however. In the few years that Node.js has been available, it's quickly gained a significant role, fulfilling the prediction that it could potentially supplant other web application stacks.

It is implemented around a non-blocking I/O event loop and a layer of file and network I/O libraries, all built on top of the V8 JavaScript engine (from the Chrome web browser). At the time of writing this, Microsoft had just proposed a patch to allow Node.js to utilize the ChakraCore JavaScript engine (from the Edge web browser). The theoretical possibility of hosting the Node.js API on top of a different JavaScript engine may come true, in the due course of time. Visit https://github.com/nodejs/node-chakracore to take a look at the project.

The I/O library is general enough to implement any sort of server implementing any TCP or UDP protocol, whether it's DNS, HTTP, IRC, or FTP. While it supports developing servers or clients for any network protocol, its biggest use case is in regular websites in place of technology such as an Apache/PHP or Rails stack or to complement existing websites. For example, adding real-time chat or monitoring existing websites can be easily done with the Socket.IO library for Node.js.

A particularly intriguing combination is deploying small services using Docker into cloud hosting infrastructure. A large application can be divided into what's now called microservices and easily deployed at scale using Docker. The result fits agile project management methods since each microservice can be easily managed by a small team which collaborates at the boundary of their individual API.

This book will give you an introduction to Node.js. We presume the following:

You already know how to write software

You are familiar with JavaScript

You know something about developing web applications in other languages

We will cover the following topics in this chapter:

An introduction to Node.js

Why you should use Node.js

The architecture of Node.js

Performance, utilization, and scalability with Node.js

Node.js, microservice architecture, and testing

Implementing the Twelve-Factor App model with Node.js

We will dive right into developing working applications and recognize that often the best way to learn is by rummaging around in working code.