Mô tả

Just released with all new NodeJS best practices and trends for 2023! Join a live online community of over 900,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 2023. 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. Foundations

  • Focus on Node internals

  • Libuv, threads, processes, event loop

  • Asynchronous programming

  • Node vs PHP vs Python

  • Observer Design Pattern

  • Event Emitters


2. Module System

  • The require Function

  • Creating Your Own Modules

  • CommonJS vs ECMAScript (ES6) modules

  • Module Caching

  • Using index.js


3. Package Management

  • NPM: The Node Package Manager

  • Creating Your Own Packages

  • Package And the NPM Registry

  • Third Party Modules

  • The node_modules Folder

  • Semantic Versioning

  • package-lock.json And Versioning

  • Vulnerabilities in Dependencies


4. File I/O: Planets Project

  • Exploring Exoplanets With Node

  • Exploring Kepler Space Telescope Data

  • Working With Streams

  • Streaming Large Data Files

  • Parsing Our Planets Data

  • Working With CSV Files

  • Finding Habitable Planets


5. Web Servers

  • What is a Web Server?

  • HTTP Responses and Requests

  • HTTP APIs and Routing, Parameterized URLs

  • Same Origin Policy, CORS

  • Requests and Responses as Streams


6. Express.js

  • Express vs Next.js vs Koa

  • Route Parameters

  • Model View Controller (MVC) pattern

  • Postman and Insomnia

  • Development Dependencies

  • Middleware

  • Logging Middleware Example / Writing Our Own Middleware

  • POST Requests in Express

  • MVC In Express

  • Express Routers

  • RESTful APIs

  • CRUD

  • Sending Files

  • Serving Websites With Node

  • Templating Engines


7. NodeJS NASA Project

  • Architecture diagrams on LucidChart

  • GET, POST, DELETE routes.

  • Serving React.js Applications in Express

  • CORS middleware

  • Models vs Controllers vs Routers

  • Loading Data On Startup

  • Automating Full Stack Applications With NPM

  • Serving React Front End (in Production)

  • Logging Requests with Morgan

  • Serving Applications With Client Side Routing

  • Building A Data Access Layer

  • Integrating with Frontend, Top Down Approach, Bottom Up Approach

  • Updating Our Architecture


8. Testing APIs

  • Unit tests vs API tests vs UI tests

  • Testing Node APIs with Jest and Supertest


9. Improving Node Performance

  • Example app which blocks event loop + real life blocking functions

  • Node Cluster Module theory + in action

  • Clustering in the real world

  • Load balancing

  • PM2 theory + in action

  • Managing Live Clusters with PM2

  • Zero Downtime Restarts

  • Improving Performance of NASA Project

  • Stateless APIs

  • Node Worker Threads


10. Databases

  • Using MongoDB to add persistence to NASA Project

  • Big focus on NoSQL vs SQL, PostgreSQL vs MongoDB, when to use both including Trends, Object-Relational Mismatch, ACID, References, Schemas. Schema-less vs Schemas

  • MongoDB Atlas

  • Horizontally Scaling Databases

  • Mongoose

  • Mongoose Models vs MVC Models

  • ObjectIDs in MongoDB

  • Pagination

  • Choosing A Database For Our NASA API


11. Working With REST APIs

  • Demonstrate integrating with a REST API by working with SpaceX API

  • Versioning REST APIs

  • Running Search Queries

  • SpaceX Launch Data

  • Mapping API Data to Our Database

  • Using Paginated APIs

  • Adding Pagination To Our API


12. Authentication

  • Focus on Security first principles with JWT, cookies, CSRF

  • Servers with HTTPS and SSL / TLS

  • Helmet.js

  • Working With Auth0


13. Deployment and CI/CD

  • Focus on building out a simple CI pipeline for NASA Project on GitHub

  • What is CI vs CD?

  • Automated tests

  • Dynamic configuration with secrets


14. Node Production and the Cloud (AWS)

  • Deploy to production with Docker to Amazon EC2

  • Virtual Machines

  • Serverless vs Containers

  • Docker files

  • Managing Docker Containers and Images

  • Working With SSH

  • Production Deployment with PM2 and Mongo Atlas


15. GraphQL

  • GraphQL vs REST

  • Building a GraphQL API


16. Sockets (WebSockets, Socket io)

  • Sockets overview

  • Sockets vs polling

  • WebSockets (vs Socket io)

  • Socket io Client and Server APIs

  • Broadcasting Events

  • Build out Full Stack Multiplayer Pong with Sockets

  • Implementing Pong Game Logic

  • Using Socket io With Express.js

  • Namespaces and Rooms


