Node JS: Advanced Concepts (Udemy.com)

Get advanced with Node.Js! Learn caching with Redis, speed up through clustering, and add image upload with S3 and Node!

Created by: Stephen Grider

Produced in 2021

icon
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

icon
Quality Score

Content Quality
/
Video Quality
/
Qualified Instructor
/
Course Pace
/
Course Depth & Coverage
/

Overall Score : 92 / 100

icon
Live Chat with CourseDuck's Co-Founder for Help

Need help deciding on a node.js course? Or looking for more detail on Stephen Grider's Node JS: Advanced Concepts? Feel free to chat below
Join CourseDuck's Online Learning Discord Community

icon
Course Description

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.Who this course is for:
  • Anyone who wants a deep mastery of Node
  • Engineers looking to understand the internals of Node
  • Programmers looking to improve Node's performance

*Some courses are excluded from this sale. Coupon not working? If the link above doesn't drop prices, clear the cookies in your browser and then click this link here.
Also, you may need to apply the coupon code directly on the cart page to get the discount.

Coupon Code

icon
Instructor Details

Stephen Grider

Stephen Grider has been building complex Javascript front ends for top corporations in the San Francisco Bay Area. With an innate ability to simplify complex topics, Stephen has been mentoring engineers beginning their careers in software development for years, and has now expanded that experience onto Udemy, authoring the highest rated React course. He teaches on Udemy to share the knowledge he has gained with other software engineers. Invest in yourself by learning from Stephen's published courses.

icon
Reviews

4.6

362 total reviews

5 star 4 star 3 star 2 star 1 star
% Complete
% Complete
% Complete
% Complete
% Complete

Finally, simple yet brilliant explanation of Event Loop. True ability of bringing complex topics easy way. Big thanks Stephen!

Gran curso! Muy completo y bastante detallado con todo tipo de esquemas y ejemplos. Trata conceptos avanzados tanto de Node, como de JS nativo. Muy interesante el cacheo de consultas a Mongoose con Redis o la master class de testing con Jest. Sin duda un curso obligatorio para conocer conceptos avanzados de desarrollo de aplicaciones con JS.

Very nice course on diving into NodeJS's low-level ecosystem.Some improvement would be to put Git direct access to source code as branches and links resources for sections.

It's a great course to be a better javascript develper.Most of the courses are good for "frontend" developers, but this is better for "backend".It explains and give examples of some subjects (work with mongo, amazon S3, testing with jest...) in a very detalied (may be a bit slowly, some lessons are very short).To say a negative point, the source is not included, and due to the use of external services (mongodb, amazon s3...) it's needed to join to some services if you want to test the code by yourself.But I recommend this course, as I've said, I like it a lot.

Stephen Grider is an awesome instructor. What a cool course. You will definitely learn a ton! If I could give 6/5 stars, I would.

A good course which also guides its users with a thought process to be applied while developing a node application like using javascript proxy, keeping security, load time, server performance and application budget checks via image content upload with S3 bucket.

The start was a good approach. The premade application code is outdated and is not working correctly on new nodejs versions. The course marked as advanced, but advanced was only first 2 parts(or sections not sure how to call it since the teacher calls section to every lesson) of the course where exactly in-deep knowledge about nodejs was shown. Also realisation of content type of an uploading image was not shown, thou it is not a big deal, but was promised =).

The course was interesting but I feel there were some errors that were prevented including ```await next()``` presented lesson 68 (the express next function doesn't return a promise and hence this statement wouldn't work) and bad practices such as prototype mutation on most of the Browser Testing section. Otherwise it was pretty good.

So far my experience is really good, learning many new methods and whys of them with a very good explanation.

I actually love what Stephen brings to the table. The content on this course is also interesting. However, I felt that some of the contents were a little out of place, like the Redis part, Integration testing etc. Would have liked to see more in-depth concepts of Node itself. Could have covered topics like Error Handling concepts and best practices, using EventEmitter in a practical way, Socket IO, Performance Profiling etc. In that sense, I am a little disappointed.

By Saad on

love the content. Actually, Its what I expect, because just by looking at the profile of Stephen , you can get the whole picture of how great everything he teaches is.

Indeed an excellent course, thank you Stephen!!