Glossary

Each technical word here is explained in plain English. In a lesson, the first time a word from this list appears, it has a dotted line under it. Point at it, or move to it with the Tab key, to see what it means. Select it, or tap it on a phone, to come to this page.

aggregate function: A function that turns many rows into one value, like count(), sum() or avg(). Lesson
alias: A new name for a column or table inside one query, given with AS, like sum(total) AS spent. Lesson
amortized: Averaged over many steps. A few steps are slow, but the average stays fast, like O(1) for list.append.
anagram: A word made from the same letters as another, like tea and eat. Lesson
API: The set of requests one program accepts from another, and what it answers.
argument: A value you pass to a function when you call it. Lesson
ASGI: The async version of WSGI. Servers like Uvicorn use it to run FastAPI and async Django. Lesson
base case: The input where a recursive function stops calling itself and returns an answer directly. Lesson
Big-O: A way to say how the work grows as the input grows. O(n) means the work grows in step with n items. Lesson
binary search: Finding an item in a sorted list by checking the middle and throwing away the half it can't be in. Lesson
breadth-first search: A search that visits all places one step away, then all places two steps away, and so on.
brute force: The simplest solution that tries every possibility. It is usually correct but slow. Lesson
bytecode: Simple instructions that Python makes from your code before it runs it. Lesson
cache: A fast store that keeps copies of data you read often, so you don't fetch it again. Lesson
call stack: The pile of function calls that have started but not finished yet. Lesson
CDN: Servers around the world that keep copies of files near users, so pages load fast anywhere. Lesson
closure: A function that remembers names from the function it was made in. Lesson
commit: A saved version of a whole project in Git, with a message saying what changed and why. Lesson
comprehension: A short way to build a list, set or dict in one line, like [x * 2 for x in nums]. Lesson
constraint: A rule a table checks on every change, like NOT NULL, UNIQUE or CHECK (price > 0). Lesson
context manager: An object used with with. It runs set-up code at the start and clean-up code at the end, even after an error. Lesson
correlated subquery: A subquery that reads a column of the outer query's row, so it runs again for each row. Lesson
cosine similarity: A score from -1 to 1 for how close two vectors point. Close meanings score near 1. Lesson
CTE: A query named in WITH, before the main query. The main query reads it like a table. Lesson
database index: An extra sorted structure the database keeps, so it can find rows without reading the whole table. Lesson
dataclass: A class marked @dataclass, for which Python writes __init__, __repr__ and == from the listed fields. Lesson
DataFrame: A pandas table, stored column by column, with a name for each column. Lesson
decorator: A function that takes a function and returns a new one that adds something, like timing. Written @name above a def. Lesson
deep copy: A copy of an object and everything inside it, so the two share nothing. Lesson
default argument: A value a parameter gets when the caller leaves it out, like n=10. Lesson
deploy: Putting a new version of the code live, for real users. Lesson
deque: A double-ended queue from collections. It adds and removes items at both ends in one step. Lesson
dict: Python's hash map. It maps each key to a value, like {"ana": 31}. Lesson
DNS: The internet's phone book. It turns a name like rungwise.dev into a server's address. Lesson
edge case: An unusual input at the limits, like an empty list, one item, or very large numbers. Code often breaks there.
embedding: A list of numbers that stands for the meaning of a text. Texts with close meanings get close numbers. Lesson
endpoint: One address of an API that accepts requests, like /api/orders.
eval set: A fixed list of test questions with known right answers, used to measure the system after each change. Lesson
event loop: One thread that runs many paused tasks, switching to whichever one is ready. Lesson
exception: An error object that Python raises when something goes wrong. Code can catch it with try and except. Lesson
f-string: Text with an f before the quote, like f"{qty} pens". Python puts the values in the braces into the text. Lesson
foreign key: A column that points at a row in another table, by that row's primary key. Lesson
generator: A function that gives out one value at a time with yield, and pauses in between. It keeps memory small. Lesson
GraphQL: An API style where the app sends one query that names every field it needs. Lesson
gRPC: An API style for calls between services, with typed messages sent in a small binary form. Lesson
hash: A number made from a value. Dicts and sets use it to find the right slot quickly. Lesson
hash map: A table that finds a value from its key in about one step, using the key's hash. In Python it is a dict. Lesson
hashable: Has a hash that never changes, so it can be a dict key or go in a set. Numbers, text, and tuples of them are hashable. Lesson
heap: A structure that always gives you the smallest item in one step. Adding or taking an item costs O(log n).
HTTP: The rules a browser and a server use to ask for a page and send it back. Lesson
HTTPS: HTTP sent through TLS, so nobody on the way can read or change it. Lesson
idempotent: Has the same effect whether you do it once or many times, like deleting the same note twice. Lesson
immutable: Cannot be changed after it is made. Numbers, text and tuples are immutable. Lesson
interpreter: The program that reads your Python and runs it, one step at a time. Lesson
iterator: An object that hands out the next item each time you ask, until there are none left. Lesson
lambda: A small function with no name, written in one line, like lambda x: x * 2.
latency: How long one request takes, from asking to getting the answer. Lesson
LLM: A large language model. It reads text and writes text, like a chatbot does. Lesson
load balancer: A server that spreads incoming requests across several app servers. Lesson
middleware: Code that wraps every request and response in a web app, like a login check or extra headers. Lesson
module: A Python file you can import. import prices runs prices.py once and gives you its names. Lesson
mutable: Can be changed after it is made. Lists, dicts and sets are mutable. Lesson
N+1 queries: One query for a list, then one more query for each item in it. It gets slower as the list grows. Lesson
NULL: SQL's mark for "unknown" or "no value". A comparison like = NULL is unknown too, so test it with IS NULL. Lesson
ORM: A library that turns database rows into objects in your code, and writes the SQL for you. Lesson
p95: The time that 95 of every 100 requests finish within. The slowest 5 take longer. Lesson
parameter: A name in a function's definition that gets a value when the function is called. Lesson
primary key: The column (or columns) whose value is different in every row, so it names one row. Lesson
pull request: A request to merge one branch into another, usually main, so teammates can review the change first. Lesson
queue: A line of items where you add at the back and take from the front. The first in is the first out. Lesson
RAG: Retrieval-augmented generation. Find the right documents first, then ask the model to answer only from them. Lesson
rebase: A Git command that replays your commits on top of another branch, as new commits, to make one straight line of history. Lesson
recursion: When a function calls itself on a smaller part of the problem. Lesson
replica: A copy of a database that stays in sync with the main one and can answer reads. Lesson
reranker: A slower, more careful model that puts the best few search results in a better order. Lesson
REST: An API style where each thing has a URL, and HTTP verbs like GET and POST act on it. Lesson
rollback: Going back to the last version that worked. Lesson
round trip: One message out and its answer back. Distance sets how long it takes. Lesson
rung: One step of a lesson's ladder. Each lesson solves its problem three ways, Okay, Better and Best, and each way is a rung. Lesson
scope: The part of the code where a name can be used. Each function call has its own scope. Lesson
semi-join: A filter that keeps a row when a match exists (semi-join), or when none does (anti-join), without copying it once per match. Lesson
shallow copy: A new outer list or dict whose items are the same objects as the original's. Lesson
shard: One part of a database that has been split across several machines. Each holds some of the rows. Lesson
slice: A part of a list or text, taken by positions, like nums[1:4]. It makes a new copy. Lesson
sliding window: A stretch of items in a row that moves along a list. It grows at the right and shrinks at the left, so each item is seen about twice. Lesson
space complexity: How the extra memory grows with the input size, written in Big-O. Lesson
stable sort: A sort that keeps equal items in the order they came in. Lesson
stack: A pile of items where you add and take from the top. The last item in is the first out. Lesson
stateless: Keeps nothing between requests, so any copy of the server can answer any request. Lesson
status code: The three-digit number at the start of an HTTP response, like 200 or 404. It says what happened. Lesson
subquery: A query inside another query. It hands its answer to the outer query. Lesson
terminal: A window where you type commands for the computer, like python shop.py. On Windows it is called PowerShell or Command Prompt. Lesson
time complexity: How the running time grows with the input size, written in Big-O. Lesson
TLS: The layer that encrypts a connection. It costs extra round trips to set up. Lesson
tokenizer: The first step of reading code. It cuts the text into small pieces, like names, numbers and brackets. Lesson
traceback: The report Python prints when an error is not caught. It lists the calls that led to the error. Lesson
transaction: A group of database changes that all happen, or none do. Lesson
TTL: Time to live. How long a copy may be kept before it must be fetched again. Lesson
tuple: A fixed group of values in order, like (3, 4). It can't be changed after it is made. Lesson
two pointers: Two positions that move through a list, often from both ends toward the middle, to check pairs in one pass. Lesson
type hint: A label on an argument or result, like int or list[str], that tools such as mypy check. Python itself ignores it. Lesson
vector: A list of numbers. In AI work, usually an embedding. Lesson
virtual environment: A folder with its own Python and its own installed packages, made for one project so projects don’t clash. Lesson
window function: A function, like ROW_NUMBER, that looks at related rows but keeps every row in the result. Lesson
WSGI: The standard way a Python web server calls a sync app, such as Flask or Django. Lesson