17~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!

Bạn sẽ học được gì

Yêu cầu

Nội dung khoá học

26 sections

Introduction

9 lectures
Course Outline
06:22
Join Our Online Classroom!
04:01
Exercise: Meet Your Classmates and Instructor
01:41
Node.js - How We Got Here
09:19
Node.js Runtime
08:19
How To Succeed In The Course
03:59
Latest Version Of Node.js
01:16
Course Projects + Code + Resources
00:17
ZTM Resources
04:23

Node.js Fundamentals: Foundations and Environment Setup

11 lectures
OPTIONAL: Installing Node.js
06:22
OPTIONAL: Windows Installation Tips
03:05
The Node.js Release Cycle
04:05
The Node.js REPL
06:08
Web Developer Monthly
00:22
Setting Up Our Developer Environment
04:30
Our First Node.js App
11:35
Node.js VS JavaScript
05:45
The global Object
05:45
Introduction to Backend VS Frontend
08:55
Monthly Coding Challenges, Free Resources and Guides
00:40

Node.js Fundamentals: Internals

17 lectures
What Node.js Includes
09:38
Node Internals Deep Dive
10:57
libuv Internals Deep Dive
12:53
Synchronous vs Asynchronous
05:23
Asynchronous Callbacks
05:55
Non-Blocking Input & Output
03:32
Exercise: Is JavaScript Asynchronous?
02:27
Multi-Threading, Processes, and Threads
11:40
Is Node.js Multi-Threaded?
10:56
The Event Loop
04:03
Callback Queues
04:51
Phases of the Event Loop
09:18
Comparing Node With PHP and Python
06:33
What Is Node.js Best At?
04:52
Observer Design Pattern
05:27
The Node Event Emitter
14:06
Recommended Path: Asynchronous JavaScript
00:38

Node.js Fundamentals: Module System

10 lectures
The require Function
02:49
Making HTTP Requests
11:09
Why Use Modules?
04:05
Creating Our Own Modules
13:02
Exporting From Modules
04:03
CommonJS vs ECMAScript Modules
04:11
Creating Our Own ECMAScript Modules
06:31
Module Caching
07:42
Using index.js
08:40
Should We Use index.js?
04:42

Node.js Fundamentals: Package Management

10 lectures
NPM: The Node Package Manager
04:39
Creating Our First NPM Package
09:23
Packages And The NPM Registry
01:56
Using Third Party Modules
11:11
The node_modules Folder
09:54
Semantic Versioning
02:37
package-lock.json and Versioning
09:42
Vulnerabilities In Dependencies
04:54
Installing NPM Tools: nodemon
09:56
LinkedIn Endorsements
00:40

Node.js File I/O - Planets Project

10 lectures
Code For This Section
00:17
Exploring Planets With Node
01:49
Importing Kepler Space Telescope Data
04:52
Setting Up Our CSV Parser
05:24
Latest Version of CSV Parser
00:17
Streaming Large Data Files
05:32
Reading Our Planets Data
06:48
Parsing Our Planets Data
06:04
Finding Habitable Planets
08:26
Exploring Habitable Planets
07:18

Web Servers with Node.js

14 lectures
Code For This Section
00:10
What is a Web Server?
05:24
Introduction to HTTP Responses and Requests
03:57
HTTP Requests
07:41
HTTP Responses
13:36
Our First Webserver
10:12
HTTP APIs and Routing
09:00
Parameterized URLs
10:37
Same Origin Policy
09:23
Exercise: Same Origin Policy
00:50
Cross Origin Resource Sharing (CORS)
10:29
POSTing Data to the Server
11:31
Requests and Responses as Streams
11:50
Web Servers Recap
04:05

First Express.js API

19 lectures
Code For This Section
00:10
Why Express?
03:35
Introduction to Express
09:36
Express vs Next.js vs Koa
11:18
Route Parameters
09:04
Postman and Insomnia
06:07
Development Dependencies
03:49
Middleware
07:30
Writing Our Own Logging Middleware
10:25
POST Requests in Express
16:21
Model View Controller (MVC)
07:38
Model View Controller in Express
18:30
Express Routers
16:38
RESTful APIs
11:39
Create Read Update and Delete (CRUD)
06:56
Sending Files
06:06
Serving Websites With Node
09:45
Templating Engines
11:33
Layouts and Separation of Concerns
07:43

NASA Project

