What did you use before the appearance of Promise?

Before the appearance of Promise, callbacks were widely used.

The essence of callbacks:

A function is passed to another function as an argument and is executed after a certain operation is completed.

Example:

// Example of calling an asynchronous operation with a callback
function fetchData(callback) {
  setTimeout(() => {
    const data = "Some data";
    callback(null, data); // First argument - error, second - result
  }, 1000);
}

fetchData((err, data) => {
  if (err) {
    console.error("Error fetching data:", err);
  } else {
    console.log("Data received:", data);
  }
});

Disadvantages of using only callbacks:

• Callback Hell: A chain of nested asynchronous operations leads to deeply nested and hard-to-read code.
• Error handling difficulties: Errors need to be passed and checked at each level of nesting.
• Lack of a standardized approach: Different libraries could use different conventions for callbacks.

Alternative approaches before Promise:

Before the advent of Promise, besides "bare" callbacks, libraries and patterns for managing asynchrony were used, such as:

• Asynchronous libraries: For example, async (for Node.js, but could also be used in browsers). They provided utilities for managing asynchronous flows (parallel execution, sequential execution).
• Publisher/Subscriber (Pub/Sub) pattern: For more complex interaction scenarios.
• Event emitters: In Node.js and browser environments (e.g., EventEmitter).

Nevertheless, callbacks remained the basis for many asynchronous operations. Promises provided a more structured, unified, and readable way to work with asynchrony, eliminating many problems of "Callback Hell".