Understanding Callbacks, Promises, and Async/Await in JavaScript

Purushotham Jakka — Sun, 01 Mar 2026 08:46:20 +0000

JavaScript is famous for being asynchronous. That means it doesn't wait around for slow tasks (like fetching data from a server) to finish before moving on. Instead, it uses special patterns to handle these tasks: callbacks, promises, and async/await. Let's break them down in plain English.

Callbacks: The Old School Way

A callback is just a function you hand over to another function, saying: "When you're done, call me back."

Example:

function getDataCallback(callback) {
  setTimeout(() => {
    callback(null, { user: "Alice" });
  }, 1000);
}

getDataCallback((error, result) => {
  if (error) {
    console.error("Error:", error);
  } else {
    console.log("Callback Result:", result);
  }
});

Problem: If you need multiple steps (like fetch user -> then fetch posts -> then fetch comments), callbacks quickly become messy. This is called callback hell.

Promises: A Cleaner Deal

A promise is like an IOU for a future value. It says: "I promise I'll give you the data later, or I'll tell you why I failed."

Example:

function getDataPromise() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve({ user: "Alice" });
    }, 1000);
  });
}

getDataPromise()
  .then((result) => {
    console.log("Promise Result:", result);
  })
  .catch((error) => {
    console.error("Promise Error:", error);
  });

Promises let you chain multiple steps without nesting too deeply.

Async/Await: The Modern Way

Async/await makes asynchronous code look synchronous. It's built on top of promises but feels more natural to read.

Example:

async function getDataAsync() {
  try {
    const result = await getDataPromise();
    console.log("Async/Await Result:", result);
  } catch (error) {
    console.error("Async/Await Error:", error);
  }
}

getDataAsync();

With await, you can write code that looks like normal step-by-step instructions, but it still runs asynchronously under the hood.

Conclusion

Callbacks, promises, and async/await are just different ways of handling asynchronous tasks in JavaScript.

Callbacks are the foundation (Simple but messy when chaining many steps).
Promises improved readability (Cleaner, with .then() and .catch()).
Async/await is the modern, elegant solution (Most readable, looks like synchronous code).

If you're writing new code today, async/await is usually the best choice.

Frequently used git commands

Purushotham Jakka — Sat, 04 Nov 2023 11:31:12 +0000

Following are the most used git commands which covers 90% of our work.

git clone <repository link> - Clones git repository
git branch - Displays all the local branches
git status - Displays files which are modified, added, or deleted
git checkout <branch name> - Switches to the given branch
git checkout -b <branch name> - Creates a new branch from current branch
git add <file path> - Stages given file(s)
git commit -m <message> - Commits the staged files with the message
git pull origin <branch name> - Pulls from remote repository into current branch
git push origin <branch name> - Pushes to the linked remote repository
git push -u origin <branch name> - Creates a new remote branch from local branch and pushes
git fetch - Gets all the remote branches
git log - Displays entire commit history
git cherry-pick <commit hash> - Merges given commit into current branch
git merge <branch name> - Merges given branch into current branch
git reset --hard commit <commit hash> - Resets branch to a given commit in the history
git stash - Saves uncommitted (both staged and unstaged) changes
git stash pop - Re-applies saved changes

DEV Community: Purushotham Jakka

Understanding Callbacks, Promises, and Async/Await in JavaScript

Callbacks: The Old School Way

Promises: A Cleaner Deal

Async/Await: The Modern Way

Conclusion

Frequently used git commands