Events and Event-Driven Architecture

Core idea: Node's built-in modules (http, fs, timers) run on an event-driven model with two roles:

• 📤 Emitter — an object that fires a named event when something happens (a request comes in, a timer ends, a file finishes reading)

• 👂 Listener — a callback you attach ahead of time, which runs when that event fires

🌐 Example: HTTP server as an emitter

const server = http.createServer();

server.on('request', (req, res) => {
  console.log('Request received');
  res.end('Request received');
});

Walking through it:

1. 👂 server.on('request', callback) registers a listener for 'request'.

2. 📤 Every incoming request makes the server emit a 'request' event.

3. ✅ Because a listener is already attached, the callback runs and responds to the client.

Why this works: 💡 server is an instance of Node's EventEmitter class — it inherits emitting and listening behavior from there.

👀 This is the Observer Pattern

EventEmitter is Node's implementation of the Observer Pattern:

• 👂 The observer (listener) waits.

• 📤 The subject (emitter) eventually fires the event it's waiting for.

• ⚡ Code reacts to events instead of being called directly — the reverse of a normal function call.

🎯 Why it's useful

• 🔗 Decoupling — modules don't call each other's functions directly. fs doesn't need to know anything about http; each module just emits its own events, and any other code can listen and react.

• 👥 One event, many reactions — attach several listeners to the same event with no extra wiring.

✅ Takeaway

📤 Emitter fires an event → 👂 listener reacts with a callback. 🚀 This pattern is foundational across Node's core API, and the next lecture puts it into practice directly with EventEmitter.