Long polling as fallback in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Understanding long polling fallback behavior

Consider a Node.js server that uses long polling as a fallback when WebSocket is unavailable. What will the client receive if the server holds the request open until new data arrives?

Node.js

const http = require('http');
let dataAvailable = false;

http.createServer((req, res) => {
  if (req.url === '/poll') {
    if (dataAvailable) {
      res.end('New data');
      dataAvailable = false;
    } else {
      // Hold request open
      setTimeout(() => {
        res.end('No new data');
      }, 5000);
    }
  } else {
    res.end('Hello');
  }
}).listen(3000);

A The client receives 'Hello' regardless of the URL requested.

B The client always receives 'No new data' immediately without waiting.

C The client request times out immediately with an error if dataAvailable is false.

D The client receives 'New data' immediately if dataAvailable is true; otherwise, it waits 5 seconds and receives 'No new data'.

💡 Hint

Think about how the server responds based on the dataAvailable flag and the timeout.

The server checks if dataAvailable is true. If yes, it responds immediately with 'New data'. If not, it holds the request open for 5 seconds before responding with 'No new data'. This simulates long polling fallback behavior.

📝 Syntax

intermediate

Identify the syntax error in long polling implementation

Which option contains a syntax error that would prevent a Node.js long polling server from running?

Node.js

const http = require('http');

http.createServer((req, res) => {
  if (req.url === '/poll') {
    setTimeout(() => {
      res.end('Data');
    }, 3000);
  } else {
    res.end('OK');
  }
}).listen(3000);

A Missing semicolon after setTimeout call.

B Missing curly braces around if block.

C Missing closing parenthesis for setTimeout function.

D Missing callback function in createServer.

💡 Hint

Check the parentheses matching in the setTimeout call.

Option C is correct because the setTimeout call is missing a closing parenthesis, causing a syntax error. Other options are either stylistic or incorrect.

❓ state_output

advanced

What is the output after multiple long polling requests?

Given this server code, what will the client receive on the second poll request?

Node.js

const http = require('http');
let dataQueue = ['first', 'second'];

http.createServer((req, res) => {
  if (req.url === '/poll') {
    if (dataQueue.length > 0) {
      res.end(dataQueue.shift());
    } else {
      setTimeout(() => {
        res.end('no data');
      }, 2000);
    }
  } else {
    res.end('welcome');
  }
}).listen(3000);

A The client receives 'second' immediately on the second request.

B The client receives 'first' again on the second request.

C The client waits 2 seconds and receives 'no data' on the second request.

D The client receives 'welcome' on the second request.

💡 Hint

Think about how dataQueue.shift() changes the queue after each request.

On the first poll, 'first' is removed and sent. On the second poll, 'second' is removed and sent immediately. Only after the queue is empty does the server wait 2 seconds and send 'no data'.

🔧 Debug

advanced

Why does this long polling server never respond?

Examine the code below. Why does the client never get a response?

Node.js

const http = require('http');
let hasData = false;

http.createServer((req, res) => {
  if (req.url === '/poll') {
    if (hasData) {
      res.end('Data ready');
      hasData = false;
    } else {
      // Missing response or timeout here
    }
  } else {
    res.end('Hello');
  }
}).listen(3000);

A Because the hasData variable is never set to true.

B Because the else block for no data does not send any response or end the request.

C Because the server listens on the wrong port.

D Because res.end is called twice in the if block.

💡 Hint

Check what happens when hasData is false.

The else block for when hasData is false does not send any response or close the connection. This causes the client to wait indefinitely, so no response is received.

🧠 Conceptual

expert

Why use long polling as a fallback in real-time apps?

Which reason best explains why long polling is used as a fallback method for real-time communication when WebSocket is unavailable?

A Long polling allows the server to push updates by holding client requests open until new data is available, simulating real-time communication over HTTP.

B Long polling reduces server load by closing connections immediately after sending data.

C Long polling uses WebSocket protocol internally to maintain a persistent connection.

D Long polling requires the client to constantly reconnect without waiting for server data.

💡 Hint

Think about how long polling mimics real-time updates over traditional HTTP.

Long polling keeps the client request open until the server has new data, allowing near real-time updates without WebSocket. It does not use WebSocket internally and does not close connections immediately.