📖 The Plain-English Glossary

Every technical term used in this course, defined in one or two plain sentences. No definition here is allowed to use another technical term without linking to it.

Tip: On GitHub, press Ctrl+F (or Cmd+F on Mac) and type the word you’re looking for.

A

Agile — A way of building software in small steps with constant feedback, instead of planning everything upfront. Like cooking while tasting, rather than following a fixed banquet plan. (Module 07)
Algorithm — A precise, step-by-step recipe for solving a problem. Your morning routine is one; so is Google’s search ranking. (Module 04)
AI (Artificial Intelligence) — Software that performs tasks we used to think required human intelligence, like recognizing faces or writing text. Today’s AI learns patterns from examples rather than following hand-written rules. (Module 16)
API (Application Programming Interface) — A menu of things one program can ask another program to do. Like a waiter carrying structured orders between you (the app) and the kitchen (the server). (Module 10)
App / Application — A program built for regular people to use: WhatsApp, Excel, Candy Crush. (Module 02)
Array — A row of items stored in numbered slots, like numbered parking spots. Fast to visit slot #42, slow to squeeze a new car into the middle. (Module 11)
Authentication — Proving who you are (password, fingerprint, code from your phone). (Module 14)
Authorization — What you’re allowed to do once you’re in. A hotel keycard proves you’re a guest (authentication) but only opens your room (authorization). (Module 14)
Automated test — A small program whose only job is to check that another program still works. (Module 09)

B

Backend — The part of an app that runs on the company’s computers, not yours: the kitchen of the restaurant. You never see it directly. (Module 10)
Backlog — The ordered wish-list of everything a team might build someday. (Module 18)
Backup — A spare copy of data kept somewhere safe, so one disaster can’t destroy the only copy. (Module 12)
Bandwidth — How much data can flow per second through a connection. A wide truck, as opposed to a fast bike (see Latency). (Module 13)
Binary — Writing information using only two symbols, 0 and 1 — because computer parts are billions of tiny on/off switches. (Module 01)
Bit — One single 0 or 1. The smallest possible piece of information. (Module 01)
Branch — In version control: your own experimental copy of the project, so you can make changes without touching the original until you’re ready. (Module 08)
Browser — The app you view websites with (Chrome, Safari, Firefox, Edge). A universal player for web pages. (Module 03)
Bug — A mistake in software: the gap between what the programmer meant and what they wrote. Named after a real moth found in a 1947 computer. (Module 09)
Byte — Eight bits. Roughly enough to store one letter. (Module 01)

C

Cache — A small stash of recently-used things kept close by so you don’t have to fetch them again. Like keeping the salt next to the stove instead of in the pantry. (Module 13)
CDN (Content Delivery Network) — Copies of a website stored in many cities so it loads from a computer near you. A chain of local warehouses instead of one distant factory. (Module 15)
CI (Continuous Integration) — Robots that automatically re-run all of a project’s tests every time anyone changes the code. (Module 09)
Client — Any program that asks for things over a network — usually your browser or app. The customer, where the server is the shop. (Module 03)
Cloud (the) — Other people’s computers, rented over the internet. Physically: warehouse-sized data centers. (Module 15)
Code — Instructions for a computer, written in a programming language. It’s text, in files, written by people. (Module 02)
Commit — In version control: a saved snapshot of your project plus a note about what changed. Like a saved game you can always return to. (Module 08)
Compiler — A translator program that converts human-readable code into machine instructions, all at once, in advance. (Module 02)
Cookie — A small note a website asks your browser to remember, so it recognizes you next visit. (Module 03)
CPU (Central Processing Unit) — The chip that actually executes instructions, one after another, billions of times per second. The chef of the computer. (Module 01)
Crash — When a program hits a situation it can’t handle and stops working entirely. (Module 09)
CSS — The language that describes how a web page looks: colors, fonts, layout. The clothing on the HTML skeleton. (Module 10)
CSV file — A spreadsheet saved as plain text: values separated by commas, one row per line. (Module 06)

D

Data — Recorded facts. Digital data is facts written as numbers so computers can store and process them. (Module 06)
Data center — A warehouse-sized building full of computers. This is where “the cloud” physically lives. (Module 15)
Data structure — A container shape for organizing data (list, table, dictionary…), each with different strengths. (Modules 06, 11)
Database — An organized collection of data plus the software librarian that guards it, finds things instantly, and lets thousands of people use it at once without chaos. (Module 12)
Debugging — Detective work to find and fix a bug. (Module 09)
Deploy — To move new code onto the real servers so actual users get it. Software’s “moving day.” (Module 07)
DevOps — The practice (and job) of keeping the machinery that builds and runs software working smoothly. (Module 18)
Dictionary (data structure) — A container where you look things up by name instead of position, like a contact book. Also called a hash map or key-value store. (Module 11)
DNS (Domain Name System) — The internet’s phone book: turns names like google.com into numeric addresses computers use. (Module 03)
Driver — A small program that teaches the operating system to talk to one specific gadget (printer, mouse, camera). (Module 13)

