Essential CSS
JavaScript Roadmap
Learn JavaScript
Mastering Web Typography
Practical Astro
Understanding Async JS
Unorthodox Tailwind
API Masterclass
Build and Deploy
The Beginner Freelancer
Real World Node
Profile Billing Logout
Understanding Async JS
Lesson Plan
  1. Introduction
    1. What is Asynchronous JS?
    2. Callbacks are not automatically asynchronous
    3. What is an API?
    4. Evolution of HTTP APIs
    5. Ajax vs Asynchronous JavaScript
  2. Fundamental Concepts
    1. How to fetch resources
    2. Using XHR
    3. Using the Fetch API
    4. Using libraries
    5. Core JavaScript concepts
    6. Understanding Promises
    7. Understanding Async Functions
    8. Understanding the Event Loop
    9. Understanding JSON
    10. Async JS Best Practices
    11. Using Optimistic UI
  3. Understanding Rest API
    1. Diving into Rest APIs
    2. The Rest Architecture
    3. The Rest Structure
    4. Anatomy of a Request
    5. What's an endpoint
    6. Request methods
    7. Understanding request headers
    8. Understanding the request body
    9. Authentication
    10. Basic Authentication
    11. Bearer Authentication
    12. Authenticating with API keys and API Secrets
    13. Cross Origin Resource Sharing
    14. Anatomy of a response
    15. HTTP Statuses
    16. Response headers
    17. The response body
    18. Handling Errors
    19. Reading API documentations
    20. Understanding Curl
  4. Node Basics
    1. Why we are using Node
    2. Command Line Basics
    3. Installing Node
    4. Managing dependencies
    5. Using ES Modules in Node
    6. Using Node
    7. Restarting the server automatically
    8. Sending requests via Node
    9. Protecting API keys and secrets
  5. Building a server
    1. What's a server
    2. Building a simple server with Express
    3. Two kinds of servers
    4. API Server architecture
    5. Handling routes
    6. Understanding Middlewares
    7. Enabling CORS
    8. Receiving data
    9. Sending responses
    10. Handling errors in Express
    11. Using the server as a proxy
    12. Minimum viable server
  6. Open Authorization
    1. Open Authorisation (OAuth)
    2. Authenticating with Access Tokens
    3. Obtaining Access Tokens
    4. Public and Confidential Clients
    5. Authorisation Code Grant
    6. Understanding scope
    7. Proof Key for Code Exchange (PKCE)
    8. PKCE with Twitter
    9. Dynamic state and `code_verifier`
    10. Saving the access token in cookies
    11. Passing access tokens to the browser
    12. Saving the access token in local storage
    13. Refresh Token Grant
    14. Device Code Grant
    15. Client libraries vs REST
  7. Building Social Media Logins
    1. Introduction
    2. Starter Files
    3. Creating SSL certificates
    4. Login in with Github
    5. Github: Saving the token to local storage
    6. Github: Persisting the login status
    7. Login with Twitter
    8. Twitter: Saving the token to local storage
    9. Twitter: Persisting the login status
    10. Twitter: Refreshing the access token
    11. Login with Facebook
    12. Facebook: Saving the token to localStorage
    13. Facebook: Persisting the login status
    14. Facebook: Refreshing the access token
    15. Login with google
    16. Google: Saving the token to localStorage
    17. Google: Refreshing the access token

Callbacks are not automatically asynchronous

2m:27s

It’s a common misconception that callbacks are asynchronous.

It is not.

Let’s examine why.

What’s a Callback?

Callback is an important JavaScript concept you have to understand.

And they’re super simple: They’re just functions that are passed into another function as an argument.

Here’s an example of a simple callback in action.

// `log` is the callback in this example
const items = [1, 2, 3]
items.forEach(log)
function log(item) {
console.log(item)
}

In this case:

  • log is just a function.
  • By itself, log is not a callback.
  • When it is passed into forEach, log becomes a callback.

That’s it.

A more accurate way to define callbacks

The above definition is workable but not accurate.

There’s a more accurate way to define callbacks. Learning this will help you understand why and how we use callbacks.

In this definition: callbacks are accepted into a function as an argument. These functions are then called within the receiving function.

This requires a bit of explanation so let’s consider the following code:

// fn is the callback
function greet (fn) {
const message = "hello world"
fn(message)
}
function sayName (message) {
console.log(message + " my name is Zell Liew")
}
greet(sayMyName)) // Hello world, my name is Zell Liew

In this example:

  • greet takes in a function (fn) as an argument.
  • This fn is a callback.
  • The fn is called somewhere in greet.

Practically both definition work because the callback (either fn or sayName) refer to the same value.

But theoretically, you can see how this deeper definition gives you a better understanding of how and why callbacks are used.

Now let’s move on.

Most callbacks are synchronous

Both callbacks in the above examples are synchronous because they do not wait for anything.

In the forEach example, JavaScript executes each log function without waiting for any events.

const items = [1, 2, 3]
items.forEach(log)
function log(item) {
console.log(item)
}

Likewise, in the detailed (greet and sayMyName) example, JavaScript goes logs the sentence without waiting for any events.

function greet (fn) {
const message = "hello world"
fn(message)
}
function sayName (message) {
console.log(message + " my name is Zell Liew")
}
greet(sayMyName)) // Hello world, my name is Zell Liew

Only a handful of callbacks are asynchronous

Here’s a fun fact: We cannot make asynchronous callbacks from scratch.

All asynchronous callbacks must be built on top of a function that is already asynchronous to begin with.

Here are some examples:

  1. addEventListener
  2. setTimeout
  3. setInterval
  4. XMLHttpRequest
  5. fetch
  6. IntersectionObserver

That’s all you need to know about callbacks and the difference between synchronicity and asynchronicity.

For the rest of this course, we will focus on giving you the practical knowledge you need to be able to use Asynchronous JavaScript and Rest APIs fluently.

For this to happen, you need to understand what an API is.