30 lectures
Code For This Section
00:16
Introduction & Architecture
11:02
NASA Dashboard Front End Setup
05:47
NASA Dashboard Functionality
05:11
What You Need To Know
02:14
React.js Front End Code Walkthrough
18:10
API Server Setup
12:32
Environment Variables On Windows
00:16
GET /planets
15:32
CORS Middleware
07:22
Models vs Controllers vs Routers
04:41
The Planets Model
05:30
Loading Data On Startup
15:39
Common Issues With NPM Scripts
00:46
Automating Full Stack Applications With NPM
13:44
Serving React.js Front End In Production
12:15
Setting BUILD_PATH On Windows
00:21
Logging Requests With Morgan
08:44
The Launches Model
12:56
GET /launches
16:56
Serving Applications With Client Side Routing
05:58
Working With Data Models: Building a Data Access Layer
08:49
POST /launches: Creating Launches 1
13:15
POST /launches: Creating Launches 2
10:41
POST /launches: Validation For POST Requests
12:39
Connecting POST /launches With Front End Dashboard
13:39
DELETE /launches: Aborting Launches 1
13:05
DELETE /launches: Aborting Launches 2
12:00
Updating Our Architecture Diagram
11:42
Exercise: Imposter Syndrome
02:55

Testing APIs

5 lectures
Testing In Node
03:26
Testing APIs With Jest
14:21
Testing API Endpoints With Supertest: GET
08:03
Testing API Endpoints With Supertest: POST
09:09
Testing API Endpoints With Supertest: Error Cases
06:48

Improving Node Performance

16 lectures
Code For This Section
00:10
Node Server Performance
04:15
Building A Simple Blocking Server
10:20
Real Life Blocking Functions
08:47
Running Multiple Node Processes
03:18
The Node Cluster Module
04:17
Clustering In Action
12:27
Maximizing Cluster Performance
07:40
Load Balancing
05:36
The PM2 Tool
02:26
Using PM2 To Create Clusters
09:38
Managing Live Clusters With PM2
06:10
Zero Downtime Restart
03:46
Improving Performance Of Our NASA Project
08:06
Worker Threads
08:21
Worker Threads In Action
08:15

Databases

35 lectures
Introduction to Databases
03:46
Recommended Path: SQL
00:26
Comparing SQL vs NoSQL
08:10
Database Schemas & Schemaless Databases
03:45
Choosing a Database for our NASA Project
05:32
SQL vs MongoDB: Trends and Object-Relational Impedance Mismatch
08:18
SQL vs MongoDB: Schemas, References, and ACID Transactions
14:19
Setting up MongoDB Atlas
12:55
Connecting to MongoDB
08:54
Connecting with the Latest Version of Mongoose
00:21
Mongoose
05:24
Creating Mongoose Schema for Launches
15:18
Exercise: Creating Mongoose Schema for Planets
05:29
Reminder: Destination Planets Dropdown
00:24
Creating Models From Schemas
04:30
Mongoose Models vs MVC Models
04:15
Creating and Inserting Documents
08:09
Finding Documents
06:48
The Upsert Operation
08:20
Exploring Data Using Atlas
04:52
Updating Project Architecture
05:09
ObjectIDs
03:51
Excluding Fields From The Response
03:30
Saving Launches
04:51
Listing All Launches
02:57
Referential Integrity
10:56
Auto Increment In MongoDB
07:28
Getting Latest Flight Number
05:58
Scheduling New Launches
09:00
Investigating A Mongoose Mystery
07:10
Aborting Launches
12:54
Aborting with the Latest MongoDB Driver
00:19
Updating Tests For Mongoose 1
15:02
Updating Tests For Mongoose 2
10:00
Fixing A Bug In Jest: Open Handles
00:25

Working With REST APIs - SpaceX Project

18 lectures
Working With SpaceX
02:47
The SpaceX API
03:22
Versioning Node APIs
09:09
Updating Our API Tests
01:00
Exploring SpaceX Launches API
05:39
Running Search Queries
13:04
Loading SpaceX Data In Our API
14:51
Mapping SpaceX Data To Our Database
11:56
Using Paginated APIs
07:59
Minimizing API Load
08:18
Persisting SpaceX Launches
06:40
Paginating Our Endpoints 1
07:57
Paginating Our Endpoints 2
15:27
Sorting Paginated Data
03:48
Cleaning Up Launch Data
03:33
Managing Secrets With Dotenv
09:04
Running API Tests With Dotenv
00:18
Securing Leaked Secrets
05:09

Node Security + Authentication

