Computing posters
LearnPosters has 100 free printable computing posters, grouped into 8 topics: Foundations, Tools, The web, Languages, Data. The reference every programmer re-Googles once a week. They are made for secondary students and self-taught beginners. Every one downloads as a vector PDF that prints sharp on US Letter, A4 or a copy-shop A1. No account and no watermark.
Regex syntax, git commands, HTTP status codes, complexity classes. Not tutorials — the lookup tables. Pinned above a desk, these stop being a search and start being a glance.
100 free printable posters · 8 topics · vector PDF
Foundations
Number systems, data structures, complexity — what is under everything else.
Big-O Complexity
How an algorithm's cost grows, from constant to catastrophic.
Data Structure Costs
What each structure is fast at, and what it is slow at — how to choose.
Binary, Hex & Decimal
The three bases side by side, with the trick for converting in your head.
Bits, Bytes & Sizes
What the units actually mean, and why a 1 TB drive shows up as 931 GB.
Floating Point
Why 0.1 + 0.2 is not 0.3, and what to do about it.
Unicode & Encoding
Characters, code points and bytes — and where mojibake comes from.
Sorting Algorithms
The classic sorts, their costs, and which one your language actually uses.
Recursion
The two parts every recursive function needs, and when to avoid it.
Graph Traversal
Depth-first and breadth-first — the two ways to walk anything connected.
Hash Tables
How O(1) lookup actually works, and when it stops being O(1).
Bitwise Operations
The six operators, what each does, and the tricks worth knowing.
Boolean Logic
The logic gates, their truth tables, and De Morgan's laws.
Time & Time Zones
The rules that prevent the entire category of date bugs.
Compiled & Interpreted
What happens between your source code and a running program.
Tools
Git, the terminal, regular expressions: the daily drivers.
Git: Everyday Commands
The dozen commands that cover almost every normal day.
Git: Undoing Things
The command for each kind of mistake — and which ones destroy work.
Regular Expressions
Every metacharacter worth knowing, with what it matches.
The Terminal
Navigation, files and processes — the commands underneath every tool.
Editor Shortcuts
The two dozen keystrokes that stop you reaching for the mouse.
Merge vs Rebase
Two ways to integrate a branch, and which one to use where.
Stash & Worktree
Two ways to put work aside and come back to it.
Git Bisect
Finding the commit that broke something, by binary search.
Useful Git Config
The settings worth putting in your global config on a new machine.
SSH Keys
Generating, adding and using a key pair instead of a password.
Docker Basics
The commands and the three concepts underneath them.
Writing a Dockerfile
The instruction order that keeps builds fast and images small.
Makefiles
A task runner that works everywhere, and the two rules that trip you up.
Debugging Method
A procedure for finding a bug, rather than guessing at it.
Code Review
What to look for, and what to leave to the linter.
Commit Messages
What belongs in a commit message, and the convention worth adopting.
The web
HTTP, CSS layout, and how a request actually travels.
HTTP Status Codes
The codes you actually meet, grouped by who is at fault.
HTTP Methods
What each verb promises, and which ones are safe to retry.
CSS Flexbox
One axis, two alignment properties, and the handful of values that do everything.
CSS Grid
Two dimensions at once: the properties for rows, columns and placement.
Loading a Web Page
Every step between typing a URL and seeing pixels.
Semantic HTML
The elements that carry meaning, and why a div is not one of them.
Accessibility
The checks that catch most barriers, in the order worth doing them.
ARIA
When to use ARIA, and the rule that makes it mostly unnecessary.
CORS
Why the browser blocks a request, and what actually fixes it.
Cookies & Storage
Four places a browser can keep data, and which to use.
Web Performance
The metrics that are measured, and what actually moves each one.
Responsive Design
Breakpoints, units and the approach that needs fewest of them.
How a Browser Renders
The pipeline from HTML to pixels, and which changes are cheap.
HTTP Headers
The request and response headers worth knowing by name.
Languages
Python, JavaScript, SQL and the syntax you look up mid-file.
Python Syntax
The core syntax on one sheet — collections, control flow and functions.
Python Data Structures
Which built-in to reach for, with the cost of the operations you will do.
JavaScript Syntax
Modern JavaScript essentials — declarations, functions, destructuring, modules.
JS Array Methods
Which method to reach for, and which ones change the original array.
JavaScript Equality
Why == and === differ, and the coercion table that explains the surprises.
TypeScript Types
The type vocabulary, from primitives to the utility types worth knowing.
SQL Basics
The clauses of a SELECT, in written order and in the order they run.
SQL Joins
The four joins, what each keeps, and the one that silently multiplies rows.
SQL Aggregates
GROUP BY, the aggregate functions, and where each filter belongs.
Regex Lookarounds
Zero-width assertions — matching by what surrounds a thing, without consuming it.
Bash Scripting
Variables, tests and loops, plus the two lines to start every script.
JSON & YAML
What each format allows, and the YAML gotchas that bite.
Branching Models
Three common workflows, and what each one is optimising for.
Semantic Versioning
What each number means, and what the range operators actually allow.
REST API Design
Conventions that make an API predictable, and the ones worth arguing about.
Error Handling
Patterns across languages, and the rule that applies in all of them.
Data
Databases, formats, statistics and the shapes data arrives in.
Normalisation
The first three normal forms, in the order you apply them.
Indexes
What an index does, when it helps, and what it costs.
ACID
The four guarantees a transactional database makes.
Isolation Levels
Four levels, and which anomalies each one still permits.
SQL vs NoSQL
What each is actually optimised for, past the marketing.
The CAP Theorem
The trade-off every distributed system makes, stated precisely.
Data Formats
Which serialisation format to use, and what each trades away.
Descriptive Statistics
Mean, median, mode and spread — and when each one misleads.
Correlation & Causation
What a correlation coefficient tells you, and the four things it might mean.
Sampling & Bias
Where a dataset goes wrong before any analysis begins.
Data Cleaning
The checks worth running on any dataset before analysing it.
Choosing a Chart
Which chart answers which question — and the two to avoid.
Security
Auth, crypto, and the failures that keep happening.
Storing Passwords
How passwords must be stored, and what each term in the recipe is for.
AuthN vs AuthZ
Two words one letter apart that solve completely different problems.
Common Web Risks
The vulnerability classes that account for most real breaches.
SQL Injection
How it works, and the one fix that actually stops it.
XSS & CSRF
Two browser attacks constantly confused, and the defence for each.
HTTPS & TLS
What the padlock actually guarantees, and what it does not.
Hashing vs Encryption
One is reversible and one is not — and choosing wrong is a breach.
Secrets
Where credentials must not go, and what to do when one leaks.
MFA & Passkeys
The factors ranked by how well they resist phishing.
Threat Modelling
Four questions that surface most design-level security problems.
Systems
Processes, memory, networking and how a machine actually runs.
Processes & Threads
What each one owns, and why the difference decides how you parallelise.
Concurrency & Parallelism
Two words used interchangeably that mean different things.
Memory Hierarchy
How far away each kind of storage is, in time the CPU can feel.
Stack & Heap
Where a variable actually lives, and what that costs.
Garbage Collection
How automatic memory management works, and what it costs you.
The Network Stack
The layers a packet passes through, and what each adds.
DNS
How a name becomes an address, and what each record type does.
Caching
Where to cache, how to invalidate, and the failure modes of each.
Load Balancing
How traffic is spread across servers, and what each algorithm assumes.
HTTP Caching
The headers that control browser and CDN caching, and what each does.
AI & ML
Models, prompts, embeddings and the vocabulary around them.
LLM Vocabulary
The words that appear in every model announcement, defined plainly.
Structuring a Prompt
The parts of a prompt that reliably improve an answer.
Temperature & Sampling
The parameters that control randomness, and what to set them to.
Embeddings
Turning text into vectors so that meaning becomes distance.
Retrieval-Augmented Generation
The pipeline that lets a model answer from your documents.
Kinds of Model
Supervised, unsupervised, reinforcement, generative: the differences.
Evaluating AI Output
How to check an answer, and the failure modes to check for specifically.
Tokens & Cost
How usage is billed, and where the money actually goes.
Questions about the Computing posters
- What is the Computing section of LearnPosters?
- The reference every programmer re-Googles once a week. Regex syntax, git commands, HTTP status codes, complexity classes. Not tutorials — the lookup tables. Pinned above a desk, these stop being a search and start being a glance.
- What topics do the Computing posters cover?
- 100 posters across 8 topics. Foundations — Number systems, data structures, complexity — what is under everything else. Tools — Git, the terminal, regular expressions: the daily drivers. The web — HTTP, CSS layout, and how a request actually travels. Languages — Python, JavaScript, SQL and the syntax you look up mid-file. Data — Databases, formats, statistics and the shapes data arrives in. Security — Auth, crypto, and the failures that keep happening. Systems — Processes, memory, networking and how a machine actually runs. AI & ML — Models, prompts, embeddings and the vocabulary around them.
- Who are the Computing posters for?
- The computing charts are pitched at secondary students and self-taught beginners. Nothing here is tied to a school year, so a curious beginner and someone revising the same material for an exam are looking at the same computing chart.
- Which Computing poster should I print first?
- Big-O Complexity, Data Structure Costs and Binary, Hex & Decimal are the ones people reach for first — they are the references the rest of the computing set assumes you already have on the wall.Big-O ComplexityData Structure CostsBinary, Hex & Decimal
- Are the Computing posters free to print?
- Yes — all 100 of them. Each computing poster is a free vector PDF that needs no account, prints on US Letter or A4, and enlarges to A1 without softening. Home, classroom, library and tutoring use are all covered by the licence.Read the licence
Where the computing charts come from
These posters summarise. When you need the full account — or the normative text a chart is compressing — start here.
- MDN Web Docs — Mozilla. The reference the web-platform charts are checked against.
- RFC 9110 — HTTP Semantics — IETF. The normative definition of every status code on the HTTP chart.