Book Overview & Buying
Table Of Contents

Hands-On JavaScript High Performance

By : Scherer

2.3 (3)

Buy this Book

Hands-On JavaScript High Performance

2.3 (3)

By: Scherer

Buy this Book

Overview of this book

High-performance web development is all about cutting through the complexities in different layers of a web app and building services and APIs that improve the speed and performance of your apps on the browser. With emerging web technologies, building scalable websites and sustainable web apps is smoother than ever. This book starts by taking you through the web frontend, popular web development practices, and the latest version of ES and JavaScript. You'll work with Node.js and learn how to build web apps without a framework. The book consists of three hands-on examples that help you understand JavaScript applications at both the server-side and the client-side using Node.js and Svelte.js. Each chapter covers modern techniques such as DOM manipulation and V8 engine optimization to strengthen your understanding of the web. Finally, you’ll delve into advanced topics such as CI/CD and how you can harness their capabilities to speed up your web development dramatically. By the end of this web development book, you'll have understood how the JavaScript landscape has evolved, not just for the frontend but also for the backend, and be ready to use new tools and techniques to solve common web problems.

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Tools for High Performance on the Web

Technical requirements

DevTools for different environments

Chrome – an in-depth look at the Performance tab

Chrome – an in-depth look at the Memory tab

Chrome – an in-depth look at the Rendering tab

jsPerf and benchmarking

Summary

Free Chapter

Immutability versus Mutability - The Balance between Safety and Speed

Technical requirements

The current fascination with immutability

Writing safe mutable code

Functional style programming

Summary

Vanilla Land - Looking at the Modern Web

Technical requirements

A dive into modern JavaScript

Understanding classes and modules

Working with the DOM

Understanding the Fetch API

Summary

Practical Example - A Look at Svelte and Being Vanilla

Technical requirements

A framework for pure speed

Build the basics – a Todo application

Getting fancier – a basic weather application

Summary

Switching Contexts - No DOM, Different Vanilla

Technical requirements

Getting Node.js

Understanding the DOM-less world

Debugging and inspecting code

Summary

Message Passing - Learning about the Different Types

Technical requirements

Local communication using the net module

Utilizing the network

A quick glance at HTTP/3

Summary

Streams - Understanding Streams and Non-Blocking I/O

Technical requirements

Getting started with streams

Building a custom Readable stream

Building a Writable stream

Implementing a Duplex stream

Implementing a Transform stream

Using generators with streams

Summary

Data Formats - Looking at Different Data Types Other Than JSON

Technical requirements

Using JSON

Implementing the encoder

Implementing the decoder

A look at data formats

Summary

Practical Example - Building a Static Server

Technical requirements

Understanding static content

Setting up our server

Adding caching and clustering

Summary

Workers - Learning about Dedicated and Shared Workers

Technical requirements

Offloading work to a dedicated worker

Moving data in our application

Sending binary data in the browser

Sharing data and workers

Building a simple shared cache

Summary

Service Workers - Caching and Making Things Faster

Technical requirements

Understanding the ServiceWorker

Caching pages and templates for offline use

Saving requests for later

Summary

Building and Deploying a Full Web Application

Technical requirements

Understanding Rollup

Integrating into CircleCI

Summary

WebAssembly - A Brief Look into Native Code on the Web

Technical requirements

Understanding WebAssembly

Writing WebAssembly modules

Writing C/C++ for the web

A look at SQLite in the browser

Summary

Message Passing - Learning about the Different Types

In the previous chapter, we looked at Node.js and the base environment we need to create server-side applications. Now, we will look at how we can use the communication techniques we looked at previously to write scalable systems. Message passing is a great way for applications to be decoupled yet still work together. This means that we can create modules that work independently from each other, either through processes or threads, and still achieve a common goal.

In this chapter, we will cover the following topics:

Local communication using the net module
Utilizing the network
A quick glance at HTTP/3

We will also take a look at the future of client/server communication while looking at the HTTP/3 standard that is being developed. Then, we will look at the implementation of the QUIC protocol, a protocol developed by Google...