Big-O Growth Rates Compared: O(1) to O(n!)
Compare O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n), and O(n!) with exact growth values at n = 10, 100, 1000 and concrete algorithm examples.
In-depth technical guides, tutorials, and computer science explainers built to help developers solve day-to-day coding problems.
Compare O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n), and O(n!) with exact growth values at n = 10, 100, 1000 and concrete algorithm examples.
Draw a heart in Desmos with four easy methods: parametric sin³ curves, polar cardioids, the implicit algebraic formula, and copy-paste Valentine art.
Build an Arduino Nano and HC-SR04 ultrasonic distance sensor on perfboard with a piezo alarm. Wiring, parts, distance formula, and sketch.
Convert hourly pay to annual, monthly and weekly gross salary, or calculate time card hours and overtime. Worked examples and formulas without taxes.
Calculate how many tiles and boxes to buy for floors and walls. Measure rooms, account for tile sizes, grout spacing, and straight vs diagonal cut waste.
Calculate gas mileage in MPG, cost per mile, trip fuel cost, and L/100 km. Learn the fill-up method with three worked examples and money-saving tips.
See how much one semester can raise your cumulative GPA on a 4.0 scale. Calculate target grades, credit inertia, and three realistic worked scenarios.
Invert a 3x3 matrix step by step with Gauss-Jordan elimination, calculate determinants by row reduction, and identify when a matrix has no inverse.
Calculate roof pitch, pitch multipliers, roofing squares, and shingle bundles. Learn how to estimate waste and order bundles with two worked examples.
Calculate sample and population standard deviation step by step. Learn when to divide by n vs n-1, how to find variance, and how to detect IQR outliers.
Learn how to draw a Thanksgiving turkey, pumpkin pie slice, and autumn maple leaf in Desmos with copy-ready equations, step-by-step math, and styling tips.
Read a 12V battery or 5V sensor on a 3.3V Arduino or ESP32 pin: standard E12 resistor pairs, ADC loading effects, and two step-by-step worked examples.
Calculate wire voltage drop with formulas, the 3% and 5% NEC guidelines, copper vs aluminum comparisons, and three worked 120V, 12V, and 240V examples.
Compare BFS and DFS with a worked graph, visiting order, queue and stack states, discovery/finish times and cycle detection rules.
Master binary min-heaps and max-heaps with step-by-step insert (sift up), delete-min (sift down), array vs tree mapping, heapsort, and Big-O runtimes.
Master Boolean algebra laws including De Morgan, absorption, and consensus theorems with step-by-step worked algebraic simplifications and truth tables.
Convert Indian CGPA to the US 4.0 GPA scale. Learn how WES evaluations and 9.5 percentage formulas work, with worked examples for US college applications.
Calculate flooring waste factor, measure rectangular and L-shaped rooms, choose 5%, 10%, or 15% extra material, and determine how many boxes to buy.
Calculate how many 40, 60, or 80 lb bags of concrete you need for slabs, footings, and post holes, including cubic yards and waste allowance.
Calculate how much paint you need for any room. Measure walls, deduct doors and windows, calculate coats, and compare gallon versus quart buying options.
Calculate electricity cost from watts and kWh. See worked monthly costs for space heaters, PCs, and LED bulbs at editable US residential electric rates.
How loan amortization schedules work, why early payments are mostly interest, and how an extra $100/month saves $49,138 on a $200,000 30-year fixed loan.
Find modular inverses with the extended Euclidean algorithm step by step, trace Bezout coefficients in tables, and compute powers by repeated squaring.
Learn percent change, percent of, what percent, percent difference, discounts, and sales tax with step-by-step formulas and five worked US examples.
Master scientific, engineering, and E notation rules with four worked homework examples for addition, subtraction, multiplication, and division.
Master significant figures rules for leading, trailing, and captive zeros, exact numbers, and operations with five worked chemistry-style examples.
Learn two's complement, one's complement, and sign-magnitude with bit-level formulas, 4 to 32-bit ranges, and worked 8-bit addition and overflow examples.
Calculate the final exam score you need to reach your target course grade. Learn the weighted formula with three worked scenarios and study tips.
Calculate z-scores, find left, right, and between normal curve probabilities, and find percentile cutoffs with three worked homework problems and formulas.
Master AVL tree rotations with step-by-step LL, RR, LR, and RL examples, balance factor calculations, and a direct comparison against an unbalanced BST.
Compare 2NF, 3NF, and BCNF step by step with candidate keys, minimal covers, and decompositions. See where 3NF and BCNF differ through worked examples.
How to calculate break-even ROAS and target CPA with real product margins, shipping, payment fees, and returns. Use it to set profitable ad bids.
Trace Dijkstra's algorithm step by step with priority queue states, distance tables, negative edge failure cases, and a Bellman-Ford comparison.
Compute linear discrete convolution step by step with a flip-and-slide table, solve circular convolution, and relate time-domain aliasing to the DFT.
Break down every US Etsy seller fee: listing, transaction, payment processing, and Offsite Ads, with exact formulas and a worked order profit example.
Calculate semester and cumulative GPA on a 4.0 scale with letter grades and credit hours, and find the target grades needed to raise your average.
Convert decimal numbers to 32-bit IEEE 754 single precision step by step with sign, biased exponent, mantissa bits, rounding, and why 0.1 + 0.2 != 0.3.
Learn how LR(1) items work, how LALR(1) merges identical cores, and why state merging causes reduce/reduce conflicts that LR(1) avoids, with worked tables.
Learn the six RV32I instruction formats (R, I, S, B, U, and J) with bit-level breakdowns, immediate scrambling rules, and worked binary and hex examples.
Compare bubble, insertion, selection, merge, quick, and heap sort on the same input with exact comparisons, swaps, stability, and Big-O complexities.
Learn compiler bootstrapping, cross-compilers and T-diagrams, then compare syntax-error recovery methods with computed LL(1) and LR traces.
See generated ambiguity witnesses, two parse trees and leftmost derivations for expressions, dangling else and a recursive equal-count grammar.
Build LEADING/TRAILING sets, a precedence table and f/g functions, then follow a generated shift-reduce trace for id + id * id.
Generate a predictive C parser for expressions, inspect its rewritten grammar and call trace, then compile and run accepted and rejected inputs.
Resolve every expression-grammar shift/reduce conflict with left, right and nonassoc declarations, using generated LR decisions and parse traces.
Step-by-step CYK algorithm tutorial: convert a CFG to Chomsky normal form (CNF), fill the triangular parse table for baaba, and verify string membership.
Build canonical LR(1) items, merge ten states into seven LALR states, read both tables, and see why an assignment grammar is LALR but not SLR.
Worked direct and indirect left-recursion removal, left factoring and LL(1) tables, including why factoring dangling else does not remove its conflict.
Master the pumping lemma for regular languages with our proof template, common mistakes to avoid, and worked proofs for aⁿbⁿ, palindromes, and a^(n²).
A four-variable Quine–McCluskey example with don't-cares: every combining round, prime-implicant chart, essential prime and exact minimum SOP cover.
Take (a|b)*a(a|b) through Thompson NFA, epsilon-closure subset construction and DFA minimisation, with generated transition tables and partition rounds.
The classic 5-process banker's algorithm example: the Need matrix, the safety check row by row, a safe sequence, and requests granted or refused.
FIRST and FOLLOW sets for the classic expression grammar, worked rule by rule, then the LL(1) parsing table and a full parse of id + id * id.
The textbook reference string through FIFO, LRU and Optimal page replacement with 3 frames: 15, 12 and 9 faults, step by step, plus Belady's anomaly.
SJF, SRTF and priority CPU scheduling worked on the textbook examples: Gantt charts, completion, turnaround and waiting times, and the averages to check.
Build the canonical LR(0) items and the SLR(1) parsing table for the expression grammar, see why LR(0) has conflicts, and trace a parse of id * id + id.
How spinning circles redraw any shape: a square worked out circle by circle, how many circles you need, and how to put a drawing in Desmos as one equation.
Switch a 12 V load from a 3.3 V or 5 V pin with a 2N2222: the base resistor worked out, why hFE misleads, a perfboard layout, and when to add a diode.
Move an Arduino Nano project from breadboard to perfboard or stripboard: headers, power rails, track cuts, and a worked LED, button and I2C layout.
Seven easy Desmos art projects with copy-ready equations: a heart, smiley face, flower, spiral, butterfly, house and your name, plus finishing tips.
Write words in the Desmos graphing calculator: equations for straight letters, curves and spacing, worked for H, I, A, O and C, plus a fast generator.
Build a 555 astable LED blinker on perfboard or stripboard: part values, the pinout, a placement that keeps wires short, track cuts, and a pre-power check.
Read a Bode plot: corner frequencies, −20 dB/decade slopes, the gain and phase margins of 10/(s(s+1)(s+10)), and the gain that makes it unstable.
Read capacitor markings: 104 is 100 nF, 103 is 10 nF. A chart of common codes, plus tolerance letters, voltage prefixes like 2A, and 4n7 notation.
Why voltage uses 20·log and power 10·log, a dB-to-ratio table to memorise, what dBm means (0 dBm = 1 mW, 30 dBm = 1 W), and adding gains in a chain.
Estimate how long a quadcopter can hover from battery capacity, weight and efficiency, with worked numbers for a 4S camera drone and a 6S FPV quad.
How much heat a motor driver makes: conduction loss 2·I²·RDS(on), switching loss, why hot MOSFETs lose more, and when your driver needs a heatsink.
f = 1/(2π√LC) worked with real values: tune an AM radio across its band, pick an inductor for 10.7 MHz, and see why the reactances cancel at resonance.
AND, OR, NOT, NAND, NOR, XOR and XNOR with their truth tables and Boolean expressions, why NAND alone can build anything, and a half adder from two gates.
What KV means on a brushless motor, how to turn it into RPM on 4S or 6S, why the loaded speed is lower, and why high-KV motors spin small props.
Estimate static thrust from shaft power and prop diameter with momentum theory, and see why bigger, slower props lift more per watt than small fast ones.
Convert an IMU quaternion to roll, pitch and yaw and back, with worked numbers, the ZYX convention, why you normalise first, and what gimbal lock does.
fc = 1/(2πRC), worked with real part values: what −3 dB means, how fast the filter rolls off, and how to pick R and C for a target frequency.
Read 4, 5 and 6-band resistors: the color chart, which end to start from, and worked examples for 220 Ω, 1 kΩ, 10 kΩ and 47 kΩ.
Work out the torque and wheel RPM a wheeled robot needs from its weight, speed, acceleration, slope and floor, with worked numbers in N·m, kg·cm and oz·in.
Compute attribute closures step by step, use them to find every candidate key, then decide 2NF, 3NF or BCNF. Worked on the classic R(A, B, C, D, E).
Split an address into tag, index and offset for direct-mapped, set-associative and fully associative caches, with a worked example and hit/miss trace.
One request queue worked through FCFS, SSTF, SCAN, C-SCAN, LOOK and C-LOOK, with the head path and total head movement for each.
The classic memory allocation exercise (holes of 100, 500, 200, 300, 600 KB; processes of 212, 417, 112, 426 KB) worked through first, best and worst fit.
Build a Huffman tree for six characters by merging the two rarest, read off the codes, and count the bits saved. The classic CLRS example.
Apply the master theorem to T(n) = aT(n/b) + f(n): compare f(n) with n^log_b(a), pick the case, get the bound. Ten solved recurrences.
Size every trace on a 12 V, 3 A motor-driver board: signal traces, the power trace by IPC-2221, voltage drop, the ground return and how many vias to use.
Build a PDA for aⁿbⁿ, write its transitions, and trace it on aabb, aab and abb with the stack at every move. Plus empty-stack acceptance.
Translate SQL queries into relational algebra with π, σ, × and ⋈, draw the query tree, then optimise it by pushing selections down. Six worked examples.
Design a Turing machine for aⁿbⁿ by marking matched symbols, write its transition table, and follow every move on the tape for aabb.
Pixelate, blur or cover? Which hides faces, plates and text, how big blocks must be, and the leaks people miss: EXIF data, reflections, fake redaction.
Steps per mm for GT2 belts, lead screws and extruders, set in Marlin (M92) or Klipper (rotation_distance), plus E-step calibration with an example.
Pick a LiPo for a robot, RC car or drone: cell count from your motors and ESC, capacity from the run time you want, C rating from the peak current.
Tune a PID loop by hand in four steps, read the symptoms of each wrong gain, and get tested loop code with anti-windup and derivative on measurement.
Solve a series-parallel resistor circuit: reduce it to one equivalent resistance, then work back to the current, voltage and power in every resistor.
A UTM naming convention your team can follow: source and medium values GA4 understands, a campaign name formula, and why tags get lost.
The four Denavit–Hartenberg parameters, how to assign frames, and a worked 3-link arm from DH table to link matrices and end-effector pose.
Round Robin scheduling solved step by step: the ready queue after each time slice, the Gantt chart, and turnaround, waiting and response times.
Thompson's construction step by step: the NFA for each operator, the (a|b)*abb example, then subset construction down to a 4-state DFA.
Turn a schematic into a perfboard or stripboard layout step by step: placing parts, routing wires, track cuts, and checking the board before you solder.
How graph art is built in Desmos: domain restrictions, circles, parametric curves and shading, plus the fast way to turn a sketch into equations.
What each section of an electronics datasheet tells you, why absolute maximum ratings are not operating conditions, and the mistakes beginners make.
Three-address code step by step: expressions, quadruples, triples, indirect triples, if-else and while loops, and the DAG, with textbook examples.
A value is an outlier if it falls below Q1 − 1.5×IQR or above Q3 + 1.5×IQR. Why Tukey chose 1.5, how box plot whiskers use it, and a worked example.
Why break-even point is entirely a function of contribution margin, and why lowering price affects break-even volume more dramatically than people expect.
What a histogram bin is, five bin-count rules (square root, Sturges, Rice, Scott, Freedman-Diaconis) with a worked example, and what Excel, NumPy, R use.
How a CIDR prefix like /24 sets network size, why usable hosts are two fewer than the address count, and how to read a subnet mask correctly.
Why Pearson correlation only measures linear strength, and the three ways a strong correlation appears with no causal link at all.
Minimize a DFA step by step on one 8-state example: remove unreachable states, then the equivalence method, table filling and Hopcroft's algorithm.
Before modeling or drawing conclusions, a handful of summary statistics catch most of the obvious problems and surprises in a new dataset.
How Gaussian elimination reduces a system of linear equations to solvable form, why partial pivoting matters, and what a singular system actually means.
An API (Application Programming Interface) is a defined contract that lets one piece of software request functionality or data from another, without needin
ASCII (American Standard Code for Information Interchange) is a 7-bit character encoding covering 128 code points — English letters, digits, punctuation, a
Base64 is a binary-to-text encoding that represents arbitrary bytes using 64 printable ASCII characters (A-Z, a-z, 0-9, +, /). It is used to safely embed b
A CLI (Command-Line Interface) is a text-based way of interacting with a program by typing commands into a terminal, as opposed to clicking through a graph
Compression reduces the size of data by removing redundancy, either losslessly (the original can be perfectly reconstructed, as in ZIP or PNG) or lossily (
A cookie is a small piece of data a server asks a browser to store and automatically resend with every subsequent request to that domain. Cookies are how s
Cron is a time-based job scheduler on Unix-like systems, configured with a five-field expression — minute, hour, day of month, month, day of week — that de
CSS (Cascading Style Sheets) is the language used to describe how HTML elements should look — layout, color, typography, spacing, and responsive behavior a
CSV (Comma-Separated Values) is a plain-text format for tabular data, where each line is a row and commas separate columns. It has no official type system
Decoding is the reverse of encoding: converting data back from its encoded representation to its original form using the same scheme it was encoded with. D
Encoding is the process of transforming data from one representation into another according to a defined, reversible scheme — for example turning binary by
Encryption transforms readable data (plaintext) into unreadable data (ciphertext) using a cryptographic key, such that only someone holding the correct key
GraphQL is a query language and runtime for APIs where the client specifies exactly which fields it needs in a single request, instead of hitting multiple
Hashing runs data through a one-way function to produce a fixed-size digest that acts as a fingerprint of the input. Unlike encryption, hashing is not mean
HTML (HyperText Markup Language) is the standard markup language for structuring content on the web, using nested elements (tags) like `<p>`, `<div>`, and
JavaScript is a dynamically-typed scripting language that runs natively in every web browser, making it the language of client-side interactivity on the we
JPEG (Joint Photographic Experts Group) is a lossy raster image format that uses discrete cosine transform compression to shrink file size by discarding im
JSON (JavaScript Object Notation) is a lightweight, text-based data format for representing structured data as key-value pairs, arrays, and nested objects.
A JWT (JSON Web Token) is a compact, signed token format used for authentication and information exchange. It has three base64url-encoded parts separated b
MD5 is a 128-bit cryptographic hash function from 1992 that is now considered broken for security purposes — practical collision attacks exist, meaning two
Next.js is a React framework that adds server-side rendering, static site generation, file-based routing, and build tooling on top of React. It lets a sing
Node.js is a JavaScript runtime built on Chrome's V8 engine that lets JavaScript run outside the browser — on servers, in build tools, and in CLIs. Its eve
PNG (Portable Network Graphics) is a lossless raster image format that supports full alpha transparency and up to 16-bit color depth per channel. Because c
React is a JavaScript library for building user interfaces out of reusable components that declaratively describe what the UI should look like for a given
A regular expression (regex) is a pattern language for matching, searching, and replacing text. Patterns are built from literal characters and metacharacte
REST (Representational State Transfer) is an architectural style for web APIs built around resources identified by URLs and manipulated with standard HTTP
An SDK (Software Development Kit) is a bundle of tools, libraries, documentation, and sometimes a compiler or emulator that lets developers build applicati
A session is server-side state tied to a particular user's visit, usually identified by a session ID stored in a cookie. Unlike a JWT, a plain session requ
SHA-256 is a cryptographic hash function that produces a fixed 256-bit (64 hex character) digest from any input. It is a one-way function — practically imp
A slug is a URL-safe, human-readable identifier for a resource — typically lowercase, with spaces replaced by hyphens and special characters stripped. Slug
SVG (Scalable Vector Graphics) is an XML-based vector image format that describes shapes with mathematical paths instead of a pixel grid. This means SVGs s
In authentication, a token is an opaque or self-contained string issued to a client after login, presented on subsequent requests to prove identity without
TypeScript is a superset of JavaScript that adds static type annotations, checked at compile time before the code is transpiled down to plain JavaScript. T
Unicode is a character set standard that assigns a unique code point to every character across virtually all of the world's writing systems, plus symbols a
UTF-8 is a variable-width encoding of Unicode that uses 1 to 4 bytes per character. ASCII characters take exactly 1 byte (making UTF-8 backward-compatible
A UUID (Universally Unique Identifier) is a 128-bit value, usually written as 32 hex digits in five hyphenated groups, designed to be unique across systems
WebP is a modern image format from Google that supports both lossy and lossless compression plus alpha transparency and animation, typically producing 25-3
XML (Extensible Markup Language) is a markup language that encodes documents using nested tags with attributes, similar to HTML but for arbitrary structure
The exact math for adding tax to a price and, more error-prone, extracting the base amount and tax from a tax-inclusive total.
The four derivative rules that cover almost every function (power, product, quotient and chain), how each works, and mistakes when combining them.
The sample size formula n = z²p(1−p)/e² with a worked example, sample sizes by population, the formula for a mean, and Slovin's formula.
What each HTTP status code class actually signals, and the specific pairs — 401 vs 403, 301 vs 302, 500 vs 502 — that get mixed up most often.
Why one IPv4 address can be written as dotted decimal, binary octets, hex or a single integer, and how to convert between the forms.
K-map rows and columns use Gray code order (00, 01, 11, 10) so neighboring cells differ by one bit, which is what lets you group them into simpler terms.
Why one MAC address is written three different ways across vendors, and what the 'locally administered' and 'multicast' bits inside it actually mean.
How FLOPs and parameter counts are actually computed for a dense neural network layer, and why they scale completely differently as networks grow.
A comprehensive guide to deterministic and nondeterministic finite state machines, structural comparison matrices, and theoretical equivalence.
The specific real-world scenario each distribution models, and the concrete test for choosing the right one instead of guessing.
Why NPV and IRR can rank two projects differently, and why NPV is generally the more reliable of the two when they conflict.
Simpson's rule with a worked example (e^(−x²) from 0 to 1, n = 4), compared with the trapezoidal rule, plus the error bound and the 3/8 rule.
The precise definition of a p-value, why 0.05 is a convention rather than a law, and the misreading that trips up almost everyone.
Population (÷ n) vs sample (÷ n − 1) standard deviation: a worked example, why n − 1, how to choose, and the function to use in Excel, Python, R, TI-84.
Why a 99% accurate model can still be useless, and how precision, recall, and F1 each measure a genuinely different kind of mistake.
Anscombe's quartet: four datasets with almost identical correlation and completely different shapes, visible only when you plot them.
Why declining balance front-loads depreciation while straight-line spreads it evenly, and which actual assets each method models more realistically.
A step-by-step tutorial on powerset construction algorithm, computing epsilon-closures, and constructing transition tables.
How a truth table systematically covers every possible input combination, and why its row count doubling with each variable matters for real logic design.
Well-known ports are 0–1023. The common TCP/UDP ones listed, how 0–65535 splits into well-known, registered and dynamic, and Linux's different range.
ASCII and Unicode aren't really competing standards — Unicode's first 128 code points are literally identical to ASCII, extended to cover everything else.
Why APIs Base64-encode binary fields, the size and streaming tradeoffs it introduces, and multipart alternatives for large payloads.
How data URIs embed images directly in HTML/CSS, the real performance tradeoff versus a separate file request, and when it actually helps.
No. Base64 is encoding, not encryption: it has no key, so anyone can decode it instantly. Where this causes real vulnerabilities and what to use instead.
Worked examples of exactly how much larger hex and Base64 output get versus the original bytes, and how to calculate the exact size for any payload.
Base64 adds about 33% size overhead while hex doubles the data (100%). How the two encodings compare on readability and where each is actually used.
What actually separates a good online JSON formatter from a mediocre one, and why 'runs entirely in your browser' should be the first thing you check.
How JSON parsing works in your browser: syntax rules, validation, performance tricks for large files, and why a local formatter keeps your data private.
What actually separates a good online Markdown editor from a mediocre one, beyond just having a preview pane.
Where code actually executes in each model, and why the choice determines privacy, offline capability, and who pays the compute cost.
The specific error messages JSON.parse throws, what each one actually means, and the exact fix for the most common causes.
How Base64 encoding actually works, why it exists, where it silently bloats your payloads, and when to reach for it instead of raw binary or hex.
A practical tour of the DevTools panels developers use daily (Elements, Console, Network, Application) plus the shortcuts that save real time.
How HEX, RGB, HSL, and HSB actually represent color, why they convert imperfectly, and how WCAG contrast ratios decide whether text is legible.
How cron's five-field syntax works, the special characters that trip people up, and how to read or write a schedule expression with confidence.
Under RFC 4180, fields with commas, quotes or line breaks go in double quotes, with inner quotes doubled. Why naive comma splitting breaks.
How JSON, YAML, and XML represent the same data differently, why conversions between them aren't always lossless, and which format fits which job.
The small, boring tools that save developers time every day (clipboard managers, snippets, quick converters) and why flow state is worth protecting.
What a cryptographic hash guarantees, why MD5 and SHA-1 are broken for security, and when to use SHA-256 versus a password-hashing algorithm.
Why HTML reserves characters like < and &, the difference between named, decimal, and hex entities, and how missing escaping leads directly to XSS.
How PNG, JPEG, WebP, and SVG actually differ under the hood — lossy vs. lossless compression, transparency support, and when vector beats raster.
JSON's actual syntax rules, the mistakes that break parsers most often, and why strict validation catches bugs that 'looks fine to me' misses.
How a JWT's three parts work, why anyone can read the payload without a key, and the signature-verification mistakes behind real auth bypasses.
Markdown's core syntax, how CommonMark standardised it, and why the same .md file renders differently on GitHub, blogs and static site generators.
What makes PDFs large or slow, how merging, splitting and rotating work under the hood, and why client-side PDF tools avoid uploading documents.
How QR codes pack data into a grid of squares, what error-correction levels actually trade off, and why a logo in the center doesn't break the scan.
The regex building blocks that cover most real patterns, why greedy quantifiers cause surprising matches, and what catastrophic backtracking actually is.
How ASCII, Unicode, and UTF-8 relate to each other, why mojibake happens, and what actually goes wrong when an encoding mismatch corrupts text.
Why URLs need percent-encoding, which characters are actually reserved, and the double-encoding bugs that break links in production.
What a UUID's 128 bits actually encode, why v4 is random but v7 sorts chronologically, and when each version fits a database primary key better.
What WCAG's four principles actually require in practice — contrast ratios, keyboard navigation, and screen reader support — beyond just adding alt text.
Shrink image files with no visible quality loss: better lossless encoders, stripping metadata, and palette reduction where it fits.
The exact arithmetic behind converting a hex color code to its RGB values, worked through by hand for a real example.
A practical walkthrough of converting PNG to WebP, why it directly helps page-load metrics, and the fallback pattern for the rare unsupported context.
Why word count varies between tools counting the same text, and what 'reading time' estimates are actually based on.
A compact reference for cron's five fields, special characters, and the most commonly needed schedule patterns.
Why a cron job that works when run by hand fails on schedule, and the environment, logging and permission checks that find the cause.
Fifteen real-world cron schedules — from every minute to the last day of the month — with the expression and a plain-English explanation for each.
The cron expression for running a job every 5 minutes, exactly which minutes it fires on, and variants for other short intervals.
0 0 * * 1 runs a cron job every Monday at midnight; 0 9 * * 1 at 9 AM. How day-of-week numbers work, and the workaround for every other Monday.
The recurring cron mistakes that cause jobs to run at the wrong time, skip entirely, or silently double-run — and how to catch each one before deploying.
The standard five-field cron syntax versus the six-field 'extended' variant some schedulers add, and how to tell which one you're reading.
Cron vs Windows Task Scheduler: side-by-side recipes for periodic tasks, with crontab lines, matching schtasks and PowerShell commands, and systemd timers.
CSV is plain text anyone can parse; XLSX holds formulas, formatting and multiple sheets. What each is for, and what you lose converting between them.
How to decode a JWT's header and payload instantly, and why doing that is completely different from verifying its signature is actually valid.
A practical walkthrough of encoding query parameters correctly, including the specific pitfalls around spaces, ampersands, and non-ASCII characters.
How to escape user input before rendering it as HTML, and why the escaping rules change depending on where the value lands in the markup.
What actually belongs on each side of the frontend/backend split, and why the boundary is a design decision, not a fixed physical line.
Where lorem ipsum comes from, why it beats real text for layout mockups, and when a different kind of placeholder text fits better.
The QR code settings that matter (error correction level, size and quiet zone) and how to choose them for how the code will actually be scanned.
What GitHub Flavored Markdown adds to CommonMark (task lists, alerts, strikethrough, autolinks) and where those features do and don't render.
How hashing and encryption combine in digital signatures, and the practical difference between symmetric encryption keys and the keyless nature of hashing.
Hashing is one-way and keyless by design; encryption is two-way and requires a key. Confusing the two leads directly to real security mistakes.
Converting hex to HSL genuinely transforms the numbers, unlike hex to RGB. Why, and when HSL's hue and lightness model is worth the extra step.
How Base64 decoding reverses the encoding, why padding and alphabet mismatches make decodes fail, and how to recover an image from a data URI.
Step-by-step Base64 encoding for text and files, plus why line-wrapping and character-set variants matter for the result you actually need.
A practical walkthrough of generating v4 and v7 UUIDs, what randomness source actually matters, and how to pick between them for a real use case.
How JSON.stringify's indentation argument works, why 2 vs 4 spaces is mostly a style choice, and when pretty-printing large JSON hurts more than it helps.
The difference between syntax validation and schema validation, and why pasting sensitive JSON into an online validator carries a real privacy risk.
What TLS actually adds on top of plain HTTP — encryption, integrity, and identity verification — and what it deliberately doesn't protect against.
How image compression works: DCT quantization, colour palette reduction and predictive filtering, and which kind of image each technique suits.
What EXIF, IPTC, and ICC metadata each actually store inside an image file, and why EXIF GPS data specifically is a real, easy-to-overlook privacy risk.
JPEG vs PNG: lossy DCT compression against lossless deflate, and what each means for photos, screenshots, colour depth and transparency.
Why the Content-Type header is what tells a server to expect JSON, and how a mismatch between declared and actual content breaks requests silently.
JSON array syntax, mixed-type arrays, and why JSON has no concept of a 'sparse' array the way some languages do.
Minification and GZIP shrink JSON in different ways: one strips whitespace, the other exploits repetition. Combining both gives the real savings.
A formatter re-indents JSON for readability; a validator checks it's actually correct. They're often bundled together, but they solve different problems.
JSON object syntax rules, why key order isn't guaranteed by the spec, and what actually happens when a key is duplicated.
What happens inside JSON.parse(): the tokenizer and recursive descent that turn a string into objects, and why eval() was never a safe shortcut.
A practical walkthrough of JSON Schema's core keywords — type, required, properties, and enum — with a real example you can adapt directly.
CSV is flat and spreadsheet-friendly; JSON handles nesting and types. How to choose, and what goes wrong when you pick the wrong one.
Why JSON parses faster and reads more compactly than XML for the same data, and the specific things XML can express that JSON structurally cannot.
Why YAML dominates config files and JSON dominates APIs, despite YAML being a strict superset of JSON's data model.
Session cookies keep state on the server and revoke instantly; JWTs move state to the client and trade revocation for statelessness. When to use each.
How fenced code blocks work, why the language name after the triple backticks matters, and the indented code block most people forget exists.
Where Markdown rendering actually happens across different editor types, and why that decides both preview speed and what happens to content you type.
Markdown image syntax, why alt text isn't optional, and why sizing an image usually needs raw HTML because Markdown has no width or height.
Markdown table syntax, the alignment colon convention, and why tables are a GitHub Flavored Markdown extension rather than part of the original spec.
Markdown is a readable shorthand that compiles to HTML, not a rival format. What it covers, what it can't do, and when to drop into HTML.
MD5's design, why practical collisions have existed since 2004, and the narrow set of non-security uses where it's still perfectly reasonable.
How merging PDFs actually works under the hood, why it's near-instant regardless of file size, and why doing it offline matters for sensitive documents.
Why passwords need a deliberately slow, salted hash instead of a fast general-purpose one, and how bcrypt, scrypt, and Argon2 actually differ.
A practical decision checklist for choosing PNG or JPEG based on what the image actually contains, not habit.
WebP's lossless mode specifically versus PNG — where the size savings actually come from, and the compatibility check still worth running.
A compact reference covering character classes, anchors, quantifiers, groups, and lookarounds in one place.
Three tested email regex patterns (simple, practical, strict) run on 21 real and broken addresses, with code for JavaScript, Python, PHP and Java.
Capturing groups extract matched text; non-capturing groups just organize a pattern; backreferences reuse an earlier group's match within the same pattern.
Regex lookaheads check what follows a position without matching it: how they work, and the password-complexity patterns built on them.
Regex lookbehinds check what comes before a position without consuming it: the mirror of lookaheads, with a browser-support catch to know.
The three quantifier behaviors — greedy, lazy, and possessive — and exactly how each one changes what a pattern actually matches on the same input.
Why 'exact duplicate' is stricter than it sounds: trailing spaces, case and line endings all make identical-looking lines count as different.
REST's fixed endpoints vs GraphQL's client-written queries: what over-fetching and under-fetching mean, and the trade-offs neither avoids.
RGB and HEX hold exactly the same values. The real difference is where each is easier: typing a colour by hand or changing one in code.
Why the industry moved from SHA-1 to SHA-256, what actually changed between them, and what to check before migrating a system still using SHA-1.
What SHA-1 was designed to do, the 2017 'SHAttered' collision attack that broke it in practice, and where it's still acceptable to use today.
MD5 is faster with a shorter digest; SHA-256 has no known practical collision attack. Why speed is the wrong way to choose for anything security-related.
The internal structure of SHA-256 — block size, compression rounds, and why it's still considered secure — plus where it actually gets used today.
How splitting a PDF keeps only the objects each page needs, why file size follows content not page count, and how it differs from printing pages.
Static vs dynamic sites: the real difference is when HTML is generated, at build time or per request, and what that means for speed and hosting.
SVG size grows with drawing complexity, not display size, so a detailed illustration can be bigger than a PNG. When to use which.
Why SVG scales infinitely and PNG doesn't, and the specific cases — icons, logos, illustrations — where that resolution independence actually matters.
UTF-8's 1–4 bytes vs UTF-16's 2 or 4: why the web chose UTF-8 and why runtimes like JavaScript strings still use UTF-16 inside.
Why random UUID v4 keys fragment database indexes under heavy writes, and how v7's time ordering fixes it without central coordination.
The exact bit layout differences between v4 and v7 UUIDs, and the specific steps each generation algorithm follows.
WebP's dual lossy/lossless modes versus PNG's lossless-only design, and how each handles the alpha channel differently in practice.
ASCII's origin as a 7-bit telegraph-era standard, its full 128-code layout, and why it still underlies virtually every modern text encoding.
Unicode is a character-to-number mapping, not an encoding itself — the distinction that trips up nearly everyone learning the topic, explained clearly.
The variable-width byte structure that makes UTF-8 both ASCII-compatible and capable of representing all of Unicode, worked through byte by byte.
Understand the syntax of cron expressions. Learn how to format cron schedules, write recurrence rules, and use wildcards for server automation.
Discover how Base64 conversion works, the binary mapping algorithm, padding bytes rules, and when to use encoding in web APIs safely.