Mastering Key Programming Concepts: From OOP to Event-Driven Programming

Most real JavaScript applications use four programming styles at once: object-oriented code to model things, functional code to transform data, asynchronous code to wait for networks and disks, and event-driven code to react to users and messages. Knowing which one fits which job makes code easier to read and debug. This guide explains all four with short, current JavaScript examples for Node.js and the browser.

1. Why paradigms matter

A paradigm is a way of organising code. None is "best"; each solves a different problem:

JavaScript supports all four natively, which is why it helps to understand each one separately before mixing them.

2. Object-oriented programming

A class is a blueprint; an object is an instance with its own data. Modern JavaScript supports truly private fields with #:

class Employee {
  #salary;

  constructor(name, salary) {
    this.name = name;
    this.#salary = salary;
  }

  get monthlyPay() {
    return Math.round(this.#salary / 12);
  }

  work() {
    return `${this.name} does general work.`;
  }
}

class Manager extends Employee {
  constructor(name, salary, department) {
    super(name, salary);
    this.department = department;
  }

  work() {
    return `${this.name} manages ${this.department}.`;
  }
}

const staff = [new Employee('Asha', 600000), new Manager('Ravi', 1200000, 'Sales')];
staff.forEach((p) => console.log(p.work()));

The four classic principles, in plain terms:

3. Functional programming

Functional code avoids changing shared data. Functions take input and return new output:

// Pure: same input, same output, no side effects
const withGst = (amount) => Math.round(amount * 1.18);

// Immutability: copy and change, don't mutate
const order = { id: 7, status: 'pending' };
const paid = { ...order, status: 'paid' };   // order is unchanged

// Higher-order functions
const orders = [
  { id: 1, total: 1200, paid: true },
  { id: 2, total: 450, paid: false },
  { id: 3, total: 3000, paid: true },
];

const paidTotal = orders
  .filter((o) => o.paid)
  .map((o) => o.total)
  .reduce((sum, t) => sum + t, 0); // 4200

Newer array methods return copies instead of changing the original: toSorted(), toReversed(), toSpliced() and with(). Use them instead of sort() and reverse(), which change the array in place. structuredClone() makes a deep copy of plain data.

4. Asynchronous programming

JavaScript runs your code on one thread. Slow operations, such as an HTTP request or a database query, run in the background, and your code continues when they finish. There are three generations of syntax.

Callbacks came first. They nest badly when one step depends on another ("callback hell"), so use them only where an API requires them.

Promises represent a value that will arrive later:

const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

wait(500).then(() => console.log('half a second later'));

async/await is the modern way to write promise-based code so it reads top to bottom:

async function getUser(id) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), 5000); // 5-second timeout

  try {
    const res = await fetch(`https://api.example.com/users/${id}`, {
      signal: controller.signal,
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return await res.json();
  } finally {
    clearTimeout(timer);
  }
}

fetch is built into browsers and into current Node.js, so you don't need a library for simple HTTP calls. Note that fetch only rejects on network errors, not on HTTP errors, which is why the code checks res.ok.

Run independent tasks in parallel instead of one after another:

const [user, orders] = await Promise.all([getUser(1), getOrders(1)]);

// Keep going even if some fail
const results = await Promise.allSettled(ids.map(getUser));

5. Event-driven programming

In event-driven code, you register listeners and the program runs them when something happens. In the browser:

document.querySelector('#buy').addEventListener('click', (event) => {
  event.preventDefault();
  console.log('Buy button clicked');
});

In Node.js, many core objects (servers, streams, sockets) are event emitters, and you can create your own:

import { EventEmitter } from 'node:events';

const shop = new EventEmitter();

shop.on('order:paid', (order) => console.log(`Send receipt for #${order.id}`));
shop.on('order:paid', (order) => console.log(`Start delivery for #${order.id}`));

shop.emit('order:paid', { id: 42 });

The code that emits order:paid doesn't need to know who listens. That loose coupling is the main benefit: you can add a new reaction, such as an SMS, without touching the payment code.

How the event loop runs it all

The event loop is what makes async and event-driven code work together. It runs your synchronous code first, then microtasks (promise callbacks), then the next task from the queue (timers, I/O, events), and repeats:

console.log('1 sync');
setTimeout(() => console.log('4 timer task'), 0);
Promise.resolve().then(() => console.log('3 microtask'));
console.log('2 sync');
// Prints 1, 2, 3, 4

Long synchronous work, such as a big loop, blocks the loop, and nothing else runs until it finishes: no clicks, no requests. Move heavy CPU work to a Worker (browser) or worker_threads (Node.js).

6. Combining the four

A typical order flow uses all of them:

1. An Order class holds the order's data and rules (OOP).
2. Pure functions calculate totals, GST and discounts (functional).
3. The payment API is called with async/await (asynchronous).
4. On success, an order:paid event triggers the receipt, the stock update and the delivery request (event-driven).

7. Running JavaScript on Domain India

Use a current long-term-support (LTS) release of Node.js, such as Node.js 24, and upgrade before your version reaches end of life.

• Shared cPanel hosting: the Setup Node.js App tool offers Node.js 20, 22 and 24 on our cPanel servers. Choose 22 or 24, because Node.js 20 is past its end of life. See deploy a Node.js app on shared hosting.
• App Platform: Node.js apps are detected and built automatically; anything else needs a Dockerfile. The App Platform doesn't support WebSockets, so for real-time features such as live chat, use a VPS. Start with App Platform getting started.
• VPS: full root control for any Node.js setup, including WebSockets and background workers. VPS plans are self-managed.

The price on the card is a live Domain India list price and excludes 18% GST. For the same ideas in PHP, see asynchronous programming in PHP and event-driven programming in PHP.

Ready to build? Try your app on the App Platform, host it with cPanel hosting, or take full control with a VPS.