Complete Nodejs Developer In 2022 (Graphql, Mongodb, + More) (updated 10/2022)

Learn from real NodeJS experts! Includes REALLY Advanced NodeJS. Express, GraphQL, REST, MongoDB, SQL, MERN + much more

What you'll learn
Build enterprise level Node applications and deploy to the cloud (AWS)
Learn to build secure and performant, large scale applications like a senior backend developer
Lead NodeJS projects by making good architecture decisions and helping others on your team
Using NodeJS, build production grade apps including REST APIs and GraphQL APIs
Work with real life data and SpaceX API to build a NASA launch system, discover new planets that may contain life + other projects
Authentication, File I/O, Databases (SQL, MongoDB), Express Framework, Sockets, plus many other important topics a backend developer should know
Build a MERN (MongoDb, Express, React, Node) fullstack app and deploy to production
Load balancing, Monitoring, CI/CD, and Zero Downtime Deployment
Become the top 10% Node Developer. Learn REALLY advanced topics!
Focus on security best practices throughout the course so you can be confident with your deployments
Master the latest ecosystem of a Backend NodeJS Developer from scratch
Requirements
Just basic JavaScript knowledge
You DO NOT need any prior experience with NodeJS!
You DO NOT need any prior Backend Development knowledge!
Description
Just released with all new NodeJS best practices and trends for 2022! Join a live online community of over 600,000+ developers and a course taught by industry experts that have actually worked both in Silicon Valley and Toronto with Node.js. Using the latest version of Node, this course is focused on efficiency and turning you into a Back End or Fullstack developer. Never spend time on confusing, out of date, incomplete tutorials anymore! Graduates of Andrei’s courses are now working at Google, Tesla, Amazon, Apple, IBM, JP Morgan, Facebook, + other top tech companies for a reason.We guarantee you this is the most comprehensive online resource on NodeJS. This project based course will introduce you to all of the modern toolchain of a Node JS developer in 2022. Along the way, we will build a massive NASA Space launch application using Node.js, Express Framework, RESTful APIs, GraphQL, and much more! This is going to be a Fullstack MERN app. We will also build many other mini projects along the way so you feel confident deploying any Node.js project to production in the future by yourself!All code is going to be provided step by step and even if you don’t like to code along, you will get access to all the code from the projects we build so anyone signed up for the course will have their own project to put on their portfolio right away.The curriculum is going to be very hands on as we walk you from start to finish of releasing a professional (performant and secure) Node.js project all the way into production. We will start from the very beginning by teaching you Node basics and then going into advanced topics so you can make good decisions on architecture and tools on any of your future NodeJS projects. The goal is to turn you into a senior backend developer!Finally, this course will be constantly evolving and updating as the landscape changes. Just as the Node ecosystem evolves, we want this course to be constantly updated with lectures and resource for you to come back to, in order to find the latest Node best practices anytime in the future.Here is what the course will cover:1. FoundationsFocus on Node internalsLibuv, threads, processes, event loopAsynchronous programmingNode vs PHP vs PythonObserver Design PatternEvent Emitters2. Module SystemThe require FunctionCreating Your Own ModulesCommonJS vs ECMAScript (ES6) modulesModule CachingUsing index.js3. Package ManagementNPM: The Node Package ManagerCreating Your Own PackagesPackage And the NPM RegistryThird Party ModulesThe node_modules FolderSemantic Versioningpackage-lock.json And VersioningVulnerabilities in Dependencies4. File I/O: Planets ProjectExploring Exoplanets With NodeExploring Kepler Space Telescope DataWorking With StreamsStreaming Large Data FilesParsing Our Planets DataWorking With CSV FilesFinding Habitable Planets5. Web ServersWhat is a Web Server?HTTP Responses and RequestsHTTP APIs and Routing, Parameterized URLsSame Origin Policy, CORSRequests and Responses as Streams6. Express.jsExpress vs Next.js vs KoaRoute ParametersModel View Controller (MVC) patternPostman and InsomniaDevelopment DependenciesMiddlewareLogging Middleware Example / Writing Our Own MiddlewarePOST Requests in ExpressMVC In ExpressExpress RoutersRESTful APIsCRUDSending FilesServing Websites With NodeTemplating Engines7. NodeJS NASA ProjectArchitecture diagrams on LucidChartGET, POST, DELETE routes.Serving React.js Applications in ExpressCORS middlewareModels vs Controllers vs RoutersLoading Data On StartupAutomating Full Stack Applications With NPMServing React Front End (in Production)Logging Requests with MorganServing Applications With Client Side RoutingBuilding A Data Access LayerIntegrating with Frontend, Top Down Approach, Bottom Up ApproachUpdating Our Architecture8. Testing APIsUnit tests vs API tests vs UI testsTesting Node APIs with Jest and Supertest9. Improving Node PerformanceExample app which blocks event loop + real life blocking functionsNode Cluster Module theory + in actionClustering in the real worldLoad balancingPM2 theory + in actionManaging Live Clusters with PM2Zero Downtime RestartsImproving Performance of NASA ProjectStateless APIsNode Worker Threads10. DatabasesUsing MongoDB to add persistence to NASA ProjectBig focus on NoSQL vs SQL, PostgreSQL vs MongoDB, when to use both including Trends, Object-Relational Mismatch, ACID, References, Schemas. Schema-less vs SchemasMongoDB AtlasHorizontally Scaling DatabasesMongooseMongoose Models vs MVC ModelsObjectIDs in MongoDBPaginationChoosing A Database For Our NASA API11. Working With REST APIsDemonstrate integrating with a REST API by working with SpaceX APIVersioning REST APIsRunning Search QueriesSpaceX Launch DataMapping API Data to Our DatabaseUsing Paginated APIsAdding Pagination To Our API12. AuthenticationFocus on Security first principles with JWT, cookies, CSRFServers with HTTPS and SSL / TLSHelmet.jsWorking With Auth013. Deployment and CI/CDFocus on building out a simple CI pipeline for NASA Project on GitHubWhat is CI vs CD? Automated testsDynamic configuration with secrets14. Node Production and the Cloud (AWS)Deploy to production with Docker to Amazon EC2 Virtual MachinesServerless vs ContainersDocker filesManaging Docker Containers and ImagesWorking With SSHProduction Deployment with PM2 and Mongo Atlas15. GraphQLGraphQL vs RESTBuilding a GraphQL API16. Sockets (WebSockets, Socket io)Sockets overview Sockets vs pollingWebSockets (vs Socket io)Socket io Client and Server APIsBroadcasting EventsBuild out Full Stack Multiplayer Pong with SocketsImplementing Pong Game LogicUsing Socket io With Express.jsNamespaces and Rooms17~20.  Bonus Sections on Deno, Advanced Asynchronous JavaScript, SQL, and TypeScript!This course is not about making you just code along without understanding the principles so that when you are done with the course you don’t know what to do other than watch another tutorial. No! This course will push you and challenge you to go from an absolute beginner in NodeJS to someone that is in the top 10% of NodeJS backend developers. We guarantee you this is the most comprehensive online course on Node.js! Have a look at the course outline video to see all the topics we are going to cover, all the projects we’re going to build, and all the techniques you’re going to learn to become a top Node developer!See you inside!––––––Taught By:Andrei Neagoie is the instructor of the highest rated Development courses on Udemy as well as one of the fastest growing. His graduates have moved on to work for some of the biggest tech companies around the world like Apple, Google, Amazon, JP Morgan, IBM, UNIQLO etc… He has been working as a senior software developer in Silicon Valley and Toronto for many years, and is now taking all that he has learned, to teach programming skills and to help you discover the amazing career opportunities that being a developer allows in life. Having been a self taught programmer, he understands that there is an overwhelming number of online courses, tutorials and books that are overly verbose and inadequate at teaching proper skills. Most people feel paralyzed and don't know where to start when learning a complex subject matter, or even worse, most people don't have $20,000 to spend on a coding bootcamp. Programming skills should be affordable and open to all. An education material should teach real life skills that are current and they should not waste a student's valuable time.   Having learned important lessons from working for Fortune 500 companies, tech startups, to even founding his own business, he is now dedicating 100% of his time to teaching others valuable software development skills in order to take control of their life and work in an exciting industry with infinite possibilities. Andrei promises you that there are no other courses out there as comprehensive and as well explained. He believes that in order to learn anything of value, you need to start with the foundation and develop the roots of the tree. Only from there will you be able to learn concepts and specific skills(leaves) that connect to the foundation. Learning becomes exponential when structured in this way. Taking his experience in educational psychology and coding, Andrei's courses will take you on an understanding of complex subjects that you never thought would be possible.   ––––Adam is one of the instructors at Zero To Mastery, one of the highest rated and fastest growing software development academies on Udemy. He has been working as a senior software developer for many years and has worked for some of the top companies in the world with revenues exceeding $50 billion. Now, Adam aims to instil his students with his love for learning and development, while helping them achieve real world success that extends far beyond the completion of his courses.Adam walks the walk when it comes to building applications that are secure, scalable, and performant and he is going to share his expertise with you to show you how real world systems are built. He understands what it’s like to go from “hello world” to large scale production deployments and promises to take you on that very same journey. Courses should teach practical skills that are current and should lay a foundation for a future in this incredible and exciting industry. And, having started as a self-taught developer, Adam knows the overwhelming feeling of not knowing where to begin, and the importance of learning from the best available sources.Drawing from his deep experience, Adam’s courses will show you that you don’t need to spend tens of thousands of dollars to take your flourishing skills into the real world and make a difference.See you inside the course!

