What is Socket.IO and how does it differ from raw WebSockets?

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Start with the transport

   Socket.IO uses Engine.IO, which opens with HTTP long-polling and upgrades to WebSocket when the connection allows it.

2. Step 2

   Add its own protocol

   On top of the transport it defines a packet format for named events, acknowledgements, and namespaces that plain WebSockets lack.

3. Step 3

   Emit named events

   Instead of one message stream, you socket.emit('chat', data) and listen with socket.on('chat', handler).

4. Step 4

   Group with rooms

   Join sockets to rooms and broadcast to a room, so you target subsets of clients without tracking them manually.

5. Step 5

   Rely on recovery

   The client auto-reconnects with backoff and heartbeats detect dead connections without custom code.

Code Example

import { Server } from 'socket.io';

const io = new Server(3000);

io.on('connection', (socket) => {
  socket.join('lobby');

  // Named event with an acknowledgement callback
  socket.on('chat', (msg, ack) => {
    io.to('lobby').emit('chat', msg);
    ack({ received: true });
  });

  socket.on('disconnect', () => {
    // reconnection is handled automatically on the client
  });
});

import { WebSocketServer } from 'ws';

const wss = new WebSocketServer({ port: 3000 });

wss.on('connection', (ws) => {
  ws.on('message', (data) => {
    // You must parse type, manage groups, and reconnect yourself
    for (const client of wss.clients) {
      if (client.readyState === client.OPEN) client.send(data);
    }
  });
});

Follow-up Questions

• Why can't a Socket.IO client connect to a plain WebSocket server?
• How do namespaces differ from rooms in Socket.IO?
• When would you choose raw WebSockets over Socket.IO?
• How does Socket.IO scale broadcasts across multiple server instances?
• What overhead does the long-polling fallback add?