Node JS- Advanced Concepts

Node JS: Advanced Concepts, available at $129.99, has an average rating of 4.57, with 179 lectures, 2 quizzes, based on 10170 reviews, and has 66259 subscribers.

You will learn about Absolutely master the Event Loop and understand each of its stages Utilize Worker Threads and Clustering to dramatically improve the performance of Node servers Speed up database queries with caching for MongoDB backed by Redis Add automated browser testing to your Node server, complete with continuous integration pipeline setup Apply scalable image and file upload to your app, utilizing AWS S3 This course is ideal for individuals who are Anyone who wants a deep mastery of Node or Engineers looking to understand the internals of Node or Programmers looking to improve Nodes performance It is particularly useful for Anyone who wants a deep mastery of Node or Engineers looking to understand the internals of Node or Programmers looking to improve Nodes performance.

Enroll now: Node JS: Advanced Concepts

Summary

Title: Node JS: Advanced Concepts

Price: $129.99

Average Rating: 4.57

Number of Lectures: 179

Number of Quizzes: 2

Number of Published Lectures: 177

Number of Published Quizzes: 2

Number of Curriculum Items: 181

Number of Published Curriculum Objects: 179

Original Price: $99.99

Quality Status: approved

Status: Live

What You Will Learn

Absolutely master the Event Loop and understand each of its stages

Utilize Worker Threads and Clustering to dramatically improve the performance of Node servers

Speed up database queries with caching for MongoDB backed by Redis

Add automated browser testing to your Node server, complete with continuous integration pipeline setup

Apply scalable image and file upload to your app, utilizing AWS S3

Who Should Attend

Anyone who wants a deep mastery of Node

Engineers looking to understand the internals of Node

Programmers looking to improve Nodes performance

Target Audiences

Anyone who wants a deep mastery of Node

Engineers looking to understand the internals of Node

Programmers looking to improve Nodes performance

Go beyond the basics of Node! ?This course will give you the skills needed to become a top Node engineer.

Query Caching with Redis??You will learn it. ?The Node Event Loop??Included. ?Scalable File Upload??Of course!

This is a must-take course if you work with Node.

Node Internals:?Here’s one of the most common interview questions you’ll face when looking for a Node job: “Can you explain Node’s Event Loop?”?There are two types of engineers: those who can describe the Event Loop and those who cannot!? This course will ensure that you are incredibly well prepared to answer that most important question.? Besides being critical for interviews, knowledge of the Event Loop will give you a better understanding of how Node?works internally.? Many engineers know not to ‘block’ the Event Loop, but they don’t necessarily understand why.? You will be one of the engineers who can clearly articulate the performance profile of Node and its Event Loop.

Caching with Redis:?We’ll also supercharge the performance of database queries by implementing caching backed by Redis.??No previous experience of Redis is required!? Redis is an in-memory data store purpose built for solving caching needs.? By adding caching to your application, you can decrease the amount of time that any given request takes, improving the overall response time of your app.

File Upload: There are many resources online that offer suggestions on how to handle file upload, but few show a solution that can truly scale.? Hint: saving files directly on your server isn’t a scalable solution!? Learn how to leverage AWS S3 to implement file upload that can scale to millions of users with a few dozen lines of simple code.? Plentiful discussions are included on security concerns with handling uploads, as well.

Continuous Integration Testing:?This is a must have feature for any serious production app.? We’ll first learn how to test huge swaths of our codebase with just a few lines of code by using Puppeteer and?Jest.??After writing many effective tests, we’ll enable continuous integration on Travis CI, a popular – and free – CI?platform.? Testing can sometimes be boring, so we’ll use this section to brush up on some advanced Javascript techniques, including one of the only legitimate uses of ES2015 Proxies that you’ll ever see!

Here’s what we’ll learn:

Master the Node Event Loop – understand how Node executes your source code.?

Understand the purpose of Node, and how the code you write is eventually executed by?C++ code in the V8 engine

Add a huge boost to performance in your Node app through clustering?and worker threads

Turbocharge MongoDB queries by adding query caching?backed by a lightning-fast Redis instance

Scale your app to infinity with image and file upload?backed by Amazon’s S3 file service

Implement a continuous integration testing pipeline so you always know your project functions properly

Think you know everything there is about?managing? cookies and session?? Well, you might, but learn even more!

Ensure your app works the way you expect with automated browser testing using?Jest and?Puppeteer

Bonus – learn advanced JS techniques along the way, including where to use ES2015 proxies!