Overview

Section 1: Introduction

Lecture 1 Course Outline

Lecture 2 Join Our Online Classroom!

Lecture 3 Exercise: Meet Your Classmates and Instructor

Lecture 4 Node.js - How We Got Here

Lecture 5 Node.js Runtime

Lecture 6 How To Succeed In The Course

Lecture 7 Latest Version Of Node.js

Lecture 8 Course Projects + Code + Resources

Lecture 9 Web Developer Monthly

Section 2: Node.js Fundamentals: Foundations and Environment Setup

Lecture 10 OPTIONAL: Installing Node.js

Lecture 11 OPTIONAL: Windows Installation Tips

Lecture 12 The Node.js Release Cycle

Lecture 13 The Node.js REPL

Lecture 14 Setting Up Our Developer Environment

Lecture 15 Our First Node.js App

Lecture 16 Node.js VS JavaScript

Lecture 17 The global Object

Lecture 18 Introduction to Backend VS Frontend

Lecture 19 Monthly Coding Challenges, Free Resources and Guides

Section 3: Node.js Fundamentals: Internals

Lecture 20 What Node.js Includes

Lecture 21 Node Internals Deep Dive

Lecture 22 libuv Internals Deep Dive

Lecture 23 Synchronous vs Asynchronous

Lecture 24 Asynchronous Callbacks

