Glossary | CodeFlow

A

5 terms

Algorithm: A finite, deterministic recipe for solving a problem — a sequence of steps that, given the input, eventually halts with the right output.
API: Application Programming Interface — the set of functions or HTTP endpoints another program is allowed to call. The contract between two pieces of software.
Argument: A value you pass to a function when you call it. The function's parameter binds to the argument inside the body.
Array: A numbered row of slots. Random access by index is constant time; insert at the front is O(n).
Async / Await: "Pause this function until the result is ready, but let the rest of the program keep running." Lets a single thread juggle many waiting tasks.

B

9 terms

Backtracking: Try a choice; if it leads to a dead end, undo it and try another. Permutations, sudoku solvers, maze runners.
Base case: The branch of a recursive function that does NOT recurse — the matryoshka that doesn't open. Without one, the function calls itself forever.
BFS: Breadth-First Search. Explore a graph level by level, using a queue. Finds shortest paths in unweighted graphs.
Big O: Notation for how an algorithm scales as input size grows. O(n) means linear, O(log n) logarithmic, O(n²) quadratic. Tells you what hurts as data gets big.
Binary search: Halve a sorted list each step. log₂(n) comparisons find anything — but only if the list is sorted.
Boolean: A value that is either true or false. Named after George Boole, who built the algebra of true/false in the 1840s.
BST: Binary Search Tree. A tree where every left subtree is smaller and every right subtree is larger than the current node. Lookup is O(log n) — when balanced.
Bubble sort: Walk the array; swap any adjacent pair that's out of order; repeat. O(n²). Pedagogical — almost never used in practice.
Bug: A defect in a program — code that does something the author didn't intend. Named after a moth that got stuck in a 1947 relay.

C

11 terms

Callback: A function passed as an argument so the receiving code can call it later — typically when an event fires or async work finishes.
Class: A blueprint for objects. Defines the data each object holds (fields) and the verbs that act on it (methods).
Closure: A function that "remembers" variables from the scope it was created in, even after that scope has returned. Useful for callbacks that need state without a class.
Collision: Two different keys that hash to the same bucket. Hash tables resolve collisions by chaining (a list inside each bucket) or open addressing (try the next bucket).
Comment: Text in source code the runtime ignores. Best comments explain why something is unusual; the worst restate what the code already says.
Compiler: A program that translates source code into a lower-level form (often machine code) before it runs. Catches some errors ahead of time.
Composition: Building one object out of others by holding them as fields. Usually preferred over inheritance: more flexible, fewer surprises.
Concatenation: Sticking two strings together with +. "Hello, " + name → "Hello, Ana".
Concurrency: Many things in progress at once, interleaved. Different from parallelism — concurrent code can run on a single thread by switching tasks.
Conditional: A branch in the code: if some condition is true, run this block; otherwise run that one. The decision is made once, then exactly one path runs.
Constructor: A method that runs when a new object is created. Sets up initial state. Spelled `__init__` in Python, `constructor` in JS, `ClassName()` in Java/C++.

D

6 terms

Data type: A label that says what kind of value is in the box — number, string, boolean, list, etc. Each type has its own legal operations.
Debugger: A tool that pauses your program mid-run so you can inspect variables and step line-by-line. Beats sprinkling print statements once you learn it.
DFS: Depth-First Search. Explore a graph branch by branch, using a stack (or recursion). Used for connectivity, cycles, topological sort.
Divide and conquer: Split a problem into smaller versions of itself, solve each, combine. Merge sort and quick sort are textbook examples.
Documentation: Writing aimed at the human reader of your code or system — what it does, how to use it, why it's shaped this way. The README is documentation; a comment is documentation; the type signature is documentation.
Dynamic programming: Solve a problem by combining solutions to overlapping subproblems — usually with memoization or a table built bottom-up. Turns exponential brute force into polynomial.

E

2 terms

Encapsulation: Keeping an object's internals private, exposing only the methods that should be callable. Lets you change the internals later without breaking callers.
Exception: A signal that something went wrong. It "unwinds" the call stack until something catches it; if nothing catches, the program ends.

F

2 terms

Framework: A library that calls your code, instead of you calling its code. React, Django, Rails. You fill in the blanks; the framework runs the show.
Function: A named recipe — gather inputs, do the work, hand back a result. Lets you name a piece of code once and call it from anywhere.