I’ve built the course that I would have wanted to take when I was learning to Node. A course that explains the concepts and how they’re implemented in the best order for you to learn and deeply understand them.

Course Curriculum

Chapter 1: The Internals of Node

Lecture 1: How to Get Help

Lecture 2: Course Resources

Lecture 3: Join Our Community!

Lecture 4: Starting With Node Internals

Lecture 5: Module Implementations

Lecture 6: Node Backed by C++!

Lecture 7: The Basics of Threads

Lecture 8: The Node Event Loop

Lecture 9: The Event Loop Implementation

Lecture 10: Event Loop Ticks

Lecture 11: Is Node Single Threaded?

Lecture 12: Testing for Single Threads

Lecture 13: The Libuv Thread Pool

Lecture 14: Threadpools with Multithreading

Lecture 15: Changing Threadpool Size

Lecture 16: Common Threadpool Questions

Lecture 17: Explaining OS Operations

Lecture 18: Libuv OS Delegation

Lecture 19: OS/Async Common Questions

Lecture 20: Review

Lecture 21: Crazy Node Behavior

Lecture 22: Unexpected Event Loop Events

Chapter 2: Enhancing Node Performance

Lecture 1: Enhancing Performance

Lecture 2: Express Setup

Lecture 3: Blocking the Event Loop

Lecture 4: Clustering in Theory

Lecture 5: Forking Children

Lecture 6: Clustering in Action

Lecture 7: Benchmarking Server Performance

Lecture 8: Benchmark Refactor

Lecture 9: Need More Children!

Lecture 10: PM2 Installation

Lecture 11: PM2 Configuration

Lecture 12: Important Note about the Upcoming Videos

Lecture 13: Webworker Threads

Lecture 14: Worker Threads in Action

Lecture 15: Benchmarking Workers

Chapter 3: Project Setup

Lecture 1: The Next Phase

Lecture 2: Updated Boilerplate

Lecture 3: Project Walkthrough

Lecture 4: Key Customization

Lecture 5: MongoDB Altas Setup and Configuration

Lecture 6: MongoDB Creation

Lecture 7: Routes Walkthrough

Chapter 4: Data Caching with Redis

Lecture 1: MongoDB Query Performance

Lecture 2: Query Caching Layer

Lecture 3: Redis Introduction

Lecture 4: Installing Redis on MacOS

Lecture 5: Redis on Windows

Lecture 6: Getting and Setting Basic Values

Lecture 7: Redis Hashes

Lecture 8: One Redis Gotcha

Lecture 9: Cache Keys

Lecture 10: Promisifying a Function

Lecture 11: Caching in Action

Lecture 12: Caching Issues

Lecture 13: The Ultimate Caching Solution

Lecture 14: Patching Mongooses Exec

Lecture 15: Restoring Blog Routes Handler

Lecture 16: Unique Keys

Lecture 17: Key Creation

Lecture 18: Restoring Redis Config

Lecture 19: Cache Implementation

Lecture 20: Resolving Values

Lecture 21: Hydrating Models

Lecture 22: Hydrating Arrays

Lecture 23: Toggleable Cache

Lecture 24: Cache Expiration

Lecture 25: Forced Cache Expiration

Lecture 26: Nested Hashes

Lecture 27: Clearing Nested hashes

Lecture 28: Automated Cache Clearing with Middlware

Chapter 5: Automated Headless Browser Testing

Lecture 1: Testing Flow

Lecture 2: Testing Challenges

Lecture 3: Commands Around Testing

Lecture 4: First Jest Test

Lecture 5: Launching Chromium Instances

Lecture 6: Chromium Navigation

Lecture 7: Extracting Page Content

Lecture 8: Puppeteer – Behind the Scenes

Lecture 9: DRY Tests

Lecture 10: Browser Termination

Lecture 11: Asserting OAuth Flow

Lecture 12: Asserting URL Domain

Lecture 13: Issues with OAuth

Lecture 14: Solving Authentication Issues with Automation Testing

Lecture 15: The Google OAuth Flow

Lecture 16: Inner Workings of Sessions

Lecture 17: Sessions From Another Angle

Lecture 18: Session Signatures

Lecture 19: Generating Sessions and Signatures

Lecture 20: Assembling the Pieces

Lecture 21: WaitFor Statements

Instructors

Stephen Grider
Engineering Architect

Rating Distribution

1 stars: 55 votes

2 stars: 108 votes

3 stars: 482 votes

4 stars: 2603 votes

5 stars: 6922 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!