Lecture 25 Non-Blocking Input & Output

Lecture 26 Exercise: Is JavaScript Asynchronous?

Lecture 27 Multi-Threading, Processes, and Threads

Lecture 28 Is Node.js Multi-Threaded?

Lecture 29 The Event Loop

Lecture 30 Callback Queues

Lecture 31 Phases of the Event Loop

Lecture 32 Comparing Node With PHP and Python

Lecture 33 What Is Node.js Best At?

Lecture 34 Observer Design Pattern

Lecture 35 The Node Event Emitter

Lecture 36 Recommended Path: Asynchronous JavaScript

Section 4: Node.js Fundamentals: Module System

Lecture 37 The require Function

Lecture 38 Making HTTP Requests

Lecture 39 Why Use Modules?

Lecture 40 Creating Our Own Modules

Lecture 41 Exporting From Modules

Lecture 42 CommonJS vs ECMAScript Modules

Lecture 43 Creating Our Own ECMAScript Modules

Lecture 44 Module Caching

Lecture 45 Using index.js

Lecture 46 Should We Use index.js?

Section 5: Node.js Fundamentals: Package Management

Lecture 47 NPM: The Node Package Manager

Lecture 48 Creating Our First NPM Package

Lecture 49 Packages And The NPM Registry

Lecture 50 Using Third Party Modules