G

3 terms

Garbage collection: The runtime automatically frees memory that's no longer reachable. Removes a class of bugs (use-after-free, leaks) at the cost of unpredictable pauses.
Graph: Nodes connected by edges. More general than a tree — graphs can have cycles, multiple components, or no root.
Greedy algorithm: Make the locally best choice at each step and never look back. Sometimes optimal (Dijkstra, Huffman); often only "good enough."

H

5 terms

Hash: A function that turns a key into an index, allowing roughly constant-time lookup. The same input always produces the same output.
Hash table: A data structure that uses a hash function to place each value in a bucket — so lookup-by-key is constant time on average.
Heap: A tree where the root is always the smallest (min-heap) or largest (max-heap). Insert and extract run in O(log n). Usually stored as an array.
Heap (memory): The region of memory where dynamic allocations live — objects whose size or lifetime isn't known at compile time. Distinct from the stack and from the data-structure heap.
Higher-order function: A function that takes another function as an argument or returns one as its result. map, filter, reduce, and most callback-flavoured APIs.

I

10 terms

IDE: Integrated Development Environment — an editor with a built-in compiler/runner, debugger, and lots of code-aware tools. VS Code, IntelliJ, Xcode.
Immutability: A value cannot be changed after creation. Any "edit" returns a new value. Common for strings, numbers, and most functional-style data structures.
Inheritance: "X but with these changes." A subclass inherits its parent's methods, can override some, can add new ones. Composition is often a cleaner alternative.
Insertion sort: Build the sorted list one item at a time, inserting each new item into its place. O(n²) worst case but blazing on tiny or nearly-sorted lists.
Instance: Another word for an object — emphasises that it was created from a class. "Instance of" is the precise spelling of "object built from."
Interface: A contract listing methods a class must implement. Lets unrelated classes be used interchangeably wherever that contract is required.
Interpolation: Embedding variables directly into a template string with placeholders. f"Hello, {name}" in Python; `Hello, ${name}` in JS.
Interpreter: A program that reads source code and executes it directly, line by line. Faster to start than a compiler but typically slower at runtime.
Iteration: One pass of a loop. Also: walking through the items of a collection one at a time.
Iterator: An object that produces a sequence of values — one per call to next(). Lets a loop walk a collection without knowing its internal shape.

L

7 terms

Lambda: A short, often anonymous function — written inline. `x => x * 2` in JS, `lambda x: x * 2` in Python. Useful as an argument to a higher-order function.
Library: A bundle of code somebody else wrote that you import into your project. requests, lodash, jUnit. Don't reimplement what a good library already does.
Linear search: Walk every element until the target is found, or fall off the end. O(n). No prep needed; works on any list.
Linked list: A chain of nodes — each node holds a value and a pointer to the next. Cheap front-insert; no random access.
Linter: A tool that scans source code for likely bugs, style violations, and code smells without running it. ESLint, Pylint, Clippy.
List: A dynamic array — same shape as a fixed array but grows on demand. Python list, JS Array, Java ArrayList, C++ vector, Go slice.
Loop: A construct that repeats a block of code, optionally bound by a counter (for) or a condition (while).

M

5 terms

Memoization: Cache the result of a pure function the first time it's called with given arguments; on subsequent calls with the same arguments, return the cached value.
Merge sort: Recursively split the array in half, sort each half, then merge the two sorted halves into one. Always O(n log n). Stable.
Method: A function attached to a class. Methods always have an implicit reference to the object they were called on — `self` or `this`.
Module: A single source file you can import into another. Modules let you split one big program across many files and reuse code across projects.
Mutability: A value is mutable if you can change it after creating it. Strings are usually immutable; lists are usually mutable. Immutability simplifies reasoning.

N

1 term

Namespace: A naming scope that prevents collisions. Two libraries can both define a `User` class — referring to one as `auth.User` and the other as `db.User` keeps them separate.

O

2 terms

Object: One instance built from a class. Every object has its own copy of the class's data; all objects share the class's methods.
Operator: A symbol that performs an operation: + adds, == compares, && combines booleans. Each operator works on specific types.

P

9 terms