33 lectures
Code For This Section
00:10
Security and Authentication Overview
03:43
Encrypted Connections with SSL and TLS
06:28
Digital Certificates, Signing, and Man In The Middle Attacks
05:42
Setting Up Our Security Example
04:18
HTTPS With Node, Self Signed Certificates, and Public Key Cryptography
16:17
Helmet.js
09:46
Authentication vs Authorization
07:28
Social Sign In
05:11
API Keys
11:03
JWT Tokens
14:31
The OAuth Standard
05:40
OAuth 2.0 Authorization Code Flow
06:34
OAuth In Action with Single Sign On
15:15
Registering with the Google Authorization Server
14:11
Authentication Endpoints With Middleware
11:07
Passport.js
03:24
Dotenv for Client Secrets
08:23
Authentication With Google And OAuth 1
11:11
Authentication With Google And OAuth 2
11:45
Cookie Based Authentication
06:54
Sessions
03:33
Server VS Client Side Sessions With Cookies
09:04
Session Middleware in Express
09:50
Setting Up OAuth Cookie Session
12:33
Sessions with the Latest Version of Passport.js
00:20
Reading and Writing the OAuth Session 1
13:02
Reading and Writing the OAuth Session 2
06:44
Restricting Access to Endpoints
07:53
Implementing Logout
07:12
Experimenting With Fake Sessions
05:11
Wrap Up and Next Steps
05:54
Resource: Security Cheat Sheet
00:17

Continuous Integration and Delivery

16 lectures
Introduction to CI and CD
06:41
Continuous Integration
08:23
Continuous Delivery
09:37
Continuous Deployment
06:00
Pipelines
04:26
GitHub Actions
09:42
Setting Up GitHub Actions
05:36
Continuous Integration: Build Pipeline
12:01
Keeping Our Pipeline Updated
00:20
Build Pipeline In Action
08:37
Common Build Pipeline Errors
00:28
GitHub Actions Marketplace
03:07
Continuous Integration: Test Pipeline
11:20
Mocking Out Databases
05:18
Databases With Continuous Integration
10:18
Populating Data For Continuous Integration
08:50

Node Production and the Cloud (Docker + AWS)

21 lectures
Deploying to the Cloud
02:14
Serverless vs Containers
03:58
Virtual Machines
04:16
What is a Container?
04:59
Installing Docker
03:28
Running Our First Docker Container
05:38
Your DockerHub Account
01:39
Creating a Dockerfile
14:02
Improving Our Dockerfile With Layers
13:22
Installing Only Production Dependencies
00:16
Updating Our API URL
02:16
Building NASA Project Docker Image
05:36
Running NASA Project in a Container
04:29
Pushing Images to Docker Hub
03:46
Exploring Amazon Web Services
06:28
Creating an EC2 Instance 1
07:50
Creating an EC2 Instance 2: Security
13:10
What is SSH?
02:58
Connecting To Our EC2 Instance With SSH
07:48
Setting Up Our EC2 Server
05:45
Deploying Our NASA API
10:38

GraphQL

22 lectures
Code For This Section
00:10
GraphQL Overview
08:03
Our First GraphQL Query
08:15
GraphQL Queries In Action
05:47
GraphQL vs REST: Over-fetching & Under-fetching
10:52
GraphQL vs REST Summary
10:08
Exploring GraphQL Implementations
03:24
GraphQL In Node
11:01
GraphiQL
04:25
Designing An E-Commerce Schema
16:01
GraphQL Tools
03:39
Modularizing Large GraphQL Projects: Schemas
14:01
GraphQL Tools Update
00:15
Resolvers
09:01
Modularizing Large GraphQL Projects: Resolvers
09:27
Filtering with Queries and Resolvers
10:20
Exercise: Query Products By ID
05:30
Mutations In Action
06:40
Implementing Mutations on the Server
10:10
Exercise: Add New Product Review
10:58
GraphQL With Apollo
07:15
Building an Apollo Server With Node.js
13:19

Sockets with Node.js

25 lectures
Code For This Section
00:10
Introduction to Sockets
02:11
Polling
03:57
What is a Socket?
02:58
Sockets VS Polling
05:01
WebSockets
05:25
Introduction to socket.io
03:20
socket.io Client and Server APIs
08:43
Multiplayer Pong Overview
03:31
Recommended Path: Pong Front End
00:27
Reviewing Our Pong Front End
11:57
Multiplayer Pong Message Sequence
07:38
Setting Up a socket.io Server
04:29
Connecting to socket.io
04:03
Handling CORS With Sockets
00:22
Identifying Connected Clients
06:38
Listening for Events in the Pong Server
03:08
Broadcasting Events
02:46
Handling Events in the Pong Client
07:15
Implementing the Game Logic: Paddle
09:20
Implementing the Game Logic: Ball
08:46
What Happens When You Disconnect?
05:23
Using Socket.io with Express
11:44
Namespaces
06:05
Rooms
10:39