Lecture 51 The node_modules Folder

Lecture 52 Semantic Versioning

Lecture 53 package-lock.json and Versioning

Lecture 54 Vulnerabilities In Dependencies

Lecture 55 Installing NPM Tools: nodemon

Lecture 56 LinkedIn Endorsements

Section 6: Node.js File I/O - Planets Project

Lecture 57 Code For This Section

Lecture 58 Exploring Planets With Node

Lecture 59 Importing Kepler Space Telescope Data

Lecture 60 Setting Up Our CSV Parser

Lecture 61 Latest Version of CSV Parser

Lecture 62 Streaming Large Data Files

Lecture 63 Reading Our Planets Data

Lecture 64 Parsing Our Planets Data

Lecture 65 Finding Habitable Planets

Lecture 66 Exploring Habitable Planets

Section 7: Web Servers with Node.js

Lecture 67 Code For This Section

Lecture 68 What is a Web Server?

Lecture 69 Introduction to HTTP Responses and Requests

Lecture 70 HTTP Requests

Lecture 71 HTTP Responses

Lecture 72 Our First Webserver

Lecture 73 HTTP APIs and Routing

Lecture 74 Parameterized URLs

Lecture 75 Same Origin Policy

Lecture 76 Exercise: Same Origin Policy

Lecture 77 Cross Origin Resource Sharing (CORS)

Lecture 78 POSTing Data to the Server

Lecture 79 Requests and Responses as Streams

Lecture 80 Web Servers Recap

Section 8: First Express.js API

Lecture 81 Code For This Section

Lecture 82 Why Express?

Lecture 83 Introduction to Express

Lecture 84 Express vs Next.js vs Koa

Lecture 85 Route Parameters

Lecture 86 Postman and Insomnia

Lecture 87 Development Dependencies

Lecture 88 Middleware

Lecture 89 Writing Our Own Logging Middleware

Lecture 90 POST Requests in Express

Lecture 91 Model View Controller (MVC)

Lecture 92 Model View Controller in Express

Lecture 93 Express Routers

Lecture 94 RESTful APIs

Lecture 95 Create Read Update and Delete (CRUD)

Lecture 96 Sending Files

Lecture 97 Serving Websites With Node

Lecture 98 Templating Engines

Lecture 99 Layouts and Separation of Concerns

Section 9: NASA Project

Lecture 100 Code For This Section

Lecture 101 Introduction & Architecture

Lecture 102 NASA Dashboard Front End Setup

Lecture 103 NASA Dashboard Functionality

Lecture 104 What You Need To Know

Lecture 105 React.js Front End Code Walkthrough

Lecture 106 API Server Setup

Lecture 107 Environment Variables On Windows

Lecture 108 GET /planets

Lecture 109 CORS Middleware

Lecture 110 Models vs Controllers vs Routers

Lecture 111 The Planets Model

Lecture 112 Loading Data On Startup

Lecture 113 Common Issues With NPM Scripts

Lecture 114 Automating Full Stack Applications With NPM

Lecture 115 Serving React.js Front End In Production

Lecture 116 Setting BUILD_PATH On Windows

Lecture 117 Logging Requests With Morgan

Lecture 118 The Launches Model

Lecture 119 GET /launches

Lecture 120 Serving Applications With Client Side Routing

Lecture 121 Working With Data Models: Building a Data Access Layer

Lecture 122 POST /launches: Creating Launches 1

