🔁 The Same Program in Three Languages

Why a Rosetta Stone?

The famous Rosetta Stone carried the same decree in three scripts, which is exactly what let scholars decode Egyptian hieroglyphs. We'll use the same trick: by holding the problem constant and varying only the language, the shared structure jumps out and the surface differences stop being scary.

💡 Read the columns, then the rows. First read one language top-to-bottom to see it as a whole. Then compare the same task across all three. You'll notice the concepts (a variable, a loop, a function) are identical — only the spelling changes.

Variables & Types

All three languages are dynamically typed — you don't declare a type up front; the value carries its type. The visible differences are the keyword (or sigil) and how a statement ends.

Node.js

const name = "Ada";      // string, cannot be reassigned
let age = 36;            // number, can change
let isMember = true;     // boolean
const scores = [90, 85]; // array
// Statements end with a semicolon (optional but conventional)

Python

name = "Ada"        # string
age = 36            # int
is_member = True    # bool (note the capital T)
scores = [90, 85]   # list
# No keyword, no semicolon; snake_case is the convention

PHP

<?php
$name = "Ada";        // every variable starts with $
$age = 36;            // int
$isMember = true;     // bool
$scores = [90, 85];   // array
// Semicolons are required

String Formatting & Printing

Building a message out of variables — "string interpolation" — is something you'll do constantly. Each language has a clean, modern way to do it.

Node.js — template literals

const name = "Ada";
const age = 36;
console.log(`${name} is ${age} years old.`);
// Uses backticks and ${ } placeholders

Python — f-strings

name = "Ada"
age = 36
print(f"{name} is {age} years old.")
# Prefix the string with f and use { } placeholders

PHP — double-quoted interpolation

<?php
$name = "Ada";
$age = 36;
echo "$name is $age years old.\n";
// Double-quoted strings expand $variables directly

Ada is 36 years old.

Printing itself differs: Node uses console.log(), Python uses print(), and PHP uses echo (and you add \n yourself, since echo doesn't add a newline).

Conditionals

Same logic, three flavors of braces and colons. Watch how Python replaces braces with indentation.

Node.js

const score = 82;
if (score >= 90) {
  console.log("A");
} else if (score >= 80) {
  console.log("B");
} else {
  console.log("C or below");
}

Python

score = 82
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("C or below")

PHP

<?php
$score = 82;
if ($score >= 90) {
    echo "A\n";
} elseif ($score >= 80) {
    echo "B\n";
} else {
    echo "C or below\n";
}

Loops

Let's sum the numbers 1 through 5. Each language offers a range-style loop, though the exact mechanics differ.

Node.js

let total = 0;
for (let i = 1; i <= 5; i++) {
  total += i;
}
console.log(total); // 15

Python

total = 0
for i in range(1, 6):   # 1..5 (stop is exclusive)
    total += i
print(total)  # 15

PHP

<?php
$total = 0;
for ($i = 1; $i <= 5; $i++) {
    $total += $i;
}
echo $total . "\n"; // 15

Functions

A reusable function that greets someone shows off each language's declaration keyword and return syntax.

Node.js

function greet(name) {
  return `Hello, ${name}!`;
}
console.log(greet("Ada"));

// Arrow-function equivalent:
const greet2 = (name) => `Hello, ${name}!`;

Python

def greet(name):
    return f"Hello, {name}!"

print(greet("Ada"))

PHP

<?php
function greet($name) {
    return "Hello, $name!";
}
echo greet("Ada") . "\n";

Hello, Ada!

The keyword differs — function (Node), def (Python), function (PHP) — but the shape is the same: name it, take parameters, return a value.

Transforming a List

A very common real task: take a list of numbers and produce a new list with each one doubled. This is where idiomatic style diverges the most.

Node.js — .map()

const nums = [1, 2, 3, 4];
const doubled = nums.map((n) => n * 2);
console.log(doubled); // [ 2, 4, 6, 8 ]

Python — list comprehension

nums = [1, 2, 3, 4]
doubled = [n * 2 for n in nums]
print(doubled)  # [2, 4, 6, 8]

PHP — array_map()

<?php
$nums = [1, 2, 3, 4];
$doubled = array_map(fn($n) => $n * 2, $nums);
print_r($doubled); // Array ( [0] => 2 [1] => 4 [2] => 6 [3] => 8 )

Node reaches for a .map() method on the array, Python uses a compact list comprehension, and PHP calls the standalone array_map() function with an arrow function (fn). Same result, three cultures.

Syntax Cheat Sheet

Keep this table handy — it's a quick translator when you jump between languages.

Hands-on Exercise

scores = [92, 74, 88, 60, 100]
average = sum(scores) / len(scores)
print(f"Average: {average}")

for s in scores:
    print("PASS" if s >= 70 else "FAIL")

Summary & Quiz

📚 Further Reading

• MDN — JavaScript Guide
• Python — The Official Tutorial
• PHP Manual — Language Reference

🚀 What's Next?

You've seen how the three languages look. Next we go under the hood: how each one actually runs on the server — Node's event loop, Python's WSGI/ASGI and the GIL, and PHP's process-per-request model — and what that means for performance.