Package: A folder of modules grouped together — a library you install with pip, npm, Maven, etc.
Parallelism: Many things actually executing simultaneously, on different cores or machines. A subset of concurrency.
Parameter: A named placeholder in a function definition. When the function runs, each parameter takes the value of the corresponding argument.
Pointer: A variable whose value is the memory address of another value. Languages like C expose pointers directly; higher-level languages use references and hide the address.
Polymorphism: One name, many shapes. Different classes can implement the same method — caller code uses the same call site and the right implementation runs at runtime.
Priority queue: A queue where the next item out is the most-important, not the oldest. Heaps are the canonical implementation.
Promise: A placeholder for a value that will arrive later. You attach handlers — `then` for the success path, `catch` for failure — and the runtime calls them when ready.
Pseudocode: Not-quite-code — a sketch of an algorithm written in informal English shapes. Useful for thinking through logic before committing to a syntax.
Pure function: A function whose output depends only on its inputs and which has no side effects. Easy to test, cache, and reason about.

Q

2 terms

Queue: A FIFO data structure — first in, first out. Like the line at a chai stall.
Quick sort: Pick a pivot; partition the array into "smaller than pivot" and "larger than pivot"; recurse on each side. Usually O(n log n), worst case O(n²).

R

6 terms

Race condition: Two operations that interleave in a way the programmer didn't anticipate. Classic case: two threads both increment a counter and one update gets lost.
Recursion: A function that calls itself, with a base case to stop the cascade. Natural fit for problems with the same shape at smaller sizes — trees, divide-and-conquer.
Refactoring: Changing the shape of code without changing what it does. Done in small, safe steps with tests as a safety net.
Reference: A pointer to where a value lives in memory. Two variables holding the same reference both see changes — they're two names for the same object.
Return value: The output a function hands back to its caller. Functions can also produce side effects (printing, mutation), but the return value is the official answer.
Runtime: The system that actually executes your program — the JavaScript engine, the Python interpreter, the JVM. Also: anything that happens while the program runs (vs. compile time).

S

9 terms

Scope: The region of code where a name is visible. A name search starts in the innermost scope and walks outward — first match wins.
Selection sort: Find the smallest element, swap it into position 0; find the next smallest, swap into position 1; repeat. O(n²) regardless of input order.
Set: A collection where duplicates do not exist. Answers one question fast: "is this thing in me?"
Short-circuit evaluation: When `a && b` knows the answer from a alone (a is false), b is never checked. Saves work — and lets you write `if (user && user.age >= 18)` without crashing on a missing user.
Side effect: Anything a function does beyond computing a return value — printing, writing a file, modifying a global, calling an API.
Sliding window: Maintain a moving window of size k over a sequence; update an aggregate (sum, max, distinct count) as the window slides. Turns many O(n × k) brute forces into O(n).
Stack: A LIFO data structure — last in, first out. Push to add to the top, pop to remove from the top. The only place you can touch is the top.
Stack overflow: The call stack ran out of room — usually because of unbounded recursion. The runtime aborts with a stack overflow error.
String: A sequence of characters — text. Most languages make strings immutable, so each "edit" is really a new string.

T

7 terms

Tail recursion: A recursive call where nothing happens after the call returns. Some compilers turn tail recursion into a loop, removing the stack cost.
Test: A small program that calls your real code with known inputs and asserts the outputs are right. Lets you change code without fear.
Thread: A lightweight unit of execution inside a process. Threads share memory, so they are fast to coordinate but easy to break with race conditions.
Tree: A branching, hierarchical structure with one root and no cycles. File systems, DOM trees, parsed code, organisation charts.
Truthy / Falsy: Many languages let non-boolean values stand in for true/false. In Python and JavaScript, 0, empty string, empty list, null and undefined are "falsy"; everything else is "truthy".
Try / Catch: A control structure that wraps risky code. If an exception fires inside try, control jumps to catch — where you decide how to handle it (log, retry, fall back, or rethrow).
Two pointers: A technique using two indexes that walk a sequence — same direction or toward each other. Solves many array problems in O(n) without extra memory.

U

1 term

Unicode: A standard that gives every character in every writing system its own number (a "code point"). UTF-8 is the most common way to store Unicode on disk.

V

3 terms

Value: A copy of the data, not a pointer to it. Numbers and booleans are value-like in most languages; lists and objects are reference-like.
Variable: A name attached to a value. The computer puts the value somewhere in memory; the name is how you talk about it later.
Version control: A system that tracks every change to your code over time and lets multiple people work on the same project. Git is the universal default.