Lecture 123 POST /launches: Creating Launches 2

Lecture 124 POST /launches: Validation For POST Requests

Lecture 125 Connecting POST /launches With Front End Dashboard

Lecture 126 DELETE /launches: Aborting Launches 1

Lecture 127 DELETE /launches: Aborting Launches 2

Lecture 128 Updating Our Architecture Diagram

Lecture 129 Exercise: Imposter Syndrome

Section 10: Testing APIs

Lecture 130 Testing In Node

Lecture 131 Testing APIs With Jest

Lecture 132 Testing API Endpoints With Supertest: GET

Lecture 133 Testing API Endpoints With Supertest: POST

Lecture 134 Testing API Endpoints With Supertest: Error Cases

Section 11: Improving Node Performance

Lecture 135 Code For This Section

Lecture 136 Node Server Performance

Lecture 137 Building A Simple Blocking Server

Lecture 138 Real Life Blocking Functions

Lecture 139 Running Multiple Node Processes

Lecture 140 The Node Cluster Module

Lecture 141 Clustering In Action

Lecture 142 Maximizing Cluster Performance

Lecture 143 Load Balancing

Lecture 144 The PM2 Tool

Lecture 145 Using PM2 To Create Clusters

Lecture 146 Managing Live Clusters With PM2

Lecture 147 Zero Downtime Restart

Lecture 148 Improving Performance Of Our NASA Project

Lecture 149 Worker Threads

Lecture 150 Worker Threads In Action

Section 12: Databases

Lecture 151 Introduction to Databases

Lecture 152 Recommended Path: SQL

Lecture 153 Comparing SQL vs NoSQL

Lecture 154 Database Schemas & Schemaless Databases

Lecture 155 Choosing a Database for our NASA Project

Lecture 156 SQL vs MongoDB: Trends and Object-Relational Impedance Mismatch

Lecture 157 SQL vs MongoDB: Schemas, References, and ACID Transactions

Lecture 158 Setting up MongoDB Atlas

Lecture 159 Connecting to MongoDB

Lecture 160 Connecting with the Latest Version of Mongoose

Lecture 161 Mongoose

Lecture 162 Creating Mongoose Schema for Launches

Lecture 163 Exercise: Creating Mongoose Schema for Planets

Lecture 164 Reminder: Destination Planets Dropdown

Lecture 165 Creating Models From Schemas

Lecture 166 Mongoose Models vs MVC Models

Lecture 167 Creating and Inserting Documents

Lecture 168 Finding Documents

Lecture 169 The Upsert Operation

Lecture 170 Exploring Data Using Atlas

Lecture 171 Updating Project Architecture

Lecture 172 ObjectIDs

Lecture 173 Excluding Fields From The Response

Lecture 174 Saving Launches

Lecture 175 Listing All Launches

Lecture 176 Referential Integrity

Lecture 177 Auto Increment In MongoDB

Lecture 178 Getting Latest Flight Number

Lecture 179 Scheduling New Launches

Lecture 180 Investigating A Mongoose Mystery

Lecture 181 Aborting Launches

Lecture 182 Aborting with the Latest MongoDB Driver

Lecture 183 Updating Tests For Mongoose 1

Lecture 184 Updating Tests For Mongoose 2

Lecture 185 Fixing A Bug In Jest: Open Handles

Section 13: Working With REST APIs - SpaceX Project

Lecture 186 Working With SpaceX

Lecture 187 The SpaceX API

Lecture 188 Versioning Node APIs

Lecture 189 Updating Our API Tests

Lecture 190 Exploring SpaceX Launches API

Lecture 191 Running Search Queries

Lecture 192 Loading SpaceX Data In Our API

Lecture 193 Mapping SpaceX Data To Our Database

Lecture 194 Using Paginated APIs

Lecture 195 Minimizing API Load

Lecture 196 Persisting SpaceX Launches

Lecture 197 Paginating Our Endpoints 1

