Comparison with long-running servers (Node.js) in PHP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

PHP script execution time behavior

What will be the output of this PHP script when run from the command line?

<?php
sleep(2);
echo "Hello World";
?>

PHP

<?php
sleep(2);
echo "Hello World";
?>

A Prints 'Hello World' after 2 seconds delay

B Throws a runtime error due to sleep

C Prints nothing and exits immediately

D Prints 'Hello World' immediately

💡 Hint

Think about how PHP scripts run and what sleep() does.

PHP scripts run from start to finish each time they are called. The sleep(2) pauses execution for 2 seconds, so the output appears after the delay.

🧠 Conceptual

intermediate

Difference in request handling between PHP and Node.js

Which statement best describes how PHP and Node.js handle incoming web requests?

A PHP uses a single long-running process; Node.js creates a new process per request

B Both PHP and Node.js use a single process that blocks on each request

C Both PHP and Node.js create a new process for each request

D PHP runs a new process for each request; Node.js uses a single long-running process to handle many requests asynchronously

💡 Hint

Think about how PHP scripts are executed by web servers versus how Node.js servers work.

PHP typically runs a new process or thread for each request, starting fresh each time. Node.js runs a single long-running process that handles many requests asynchronously without restarting.

❓ Predict Output

advanced

Memory usage difference in PHP vs Node.js long-running server

Consider this PHP script and this Node.js server snippet. Which statement about their memory usage is true after handling many requests?

PHP script (simplified):
<?php
// runs once per request
$data = range(1, 100000);
echo count($data);
?>

Node.js server snippet:
const http = require('http');
let data = [];
http.createServer((req, res) => {
  data = Array.from({length: 100000}, (_, i) => i + 1);
  res.end(data.length.toString());
}).listen(3000);

A Both PHP and Node.js free memory after each request automatically

B PHP frees memory after each request; Node.js keeps growing memory usage with each request

C Node.js frees memory after each request; PHP keeps memory until server restart

D Both PHP and Node.js keep memory usage constant regardless of requests

💡 Hint

Think about how long the data array lives in each environment.

PHP runs fresh each request, so memory is freed after the script ends. Node.js runs a long server process, so if data is reassigned but not cleared properly, memory usage can grow over time.

🔧 Debug

advanced

Identify the error in this Node.js server code

What error will this Node.js code produce when run?

const http = require('http');
http.createServer((req, res) => {
  res.write('Hello');
  res.end();
  res.write('World');
}).listen(3000);

PHP

const http = require('http');
http.createServer((req, res) => {
  res.write('Hello');
  res.end();
  res.write('World');
}).listen(3000);

A Throws an error because res.write is called after res.end

B Prints 'HelloWorld' correctly

C Server crashes immediately on start

D No output is sent to client

💡 Hint

Consider what happens if you write to the response after ending it.

Calling res.write after res.end causes an error because the response is already finished and cannot be written to.

🧠 Conceptual

expert

Why might Node.js be preferred for real-time applications over PHP?

Which reason best explains why Node.js is often chosen for real-time apps compared to PHP?

A Node.js restarts the server process for each request, improving real-time performance

B PHP has built-in support for WebSockets and real-time events, unlike Node.js

C Node.js uses a single-threaded event loop allowing non-blocking I/O, enabling many simultaneous connections efficiently

D PHP runs continuously in memory, making it faster for real-time apps

💡 Hint

Think about how Node.js handles input/output operations compared to PHP.

Node.js uses an event-driven, non-blocking I/O model with a single-threaded event loop, which makes it efficient for handling many real-time connections simultaneously. PHP typically runs a new process per request, which is less efficient for real-time.