Emitting and receiving messages in Express - Performance & Optimization

Performance: Emitting and receiving messages

MEDIUM IMPACT

This concept affects server response time and network latency impacting how fast messages are sent and received between client and server.

Sending real-time messages between client and server

Express

app.get('/send', (req, res) => {
  // Using setImmediate to batch emits asynchronously
  let i = 0;
  function emitBatch() {
    for(let count = 0; count < 100; count++, i++) {
      io.emit('message', { text: `Message ${i}` });
      if(i >= 10000) return res.send('Messages sent');
    }
    setImmediate(emitBatch);
  }
  emitBatch();
});

Batching emits asynchronously prevents blocking the event loop, allowing other requests to be handled smoothly.

📈 Performance GainNon-blocking emits reduce INP and improve server responsiveness

Sending real-time messages between client and server

Express

app.get('/send', (req, res) => {
  // Emitting message inside a heavy synchronous loop
  for(let i = 0; i < 10000; i++) {
    io.emit('message', { text: `Message ${i}` });
  }
  res.send('Messages sent');
});

Emitting many messages synchronously blocks the event loop, delaying other requests and responses.

📉 Performance CostBlocks event loop causing delayed responses and higher INP

Performance Comparison

Pattern	Event Loop Impact	Network Load	Client Responsiveness	Verdict
Synchronous heavy emits	Blocks event loop	High burst load	Delayed input response	[X] Bad
Asynchronous batched emits	Non-blocking event loop	Evenly distributed load	Fast input response	[OK] Good

Rendering Pipeline

Message emitting triggers network I/O and event loop processing on the server, affecting how quickly clients receive updates.

→Event Loop

→Network I/O

→Client Rendering

⚠️ BottleneckEvent Loop blocking due to synchronous heavy emits

Core Web Vital Affected

INP

This concept affects server response time and network latency impacting how fast messages are sent and received between client and server.

Optimization Tips

1Avoid synchronous loops emitting many messages to prevent event loop blocking.

2Batch or throttle message emits to spread network load evenly.

3Monitor event loop delays and network timing to optimize message flow.

Performance Quiz - 3 Questions

What is the main performance issue with emitting many messages synchronously in Express?

A It increases bundle size significantly

B It causes layout shifts on the client

C It blocks the event loop causing delayed responses

D It reduces server memory usage

DevTools: Network and Performance panels

How to check: Open DevTools, go to Network panel to observe message packets timing and size; use Performance panel to record server response and event loop delays.

What to look for: Look for long blocking tasks in Performance and clustered network packets causing delays in Network panel

Practice

1. In Express with Socket.IO, what does emitting a message mean?

easy

A. Starting the server

B. Listening for incoming messages

C. Closing the connection

D. Sending a message to connected clients

Solution

1. Step 1: Understand the meaning of emitting

   Emitting means sending a message or event from the server to clients or vice versa.

2. Step 2: Differentiate emitting from receiving

   Receiving means listening for messages, not sending them.

3. Final Answer:

   Sending a message to connected clients -> Option D

4. Quick Check:

   Emitting = Sending message [OK]

Hint: Emitting means sending messages out [OK]

Common Mistakes:

• Confusing emitting with receiving
• Thinking emitting closes connections
• Mixing emitting with server start

2. Which of the following is the correct syntax to emit a message named 'chat message' with data 'Hello' to all clients using Socket.IO in Express?

easy

A. io.send('chat message', 'Hello');

B. io.emit('chat message', 'Hello');

C. socket.emit('chat message');

D. io.on('chat message', 'Hello');

Solution

1. Step 1: Identify the method to send to all clients

   The io.emit method sends a message to all connected clients.

2. Step 2: Check the syntax correctness

   io.emit('chat message', 'Hello'); correctly emits the event with data.

3. Final Answer:

   io.emit('chat message', 'Hello'); -> Option B

4. Quick Check:

   Use io.emit to broadcast [OK]

Hint: Use io.emit(event, data) to send to all clients [OK]

Common Mistakes:

• Using io.on instead of io.emit
• Omitting the data argument
• Using socket.emit to broadcast to all clients

3. Given this server code snippet in Express with Socket.IO:

io.on('connection', (socket) => {
  socket.on('greet', (msg) => {
    socket.emit('reply', `Hello, ${msg}`);
  });
});

What will the client receive if it emits 'greet' with message 'Alice'?

medium

A. A 'reply' event with message 'Hello, Alice'

B. No message received

C. A 'greet' event with message 'Hello, Alice'

D. An error because of missing broadcast

Solution

1. Step 1: Understand the event flow

   The server listens for 'greet' from the client, then emits 'reply' back to the same client.

2. Step 2: Check the emitted message content

   The message sent is `Hello, ${msg}`, so with 'Alice' it becomes 'Hello, Alice'.

3. Final Answer:

   A 'reply' event with message 'Hello, Alice' -> Option A

4. Quick Check:

   Reply event sends greeting with name [OK]

Hint: Server emits reply event with personalized message [OK]

Common Mistakes:

• Expecting broadcast to all clients
• Confusing event names 'greet' and 'reply'
• Thinking no message is sent back

4. What is wrong with this Express Socket.IO server code snippet?

io.on('connection', (socket) => {
  socket.emit('welcome', 'Hello client');
  socket.on('message', (msg) => {
    io.emit('message', msg);
  });
  socket.on('disconnect', () => {
    socket.emit('goodbye', 'Bye');
  });
});

medium

A. Missing callback for 'welcome' event

B. Using io.emit inside 'message' handler is invalid

C. Emitting 'goodbye' after disconnect causes error

D. No error, code is correct

Solution

1. Step 1: Analyze the 'disconnect' event usage

   When a client disconnects, the socket is closed and cannot emit messages.

2. Step 2: Identify the error

   Trying to emit 'goodbye' after disconnect causes an error because socket is no longer connected.

3. Final Answer:

   Emitting 'goodbye' after disconnect causes error -> Option C

4. Quick Check:

   Cannot emit after disconnect [OK]

Hint: Don't emit messages after disconnect event [OK]

Common Mistakes:

• Thinking io.emit is invalid inside handlers
• Expecting callback needed for emit
• Assuming no error on emitting after disconnect

5. You want to send a private message from one client to another using Express and Socket.IO. Which approach correctly emits a message only to the target client identified by targetId?

hard

A. io.to(targetId).emit('private message', msg);

B. io.emit('private message', { to: targetId, text: msg });

C. socket.broadcast.emit('private message', { to: targetId, text: msg });

D. socket.emit('private message', msg);

Solution

1. Step 1: Understand how to target a specific client

   Socket.IO uses io.to(socketId).emit() to send messages to a specific client.

2. Step 2: Evaluate each option

   io.to(targetId).emit('private message', msg); correctly uses io.to(targetId).emit() to send only to the client with targetId.

3. Final Answer:

   io.to(targetId).emit('private message', msg); -> Option A

4. Quick Check:

   Use io.to(socketId).emit for private messages [OK]

Hint: Use io.to(targetId).emit for private messages [OK]

Common Mistakes:

• Using io.emit broadcasts to all clients
• socket.broadcast.emit sends to all except sender
• socket.emit sends only to sender, not target