Lecture 198 Paginating Our Endpoints 2

Lecture 199 Sorting Paginated Data

Lecture 200 Cleaning Up Launch Data

Lecture 201 Managing Secrets With Dotenv

Lecture 202 Running API Tests With Dotenv

Lecture 203 Securing Leaked Secrets

Section 14: Node Security + Authentication

Lecture 204 Code For This Section

Lecture 205 Security and Authentication Overview

Lecture 206 Encrypted Connections with SSL and TLS

Lecture 207 Digital Certificates, Signing, and Man In The Middle Attacks

Lecture 208 Setting Up Our Security Example

Lecture 209 HTTPS With Node, Self Signed Certificates, and Public Key Cryptography

Lecture 210 Helmet.js

Lecture 211 Authentication vs Authorization

Lecture 212 Social Sign In

Lecture 213 API Keys

Lecture 214 JWT Tokens

Lecture 215 The OAuth Standard

Lecture 216 OAuth 2.0 Authorization Code Flow

Lecture 217 OAuth In Action with Single Sign On

Lecture 218 Registering with the Google Authorization Server

Lecture 219 Authentication Endpoints With Middleware

Lecture 220 Passport.js

Lecture 221 Dotenv for Client Secrets

Lecture 222 Authentication With Google And OAuth 1

Lecture 223 Authentication With Google And OAuth 2

Lecture 224 Cookie Based Authentication

Lecture 225 Sessions

Lecture 226 Server VS Client Side Sessions With Cookies

Lecture 227 Session Middleware in Express

Lecture 228 Setting Up OAuth Cookie Session

Lecture 229 Sessions with the Latest Version of Passport.js

Lecture 230 Reading and Writing the OAuth Session 1

Lecture 231 Reading and Writing the OAuth Session 2

Lecture 232 Restricting Access to Endpoints

Lecture 233 Implementing Logout

Lecture 234 Experimenting With Fake Sessions

Lecture 235 Wrap Up and Next Steps

Lecture 236 Resource: Security Cheat Sheet

Section 15: Continuous Integration and Delivery

Lecture 237 Introduction to CI and CD

Lecture 238 Continuous Integration

Lecture 239 Continuous Delivery

Lecture 240 Continuous Deployment

Lecture 241 Pipelines

Lecture 242 GitHub Actions

Lecture 243 Setting Up GitHub Actions

Lecture 244 Continuous Integration: Build Pipeline

Lecture 245 Build Pipeline In Action

Lecture 246 Common Build Pipeline Errors

Lecture 247 GitHub Actions Marketplace

Lecture 248 Continuous Integration: Test Pipeline

Lecture 249 Mocking Out Databases

Lecture 250 Databases With Continuous Integration

Lecture 251 Populating Data For Continuous Integration

Section 16: Node Production and the Cloud (Docker + AWS)

Lecture 252 Deploying to the Cloud

Lecture 253 Serverless vs Containers

Lecture 254 Virtual Machines

Lecture 255 What is a Container?

Lecture 256 Installing Docker

Lecture 257 Running Our First Docker Container

Lecture 258 Your DockerHub Account

Lecture 259 Creating a Dockerfile

Lecture 260 Improving Our Dockerfile With Layers

Lecture 261 Installing Only Production Dependencies

Lecture 262 Updating Our API URL

Lecture 263 Building NASA Project Docker Image

Lecture 264 Running NASA Project in a Container

Lecture 265 Pushing Images to Docker Hub

Lecture 266 Exploring Amazon Web Services

Lecture 267 Creating an EC2 Instance 1

Lecture 268 Creating an EC2 Instance 2: Security

Lecture 269 What is SSH?

Lecture 270 Connecting To Our EC2 Instance With SSH

Lecture 271 Setting Up Our EC2 Server

Lecture 272 Deploying Our NASA API

Section 17: GraphQL

Lecture 273 Code For This Section

Lecture 274 GraphQL Overview

Lecture 275 Our First GraphQL Query

