
What is sudo, in plain words: how it works, whose password it asks for, why sudo npm and sudo pip break your project, and when you really need it.

What a tar.gz (tarball) is, in plain words: tar vs gzip, how to extract it with tar -xf, and how to peek inside first so files don't spill everywhere.

What command-line flags (-r, --force) are: reading glued -rf, what the double dash -- does, why -v means different things, and when order matters.

scp vs rsync: how these commands for copying files to a server differ, which to pick for one file vs a folder deploy, and the rsync trailing-slash trap.

What stdin (standard input) is, in plain words: where a program reads data from, why CI and AI agents hang on a question, and how to fix it.

What a shebang (#!) at the top of a script is, in plain words: who reads that line, why /usr/bin/env exists, and where the mysterious python3\r comes from.

What a PID (process ID) is, in plain words: how to find it, what kill does with it, why PID 1 is special, and why a number saved to a file is risky.

.bashrc or .bash_profile: the difference, which file the terminal, SSH and Mac read, where PATH and aliases go, and why a new .bash_profile breaks .profile.

What umask is in Linux, in plain words: why a new file gets 644 instead of 666, why a script is born unable to run, and how to lock down secrets from the start.

What a mount point is in Linux, in plain words: why there's no D: drive, where files in a folder disappear to, and why Docker loses your node_modules.

What a daemon is in Linux, in plain words: why a program dies along with SSH, where the d in sshd comes from, and how to turn a bot into a systemd service.

Single vs double quotes in bash and zsh: how they differ, why echo eats $5 and exclamation marks, and which quotes to use for JSON, git and curl.

What is xargs in plain words: why you need it, why echo file | rm does nothing, how to avoid tripping on spaces and quotes, and what xargs -0 does.

What is swap memory in plain words: where memory goes, why a build on a cheap server fails with Killed, and how to add swap in five commands.

What is a dotfile in plain words: why files like .env and .gitignore start with a dot, how to see them, and why cp with an asterisk loses them.

curl vs wget, which to pick: the difference in plain words. Why curl prints a file to the terminal, gets lost on redirects, and when wget is easier.

What a TTY in the terminal is, in plain words: why colors vanish in a pipe, Python stays silent until the end, and why you get a not-a-TTY error.

What a subshell in bash is, in plain words: why a variable set in a while loop after a pipe vanishes, what ( ) is for, and how to keep cd and counters.

What a heredoc in bash is, in plain words: how cat <<EOF works, why the $ inside disappear, why to quote 'EOF', and how AI agents use it for commits.

find vs grep, the difference in plain words: one finds files by name, the other finds text inside. When to use which, and how to combine them.

What a zombie process is, in plain words: where defunct in ps comes from, why kill -9 is powerless, and how zombies pile up in Docker with headless Chrome.

What a pipe (|) is in the terminal, in plain words: why commands run at the same time, where Broken pipe comes from, and how to feed logs straight to AI.

What a hard link is, in plain words: how rm removes a name rather than a file, what an inode is, and why an edit in node_modules can hit every project.

How source differs from running ./script.sh: why cd and export don't stick, why activate breaks, and why exit in a sourced file closes your terminal.

What the PATH variable is in plain words: why you get command not found after installing, how to view PATH, add a folder and not break your terminal.

What a file descriptor is in plain words: where Too many open files and EMFILE come from, why network connections count too, and how to find a leak.

What a checksum is in plain words: how SHA-256 works, how to verify a downloaded file on any system, and what this check will not protect you from.

How && differs from ; in bash: what happens when the first command fails, which exit code the chain returns, what to do in PowerShell and when to use each.

What a symbolic link is in plain words: how ln -s works, how it differs from a hard link, and why rm -r with a slash deletes the real folder's contents.

A glob pattern in plain words: what * and ** mean, why a command without quotes loses files, and why *.js means different things in .gitignore and ESLint.

A dynamic array in plain words: what capacity is, why push is almost always instant but sometimes copies the entire array, and when you'll actually notice.

localhost vs 0.0.0.0 explained: how to open a site from your phone, why Next and Docker listen on the whole network by default, and which address to pick.

What are stdout and stderr in plain words: every program's two outputs, how > and 2>&1 work, why order matters, and why Python logs in Docker show up late.

What is a program exit code in plain words: what 0, 1, 127, 130 and 137 mean, how to check it with echo $? and why a single pipe | can break your CI.

What is a Web Worker in plain words: a second thread for heavy JavaScript, how it talks to the page, why data gets copied, and when you don't need one.

dependencies vs devDependencies in package.json: the difference in plain words, why a Vite site barely cares, and why your deploy fails with vite: not found.

What Big O notation means in plain words: how to tell how much slower code gets as data grows, and why includes inside a loop is a quiet time bomb.

What a source map is in plain words: how it turns an error in minified code into the right line of your file, and why you shouldn't publish it openly.

What a polyfill is in plain words: how it adds missing functions to a browser, how it differs from transpiling, and when you actually still need one.

TCP vs UDP explained simply: the real difference, why video calls and games pick UDP, what HTTP/3 runs on, and which of it you can use from a browser.

LRU cache explained simply: how it decides what to evict, why a plain-object cache eats your memory, and how to build an LRU on a JavaScript Map in 15 lines.

Sliding window explained simply: how to find your best sales week without a nested loop, fixed vs flexible windows, and what it has to do with rate limits.

Bloom filter explained simply: how it answers 'definitely not' or 'maybe yes', why 10 bits per item is enough for 1% errors, and where databases use it.

encodeURI vs encodeURIComponent: which one to use for URL parameters, why & and + break your search, what %2520 means, and why URLSearchParams beats both.

What a ring buffer is, in plain words: how to keep the last N events in fixed-size memory, and why your computer already stores its logs this way.

What a heartbeat is, in plain words: why WebSocket and Supabase Realtime send a message every 25 seconds, and how to tell that a connection has died.

What a dead letter queue (DLQ) is, in plain words: where to send messages that fail every time, and how to set up a DLQ in Supabase Queues and Amazon SQS.

border vs outline in CSS: the difference, why a border on hover shifts your layout by 2 pixels while outline doesn't, and which to use for focus and cards.

What a trie is in plain words: how a prefix tree finds words by their first letters, why autocomplete stays fast on 100,000 words, and when filter is enough.

What a priority queue and a heap are, in plain words: grab the most urgent item in log n steps, find the top 10 of a million lines, and stop sorting everything.

What a JavaScript Proxy is in plain words: how a middleman object intercepts reads and writes, what powers Vue reactivity, and three traps where it breaks.

text vs varchar in PostgreSQL and Supabase: the real difference, why varchar(255) is a MySQL habit, how to limit length and what a beginner should pick.
The Shadow DOM in plain words: why page styles don't apply inside a widget while fonts and colors leak in, and why querySelector can't find a button you can see.
Optimistic locking in plain words: how two editors silently overwrite each other, and how a version column in your database catches the conflict before it lands.
A state machine in plain words: why three flags — isLoading, isError and data — give you eight states instead of four, and how a single status fixes it.
useState vs useRef in React: which one triggers a re-render, when you see the new value, and where to keep a timer id. A simple rule for which to pick.
What backpressure is, in plain words: the receiver's “slow down” signal to a data source. Why your script eats memory without it, and how to fix it in Node.
What a percentile is, in plain words: p50, p95 and p99 in speed metrics. Why average response time fools you, and how to calculate a percentile yourself.
What a cache stampede is: a hot key expires and hundreds of requests hit the database at once. Why it happens and three ways to prevent it in your app.
PUT vs PATCH in a REST API: full replacement vs partial update, idempotency, null in the body, and the fetch method: 'patch' trap. Which one to pick and when.

What integer overflow is, in plain words: a number hits its ceiling and wraps into the negatives. Where 2,147,483,647 breaks real apps.

What a sparse array is, in plain words: holes instead of elements. Why Array(3).map does nothing, and why the array's length lies to you.

What a semaphore is, in plain words: a counter that lets at most N tasks use a resource at once. How to limit parallel requests with it and avoid 429s.

What type coercion in JavaScript is, in plain words: why "5" + 2 gives "52" while "5" - 2 gives 3, and how to stop shipping these bugs in your code.

What binary search is, in plain words: how it finds one item among a million in 20 steps, why order matters, and how git bisect hunts down the buggy commit.

Optional chaining (?.) in plain words: how it stops “Cannot read properties of null”, where it still crashes, and why not to use it everywhere.

What a prototype is in JavaScript: where objects get properties you never added, why a word counter breaks on “constructor”, and why __proto__ is risky.

What a closure is in plain words: a function that remembers the variables from where it was born. And why it makes a React timer show 1 forever.

preventDefault vs stopPropagation in plain words: what each one stops, why AI adds both “just in case”, and how that breaks menus and analytics. Which to pick.

What a WeakMap is, in plain words: a dictionary that doesn't keep its keys alive. Why a cache built on a plain Map leaks, and when WeakMap is the right fix.

What template literals in JavaScript are: backticks, ${} interpolation, tags like sql`` — and the one mistake that turns a safe query into an SQL injection.

What a Symbol in JavaScript is, in plain words: a key that skips JSON and Object.keys, breaks string concatenation, and is the reason for...of works at all.

What is short-circuit evaluation (&& and ||), in plain words: why the second half may never run, and where a lone zero in your React UI comes from.

What is a linked list, in plain words: a chain where each item only knows the next one. Where it lives in React hooks and in your Git history.

What is a bitmask, in plain words: many yes/no flags packed into one number. Explained with Discord bot permissions, chmod 755 and a JavaScript trap.

for vs while loop: the difference and which to choose. Compared on five criteria, plus when you need do...while and how to fetch every API page safely.

A tuple, explained simply: a fixed-length array where each position has its own meaning and type. Why useState is a tuple and where TypeScript won't protect you.

A singleton, explained simply: one instance for the whole app. Why hot reload multiplies database connections and how globalThis fixes it.

A higher-order function, explained simply: a function that takes or returns another function. Why map(parseInt) gives NaN and how to read this kind of code.

setTimeout vs requestAnimationFrame: which to use for animation, timers and games. Why animations stutter and speed up on 120 Hz screens — and how to fix it.

What is a reducer in simple terms: how reduce and useReducer work, why mutating state won't re-render the screen, and why an empty array can crash it.

What is a hash table in simple terms: how it finds things without scanning, where it hides in JavaScript and Python, and why an object key turns into a string.

What is a generator in JavaScript in simple terms: how function* and yield work, why calling one does nothing, and where generators hide in AI streaming.

async or defer: the difference for the script tag and which to pick. A comparison on five criteria, plus the trap: async scripts run in a random order.

What is the event loop in JavaScript, in plain words: why setTimeout(0) waits for promises and why a heavy loop freezes the whole page.

What is memoization, in plain words: a function remembers its answers. Why the cache stays silent when you pass an object, and when it freezes your data.

What is event delegation in JavaScript, in plain words: one handler on the parent instead of a hundred, and why buttons added later stay silent.

some vs every in JavaScript: the difference and which to pick. A comparison on five criteria, plus a trap: every on an empty array always returns true.

What a graph is in programming, in plain words: points and the links between them. Where graphs hide in apps and maps, and why a graph walk can loop forever.

What a getter and a setter are, in plain words: a property that looks like a field but actually runs code. And why JSON.stringify quietly drops it.

What a generic is in TypeScript, in plain words: a function that remembers the type of what you gave it. Why it beats any, and where you've already seen one.

includes vs indexOf in JavaScript: how they differ, what they return and when to use which. Plus the if (indexOf(...)) bug that makes a check work backwards.

What an enum is, in plain words: a closed list of allowed values. The bug it catches, why JavaScript has no enum, and what to write instead of enum in TypeScript.

What a stack is, in plain words: a pile where the last thing in is the first thing out. How Ctrl+Z, the Back button and the call stack in your code are built on it.

What a default parameter is, in plain words: the value a function uses when you don't pass one. Two traps — null in JavaScript and a shared list in Python.

interface vs type in TypeScript: what the difference is and which one a beginner should pick. A criteria breakdown, the official docs' rule of thumb, and the interface merging trap.

What an operator is in plain words: plus, remainder, comparison. How operators solve real tasks — and where the trap with negative numbers hides.

What a tree data structure is in plain words: root, nodes and leaves. Where you meet trees every day and why a database stores them as a flat list.

What a random number is in code and how Math.random works: why it's pseudo-random, where the Math.round trap hides, and when you need crypto instead.

innerHTML vs textContent: what's the difference and which to use. A five-criteria comparison, how innerHTML opens a hole for foreign code, and where innerText fits.

What hoisting in JavaScript is, in plain words: why a function works before it's declared, const crashes with an error, and var quietly gives you undefined.

What a Set in JavaScript is, in plain words: a collection without duplicates and an instant has() check. When to pick a Set over an array — and where it quietly fails.

What a Map in JavaScript is, in plain words: a dictionary where any value can be a key. How Map differs from an object and from the .map() method — and when to use it.

filter or find in JavaScript: what each returns, which to pick when, and why if (arr.filter(...)) is always true. A comparison on five criteria and a clear verdict.

The JavaScript spread operator in plain words: what three dots mean in code, how to copy and merge arrays and objects, and where the copy trap hides.

Destructuring in JavaScript in plain words: pull fields out of objects and arrays in one line, read [count, setCount], and fix the Cannot destructure error.

What a pure function is in programming, in plain words: same input, same output, no side effects. Why it matters in React and in tests, with examples.

slice vs splice in JavaScript: the difference and which to pick. Five criteria side by side, the splice return-value trap, and a safe replacement for React.

What is try catch, in plain words: a safety net for your code. How it works, why you need finally, and why try without await catches nothing.

What is a data type, in plain words: a label that tells a program how to read a value. The main types, how to check them, and where the bugs come from.

What is a comment in code, in plain words: a margin note the program skips. How to write one, why 'why' beats 'what', and how to steer AI with comments.

for in vs for of in JavaScript, explained simply. Why for in over an array gives "0" and "1" as strings, why for of crashes on an object — and which to pick.

What an if statement is, in plain words: a fork in the code, “if — else”. Why code checks branches top to bottom and how one wrong order breaks discounts.

What a file path is, in plain words: a file's address on disk. How an absolute path differs from a relative one, and what ./ and ../ mean in code.

What a class is in programming, in plain words: a blueprint for objects. How a class differs from an object, what new does, and why AI writes classes.

Function vs method: the difference in plain words. Why Python uses len(x) and not x.len(), what this gives a method, and when to write each one.

What a string is, in plain words: text in quotes. Why "2" + "2" gives "22", an emoji counts as two characters, and everything from a form arrives as a string.

What return does in a function, in plain words: the answer a function hands back. Why console.log shows a number but your variable holds undefined.

What a boolean is, in plain words: true or false. Why "false" in quotes counts as true, an empty array does too, and zero counts as false.

for loop or map in JavaScript: what's the difference and which to pick. A comparison on five criteria, where forEach fits, and the await-inside-map trap.

What scope is in programming, in plain words: where in code a variable exists and where it doesn't. Why is not defined happens and how to read curly braces.

What null means in programming, in plain words: "deliberately empty." How null differs from undefined, where Cannot read properties of null comes from, and how to avoid it.

What an object in programming is, in plain words: a card with labeled fields. How it works, where it shows up in AI-written code, and why {a:1} isn't {a:1}.

let vs const in JavaScript: what the difference is and which to pick. A criteria breakdown, a one-second rule, and why const doesn't mean "can't change."

What is an array in plain words: a list that keeps its order. Why counting starts at zero, where the most common beginner bug comes from, and why an empty array matters.

What is a loop in programming, in plain words: repeat one action for every item in a list. Why you almost never know the number of repeats in advance.

What is a callback in plain words: a function you hand over instead of calling. Why it works that way, where you've already written one, and which parentheses break everything.

Array vs object: how they differ and which to pick for your data. A one-sentence rule, a breakdown by criteria, and why searching an array is a thousand times slower.

State is everything your app remembers between two clicks. What state is in plain words, and why interfaces break wherever one truth is stored twice.

A regression is an old bug that came back. What a regression is in plain words, why someone else's edit usually brings it, and how to catch it for good.

A dependency is someone else's code running inside your project. What a dependency is in plain words, why there are hundreds, and when to just write it yourself.

A variable isn't a box holding a value — it's a tag attached to one. That's the bug every beginner hits: you edit the copy of a list and break the original.

A diff isn't a report of what changed — it's a recipe for turning the old version into the new one. Learn to read minuses, pluses and those @@ marks in five minutes.

Infinite scroll loads more content as you scroll. Here's how it works, where it breaks — the footer, the Back button, Google — and when to use it.

A skip link is a hidden “Skip to main content” link that appears when you press Tab. Who needs it, how to build one in five minutes and how to test it.

A command palette is a window you open with a shortcut: type what you want to do and hit Enter. How it works and whether your app actually needs one.

Client-side routing changes the page address without asking the server. How it works under the hood, and the four things the browser no longer does for you.

A hamburger menu is the three-line icon that hides a site's navigation. What the NN/g study found: on desktop, hidden menus get used about half as often.

Website breadcrumbs are the “Home > Section > Page” trail. Who they actually help, how to build them right, and what Google changed about them in 2025.

Autofill doesn't read your name or id — it reads the autocomplete attribute. Here's the word list browsers look for, and why you can't just switch it off.

An input mask types the brackets and dashes for you. Here's why it validates nothing, where pasting breaks it, and what to use instead in your forms.

A required field is the required attribute plus a marker for humans. Why NN/g and GOV.UK give opposite advice — and how to pick the rule for your own form.

Progressive disclosure means deferring rare features to a second level. Here's why it speeds beginners up, the two conditions it needs, and where it breaks.

What optimistic UI means in plain words: the app shows the result before the server confirms it. Why teams do it, and how to roll it back without losing the user.

What an empty state is and how to design one: the three kinds of emptiness, the mistake beginners make, and what to write instead of "No data".

What a toast notification is: a small panel that pops up and disappears on its own. When it fits, how long to keep it, and who never gets to read it at all.

Toast vs inline error, compared on visibility, accessibility and message length. A straight answer on where form errors belong and when a toast is the right call.

Tree shaking drops unused code from your build. Here's why it works with some libraries and silently does nothing at all with others.

Lazy loading defers images until you scroll and saves bandwidth. But one line on the first screen makes your site slower — here's exactly why that happens.

Code splitting cuts one big JavaScript file into parts that load on demand. Here's how it works, where it pays off, and where cutting actually hurts.

An AI detector doesn't see AI. It measures how predictable your text is — which is why it flagged 61% of essays by non-native writers. Here's how it works.

A false positive is a system accusing someone innocent. Let's do the math on why a filter that's 99% accurate produces half its flags in error.

A confidence score is how sure a model is of its words, not of their truth. Where the number comes from, and why fine-tuning made it lie.

An open redirect is a hole you add yourself with a next parameter on the login form. How your own domain becomes a phishing link, and the three ways to fix it.

CSP isn't a filter for bad code, it's an allowlist of sources. What Content Security Policy is, why it blocks your own scripts, and how to turn it on safely.

Contrast ratio measures brightness, not colour. Here's the formula, the 4.5:1 threshold, and why a colour that looks bright fails the check.

Alt text describes an image's role, not its pixels. Here's what to write for photos, icons and buttons — and when empty alt is the right answer.

A screen reader turns your markup into speech. Here's how people actually use it: 72% jump between headings instead of listening straight through.

Object storage is the warehouse for files that sits next to your database. Why it has no folders, why you need it on project one, and how a file gets a URL.

EXIF is a dossier inside the photo: date, camera, coordinates. What's really in there, what it costs your app, and how to strip it without tipping photos sideways.

A presigned URL is a temporary pass to a file in storage. What's baked into the signature, why the link isn't single-use, and why it dies before its expiry.

Hydration is the moment JavaScript wires itself into the HTML the server already sent. Here's where the dead window and mismatch errors come from.

Core Web Vitals are three metrics: LCP, INP and CLS. Here are the thresholds, where Google gets the numbers, and why INP can't be measured in a lab.

Chat, analytics and pixels are someone else's code with your code's rights. What third-party scripts are, how they slow a site, and how to tame them.

Retention is the share of people who come back after N days. The average app loses 77% in three days. Here's how to measure it and what shape the curve should be.

A funnel is your user's path, split into steps. Here's why step percentages multiply instead of adding up, and which step to fix first.

A cohort is a group of users who arrived at the same time. Here's why overall averages lie, how to read a cohort table and what to look for in it.

Wireframe vs mockup: how they differ and what to do first. Compared on edit cost, honest feedback, and usefulness to AI — with a straight answer for beginners.

UI is the screen, UX is the whole path to the goal. What separates UI from UX, where the term came from, and why AI nails the first but fumbles the second.

A design token is a name for a value, not the color itself. Why tokens exist, what aliases are, and why without them dark mode turns into manual repainting.

A design system isn't a component library, it's a set of decisions made once. How it differs from a style guide, and why you want one even building solo.

A payout moves money from your payment provider's balance to your bank. Why the first one takes up to two weeks and why daily payouts don't speed it up.

A chargeback is when your customer's bank pulls the money back from you. How disputes work, what they really cost, and why even a win hurts your stats.

3-D Secure is payment confirmation on the customer's bank side. Who pays for a fraud dispute after 3DS, when it's mandatory, and what the friction costs.

Secure storage is a safe inside your phone: the key never leaves the chip, and the app itself can't read it. Keychain, Keystore, and where not to put a token.

A refresh token is the long key you trade for a short pass. Why apps use two tokens instead of one, and why the server sometimes logs you out on every device.

A passkey is a login without a password: the site only stores a public key. Here's how your phone signs you in and why phishing stops working.

What a push token is in plain words: how an app gets an address for notifications, why you must never cache it, and how to clean out dead tokens.

What a background task is on a phone: how many seconds iOS gives you, how Android defers work in Doze, and three honest ways to get work done in the background.

What app permissions are in plain words: how the system prompt works, why it never appears again after a denial, and when to ask so you don't lose access.

What an incident is in plain words: how to tell an outage from a bug, Google's three questions for declaring one, and why the incident commander fixes nothing.

What a postmortem is in plain words: why you write outages down, why there are no names in it, and the one mistake that makes the whole document useless.

How a changelog differs from release notes: different readers, different lifespan, and a 500-character limit. Which one you must keep, and which you can skip.

What personal data means in plain words: why an email and a device ID count, and why replacing a name with user_8123 doesn't take your database out of scope.

Database normalization in plain words: the three problems of a wide table, the three normal forms explained simply, and when duplicating data is actually right.

JOINs in plain words: how to stitch two tables in one query, how INNER differs from LEFT, and the two traps that make the total in your report wrong.

Foreign keys in plain words: how the database blocks orders from users who don't exist, what ON DELETE CASCADE does, and why you must add the index yourself.

Session vs JWT: how they differ, why a token can't be revoked, and which one a beginner should pick. Compared on revocation, speed and complexity.

Exponential backoff doubles the wait before each retry. Here's why doubling alone still takes a service down, and what a bit of randomness fixes.

Data labeling is the set of right answers a model learns from. Who writes them, and why trained labelers agree only about three times out of four.

Backups and replicas protect against different things: a replica against a dead server, a backup against your own mistake. The difference, and what to pick.

What graceful shutdown means in plain words: how an app should die, why the signal often never arrives in Docker, and what the 30 seconds of grace are for.

What a load balancer is, in plain words: how it splits requests across servers, why your IP rate limit breaks right after you add one, and what sticky sessions do.

What a deep link is, in plain words: how myapp:// differs from a universal link, why any app can claim your scheme, and what the file on your domain decides.

Vertical vs horizontal scaling explained: how they differ, why upgrading a machine means powering it off, and why a bigger disk is a one-way ticket.

UTC and time zones in plain words: why adding a time to a date is riskier than leaving it out, and how to stop losing whole days.

Uptime and SLA in plain words: how many minutes hide behind 99.9%, and why a chain of services is less reliable than its weakest link.

What debounce means in plain words, and how it differs from throttle. How a 300 ms delay kills redundant requests, and why answers arrive out of order without it.

What classification in machine learning means, in plain words: the model sorts text onto your shelves. Why it's cheaper than generation and how to measure it.

What a circuit breaker is, in plain words: a fuse that stops calling a service that's already down. The three states, and how it differs from a rate limit.

An LLM judge is a model that grades another model's answers. The three biases that skew it (style, length, order) and how to build a fair check.
A favicon is your site's icon in the browser tab and in mobile Google results. What it's for, which sizes to ship in 2026, and why it gets stuck in cache.

A breakpoint pauses your code on a chosen line and shows every variable at that exact moment. Why it beats console.log and how to set your first one.

A schema is the shape contract for your data: tables, fields, types. Here's how it catches garbage at write time — and where it hides in «schemaless» databases.

A runtime is the environment that executes your code and gives it hands: files, network, output. Why one language can do different things in different places.

A deadlock is a mutual block: two processes hold a resource each and wait for each other forever. How the database detects deadlocks — and how not to create them.

A payload is the useful data inside a request. Here's what a payload is, how it differs from headers, and where an API request actually breaks.

A flaky test fails every other run on identical code. Here's what a flaky test is, where the flakiness comes from, and why a retry is the worst possible fix.

Boilerplate is the repetitive code every project needs. Here's what boilerplate is, how it differs from a template, and why AI made it more valuable, not less.

Latent space is a «summary» instead of pixels. Here's what it is, why an image shrinks 48× before generation, and what that explains about AI images.

AI slop isn't «badly written». It's content nobody asked for. Here's what AI slop means, where the word came from, and how not to produce it yourself.

A function isn't a way to save lines. Here's what a function is in plain words, how it's built, and why it decides whether AI can fix your code or wreck it.

Recursion is a function calling itself. What recursion is in plain words, why the base case is mandatory, and where that stack overflow error comes from.

Overfitting is when a model memorised the examples instead of learning the rule. What overfitting is, why the score rises as usefulness drops, and how to spot it.

Code coverage shows which lines ran during your tests, not which ones were checked. What code coverage is, where the catch hides, and how to read a report honestly.

AI terms explained simply: token, context, hallucination, temperature, RAG, agent. One line per word — plus the misconception that keeps tripping people up.

Voice cloning isn't about how long your sample is — it's about how clean it is. Here's how a model captures a voice “fingerprint”, and what that means for you.

Tokens per second (t/s) is the headline number for AI speed. Here's what it measures, why one number lies, and how to measure your own model's speed.

What a URL is and what it's made of: scheme, host, port, path, query and hash. And why everything after the # never reaches the server at all.

What a unix timestamp is in plain words: one number instead of a date. Why 10 digits means seconds, 13 means milliseconds, and where that 1970 comes from.

What a float is in plain words: why 0.1 + 0.2 = 0.30000000000000004, where that breaks money calculations, and how to compare decimal numbers properly.

Library vs framework: the difference isn't size, it's who calls whom. A criteria table on the cost of entry and exit — and what to pick for your first project.

The User-Agent is the string your browser introduces itself with on every request. Here's what's in it, why it has been lying since the 90s, and how to read it.

VRAM is the video card's memory, where the whole model has to fit. Why "7B" isn't 7 gigabytes, how to calculate what you need, and what to do if it won't fit.

Cosine similarity measures the angle between embeddings. What those numbers actually mean, why 0.8 isn't 80%, and why you can't eyeball a threshold.

A stop sequence cuts generation off at the right spot. What it is, why the string itself never shows up in the answer, and how to spot a truncated reply.

What a subdomain is in plain words: app.mysite.com takes a minute and costs nothing. But the browser treats it as a separate site — your login doesn't travel.

What a fork is in plain words: a copy of someone else's repository inside your GitHub account. How a fork differs from a clone, and why it quietly goes stale.

Model deprecation is a shutdown announced in advance. Here's the model lifecycle, the notice periods, and why a silent version swap hurts more than an error.

A task queue is a coat-check ticket for slow work: your app answers instantly, a background worker finishes the job. Here's the mechanics and the big catch.

A cold start isn't a slow server — it's no server at all. Here's why the first request after a pause takes seconds, and how to make that wait disappear.

Vector search vs BM25: compared by what each one finds and where it silently misses. Plus the formula used to fuse them into a single ranked list.

Primary keys in plain words: what they're for, why email makes a bad key, and what to pick — auto-increment, UUIDv4 or UUIDv7.

An AI watermark isn't a caption in the corner — it's an invisible signal inside the pixels. How SynthID works, how it differs from C2PA, and how to check an image.

A proxy is a middleman between your app and someone else's service. What a proxy server is, forward vs reverse, and why your API key needs one.

OCR turns an image into text. The old engine failed honestly; a model invents confidently — and it happens most on digits. Here's why.

Encryption hides data in a way you can undo. Here's what the padlock in your browser actually protects — and what it doesn't.

Spreadsheets don't break on volume: 10 million cells is fine. Here's where they actually break, where a database is overkill, and what to pick.

Speech-to-text doesn't hear letters: the model looks at a picture of sound and guesses the text. That's where all its quirks come from — and how to fix them.

A MIME type decides what the browser does with a file: show it, download it, or refuse to run it. Content-Type, the Refused to execute error, and nosniff.

A bundler is the translator between your code and the browser. What a bundler does, why the build command exists, and why they're all being rewritten in Rust.

What a memory leak is in plain words: a bug tests can't catch because the code isn't wrong. The three places it almost always leaks, and how to spot it.

What a hash is in plain words: why a service that emails you your old password can't be doing it honestly — and where the password actually goes.

A UUID is a long id like 550e8400-e29b-41d4… Here's why it beats 1, 2, 3, what plain numbers leak, and what the new UUIDv7 fixes.

GET and POST aren't a formality — they're a promise. Here's the difference, and how mixing them up made real people's data disappear.

What a seed is, in plain words: one number sets the starting noise an image grows from. Lock it down and your prompt edits finally become visible.

The user tapped Pay once and got billed twice. What idempotency is, where the retries nobody made come from, and how to disarm them in your own app.

A string like eyJhbGciOi… looks encrypted, but it reads in one second. What base64 actually is, why it exists, and why you must never hide secrets in it.

Your app flew on 200 rows and died on 50,000. What a database index is, how to spot a missing one with a single command, and which columns deserve one.

SSH is a secure login into a remote computer. Here's what SSH is, why the safest login uses no password at all, and where you'll run into it.

Hashing is a one-way fingerprint of data. Here's what a hash is, why a site stores not your password but its imprint, and how hashing differs from encryption.

A race condition is a bug that fires every other time and vanishes when you look. Here's what a race condition is, why code 'runs ahead,' and how to fix it.

Docker and a virtual machine both promise 'runs the same everywhere,' but differently. We compare Docker vs VM on weight, speed and isolation — and what to choose.

WebSocket is an open pipe between the browser and the server: data flows both ways on its own. Here's how it works and when plain HTTP isn't enough.

Technical debt isn't "bad code" — it's the price of "fast now". Here's how it grows interest, why AI speeds it up, and when it's time to pay it back.

Hosting is a computer where your site lives 24/7. Here's how it differs from your laptop and which kind of hosting to pick for your first project.

YAML is the config format where indentation is syntax. How to read YAML, why one space can break the file, and how to dodge the famous Norway problem.

A linter reads your code as text and catches mistakes before you run it: typos, dead variables, suspicious spots. How it works and how to turn it on.

A CLI is a program with no windows or buttons, driven by text. Learn to read any command with one simple pattern — and why AI agents live in CLIs.

Web scraping is a program reading websites for you and saving the data into a table. How it works, where the limits are, and how AI changed the game.

A version like 1.0.0 isn't a counter — it's a promise about what breaks on update. Semver explained: the ^ in package.json and lock files.

Logs are your program's diary: what happened and when. Where to read them on the frontend, backend and hosting — and how to feed them to AI properly.

What is refactoring in plain words: editing code so that nothing changes on the outside. Why touch working code at all, and how to ask AI to do it safely.

What is Markdown in plain words: every AI answer is written in it. Here are the six markup symbols that cover almost everything you'll ever need.

What is an IP address in plain words: mail for computers, external vs internal addresses — and how to open your project on your phone using the terminal URL.

Authentication answers "who are you", authorization — "what are you allowed to do". A table, examples, and which error means what: 401 vs 403.

A database migration isn't moving data — it's a version of your table structure. What it is, how it works, and why you need one even solo.

What a cookie is in plain words: the server doesn't remember you, and a cookie is the coat-check ticket it recognizes you by. And why it isn't spying.

npm is a warehouse of ready-made JavaScript code plus the command that installs it. What npm is in plain words, what npm install does, and why it's both handy and risky.

Node.js is how you run JavaScript outside the browser: on a server, in the terminal, anywhere. Here's what Node.js is in plain words, and why you'll need it.

An eval is a small exam you write for a model, tuned to your task. What an eval is in plain words, how it differs from a benchmark, and how to build your own in an evening.

top-p cuts off the model's tail of unlikely words. What top-p means in plain words, how it differs from temperature, and why turning both knobs at once is a mistake.

LoRA freezes the model and trains two tiny matrices on top. What LoRA means in plain words: why it trains thousands of times fewer parameters, and why adapters matter.

A regular expression looks like random symbols and scares beginners. It's really a short language for searching text — here's what regex is and how to read one.

A tokenizer slices your text into chunks before the model ever sees it — and non-English text makes more chunks. What a tokenizer is, and why it drives cost.

A port isn't an address — it's a «door» on your computer: the :3000 in localhost:3000 says which program to knock on. What a port is, and why there are thousands.

A Git commit isn't «save this file» — it's a snapshot of your whole project with a note on why. What a commit is made of, and why it's so hard to lose.

Docker packs your app together with its whole environment into a container that runs the same on your laptop and on the server. Here's what Docker is and why you'd want it.

DNS is the phone book of the internet: it turns a site's name into a server's address. Here's what DNS is and why your site didn't open instantly after you connected the domain.

A stack trace is the map of calls that led to an error. Here's how to read a stack trace and find the line in your own code where it crashed in 10 seconds, even as a beginner.

Open source doesn't mean free, and it doesn't mean 'do whatever you want.' Here's what open source actually is — and why the license decides everything.

A Git branch isn't a copy of your code folder — it's a lightweight bookmark to one commit. Here's what a branch is, why you need it, and why it's instant.

A library is someone else's code you call by name. What a library is, how it differs from a framework, and why every import is worth checking.

AGI is an AI that can do everything a human can. Sounds simple, but there's no single definition. Here's what AGI actually means and why the finish line keeps moving.

A foundation model is one big neural net trained on everything at once, then adapted to any task. Here's what a foundation model is and how the LLM fits in.

What is a server, in plain words: not a metal box but a program that waits for a request and answers. Here's how it works — and why your laptop is one too.

Middleware is the code between 'a request arrived' and 'you responded.' Here it is on a conveyor belt: where login, logs and CORS live — and why you need next().

Async code doesn't wait: it moves on while the answer is still in transit. That's why your data is undefined even though it clearly arrives — and how await fixes it.

An ORM is a translator between your code and your database: you write user.save() instead of an SQL query. Here's what it's for — and where its big catch hides.

Machine learning is when you don't program the rules — you teach with examples. Here's what machine learning actually is, in plain words, and where it lives.

A repository is your project plus its whole history of changes. What a repo is, how it differs from GitHub, and why there's a hidden .git folder.

A dataset is the set of examples a model learns from. What a dataset is, why it's split into three parts, and why garbage in means garbage out.

Semantic search finds by meaning, not exact words. Ask one thing, find the same thing phrased differently. Here's how it works and how to build your own.

Latency is how long you wait for an answer. With AI it splits into two parts, and one of them ruins the whole feeling of 'fast'. Let's find where the seconds go.

A raw model from the internet is rude and useless — humans rating answers make it polite. What RLHF is in plain words, and why it makes AI a bit of a flatterer.

Git stores not the latest version of your code but every step of it — and works offline. Here's what Git is in plain words, and why you need it.

'It's just a wrapper around GPT' sounds like a verdict, but that's how half of all useful AI products are built. Here's what an AI wrapper is and why it's fine.

An SLM is a small language model that fits on a phone and works offline. Here's what an SLM is, how it differs from an LLM, and when to reach for one.

Every site answers with a three-digit code: 200 is OK, 404 is not found, 500 is the server broke. Here's what HTTP codes are and how to read them by the first digit.

The terminal looks like a hacker window from the movies. It's really just a chat with your computer: you type a command, it replies. Let's demystify it.
An AI doesn't reveal a finished answer — it births it one token at a time and hands it straight to you. Here's what streaming is and why it exists.
The padlock next to the address doesn't mean 'this site is trustworthy.' It means only one thing. Here's what HTTPS is and what it actually protects.
One line — 'npm install' — and a folder weighs more than your whole project. Here's what a package manager is, and why it's both a superpower and a risk.
Want your bot to know your documents? Beginners reach for fine-tuning, but you almost always need RAG. Compared on cost, freshness, and complexity.

JSON isn't code, it's data: two kinds of brackets and a colon. Learn what JSON is, how to read one, and why it shows up in every API response and config file.

What frontend and backend are, how they differ, and why an API key on the frontend leaks in a minute. The two halves of any app, explained simply.

A cache is a pocket for data you already fetched, so you don't fetch it twice. Here's what caching is, why clearing the cache helps, and how it saves money on AI.

A container packages a program together with its environment so it runs the same everywhere. Here's what a Docker container is — and why it isn't a VM.

A small model on your laptop answers almost like a giant. Distillation is when the big model personally tutors the small one.

A model has 600 billion parameters, but only a small slice fires per word. That's MoE — here's how one router keeps a giant nimble.

A pull request is a proposed change, reviewed before it merges. Here's what a pull request is, why you want one even solo, and how to use it.

A knowledge cutoff is the line past which a model knows nothing. Here's why it confidently makes up recent events, and how to work around it.

A reasoning model thinks to itself first, then answers. Those hidden thoughts cost money and time — here's how it works and when it's actually worth it.

A diffusion model doesn't paint an image pixel by pixel — it develops it out of pure noise, removing static step by step. Here's how it works, in plain words.

An SDK is a ready-made toolkit for a service: a code library plus tools. Here's what an SDK is, how it differs from an API, and why you'd want one.

A rate limit caps how often you can call an API. Here's why a service answers 429, why it isn't a bug in your code, and how to live with it.

A framework is a ready-made app skeleton. Here's what a framework is, how it differs from a library, and why you don't call it — it calls you.

A transformer is the engine behind every AI like ChatGPT. Here's what a transformer is — and why it doesn't read text the way you do.

Llama 70B, Qwen 7B — what's the B? It's billions of parameters. Here's what model parameters are, and why bigger doesn't always mean smarter.

A GPU is the graphics card almost all AI runs on. Here's what a GPU is, how it differs from a CPU, and why neural networks can't live without it.

Serverless isn't "no server" — it's a server that sleeps until called. Here's what serverless is, what you pay for, and what a cold start really is.

localhost is an address that loops back to your own computer. Here's what localhost is, why only you can see it, and where ports fit in.

It's not always a weak server — sometimes it's distance. Here's what a CDN is, how a network of copies speeds up a site, and why you need one early.

Inference is a trained model working for you right now. Here's why every answer costs money each time, and what drives its speed and price.

A benchmark is a standardized exam for AI models. Here's how to read leaderboards without the illusions, and why your own mini-test beats any ranking.

A multimodal model doesn't look at an image the way you do — it turns it into the same numbers as text. How AI works with photos, sound and text at once.

Fine-tuning teaches a model style and behavior, not new facts. Here's how it differs from RAG and why a beginner should care about the difference.

The DOM is the live tree of the page the browser builds from your HTML. In plain words: how it differs from the source, and why your element 'isn't found.'

A REST API isn't a technology — it's a set of good manners for programs talking over the internet. In plain words: four verbs, addresses, and why the server never remembers you.

React is a library where you describe how the screen should look, and it redraws it for you. In plain words: components, state, and the one trick that changes everything.

CORS isn't 'your server broke.' It's the browser hiding the response to protect you. Here's why the CORS error happens and how to fix it honestly.

A JWT is a pass you carry with you, not an entry in the server's logbook. Here's how the server lets you in while storing nothing about you — and where the trap is.

2FA is a second key to your account that changes every 30 seconds. Here's why it holds even when your password has long leaked into someone else's database.

Your site works, but it's nowhere in search. SEO isn't marketing magic — it's how you tell Google what your page is about. Explained plainly, no jargon.

The 'Sign in with Google' button never hands your password to the site — that's the whole point. OAuth explained plainly: how it works, why it exists, where you've met it.

Title and description are the only thing a person sees about your page BEFORE clicking. They're hidden in the code, not on screen. Which ones matter and how to write them.

A closed model is a taxi, an open one is your own car. We compare on price, privacy and the learning curve, and say plainly who should pick which — and when to switch.

“Works on my computer” isn't the same as “available to people.” Deploy moves your app to where it lives without you. Here's what it really means.

Write an API key into your code, push to GitHub, and bots steal it in minutes. Environment variables keep secrets out of the code. Here's how.

A vector database searches by meaning, not exact words: it finds the right thing even when you don't guess the phrasing. Here's how it works.

SQL is the language you use to ask a database for the rows you want. Explained simply: what it's for, how it reads, and why everyone still learns it.

An API is the window through which one program asks another to do something or hand over data. Explained simply, no jargon, with real examples.

A database is an app's memory that survives a restart. Explained simply: what it's for, how it's built, and when you actually need one.

An LLM isn't a knowledge base — it's a text-continuation machine. Here's what a large language model really is, and why it's so confidently wrong.

A neural network doesn't memorize examples or follow rules — it turns millions of knobs until it guesses right. Here's the plain-words version, no formulas.

You describe what you need in plain words, and an agent writes, runs and fixes the code. Here's what the process is — and the first three moves to make.

One setting decides whether the AI answers dull and identical or creative and risky. At zero it's by-the-book; turn it up and it writes poetry, but it may also make things up.

The model never trained on your documents — yet it answers from them. The trick is that it gets handed the right snippets right before answering. That's RAG.

MCP is USB for AI agents. One common port, and an agent can reach your browser, your database and your files — no custom adapter for each.

In a long chat, old messages get pushed out of the model's memory — that's why it loses the thread. Explained with a simple picture.

The model confidently spat out nonsense. Feels like a lie. But it can't lie — it has no idea what truth even is. Let's see how it works and how to catch it.

A chatbot answers, then waits. An agent acts: it opens your files, runs the code, reads the error and fixes it. The difference is what it does, not just what it says.

The same sentence costs a model more in Russian than in English. Tokens are why — let's see what they are and how to pay less.

A prompt feels like a question you ask the AI. It's really a brief for a worker. Flip that, and the answers stop surprising you.

AI turns words into coordinates on a map of meaning. Close meanings land near each other — so it searches by meaning, not by exact words.

The AI wrote it, but it is your product now. You do not need to write code by hand to understand it — you need to read it. Here is how to actually do that.

A database is just a set of well-labelled lists. Get the data model right and the rest of your app falls into place. Get it wrong and you fight it forever.

KODiQ is a free mobile app that teaches you to build real things with AI — vibe coding, prompting and AI literacy in short daily lessons. Here's how it works.