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

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 + Cheatsheet

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 Creating Models From Schemas

Lecture 165 Mongoose Models vs MVC Models

Lecture 166 Creating and Inserting Documents

Lecture 167 Finding Documents

Lecture 168 The Upsert Operation

Lecture 169 Exploring Data Using Atlas

Lecture 170 Updating Project Architecture

Lecture 171 ObjectIDs

Lecture 172 Excluding Fields From The Response

Lecture 173 Saving Launches

Lecture 174 Listing All Launches

Lecture 175 Referential Integrity

Lecture 176 Auto Increment In MongoDB

Lecture 177 Getting Latest Flight Number

Lecture 178 Scheduling New Launches

Lecture 179 Investigating A Mongoose Mystery

Lecture 180 Aborting Launches

Lecture 181 Aborting with the Latest MongoDB Driver

Lecture 182 Updating Tests For Mongoose 1

Lecture 183 Updating Tests For Mongoose 2

Lecture 184 Fixing A Bug In Jest: Open Handles

Section 13: Working With REST APIs - SpaceX Project

Lecture 185 Working With SpaceX

Lecture 186 The SpaceX API

Lecture 187 Versioning Node APIs

Lecture 188 Updating Our API Tests

Lecture 189 Exploring SpaceX Launches API

Lecture 190 Running Search Queries

Lecture 191 Loading SpaceX Data In Our API

Lecture 192 Mapping SpaceX Data To Our Database

Lecture 193 Using Paginated APIs

Lecture 194 Minimizing API Load

Lecture 195 Persisting SpaceX Launches

Lecture 196 Paginating Our Endpoints 1

Lecture 197 Paginating Our Endpoints 2

Lecture 198 Sorting Paginated Data

Lecture 199 Cleaning Up Launch Data

Lecture 200 Managing Secrets With Dotenv

Lecture 201 Running API Tests With Dotenv

Lecture 202 Securing Leaked Secrets

Section 14: Node Security + Authentication

Lecture 203 Code For This Section

Lecture 204 Security and Authentication Overview

Lecture 205 Encrypted Connections with SSL and TLS

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

Lecture 207 Setting Up Our Security Example

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

Lecture 209 Helmet.js

Lecture 210 Authentication vs Authorization

Lecture 211 Social Sign In

Lecture 212 API Keys

Lecture 213 JWT Tokens

Lecture 214 The OAuth Standard

Lecture 215 OAuth 2.0 Authorization Code Flow

Lecture 216 OAuth In Action with Single Sign On

Lecture 217 Registering with the Google Authorization Server

Lecture 218 Authentication Endpoints With Middleware

Lecture 219 Passport.js

Lecture 220 Dotenv for Client Secrets

Lecture 221 Authentication With Google And OAuth 1

Lecture 222 Authentication With Google And OAuth 2

Lecture 223 Cookie Based Authentication

Lecture 224 Sessions

Lecture 225 Server VS Client Side Sessions With Cookies

Lecture 226 Session Middleware in Express

Lecture 227 Setting Up OAuth Cookie Session

Lecture 228 Sessions with the Latest Version of Passport.js

Lecture 229 Reading and Writing the OAuth Session 1

Lecture 230 Reading and Writing the OAuth Session 2

Lecture 231 Restricting Access to Endpoints

Lecture 232 Implementing Logout

Lecture 233 Experimenting With Fake Sessions

Lecture 234 Wrap Up and Next Steps

Lecture 235 Resource: Security Cheat Sheet

Section 15: Continuous Integration and Delivery

Lecture 236 Introduction to CI and CD

Lecture 237 Continuous Integration

Lecture 238 Continuous Delivery

Lecture 239 Continuous Deployment

Lecture 240 Pipelines

Lecture 241 GitHub Actions

Lecture 242 Setting Up GitHub Actions

Lecture 243 Continuous Integration: Build Pipeline

Lecture 244 Build Pipeline In Action

Lecture 245 GitHub Actions Marketplace

Lecture 246 Continuous Integration: Test Pipeline

Lecture 247 Mocking Out Databases

Lecture 248 Databases With Continuous Integration

Lecture 249 Populating Data For Continuous Integration

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

