Programming Glossary
A working developer’s glossary of 49 essential terms, organized by category. Each entry is written in plain English — useful whether you’re learning to code, prepping for a technical interview, or just trying to follow a Slack thread without nodding along blindly.
Most of these words also show up in the daily Dev Puzzle.
Core data structures
Every programming language is built on a small handful of data shapes. These are the ones you'll meet first.
- Array
- An ordered list of values stored together in memory and accessed by index. Arrays are the workhorse data structure in almost every language — fast to read, less fast to insert into the middle, and indexed from zero in nearly every modern language you'll meet.
- Object
- A collection of named values, often called a dictionary, hash, or map depending on the language. Objects are how you group related data together: a user has a name, an email, and a created-at timestamp; those live as keys on the user object.
- String
- A sequence of characters used to represent text. Behind the scenes most strings are arrays of code points, which is why they have many of the same operations: length, indexing, slicing, and iteration.
- Tuple
- A small, ordered, often-fixed-size collection of values that can be of different types. In languages that have them (Python, Rust, Swift) tuples are common return values when a function has multiple things to give back.
- Stack
- A LIFO (last-in, first-out) data structure. You push items on the top and pop them off the top. The classic real-world analogy is a stack of plates: you take from the top, you add to the top.
- Queue
- A FIFO (first-in, first-out) data structure. Items enter at the back, leave from the front — same as a line at the grocery store. Queues are everywhere in concurrent systems.
- Hash table
- A data structure that maps keys to values using a hash function for fast lookup. In most languages, this is what's underneath an Object, Map, or Dict. Average access time is constant regardless of size.
- Tree
- A hierarchical data structure where each node has a parent and zero or more children. The file system on your computer is a tree. So is the DOM in a web page. So is the AST your compiler builds.
- Graph
- A collection of nodes connected by edges. Unlike a tree, a graph can have cycles and a node can have many parents. Social networks, road maps, and dependency relationships are all naturally modeled as graphs.
- Linked list
- A sequence of nodes where each node holds a value plus a pointer to the next node. Slower to index than arrays but cheap to insert into the middle of, useful for certain algorithms.
Control flow & functions
The vocabulary of "how does my code decide what to do next."
- Function
- A reusable block of code that takes inputs (arguments), does work, and usually returns an output. Functions are the unit of reuse in almost every language and the cornerstone of writing code you can test.
- Loop
- A construct that runs the same block of code repeatedly until a condition is met. The most common forms are for, while, and do-while.
- Recursion
- When a function calls itself. Recursion is the natural way to express problems that have a smaller version of themselves inside (traversing a tree, computing a factorial, walking a directory).
- Conditional
- A branching construct (if/else, switch, ternary) that picks a path based on a boolean expression. Conditionals are how programs make decisions.
- Closure
- A function bundled together with the variables from the scope where it was defined. Closures let you write functions that 'remember' values from their environment.
- Callback
- A function passed as an argument to another function, to be invoked later. The foundation of event-driven and asynchronous code.
- Iterator
- An object that produces values one at a time. Iterators are the engine behind for-of loops, Python generators, and Java's Stream API.
Object-oriented programming
The vocabulary of how objects and classes relate to each other.
- Class
- A blueprint for creating objects. A class defines what data instances will hold and what they can do.
- Object
- An instance of a class. Where a class is the blueprint, an object is the actual house built from it.
- Inheritance
- One class taking on the properties and methods of another. A Dog class might inherit from an Animal class. Powerful, sometimes overused.
- Polymorphism
- Letting one interface stand in for many underlying types. The reason a render() method can work the same way on shapes, buttons, and pizza orders.
- Encapsulation
- Bundling data with the methods that operate on it, and hiding the internals from the outside world.
- Abstraction
- Hiding implementation details behind a simpler interface. You drive a car without thinking about combustion timing.
- Interface
- A contract that defines what methods or properties a type must have, without saying anything about how they're implemented.
Web & networking
The shared vocabulary of how data moves between browsers, servers, and APIs.
- API
- Application Programming Interface. The contract between two programs: what you can ask for, what you'll get back, and in what format.
- REST
- A style of API design built around HTTP verbs (GET, POST, PUT, DELETE) and resources identified by URL.
- Endpoint
- A specific URL an API exposes. /users/42 is an endpoint. APIs are made up of endpoints the way buildings are made up of doors.
- JSON
- JavaScript Object Notation. A lightweight text format for representing structured data. The default format for most web APIs.
- HTTP
- HyperText Transfer Protocol. The protocol your browser uses to fetch web pages and call APIs.
- Cookie
- A small piece of data the server asks the browser to store and send back on future requests. How a server remembers who you are between page loads.
- CORS
- Cross-Origin Resource Sharing. The browser security rule that says JavaScript can't make arbitrary requests to a different domain unless that domain explicitly allows it.
- DOM
- Document Object Model. The tree of HTML elements that makes up a web page, represented as JavaScript objects the browser exposes.
Concurrency & async
What to call things when more than one thing is happening at once.
- Thread
- A path of execution inside a program. Multithreaded programs can do several things in parallel. Threads share memory, the source of most concurrency bugs.
- Async
- Short for asynchronous. Code that starts an operation, doesn't wait for it to finish, and lets you continue with other work.
- Promise
- A placeholder for a value that isn't ready yet. The foundation of modern JavaScript async code.
- Race condition
- A bug that happens because two pieces of code ran at the same time in an unexpected order. Famously hard to reproduce.
- Mutex
- Mutual exclusion. A lock that lets only one thread hold a resource at a time. The standard tool for preventing race conditions.
- Deadlock
- When two threads are each waiting for a resource the other holds, and neither can move forward.
Version control
The Git vocabulary every working developer needs.
- Commit
- A saved snapshot of your code at a point in time. A clean commit history is one of the most underrated assets on a project.
- Branch
- A parallel line of development. Branches let you work on a new feature without disturbing the main codebase.
- Merge
- Combining the changes from two branches. Most merges are automatic; the ones that aren't produce merge conflicts.
- Rebase
- Rewriting a branch's history to sit on top of another branch. Powerful for keeping a clean history, controversial because rewriting shared history is a foot-gun.
- Pull request
- The modern way of saying "please review and merge this branch."
Things that bite you
Errors, bugs, and weird states you'll spend the rest of your career navigating.
- Bug
- A defect in your code. The term predates computers and reportedly comes from an actual moth that got stuck in a 1947 relay computer at Harvard.
- Stack trace
- The chain of function calls that led to a crash. Read from top to bottom.
- Null
- The value that means "nothing." Famously called the billion-dollar mistake by its creator, Tony Hoare.
- Memory leak
- Forgetting to release memory you no longer need. Fatal in long-running processes.
- Deprecated
- Marked as outdated. Still works, will eventually go away.
- Edge case
- A scenario that occurs at the extremes of valid input — empty arrays, max integer values, dates around midnight on New Year's Eve.