E

Edge case — A rare, extreme situation software must still handle: a user born on Feb 29, a name with 1,000 letters, an order of zero items. (Module 09)
Encryption — Scrambling information so only someone with the right key can read it. (Module 14)
End-to-end encryption — Encryption where only the sender and receiver hold keys — not even the company carrying the message can read it. (Module 14)

F

File — A labeled box of bytes with a name. Everything on your computer — photos, songs, programs — is files. (Module 02)
Firewall — A doorman for network traffic: checks what’s trying to come in or out and blocks what’s not on the list. (Module 13)
Framework — A pre-built skeleton for a common kind of program, so developers don’t start from zero. Like a cake mix versus raw flour. (Module 17)
Frontend — The part of an app you can see and touch. It runs on your device. The dining room of the restaurant. (Module 10)
Full-stack — Working on both frontend and backend. (Module 10)

G

Git — The world’s most popular version-control tool: a time machine for files. (Module 08)
GitHub — A website where Git projects live so people can collaborate. (Git is the tool; GitHub is the place — like Word vs. Google Drive.) (Module 08)
GPU (Graphics Processing Unit) — A chip with thousands of small workers that all do simple tasks at once. Built for graphics; now also trains AI. (Module 01)

H

Hardware — The physical parts of a computer: the stuff you could drop on your foot. (Module 01)
Hash / Hashing — Turning any data into a short fixed “fingerprint.” Same input always gives the same fingerprint, but you can’t reconstruct the input from it. (Module 14)
HTML — The language that describes a web page’s structure and content: headings, paragraphs, images, links. The skeleton. (Module 10)
HTTP / HTTPS — The set of rules browsers and servers use to talk. The S means the conversation is encrypted (the padlock in your browser). (Module 03)

I

Index (database) — A fast-lookup list a database keeps on the side, like the index at the back of a book. (Module 12)
Interpreter — A translator program that reads and executes code line by line, live. (Module 02)
IP address — A device’s numeric address on a network, like a street address for mail. (Module 03)
IoT (Internet of Things) — Everyday objects (bulbs, doorbells, fridges) with tiny computers and internet connections inside. (Module 17)

J

JavaScript — The programming language that runs inside web browsers and makes pages interactive. The muscles on the HTML skeleton. (Module 10)
JSON — A common text format for structured data: labeled boxes inside labeled boxes. What most APIs speak. (Module 06)

K

Kernel — The innermost core of an operating system: the manager’s inner office. (Module 13)

L

Latency — How long one round trip takes on a network, in milliseconds. The fast bike, as opposed to the wide truck (see Bandwidth). (Module 13)
Library (code) — A collection of ready-made code you can use instead of writing your own. Like buying pastry instead of laminating your own dough. (Module 05)
Linked list — A chain of items where each one points to the next, like a scavenger hunt. (Module 11)
Linux — A free, open-source operating system that runs most of the world’s servers (and every Android phone). (Module 02)
Loop — A code instruction meaning “repeat this.” For loops repeat once per item; while loops repeat until a condition changes. (Module 05)

M

Machine learning (ML) — Teaching software by showing it many examples and letting it find the patterns itself, instead of writing the rules by hand. (Module 16)
Malware — Malicious software: programs built to steal, spy, or damage. (Module 14)
Merge — Combining changes from one branch back into another. (Module 08)
Merge conflict — When two people changed the same line and a human has to decide which version wins. Normal, not a disaster. (Module 08)
Metadata — Data about data: a photo’s date, location, and camera model are metadata; the pixels are the data. (Module 06)
Microservices — Building a backend as many small cooperating programs instead of one big one. A food court instead of one giant restaurant. (Module 10)
Model (AI) — The result of training: a program with millions or billions of tuned “knobs” that turns inputs into predictions. (Module 16)
MVP (Minimum Viable Product) — The smallest version of a product that’s still genuinely useful, shipped early to learn from real users. (Module 07)

N

Network — Any group of connected computers that can exchange data. The internet is a network of networks. (Module 03)
NoSQL — Databases that store flexible documents (labeled boxes) instead of strict tables. A closet with bins instead of a filing cabinet. (Module 12)

O

Open source — Software whose code is public for anyone to read, use, and improve. A community cookbook instead of a secret recipe. (Module 02)
Operating system (OS) — The master program that manages a computer’s hardware and runs all other programs: Windows, macOS, Linux, Android, iOS. The hotel manager. (Module 02)

P