Lecture 250 Deploying to the Cloud

Lecture 251 Serverless vs Containers

Lecture 252 Virtual Machines

Lecture 253 What is a Container?

Lecture 254 Installing Docker

Lecture 255 Running Our First Docker Container

Lecture 256 Your DockerHub Account

Lecture 257 Creating a Dockerfile

Lecture 258 Improving Our Dockerfile With Layers

Lecture 259 Updating Our API URL

Lecture 260 Building NASA Project Docker Image

Lecture 261 Running NASA Project in a Container

Lecture 262 Pushing Images to Docker Hub

Lecture 263 Exploring Amazon Web Services

Lecture 264 Creating an EC2 Instance 1

Lecture 265 Creating an EC2 Instance 2: Security

Lecture 266 What is SSH?

Lecture 267 Connecting To Our EC2 Instance With SSH

Lecture 268 Setting Up Our EC2 Server

Lecture 269 Deploying Our NASA API

Section 17: GraphQL

Lecture 270 Code For This Section

Lecture 271 GraphQL Overview

Lecture 272 Our First GraphQL Query

Lecture 273 GraphQL Queries In Action

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

Lecture 275 GraphQL vs REST Summary

Lecture 276 Exploring GraphQL Implementations

Lecture 277 GraphQL In Node

Lecture 278 GraphiQL

Lecture 279 Designing An E-Commerce Schema

Lecture 280 GraphQL Tools

Lecture 281 Modularizing Large GraphQL Projects: Schemas

Lecture 282 Resolvers

Lecture 283 Modularizing Large GraphQL Projects: Resolvers

Lecture 284 Filtering with Queries and Resolvers

Lecture 285 Exercise: Query Products By ID

Lecture 286 Mutations In Action

Lecture 287 Implementing Mutations on the Server

Lecture 288 Exercise: Add New Product Review

Lecture 289 GraphQL With Apollo

Lecture 290 Building an Apollo Server With Node.js

Section 18: Sockets with Node.js

Lecture 291 Code For This Section

Lecture 292 Introduction to Sockets

Lecture 293 Polling

Lecture 294 What is a Socket?

Lecture 295 Sockets VS Polling

Lecture 296 WebSockets

Lecture 297 Introduction to socket.io

Lecture 298 socket.io Client and Server APIs

Lecture 299 Multiplayer Pong Overview

Lecture 300 Recommended Path: Pong Front End

Lecture 301 Reviewing Our Pong Front End

Lecture 302 Multiplayer Pong Message Sequence

Lecture 303 Setting Up a socket.io Server

Lecture 304 Connecting to socket.io

Lecture 305 Handling CORS With Sockets

Lecture 306 Identifying Connected Clients

Lecture 307 Listening for Events in the Pong Server

Lecture 308 Broadcasting Events

Lecture 309 Handling Events in the Pong Client

Lecture 310 Implementing the Game Logic: Paddle

Lecture 311 Implementing the Game Logic: Ball

Lecture 312 What Happens When You Disconnect?

Lecture 313 Using Socket.io with Express

Lecture 314 Namespaces

Lecture 315 Rooms

Section 19: Where To Go From Here?

Lecture 316 Thank You!

Lecture 317 Become An Alumni

Lecture 318 Learning Guideline

Lecture 319 LinkedIn Endorsements

Lecture 320 Coding Challenges

Section 20: Extra: Deno vs Node.js

Lecture 321 Quick Note: Upcoming Videos

Lecture 322 Why Deno?

Lecture 323 Deno Runtime And V8 Engine

Lecture 324 Deno Installation

Lecture 325 Quick Note: Installing Deno

Lecture 326 MAC/LINUX Installation Tips

Lecture 327 WINDOWS Installation Tips

Lecture 328 Setting Up Our Developer Environment

Lecture 329 Quick Note: Official VS Code Plugin

Lecture 330 Our First Deno App

Lecture 331 Exercise: Our First Deno App

Lecture 332 The Most Important Video

Lecture 333 Deno Internals And Architecture

Lecture 334 Deno Metrics

Lecture 335 Exercise: Deno Architecture

Lecture 336 Deno 1.5 Compiler Update

Lecture 337 Deno Game Changers