Lecture 276 GraphQL Queries In Action

Lecture 277 GraphQL vs REST: Over-fetching & Under-fetching

Lecture 278 GraphQL vs REST Summary

Lecture 279 Exploring GraphQL Implementations

Lecture 280 GraphQL In Node

Lecture 281 GraphiQL

Lecture 282 Designing An E-Commerce Schema

Lecture 283 GraphQL Tools

Lecture 284 Modularizing Large GraphQL Projects: Schemas

Lecture 285 GraphQL Tools Update

Lecture 286 Resolvers

Lecture 287 Modularizing Large GraphQL Projects: Resolvers

Lecture 288 Filtering with Queries and Resolvers

Lecture 289 Exercise: Query Products By ID

Lecture 290 Mutations In Action

Lecture 291 Implementing Mutations on the Server

Lecture 292 Exercise: Add New Product Review

Lecture 293 GraphQL With Apollo

Lecture 294 Building an Apollo Server With Node.js

Section 18: Sockets with Node.js

Lecture 295 Code For This Section

Lecture 296 Introduction to Sockets

Lecture 297 Polling

Lecture 298 What is a Socket?

Lecture 299 Sockets VS Polling

Lecture 300 WebSockets

Lecture 301 Introduction to socket.io

Lecture 302 socket.io Client and Server APIs

Lecture 303 Multiplayer Pong Overview

Lecture 304 Recommended Path: Pong Front End

Lecture 305 Reviewing Our Pong Front End

Lecture 306 Multiplayer Pong Message Sequence

Lecture 307 Setting Up a socket.io Server

Lecture 308 Connecting to socket.io

Lecture 309 Handling CORS With Sockets

Lecture 310 Identifying Connected Clients

Lecture 311 Listening for Events in the Pong Server

Lecture 312 Broadcasting Events

Lecture 313 Handling Events in the Pong Client

Lecture 314 Implementing the Game Logic: Paddle

Lecture 315 Implementing the Game Logic: Ball

Lecture 316 What Happens When You Disconnect?

Lecture 317 Using Socket.io with Express

Lecture 318 Namespaces

Lecture 319 Rooms

Section 19: Where To Go From Here?

Lecture 320 Thank You!

Lecture 321 Become An Alumni

Lecture 322 Learning Guideline

Lecture 323 LinkedIn Endorsements

Lecture 324 Coding Challenges

Section 20: Extra: Deno vs Node.js

Lecture 325 Quick Note: Upcoming Videos

Lecture 326 Why Deno?

Lecture 327 Deno Runtime And V8 Engine

Lecture 328 Deno Installation

Lecture 329 Quick Note: Installing Deno

Lecture 330 MAC/LINUX Installation Tips

Lecture 331 WINDOWS Installation Tips

Lecture 332 Setting Up Our Developer Environment

Lecture 333 Quick Note: Official VS Code Plugin

Lecture 334 Our First Deno App

Lecture 335 Exercise: Our First Deno App

Lecture 336 The Most Important Video

Lecture 337 Deno Internals And Architecture

Lecture 338 Deno Metrics

Lecture 339 Exercise: Deno Architecture

Lecture 340 Deno 1.5 Compiler Update

Lecture 341 Deno Game Changers

Lecture 342 Deno Game Changers 2

Lecture 343 Will Deno Kill NodeJS?

Lecture 344 Single Executable To Rule Them All

Lecture 345 Exciting Times: Deno 1.6

Lecture 346 Deno Security

Lecture 347 Deno Permissions

Lecture 348 Deno Permissions 2

Lecture 349 Deno Permissions 3

Section 21: Appendix: How JavaScript Works

Lecture 350 Quick Note: Upcoming Videos

Lecture 351 JavaScript Engine

Lecture 352 Exercise: Javascript Engine

Lecture 353 Inside the Engine

Lecture 354 Exercise: JS Engine For All

Lecture 355 Interpreters and Compilers