Where To Go From Here?

5 lectures
Thank You!
01:17
Become An Alumni
00:37
Learning Guideline
00:09
LinkedIn Endorsements
00:40
Coding Challenges
00:29

Extra: Deno vs Node.js

25 lectures
Quick Note: Upcoming Videos
00:15
Why Deno?
06:00
Deno Runtime And V8 Engine
05:25
Deno Installation
04:41
Quick Note: Installing Deno
00:22
MAC/LINUX Installation Tips
05:33
WINDOWS Installation Tips
01:17
Setting Up Our Developer Environment
05:15
Quick Note: Official VS Code Plugin
00:15
Our First Deno App
08:18
Exercise: Our First Deno App
00:18
The Most Important Video
00:59
Deno Internals And Architecture
12:39
Deno Metrics
06:50
Exercise: Deno Architecture
04:01
Deno 1.5 Compiler Update
00:08
Deno Game Changers
09:58
Deno Game Changers 2
07:56
Will Deno Kill NodeJS?
02:08
Single Executable To Rule Them All
04:08
Exciting Times: Deno 1.6
00:15
Deno Security
08:09
Deno Permissions
06:24
Deno Permissions 2
03:09
Deno Permissions 3
05:10

Appendix: How JavaScript Works

19 lectures
Quick Note: Upcoming Videos
00:09
JavaScript Engine
05:28
Exercise: Javascript Engine
00:56
Inside the Engine
04:05
Exercise: JS Engine For All
02:33
Interpreters and Compilers
06:21
Inside the V8 Engine
08:56
Comparing Other Languages
04:15
Writing Optimized Code
08:53
WebAssembly
03:15
Call Stack and Memory Heap
14:37
Stack Overflow
03:20
Garbage Collection
04:30
Memory Leaks
06:34
Single Threaded
01:58
Exercise: Issue With Single Thread
02:40
Javascript Runtime
14:07
Node.js
06:27
Recommended Path: Back To Node
00:12

Appendix: Asynchronous JavaScript

11 lectures
Quick Note: Upcoming Videos
00:09
Section Overview
04:51
Promises
22:26
ES8 - Async Await
15:22
ES9 (ES2018)
05:21
ES9 (ES2018) - Async
11:11
Job Queue
06:55
Parallel, Sequence and Race
10:00
ES2020: allSettled()
04:22
Threads, Concurrency and Parallelism
11:27
Recommended Path: Back To Node
00:11

Appendix: Pong Front End

7 lectures
Quick Note: Upcoming Videos
00:10
Pong Project Overview
02:03
JS - Create Canvas
15:50
JS - RequestAnimationFrame
17:44
JS - Game Over
13:14
Code Review
05:17
Recommended Path: Back to Sockets
00:20

Appendix: TypeScript

21 lectures
Quick Note: Upcoming Videos
00:10
Introduction To TypeScript
01:27
Dynamic vs Static Typing
11:50
Strongly vs Weakly Typed
03:18
Static Typing In JavaScript
09:45
Quick Note: Upcoming Videos
00:20
OPTIONAL: Installing TypeScript Compiler
03:41
OPTIONAL: Installing Node.js + TypeScript
00:31
TypeScript
11:33
TypeScript 2
03:16
TypeScript 3
07:24
Resources: TypeScript Types
00:09
TypeScript 4
05:38
TypeScript 5
06:39
TypeScript 6
04:48
Resources: Type VS Interface
00:02
TypeScript 7
03:34
Resources: Type Assertion
00:04
TypeScript 8
06:04
TypeScript 9
01:21
TypeScript 10
01:23

Appendix: SQL

22 lectures
Quick Note: Upcoming Videos
00:10
Exercise: Building Amazon
05:34
Exercise: Building Amazon 2
05:28
5 Types Of Databases
05:37
Exercise: What Is A Database?
01:11
SQL Playground
01:54
What Is SQL?
02:17
What Is A Query?
06:27
Exercise: Setting Up Your First Database
00:31
Imperative vs Declarative
03:23
History of SQL
02:21
Optional: History of SQL Deep Dive
00:10
Exercises: The Select Statement
00:12
SQL Standards
04:25
Tables
03:45
Columns
04:07
Rows
02:27
Primary And Foreign Keys
05:03
Relational vs NoSQL, PostgreSQL vs MongoDB Databases
10:35
Scalability
04:19
Sharding
03:04
Recommended Path: Back to Node
00:17

BONUS SECTION

1 lectures
Special Bonus Lecture
00:16

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.