Lecture 338 Deno Game Changers 2

Lecture 339 Will Deno Kill NodeJS?

Lecture 340 Single Executable To Rule Them All

Lecture 341 Exciting Times: Deno 1.6

Lecture 342 Deno Security

Lecture 343 Deno Permissions

Lecture 344 Deno Permissions 2

Lecture 345 Deno Permissions 3

Section 21: Appendix: How JavaScript Works

Lecture 346 Quick Note: Upcoming Videos

Lecture 347 JavaScript Engine

Lecture 348 Exercise: Javascript Engine

Lecture 349 Inside the Engine

Lecture 350 Exercise: JS Engine For All

Lecture 351 Interpreters and Compilers

Lecture 352 Inside the V8 Engine

Lecture 353 Comparing Other Languages

Lecture 354 Writing Optimized Code

Lecture 355 WebAssembly

Lecture 356 Call Stack and Memory Heap

Lecture 357 Stack Overflow

Lecture 358 Garbage Collection

Lecture 359 Memory Leaks

Lecture 360 Single Threaded

Lecture 361 Exercise: Issue With Single Thread

Lecture 362 Javascript Runtime

Lecture 363 Node.js

Lecture 364 Recommended Path: Back To Node

Section 22: Appendix: Asynchronous JavaScript

Lecture 365 Quick Note: Upcoming Videos

Lecture 366 Section Overview

Lecture 367 Promises

Lecture 368 ES8 - Async Await

Lecture 369 ES9 (ES2018)

Lecture 370 ES9 (ES2018) - Async

Lecture 371 Job Queue

Lecture 372 Parallel, Sequence and Race

Lecture 373 ES2020: allSettled()

Lecture 374 Threads, Concurrency and Parallelism

Lecture 375 Recommended Path: Back To Node

Section 23: Appendix: Pong Front End

Lecture 376 Quick Note: Upcoming Videos

Lecture 377 Pong Project Overview

Lecture 378 JS - Create Canvas

Lecture 379 JS - RequestAnimationFrame

Lecture 380 JS - Game Over

Lecture 381 Code Review

Lecture 382 Recommended Path: Back to Sockets

Section 24: Appendix: TypeScript

Lecture 383 Quick Note: Upcoming Videos

Lecture 384 Introduction To TypeScript

Lecture 385 Dynamic vs Static Typing

Lecture 386 Strongly vs Weakly Typed

Lecture 387 Static Typing In JavaScript

Lecture 388 Quick Note: Upcoming Videos

Lecture 389 OPTIONAL: Installing TypeScript Compiler

Lecture 390 OPTIONAL: Installing Node.js + TypeScript

Lecture 391 TypeScript

Lecture 392 TypeScript 2

Lecture 393 TypeScript 3

Lecture 394 Resources: TypeScript Types

Lecture 395 TypeScript 4

Lecture 396 TypeScript 5

Lecture 397 TypeScript 6

Lecture 398 Resources: Type VS Interface

Lecture 399 TypeScript 7

Lecture 400 Resources: Type Assertion

Lecture 401 TypeScript 8

Lecture 402 TypeScript 9

Lecture 403 TypeScript 10

Section 25: Appendix: SQL

Lecture 404 Quick Note: Upcoming Videos

Lecture 405 Exercise: Building Amazon

Lecture 406 Exercise: Building Amazon 2

Lecture 407 5 Types Of Databases

Lecture 408 Exercise: What Is A Database?

Lecture 409 SQL Playground

Lecture 410 What Is SQL?

Lecture 411 What Is A Query?

Lecture 412 Exercise: Setting Up Your First Database

Lecture 413 Imperative vs Declarative

Lecture 414 History of SQL

Lecture 415 Optional: History of SQL Deep Dive

Lecture 416 Exercises: The Select Statement

Lecture 417 SQL Standards

Lecture 418 Tables

Lecture 419 Columns

Lecture 420 Rows

Lecture 421 Primary And Foreign Keys

Lecture 422 Relational vs NoSQL, PostgreSQL vs MongoDB Databases

Lecture 423 Scalability

Lecture 424 Sharding

Lecture 425 Recommended Path: Back to Node

Section 26: BONUS SECTION

Lecture 426 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