Lecture 356 Inside the V8 Engine

Lecture 357 Comparing Other Languages

Lecture 358 Writing Optimized Code

Lecture 359 WebAssembly

Lecture 360 Call Stack and Memory Heap

Lecture 361 Stack Overflow

Lecture 362 Garbage Collection

Lecture 363 Memory Leaks

Lecture 364 Single Threaded

Lecture 365 Exercise: Issue With Single Thread

Lecture 366 Javascript Runtime

Lecture 367 Node.js

Lecture 368 Recommended Path: Back To Node

Section 22: Appendix: Asynchronous JavaScript

Lecture 369 Quick Note: Upcoming Videos

Lecture 370 Section Overview

Lecture 371 Promises

Lecture 372 ES8 - Async Await

Lecture 373 ES9 (ES2018)

Lecture 374 ES9 (ES2018) - Async

Lecture 375 Job Queue

Lecture 376 Parallel, Sequence and Race

Lecture 377 ES2020: allSettled()

Lecture 378 Threads, Concurrency and Parallelism

Lecture 379 Recommended Path: Back To Node

Section 23: Appendix: Pong Front End

Lecture 380 Quick Note: Upcoming Videos

Lecture 381 Pong Project Overview

Lecture 382 JS - Create Canvas

Lecture 383 JS - RequestAnimationFrame

Lecture 384 JS - Game Over

Lecture 385 Code Review

Lecture 386 Recommended Path: Back to Sockets

Section 24: Appendix: TypeScript

Lecture 387 Quick Note: Upcoming Videos

Lecture 388 Introduction To TypeScript

Lecture 389 Dynamic vs Static Typing

Lecture 390 Strongly vs Weakly Typed

Lecture 391 Static Typing In JavaScript

Lecture 392 Quick Note: Upcoming Videos

Lecture 393 OPTIONAL: Installing TypeScript Compiler

Lecture 394 OPTIONAL: Installing Node.js + TypeScript

Lecture 395 TypeScript

Lecture 396 TypeScript 2

Lecture 397 TypeScript 3

Lecture 398 Resources: TypeScript Types

Lecture 399 TypeScript 4

Lecture 400 TypeScript 5

Lecture 401 TypeScript 6

Lecture 402 Resources: Type VS Interface

Lecture 403 TypeScript 7

Lecture 404 Resources: Type Assertion

Lecture 405 TypeScript 8

Lecture 406 TypeScript 9

Lecture 407 TypeScript 10

Section 25: Appendix: SQL

Lecture 408 Quick Note: Upcoming Videos

Lecture 409 Exercise: Building Amazon

Lecture 410 Exercise: Building Amazon 2

Lecture 411 5 Types Of Databases

Lecture 412 Exercise: What Is A Database?

Lecture 413 SQL Playground

Lecture 414 What Is SQL?

Lecture 415 What Is A Query?

Lecture 416 Exercise: Setting Up Your First Database

Lecture 417 Imperative vs Declarative

Lecture 418 History of SQL

Lecture 419 Optional: History of SQL Deep Dive

Lecture 420 Exercises: The Select Statement

Lecture 421 SQL Standards

Lecture 422 Tables

Lecture 423 Columns

Lecture 424 Rows

Lecture 425 Primary And Foreign Keys

Lecture 426 Relational vs NoSQL, PostgreSQL vs MongoDB Databases

Lecture 427 Scalability

Lecture 428 Sharding

Lecture 429 Recommended Path: Back to Node

Section 26: BONUS SECTION

Lecture 430 Special Bonus Lecture

Students who are interested in going beyond a normal "beginner" tutorial,Programmers who want to learn the most in demand skills of a backend developer,Developers that want to be in the top 10% of NodeJS developers,Students who want to gain experience working on scalable large scale applications,Bootcamp or online tutorial graduates that want to go beyond the basics,Any backend developer who wants to learn NodeJS,Web developers and Front End Developers who want to get into the backend development world or become Fullstack Developers