Complete Nodejs Developer In 2022 (Graphql, Mongodb, + 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 jаvascript 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 jаvascript, 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 jаvascript
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 jаvascript 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 jаvascript
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 jаvascript Works
Lecture 346 Quick Note: Upcoming Videos
Lecture 347 jаvascript Engine
Lecture 348 Exercise: jаvascript 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 jаvascript Runtime
Lecture 363 Node.js
Lecture 364 Recommended Path: Back To Node
Section 22: Appendix: Asynchronous jаvascript
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 jаvascript
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

Homepage

https://www.udemy.com/course/complete-nodejs-developer-zero-to-mastery/