Coding Glossary — 95 Terms Explained

A named container that stores a value you can read or change.

let count = 5;

A variable whose value cannot be reassigned after it's set.

const PI = 3.14;

The name you give to a variable, function, or class.

A value written directly in code, like 42, "hello", or true.

The category of a value — number, string, boolean, etc.

A whole number with no decimal part.

int n = 42;

A number with a decimal part (technically a floating-point number).

float pi = 3.14;

A value that is either true or false.

let isOpen = true;

Text — a sequence of characters wrapped in quotes.

let name = "Aisha";

An explicit "no value" marker. Different from "undefined."

let user = null;

In JavaScript: a variable declared but not assigned a value.

let x; // undefined

"Not a Number" — what some math operations produce when they can't return a real number.

0 / 0 // NaN

Automatic conversion between types — common in JS, rare in Python.

"5" + 3 // "53"

Explicitly converting a value from one type to another.

Number("5") // 5

A value that cannot be changed after it's created.

A value that can be modified in place.

Code that branches based on a true/false test.

if (x > 0) {...}

The basic conditional construct.

if (cond) {}

The branch taken when the if-condition is false.

if (x) {} else {}

Code that repeats until a condition is met.

for (i=0;i<10;i++)

A loop with an initializer, condition, and increment.

for (let i=0;i<n;i++)

A loop that runs while a condition is true.

while (cond) {}

One pass through the body of a loop.

Exits the innermost loop immediately.

break;

Skips to the next iteration of the loop.

continue;

A multi-way branch based on a single value.

switch (x) {}

A function that calls itself.

function f(n) { return f(n-1); }

A loop whose condition never becomes false. Usually a bug.

Logical operators stop early when the result is determined.

false && x // x not run

A value that evaluates to true in a boolean context.

if ("hello") {}  // truthy

A value that evaluates to false in a boolean context.

if (0) {}  // falsy

A named, reusable block of code.

function f(x) { return x*2; }

A function that belongs to an object or class.

arr.push(5)

A name listed in a function's definition for an input.

function f(name) {}

The actual value passed to a function when called.

f("Aisha")

The value a function gives back to the caller.

return total;

A change a function makes outside its return value.

count++

A function with no side effects, returning the same output for the same input.

A function passed as an argument to be called later.

arr.map(x => x*2)

A function that takes or returns another function.

map, filter, reduce

A function without a name, often used as a callback.

x => x*2

JavaScript's shorthand function syntax.

(a,b) => a+b

A function that "remembers" variables from its enclosing scope.

A function that calls itself to solve a smaller version of a problem.

The region where a variable is visible.

An ordered list of values, indexed by position.

let xs = [1,2,3];

Python's name for an array.

xs = [1,2,3]

A collection of named fields (key-value pairs).

{name: "Aisha"}

Python's name for an object/map.

{"name": "Aisha"}

A general data structure of key-value pairs.

new Map()

A collection with no duplicates.

new Set([1,2,3])

The position of an item in an array, starting at 0.

arr[0] // first

The name used to look up a value in an object.

user["name"]

The data associated with a key.

user.name = "Aisha"

An immutable, ordered group of values (mostly Python).

(1, 2, 3)

A last-in-first-out collection.

A first-in-first-out collection.

A hierarchical data structure with a root and branches.

A single element in a tree or linked list.

A defect — code that runs but produces the wrong result.

An explicit failure thrown by the runtime.

TypeError

An error that can be caught and handled.

try { ... } catch { ... }

The call path leading to an error, useful for debugging.

Code that doesn't parse (missing parenthesis, etc.).

An error that happens while the program runs, not when it's parsed.

Code that runs without errors but produces wrong results.

A tool that pauses code execution so you can inspect state.

A place where the debugger pauses.

The text-output area of a development environment.

console.log(x)

When recursion goes too deep and exhausts the call stack.

A blueprint for creating objects.

class User {}

A specific object created from a class.

new User()

The function called when an instance is created.

constructor() {}

One class extending another, gaining its members.

class Admin extends User

Bundling data and behavior, hiding internal details.

Using one interface for different types.

Hiding complexity behind a simple interface.

A set of routines or endpoints another program can call.

A program that translates source code into another form (often machine code).

A program that runs source code line-by-line.

Integrated Development Environment — an editor with debugging, autocomplete, etc.

VS Code, IntelliJ

Reusable code others wrote that you import.

React, NumPy

A larger code base that imposes structure on your app.

Django, Rails

A version-controlled folder of code, usually on git.

A saved snapshot of changes in version control.

git commit -m "..."

A parallel line of development in version control.

A proposal to merge one branch into another, with review.

The process of turning source code into something runnable.

Pushing code to a server where users can use it.

Changing code's structure without changing what it does.

Shortcuts that make today easier but make future work harder.

A defined sequence of steps that solves a problem.

English-like sketches of code, used for planning.

Read-Eval-Print Loop — an interactive prompt for running code.

python (interactive)

An isolated environment to run untrusted or experimental code.