Python vs JavaScript — First, Where Do They Fit?

age = 30

let age = 30;

Python binds a name with plain assignment. JavaScript requires a declaration keyword (let, const, or the legacy var) — there's no bare-assignment form for a new binding.

MAX_SIZE = 10
# no real enforcement —
# it's just a naming convention

const MAX_SIZE = 10;
MAX_SIZE = 20; // throws TypeError

Python has no language-enforced constant — ALL_CAPS is a human convention only. JavaScript's const is enforced by the engine: reassigning it is a runtime error. (It only locks the binding, not the value's contents — Lab 21 covers what that means for objects.)

x = 5
x = "five"  # fine

let x = 5;
x = "five"; // fine

Both are dynamically typed — a variable is just a name currently pointing at a value, and that value's type can change over the variable's lifetime in either language. Lab 03 goes deep on this from the JavaScript side.

x = None

let x;        // undefined
let y = null; // null

Python has one deliberate "nothing" value, None. JavaScript splits this into two: undefined (the engine's own default for an unassigned variable) and null (a value you assign yourself, on purpose). Lab 04 covers this split in full, including the undeclared-name case.

1 == "1"  # False

1 == "1"  // true
1 === "1" // false

Python's == never silently converts between types like this. JavaScript has two equality operators: == allows type coercion before comparing, === does not. This gets its own dedicated lab later in the curriculum.

if []:      # falsy
if "":      # falsy
if "0":     # truthy (non-empty str)

if ([]) {}   // truthy!
if ("") {}   // falsy
if ("0") {}  // truthy

Both languages coerce values to true/false in a condition, but the falsy list differs: Python treats an empty list/dict/tuple as falsy; JavaScript treats every object — including an empty array [] — as truthy. Only a specific short list of primitive values is falsy in JS.

if age >= 18:
    print("adult")

if (age >= 18) {
  console.log("adult");
}

Python uses indentation itself to define a block. JavaScript uses { } — indentation is just a convention for humans and has no effect on how the code runs.

def greet():
    return "hi"

say_hi = greet
print(say_hi())

function greet() {
  return "hi";
}

let sayHi = greet;
console.log(sayHi());

"Functions are first-class values" isn't unique to either language — both let you store a function in a variable and call it through that name. JavaScript leans on this even more heavily in everyday code (Lab 11 covers why).

items = [1, 2, 3]
items.append(4)

let items = [1, 2, 3];
items.push(4);

Both are ordered, mutable, dynamically-sized sequences — mostly a naming and method-name difference (.append vs .push) at this level. JavaScript's array is, underneath, a specialized object — a later lab covers exactly what that means for how it stores its contents.

person = {"name": "Ada"}
print(person["name"])

let person = { name: "Ada" };
console.log(person.name);

Python's dictionary and JavaScript's object literal solve the same "named key to value" problem. JavaScript additionally lets you write person.name with a dot, and — unlike a Python dict — every JS object also participates in the prototype chain, a JavaScript-specific mechanism a later lab covers in depth.

try:
    risky()
except ValueError as e:
    print(e)

try {
  risky();
} catch (e) {
  console.log(e.message);
}

Structured exception handling with try/catch is a shared, general concept — the shape is nearly identical. JavaScript doesn't have typed except ValueError-style catches; you check the error's type or message manually inside one catch block. This gets its own dedicated lab later.

from math_utils import add

import { add } from "./mathUtils.js";

Both give each file its own scope and an explicit way to share specific things across files. JavaScript's module system arrived much later in the language's life than Python's, and is layered on top of an older, less isolated "just one shared global script" model — a later lab covers that history and why it matters.

class Dog:
    def __init__(self, name):
        self.name = name

class Dog {
  constructor(name) {
    this.name = name;
  }
}

The syntax looks almost identical. Underneath, they are not the same model: Python's class system is class-based from the ground up. JavaScript's class keyword is syntax sitting on top of a fundamentally different mechanism — prototype-based inheritance, where objects link directly to other objects. Several labs later in this curriculum are dedicated entirely to that distinction.

async def fetch():
    data = await get_data()
    return data

async function fetch() {
  let data = await getData();
  return data;
}

Both have async/await syntax, and both rely on an event loop underneath. Python's asyncio event loop is opt-in — most Python code is written without it. JavaScript's single-threaded, event-loop-driven execution is the default, unavoidable execution model for the entire language, in every environment. We'll come back to this in depth much later.