Packet — One small chunk of a message sent over the internet. Big messages are cut into many packets that travel separately and get reassembled. (Module 03)
Password manager — An app that generates and remembers strong, unique passwords for you, locked behind one master password. (Module 14)
Patch — A small software update, often fixing bugs or security holes. (Module 14)
Phishing — Tricking people into giving up passwords or money by impersonating someone trustworthy. The #1 real-world attack. (Module 14)
Pixel — One tiny dot of a screen or image. (Module 01)
Port — A numbered “door” on a networked computer; different services listen at different doors (the web listens at 443). (Module 13)
Process — One running program, kept in its own sealed compartment by the operating system. (Module 13)
Program — A list of instructions a computer can execute. Stored as files; written by people. (Module 02)
Programming language — A human-readable language (Python, JavaScript…) for writing instructions that get translated for the machine. (Module 02)
Protocol — An agreed set of rules for how computers talk to each other. Etiquette for machines. (Module 03)
Pseudocode — Instructions written in structured plain English before turning them into real code. (Module 04)
Pull request (PR) — A “please review and accept my changes” note in GitHub. Where code review happens. (Module 08)
Python — A popular programming language famous for reading almost like English. The one this course teaches. (Module 05)

Q

QA (Quality Assurance) — The craft (and job) of finding problems before users do. (Module 09)
Query — A question you ask a database, usually written in SQL. (Module 12)
Queue — A first-in-first-out line, like at a bakery. How printers and messaging systems keep order. (Module 11)

R

RAM (memory) — The computer’s fast, temporary workspace — the kitchen counter. Big counter = more things in progress at once. Wiped clean when power goes off. (Module 01)
Refactoring — Improving code’s internal tidiness without changing what it does. Cleaning the kitchen between rushes. (Module 18)
Regression — When a change accidentally breaks something that used to work. (Module 09)
Relational database — A database organized as tables with relationships between them (customers ↔ orders). (Module 12)
Repository (repo) — One project’s folder under version control — all its files plus their entire history. (Module 08)
Router — A device that passes packets toward their destination, like a post office sorting mail. Your home has one; the internet has millions. (Module 03)

S

SaaS (Software as a Service) — Software you use over the internet instead of installing: Gmail, Netflix, Zoom. (Module 15)
Server — A computer (or program) that stays on all the time so other computers can ask it for things. The always-open shop. (Module 03)
Scrum — The most common flavor of agile: two-week sprints, daily standups, retrospectives. (Module 18)
SDLC (Software Development Lifecycle) — The journey from idea to running software: plan → design → build → test → release → maintain. (Module 07)
SQL — The standard language for asking questions of relational databases. Polite, rigid English for the librarian. (Module 12)
SSD / hard drive (storage) — The computer’s permanent memory — the pantry. Slower than RAM but keeps everything when the power is off. (Module 01)
Stack (data structure) — A last-in-first-out pile, like plates. Powers the Undo button. (Module 11)
Stack (tech stack) — The set of tools and languages a team chose to build their product with. (Module 07)
Sprint — One short cycle (usually two weeks) in which an agile team builds a planned slice of work. (Module 18)
String — Text data: a sequence of characters. "hello" is a string; so is "5" (which is different from the number 5). (Module 05)
Syntax — The grammar rules of a programming language. Break them and the computer refuses to run your code at all. (Module 05)

T

Tech debt — The future cost of past shortcuts in code. Borrowed time, repaid with interest. (Module 18)
Terminal / command line — A text-based way to control a computer by typing commands instead of clicking. Powerful, old, still everywhere. (Module 08)
Test plan — A written list of checks to run before declaring software works. (Module 09)
Transaction (database) — An all-or-nothing group of changes: transferring money must subtract and add — or do neither. (Module 12)
Tree (data structure) — Data organized like a family tree or folders-in-folders. (Module 11)
2FA (Two-Factor Authentication) — Requiring two proofs of identity, like a password plus a code on your phone. Stops most account theft. (Module 14)

U

UI (User Interface) — Everything you see and interact with: buttons, screens, menus. (Module 18)
Unit test — An automated test for one small piece of code — testing each Lego brick before building the castle. (Module 09)
URL — A web address: https://example.com/page. (Module 03)
User story — A one-sentence requirement in the form “As a __, I want __ so that ___.” (Module 07)
UX (User Experience) — How using a product feels end to end — and the design discipline devoted to it. (Module 18)

V

Variable — A labeled jar in a program that holds a value you can read or replace. (Module 05)
Version control — A system that records every change to a project so you can see history, undo mistakes, and collaborate without chaos. (Module 08)
VPN (Virtual Private Network) — A sealed courier tunnel for your internet traffic: outsiders see the tunnel, not the contents. (The VPN company can see them — choose wisely.) (Module 13)

W

Web app — A full application that runs in your browser: Google Docs, Figma, online banking. (Module 17)
WiFi — Radio waves carrying network data over short distances. WiFi is not the internet — it’s your wireless driveway onto it. (Module 03)

Missing a term? That’s a bug in the course — tell us and we’ll add it.