Glossary¶
Every new word in the course is explained here in one line. Words are in alphabetical order. The module in brackets is where you first meet the word.
init — The special method that runs when an object is made. It stores the data (self.name = name) and can refuse bad data. (Module 5)
name — A module's name. It is "__main__" for the file you ran, so if __name__ == "__main__": marks code that runs only then. (Module 4)
Absolute path — A path that starts from the root folder /, so it means the same thing from anywhere. (Module 1)
Alias — A shortcut name for a longer command, defined in the shell, like ll for ls -l. (Module 2)
Aliasing — Two names pointing to the same object, so a change through one is seen through the other. (Module 1)
API — Application Programming Interface: a set of URLs other programs call to get data or do work. (Module 0)
API endpoint — One URL plus one method that an app can call, like GET /products. (Module 0)
apt — Debian and Ubuntu's package manager: apt-get update, then apt-get install -y name. (Module 2)
Argument — A word given to a command, saying what to work on, like logs in ls logs. (Module 2)
Asyncio — Python's library for waiting on many things at once with one thread and an event loop: async def, await, asyncio.gather. (Module 5)
Atomic — Done in one indivisible step: other programs see it either not done at all, or completely done. (Module 1)
Attribute — Data stored on an object, read with a dot: masala.stock. (Module 5)
authorized_keys — The file on a server (~/.ssh/authorized_keys) listing the public keys allowed to log in as that user. (Module 2)
Await — Inside async def: pause here until this is done, and let the event loop run other tasks meanwhile. (Module 5)
Backend — The hidden part of an app that answers requests, enforces rules and stores data. (Module 0)
Background job — A command started with & at the end, so the shell gives you the prompt back while it runs. (Module 2)
Bandwidth — How much data a connection can carry per second, like the width of a pipe. (Module 1)
Bare except — except: with no error name. It catches every error, even typos in your own code, so it hides bugs. Avoid it. (Module 4)
bash — Bourne Again SHell: the usual shell on Linux servers. (Module 2)
Bit — The smallest piece of data: a single 0 or 1. 8 bits make 1 byte. (Module 1)
Block — The fixed-size piece (usually 4 KB) in which a disk stores data. Even a tiny file uses a whole block. (Module 1)
Blocking call — A normal call that waits without letting anything else run, like time.sleep or requests.get. Inside async def it freezes the whole event loop. (Module 5)
Body — The actual data inside a request or response, after the headers. (Module 0)
Bool — A yes/no value: True or False. (Module 4)
Bottleneck — The narrowest point in a system, which slows everything else down. (Module 0)
Branch — A name that points to one commit: the newest commit of a line of work. main is the first one. Making a branch copies no files. (Module 3)
Branch protection — A GitHub setting that stops direct pushes to a branch like main, so every change must come through a reviewed pull request. (Module 3)
Break and continue — Inside a loop: continue skips to the next round, break stops the whole loop. (Module 4)
Builtin — A command that is part of the shell itself, like cd or echo, not a separate program. (Module 2)
Business rule — A rule of how the business works, enforced by the backend, like "never sell more than the stock". (Module 0)
Byte — 8 bits. Enough to store one English letter. (Module 1)
Bytecode — Simple instructions that Python compiles your code into before running it. Saved in __pycache__. (Module 0)
Cache — A small, fast place that keeps a copy of data you use often. (Module 1)
Cache line — The chunk of memory (64 or 128 bytes) the CPU copies into its cache at once. (Module 1)
Call stack — The pile of frames for the function calls happening right now; newest on top. (Module 1)
Class — A blueprint for objects: what every object has (attributes) and can do (methods). class Product:. (Module 5)
Class attribute — A value written directly inside class …:, shared by every object. Safe for constants, a bug for lists. (Module 5)
Client — A program that sends requests to another program and shows you the answer. The docker command is a client. (Module 0)
Client–server model — A design where clients send requests and servers answer them. (Module 1)
Clone — git clone <address>: download your own full copy of a repository, with all its history. (Module 3)
Closure — A function that remembers names from the function it was created in, even after that function finished. (Module 5)
Code editor — A program for writing code, like VS Code. (Module 0)
Code review — A teammate reading your change before it is merged, to catch mistakes and share knowledge. (Module 3)
Command substitution — $(command): the shell replaces it with that command's output. (Module 2)
Command-line arguments — The words typed after the program's name, like add "Masala Box" 299. Python gives them as sys.argv. (Module 4)
Commit — A save point in Git: a recorded version of your code, with a message about what changed. (Module 0)
Commit hash — The unique ID of a Git commit, made from its content, like af41737. (Module 0)
Comparison operator — ==, !=, >, <, >=, <=: they compare two values and give True or False. (Module 4)
Comprehension — A one-line way to build a list, dict or set from another collection: [p["name"] for p in catalog if p["price_paise"] < 50000]. (Module 4)
Concurrency — Doing several things in overlapping time, like waiting for 10 suppliers at once. Threads, processes and asyncio are three ways. (Module 5)
Condition — An expression that is True or False, like cart_total >= 99900. if and while use one. (Module 4)
Conflict markers — The lines <<<<<<<, ======= and >>>>>>> Git writes into a file during a merge conflict, around your version and theirs. (Module 3)
Constant — A value that never changes while the program runs. Python's convention is UPPER_CASE names: FREE_FROM_PAISE. (Module 4)
Container — A running copy of an image: a small sealed box with a program and everything it needs. (Module 0)
Context manager — An object used with with that runs setup at the start and clean-up at the end, even after an error. open() is one. (Module 5)
Context switch — The kernel pausing one thread and resuming another on a CPU core. (Module 1)
Control flow — The order in which lines run. if, for and while change it: skip lines, or repeat them. (Module 4)
Core — One worker inside a CPU. Each core runs one thing at a time; a laptop often has 8. (Module 1)
Coroutine — A function defined with async def: it can pause at await and continue later. Calling it without await doesn't run it. (Module 5)
CPU — Central Processing Unit: the part of a computer that follows instructions and does the work. (Module 1)
CPU-bound — Work that keeps the CPU busy most of the time, like resizing photos. (Module 1)
CPython — The standard Python interpreter, written in C. The one you install from python.org. (Module 0)
curl — A command-line tool that sends HTTP requests, like a tiny browser with no screen. (Module 0)
Current working directory — The folder a process starts relative paths from. os.getcwd() shows it. (Module 1)
Daemon — A program that runs in the background, waiting for work. The Docker Engine is one. (Module 0)
Data centre — A building full of servers, with fast networks, power and cooling. (Module 1)
Database — A program that stores data safely and finds it again quickly. (Module 0)
/dev/null — A special file that throws away everything written to it. (Module 2)
Dataclass — A class made with @dataclass: you list typed fields, and Python writes __init__, __repr__ and __eq__ for you. (Module 5)
Decorator — A function that takes a function and returns a wrapper around it, adding behaviour before/after. @timed above def f means f = timed(f). (Module 5)
Default factory — field(default_factory=list): a function called for each new object, so every object gets its own fresh list. (Module 5)
Default value — A value a parameter takes when the caller doesn't pass one: def line_total(price, quantity=1):. (Module 4)
Dependency — A package another package needs to work. requests depends on certifi, idna, urllib3 and charset-normalizer. (Module 5)
Detached HEAD — When Git is on a commit directly, not on a branch. New commits made there have no branch name following them. (Module 3)
Dict — Values looked up by name (a key), in { }: product["price_paise"]. Short for dictionary. (Module 4)
Diff — A list of differences between two versions of files: + lines were added, - lines were removed. git diff shows one. (Module 3)
Digest — A fingerprint (sha256:...) of an image's exact content. Unlike a tag, it can never point to other bytes. (Module 0)
Directory — Another word for a folder: a special file that lists names and their inode numbers. (Module 1)
Disk — Storage that keeps files even when the power is off. Most computers use an SSD. (Module 1)
Docker — The tool that builds and runs containers. (Module 0)
Docker Compose — A tool that starts several containers together, described in one docker-compose.yml file. (Module 0)
Docker Desktop — The app that installs and starts the Docker Engine on Mac and Windows. (Module 0)
Docker Engine — The background program that actually builds and runs containers. (Module 0)
Docker Hub — A big online library of ready-made images, like python and postgres. (Module 0)
Docstring — The text in triple quotes right under def, saying what the function does. (Module 4)
Dotfile — A hidden file or folder whose name starts with ., like .env or .bashrc. ls -a shows them. (Module 2)
Drop-in file — A small .conf file in <name>.service.d/ that overrides some lines of a unit file without editing it. (Module 2)
Dry run — Running a command or script so it only shows what it would do, without doing it. (Module 2)
Dynamic typing — In Python the value has a type, the name doesn't: one name can point to an int now and a str later. (Module 4)
ECC memory — RAM that detects and fixes some memory errors. Common in servers. (Module 1)
Enable (systemd) — systemctl enable: start a service automatically at every boot. Different from start, which runs it only now. (Module 2)
Encoding — The rule for turning text into bytes. UTF-8 handles every script, including ₹; always pass encoding="utf-8". (Module 4)
Encrypted — Scrambled so that only the intended receiver can read it. (Module 2)
End of life — The date after which a software version gets no more fixes, not even for security problems. (Module 0)
.env file — A file of settings, one NAME=value per line, loaded into the environment. Never commit real secrets in it. (Module 2)
Entry point — A command a package installs, like bazaar = "bazaar.main:run": typing bazaar calls that function. (Module 5)
Environment variable — A named setting that every program on your computer can read, like PATH. (Module 0)
Event loop — asyncio's scheduler: it runs one coroutine until it awaits, then switches to another that's ready. (Module 5)
Exception — An error object Python raises while a program runs, like ValueError. Unless handled, it stops the program. (Module 4)
Exit code — A number a program returns when it ends. 0 means success; anything else means failure. (Module 0)
export — Shell command that puts a variable into the environment, so programs started from the shell receive it. (Module 2)
Expression — Any piece of code that gives a value, like 29900 // 100 or p["name"]. (Module 4)
Extension — An add-on that teaches an editor something new, like the Python extension for VS Code. (Module 0)
F-string — Text with an f in front, where { } is replaced by a value: f"₹{price}". (Module 4)
Fast-forward — A merge where your branch was simply behind, so Git just moves its label forward. No new commit. (Module 3)
Fetch — git fetch: download new commits and branches from a remote, without changing your files or your branches. (Module 3)
Field — One piece of data in a dataclass, written as name: str or stock: int = 0. (Module 5)
File descriptor — A small number (0, 1, 2, 3, ...) a process uses to refer to a file it has open. (Module 1)
File mode — How a file is opened: "r" read, "w" write (empties the file first), "a" append (adds at the end). (Module 4)
File system — The part of the OS that organises a disk's blocks into files and folders, with names and records. (Module 1)
FileNotFoundError — The exception raised when you open a file (for reading) that doesn't exist. (Module 4)
Finally — The block after try/except that runs every time, error or not. Used to close files and connections. (Module 4)
Fingerprint — A short ID of a key, like SHA256:pVFtw..., used to check you're talking to the right server. (Module 2)
Float — A number with a decimal point, like 4.5. Stored in binary, so it can be slightly off: never use it for money. (Module 4)
Fork — Starting a new process as a copy of the current one, memory and all. Python does this on Linux. (Module 1)
Fork (GitHub) — Your own copy of someone else's repository on GitHub, used to propose changes to projects you can't push to. (Module 3)
Frame — The space for one function call: its arguments, local names, and where to return. (Module 1)
Framework — A ready-made toolbox that does the common work, so you write only your app's own code. Django is one. (Module 0)
Frontend — The part of an app you see and touch, like buttons and the search box. (Module 0)
Frozen dataclass — @dataclass(frozen=True): its objects can't be changed after they're made. (Module 5)
fsync — A request to the operating system: "put this data on the disk now, and wait until it is there". (Module 1)
Function — A piece of code with a name, defined once with def and run (called) whenever needed: delivery_charge(64900). (Module 4)
Functools.wraps — @functools.wraps(func) on a wrapper copies the original's name and docstring, so logs and tracebacks show the real name. (Module 5)
Garbage collection — Automatic freeing of objects that the program can no longer reach. (Module 1)
Generator — Something that makes values one at a time, when asked, instead of storing them all. A function with yield creates one. (Module 5)
Generator expression — A comprehension without brackets, inside sum(), any() or all(): values are made one at a time, never stored as a whole list. (Module 4)
GHz — Gigahertz: one billion ticks per second. A measure of CPU clock speed. (Module 1)
GID — Group ID: the number that names a group. (Module 2)
GIL — Global Interpreter Lock: CPython's rule that only one thread at a time runs Python code in a process. (Module 1)
Git — A tool that saves every version of your code as commits, so you can see changes and go back. (Module 0)
GitHub — A website that stores Git projects online, so you can share them and work as a team. (Module 0)
Gitignore file — A file named .gitignore that lists files Git must never save, like .env with passwords. (Module 3)
Glob — A file-name pattern like *.log or order_?.log that the shell expands into matching names. (Module 2)
Golden rule of rebase — Only rebase commits that nobody else has. Rebasing shared commits creates duplicates for your teammates. (Module 3)
Group — A named set of users, so permissions can be given to all of them at once. (Module 2)
Hard link — A second name for the same inode. The data lasts until the last name is removed. (Module 1)
HDD — Hard Disk Drive: a disk with spinning plates and a moving arm. Cheap, but slow for random reads. (Module 1)
HEAD — Git's name for "where you are now": usually the current branch, and so its newest commit. HEAD~1 is the commit before it. (Module 3)
Header — An extra line of information sent with a request or response, like Content-Type. (Module 0)
Headless — Running without a screen or keyboard, managed over the network. (Module 1)
Heap — The memory area for objects that can live longer than one function call. All Python objects live here. (Module 1)
Home folder — A user's own folder: /root for root, /home/<name> for others. Written ~. (Module 2)
HTTP — The set of rules computers use to send requests and responses on the web. (Module 0)
I/O-bound — Work that spends most of its time waiting for input/output: the disk, the network, a database. (Module 1)
IDE — Integrated Development Environment: a code editor with many built-in tools, like PyCharm. (Module 0)
Image — A ready-made package with a program and everything it needs. Containers are started from images. (Module 0)
Import — Load a module so you can use its code: import json, or from money import rupees. The module runs once. (Module 4)
Indentation — The spaces at the start of a line. In Python, 4 extra spaces mark the lines that belong to an if or a loop. (Module 4)
Index — A value's position in a list, counted from 0: cart[0] is the first, cart[-1] the last. (Module 4)
Inheritance — Building a class on top of another: class GiftCard(Product):. The child gets all the parent's methods. (Module 5)
Inode — A file's record: size, owner, permissions, times and where its data blocks are. Not its name. (Module 1)
Instance — Another word for an object made from a class: masala is an instance of Product. (Module 5)
Instruction — One tiny step the CPU understands, like "add these two numbers". (Module 1)
Int — A whole number, like 29900. Exact; Bazaar stores money as int paise. (Module 4)
Interactive rebase — git rebase -i: edit a list of your commits to reword, squash, reorder or drop them before sharing. (Module 3)
Interpreter — The program that reads your code and runs it line by line. python3 is the Python interpreter. (Module 0)
Isolation — Keeping parts apart so a problem in one can't spread to the others. Processes are isolated from each other. (Module 1)
Journal — A file system's log of changes it is about to make, so it can stay consistent after a crash. (Module 1)
Journal (systemd) — systemd's log of everything services print, with the time. Read it with journalctl. (Module 2)
journalctl — The command that reads the systemd journal, like journalctl -u bazaar-web -n 20. (Module 2)
JSON — A simple text format for data, like {"name": "Masala Box", "price": 299}. (Module 0)
JSONDecodeError — The exception json.load raises when the text isn't valid JSON, like single quotes or a half-written file. (Module 4)
Kernel — The core of the operating system: the only program allowed to touch the hardware directly. (Module 1)
Key — The name a dict uses to find a value, like "price_paise" in product["price_paise"]. (Module 4)
KeyError — The exception for a dict key that doesn't exist. (Module 4)
Keyword argument — An argument passed by name: line_total(99900, quantity=2). (Module 4)
known_hosts — The file on your laptop (~/.ssh/known_hosts) remembering the servers you've trusted. (Module 2)
Latency — How long one request takes, from start to finish. (Module 0)
Layer — One slice of a Docker image that adds or changes some files. Images are stacks of layers. (Module 0)
Least privilege — Give every user and program only the access it needs, nothing more. (Module 2)
List — Many values in order, in [ ]: cart = ["Masala Box", "Cotton Kurta"]. Can change. (Module 4)
Load average — The average number of threads running or waiting for a CPU, over 1, 5 and 15 minutes. Compare it with the core count. (Module 1)
Local name — A name made inside a function. It exists only inside, while the function runs. (Module 4)
localhost — A name that always means "this same computer". Its address is 127.0.0.1. (Module 0)
Locality — Programs tend to reuse the same data soon (temporal) and use nearby data next (spatial). Caches rely on it. (Module 1)
Lock — A token only one thread can hold at a time, used so threads don't mix up their steps. (Module 1)
Lock file — A generated file (like uv.lock) recording the exact version and hash of every package, so installs are repeatable. (Module 5)
Logs — The lines a program writes about what it is doing. The backend's diary. (Module 0)
Loop — Code that repeats. for runs once per item in a collection; while runs as long as a condition is True. (Module 4)
Main branch — The first, default branch (main). In most teams it holds the code that really runs. (Module 3)
Memory hierarchy — The levels of storage from small-fast-expensive (registers, cache) to big-slow-cheap (disk, network). (Module 1)
Memory leak — Memory a program keeps but will never use again, so its RAM keeps growing. (Module 1)
Merge — Bringing another branch's commits into the branch you are on: git merge diwali-sale. (Module 3)
Merge base — The newest commit two branches share: the point where they split. Git compares both sides against it. (Module 3)
Merge commit — A commit with two parents that joins two branches together. (Module 3)
Merge conflict — When both branches changed the same lines differently, so Git stops and asks you to choose the final version. (Module 3)
Method — A function defined inside a class, called on an object: masala.sell(2). (Module 5)
Microsecond (µs) — One millionth of a second. 1,000 µs = 1 ms. (Module 1)
Millisecond (ms) — One thousandth of a second. (Module 1)
Mode — A file's permission bits, like rw-r----- or 640: read, write and execute for owner, group and others. (Module 2)
Module — A .py file whose functions and names other files can use with import. (Module 4)
Mutable — Can be changed after it is created, like a list or dict. Ints, strings and tuples are immutable. (Module 1)
Mypy — A tool that reads type hints and reports type mistakes before the program runs. (Module 5)
nano — A simple terminal text editor. Ctrl+O saves, Ctrl+X exits. (Module 2)
Nanosecond (ns) — One billionth of a second. 1,000 ns = 1 µs. (Module 1)
None — Python's value for "nothing yet", like a discount code that isn't set. (Module 4)
Object — One thing made from a class, with its own data: masala = Product("Masala Box", 29900, "Patel Spices", 40). Also called an instance. (Module 5)
Object-oriented programming — Building a program from objects that hold data and offer actions. OOP for short. (Module 5)
Off-by-one error — A mistake at a border value, like using > where >= was meant, so exactly ₹999 is treated wrong. (Module 4)
OOM killer — The Linux kernel's out-of-memory killer: it ends a process with SIGKILL when memory runs out. (Module 1)
Operating system — The main program of a computer (Linux, macOS, Windows) that runs other programs and shares the CPU and RAM between them. (Module 1)
Option — A word that changes how a command works, like -l or --all. (Module 2)
Origin — The default name Git gives the remote you cloned from, usually the repository on GitHub. (Module 3)
Orphan — A process whose parent died first. PID 1 adopts it. (Module 1)
Override — Writing a method in a child class with the same name as the parent's, so the child's version is used instead. (Module 5)
Package — A ready-to-install piece of software from an online catalogue. (Module 2)
Package (Python) — A folder of Python modules (with an __init__.py), imported like from bazaar import money. Django apps are packages. (Module 4)
Package manager — A tool that installs, updates and removes packages, like apt (or pip for Python libraries). (Module 2)
Page — A small fixed-size piece of memory (often 4 KB) that the kernel maps between virtual addresses and RAM. (Module 1)
Page cache — Spare RAM where the operating system keeps recently used files, so reading them again is fast. (Module 1)
Paise — One hundredth of a rupee (₹1 = 100 paise). Bazaar keeps every amount as a whole number of paise. (Module 4)
Parameter — The name a function uses for an input, like paise in def rupees(paise):. (Module 4)
Parent class — The class another class is built on (Product for GiftCard). Also called the base class or superclass. (Module 5)
Parent commit — The commit that came just before a commit. Each commit points to its parent, so commits form a history. (Module 3)
PATH — The list of folders the shell searches, in order, when you type a command. (Module 0)
Path — The address of a file, like /data/orders/order_1042.json. (Module 1)
Pickling — Turning a Python object into bytes (Python's own format) so it can be saved or sent to another process. (Module 5)
PID — Process ID: the number the operating system gives every running process. (Module 1)
pip — Python's package installer: it downloads libraries other people wrote, like Django. (Module 0)
Pip — Python's standard tool for installing packages: pip install -r requirements.txt. (Module 5)
Pipe — The | symbol: it sends one command's output straight into the next command. (Module 2)
Pipeline — Several commands joined with |, each doing one small job. (Module 2)
Polymorphism — The same call doing the right thing for each kind of object: item.describe() for a product or a gift card. (Module 5)
Port — A door number on a computer. Each server program listens at its own port, like 8000. (Module 0)
PPID — Parent process ID: the PID of the process that started this one. (Module 1)
Private key — The secret half of a key pair. It stays on your laptop and is never sent anywhere. (Module 2)
Process — A program that is running right now, with its own PID and its own memory. (Module 1)
Process pool — A ready set of worker processes for CPU-heavy tasks: ProcessPoolExecutor(). (Module 5)
Prompt — The text the shell shows when it is ready for a command, like root@bazaar-server:/srv/bazaar#. (Module 2)
Property — A method used like an attribute (masala.price_rupees), made with @property. Without a setter, it's read-only. (Module 5)
Protocol — A set of rules two sides agree on to talk to each other, like HTTP. (Module 0)
Public key — The shareable half of a key pair, copied to servers you want to log in to. (Module 2)
Pull — git pull: fetch from the remote, then merge (or rebase) the new commits into your branch. (Module 3)
Pull request — A request on GitHub to merge one branch into another, with the diff, comments and reviews. GitLab calls it a merge request. (Module 3)
Push — git push: upload your branch's new commits to a remote, like GitHub. (Module 3)
PyPI — The Python Package Index (pypi.org): the public library of Python packages that pip and uv install from. (Module 5)
Pyproject.toml — The file that describes your Python package: name, version, dependencies and commands. (Module 5)
Query string — The part of a URL after ?, with extra details, like ?q=shoes. (Module 0)
Queue — A waiting line where the first one in is the first one served. (Module 0)
Race condition — A bug where the result depends on the exact timing of threads, like selling the last item twice. (Module 1)
RAID — Combining several disks so that data survives when one of them fails. (Module 1)
Raise — Start an exception on purpose: raise ValueError("only 8 left"). Stops the function, like return, but with an error. (Module 4)
RAM — Random Access Memory: the fast working memory of a computer. It forgets everything when the power goes off. (Module 1)
Rebase — git rebase main: copy your branch's commits on top of the newest main, so history stays one straight line. The copies get new hashes. (Module 3)
Recursion — A function that calls itself. Each call adds a frame to the stack. (Module 1)
Redirection — Sending a command's output to a file (>, >>) or its errors somewhere else (2>). (Module 2)
Reference counting — Counting how many names and objects point to an object, and freeing it when the count reaches zero. (Module 1)
Reflog — Git's local diary of everywhere HEAD has been. git reflog finds commits that no branch points to any more. (Module 3)
Register — A tiny storage spot inside the CPU for the values it is working on right now. The fastest memory. (Module 1)
Registry — An online library of Docker images, like Docker Hub. (Module 0)
Relative path — A path that starts from the current working directory, like orders/order_1042.json. (Module 1)
Remote — Another copy of your repository somewhere else, usually on GitHub. git remote -v lists them. (Module 3)
Remote-tracking branch — Your laptop's memory of a branch on the remote, like origin/main. Only fetch and pull update it. (Module 3)
REPL — Python's interactive prompt (>>>), started with python3: type one line, get the answer at once. (Module 4)
Repository — A folder whose history Git tracks, with all its commits in a hidden .git folder. (Module 0)
Request — A message from a frontend asking the backend to do something. (Module 0)
Requirements file — requirements.txt: the list of packages to install, each with an exact version (requests==2.34.2). (Module 5)
Response — The backend's answer to a request. (Module 0)
Return value — What a function call gives back with return. A function without return gives back None. (Module 4)
Root — The administrator user (UID 0). The kernel doesn't check read/write permissions for root. (Module 2)
RSS — Resident Set Size: how much RAM a process is really using right now. Shown by ps and top. (Module 1)
Scaling — Making a system handle more users or more data. (Module 0)
Scheduler — The part of the kernel that decides which thread runs on which CPU core, and for how long. (Module 1)
scp — Copies files between your computer and a server over SSH: scp file user@server:/path/. (Module 2)
Self — A method's first parameter: the object the method was called on (the one before the dot). (Module 5)
Serialize — Turn data into text or bytes so it can be saved or sent, like json.dumps(cart). Deserialize is the reverse. (Module 4)
Server — A computer whose job is to answer requests from other computers. (Module 0)
Service (systemd) — A program that systemd runs in the background all the time, like bazaar-web. (Module 2)
Service user — A user that runs one program (like www-data for the web server), usually with no login. (Module 2)
Set — A collection that keeps each value only once, with fast in checks: {"Patel Spices", "Meera Handloom"}. (Module 4)
Setuid — A permission bit that makes a program run as its owner (often root), like sudo and passwd. (Module 2)
Shebang — The first line of a script, like #!/usr/bin/env bash, saying which program should run it. (Module 2)
Shell — The program inside a terminal that reads your commands and runs them, like zsh, bash or PowerShell. (Module 0)
Shell script — A text file of shell commands that runs as one program. (Module 2)
Signal — A short message the kernel delivers to a process, like SIGTERM ("please stop") or SIGKILL ("stop now"). (Module 1)
Socket — A kernel object, used through a file descriptor, for sending and receiving data over the network. (Module 1)
Spawn — Starting a new process fresh, so it reads the program file again. Python does this on macOS and Windows. (Module 1)
Special method — A method with double underscores on both sides (__str__, __eq__, __len__) that Python calls for print, ==, len() and so on. Also called a dunder method. (Module 5)
SSD — Solid State Drive: the usual kind of disk today. Big and lasting, but much slower than RAM. (Module 1)
SSH — Secure Shell: an encrypted way to open a terminal on another computer. Uses port 22. (Module 2)
Stack overflow — Running out of stack space because calls go too deep. Python stops earlier with RecursionError. (Module 1)
Staging area — Git's list of changes chosen for the next commit. git add puts changes there. (Module 0)
Standard library — The modules that come with Python, ready to import: json, datetime, random, pathlib, sys and many more. (Module 4)
Stash — git stash: put uncommitted changes aside for a moment, for example to switch branches. git stash pop brings them back. (Module 3)
Status code — A number in a response that says how it went. 200 = success, 404 = not found. (Module 0)
stderr — Standard error: where a command prints its error messages (stream 2). (Module 2)
stdin — Standard input: where a command reads its input from (stream 0), like the keyboard or a pipe. (Module 2)
stdout — Standard output: where a command prints its normal results (stream 1). (Module 2)
Sticky bit — On a folder like /tmp: users may only delete or rename their own files. Shown as t. (Module 2)
StopIteration — The exception a generator raises when it has no more values. A for loop catches it for you. (Module 5)
String (str) — Text, written in quotes: "Masala Box". (Module 4)
sudo — Runs one command as root, if your user is allowed in /etc/sudoers, and records who ran it. (Module 2)
Super() — "My parent class": super().__init__(...) runs the parent's setup from inside the child. (Module 5)
Supervisor — A process (or thread) that starts other processes and restarts them if they die. (Module 1)
Swap — Disk space the OS uses as emergency RAM when real RAM is full. Much slower. (Module 1)
Symbolic link — A shortcut file that points to another file, like python3 -> python3.13. (Module 0)
System call — A request from a program to the kernel, like "open this file" or "start a process". (Module 1)
systemctl — The command that gives systemd orders: start, stop, restart, status, enable. (Module 2)
systemd — The first program Linux starts (PID 1). It starts, watches and restarts all other programs. (Module 2)
Tag — The version label of an image, after the colon: python:3.13.18-slim-trixie. (Module 0)
Terminal — A window where you type commands for your computer. (Module 0)
Thread — A worker inside a process. All threads of one process share the same memory. (Module 0)
Thread pool — A ready set of threads that runs tasks for you: ThreadPoolExecutor(max_workers=10). (Module 5)
Throughput — How many requests a system finishes per second. (Module 0)
Traceback — Python's report of where an error happened. Read it from the bottom: the last line says what went wrong. (Module 0)
Truthy and falsy — Values that count as True or False in a condition. 0, "", None and empty collections are falsy; the rest are truthy. (Module 4)
Try and except — try: runs code that may fail; except ValueError: runs instead if that error happens, so the program keeps going. (Module 4)
Tuple — A small fixed group of values in ( ), like ("Masala Box", 29900, 2). Can't be changed. (Module 4)
Type — The kind of a value, which decides what you can do with it: str, int, float, bool, None, and more. (Module 4)
Type hint — A note saying what type a value should be: price_paise: int, -> int. Python ignores it while running; tools like mypy check it. (Module 5)
UID — User ID: the number that names a user. root is 0. (Module 2)
umask — The bits removed from new files' and folders' permissions. With 022, files get 644 and folders 755. (Module 2)
Unit file — A text file that tells systemd how to run something, like bazaar-web.service. (Module 2)
Unpacking — Giving each value of a tuple or list its own name at once: name, price, quantity = line. (Module 4)
Untracked file — A file Git can see in your folder but isn't saving yet. git status lists it; git add starts tracking it. (Module 3)
Uptime — The share of time a system works, like 99.9%. (Module 1)
Uv — A fast tool that does the jobs of venv and pip (and more): uv venv, uv pip install. (Module 5)
ValueError — The exception for a value of the right type that makes no sense, like int("three"). (Module 4)
Variable — A name stuck on a value, like price_paise = 29900. Using the name later means that value. (Module 4)
Version control system — A tool that records every version of your files, with who changed what, when and why. Git is one. (Module 0)
vi — A terminal text editor found on almost every server. i to type, Esc, then :wq to save or :q! to quit without saving. (Module 2)
Virtual address — The private address a process uses for its memory; the kernel maps it to real RAM. (Module 1)
Virtual environment — A private folder of Python packages for one project, so projects don't break each other. (Module 0)
Virtual machine — Software that pretends to be a whole computer, with its own operating system and kernel. (Module 0)
Volatile — Memory that forgets everything when the power goes off, like RAM. (Module 1)
Volume — A Docker storage area that keeps data even after a container is removed. (Module 1)
VPS — Virtual Private Server: a rented virtual machine, a slice of a bigger physical machine. (Module 1)
With statement — with open(...) as f: opens something and closes it automatically when the block ends, even after an error. (Module 4)
Worker — The part of a server that handles a request. One worker handles one request at a time. (Module 0)
Wrapper — The new function a decorator returns. It calls the original and adds something around it. (Module 5)
WSL 2 — Windows Subsystem for Linux: a real Linux that runs inside Windows. Docker Desktop uses it. (Module 0)
Yield — Inside a function: hand out one value, pause, and carry on from here when the next value is asked for. (Module 5)
Zombie — A process that has finished, but whose parent has not yet collected its exit code. (Module 1)