The 1.5×IQR Rule for Outliers: What It Is and Why 1.5
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.
In-depth technical guides, tutorials, and computer science explainers built to help developers solve day-to-day coding problems.
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.
Too few bins hide real structure in your data; too many make noise look like signal. The right bin count depends on what you're actually trying to see.
How a CIDR prefix like /24 actually determines network size, why usable hosts are two fewer than the total address count, and how to read a subnet mask correctly.
Why Pearson correlation only measures linear relationship strength, and the three ways a strong correlation can appear without any causal relationship existing.
How to minimize a DFA: find equivalent states with Myhill-Nerode, then refine partitions with Hopcroft's algorithm iteration by iteration, including dead states.
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 one works, and the common mistakes when combining them.
Where the sample size formula n = z²p(1-p)/e² actually comes from, why 50% is the safest guess for an unknown proportion, and when population size stops mattering.
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 the same IPv4 address gets written as dotted-decimal, binary octets, a hex string, or one packed integer depending on context, and how to convert between them.
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 the same MAC address shows up 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.
Why not every function has a closed-form antiderivative, and how Simpson's rule approximates the area under a curve to a very high accuracy using nothing but function evaluations.
The precise definition of a p-value, why 0.05 is a convention rather than a law of nature, and the specific misinterpretation that trips up almost everyone.
Why sample variance divides by n-1 instead of n, and how to tell which formula actually applies to your dataset.
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 nearly identical correlation coefficients and completely different underlying relationships, visible only by actually plotting the data.
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.
There are 1,024 well-known ports, numbered 0–1023. How the full 0–65535 range splits into well-known, registered (1024–49151) and dynamic (49152–65535) ports.
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.
Learn how JSON parsing engines work inside your web browser. Discover performance optimization tricks, parsing syntax rules, validation protocols, and data privacy safeguards.
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 browser DevTools panels developers actually use daily — Elements, Console, Network, and Application — plus the shortcuts and workflows 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 containing commas, double quotes or line breaks should be enclosed in double quotes, with inner quotes doubled. Why naive 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.
Which small, boring tools actually save developers time daily — clipboard managers, snippet libraries, quick converters — and why flow state is worth protecting.
What a cryptographic hash actually guarantees, why MD5 and SHA-1 are broken for security use, and when to reach for SHA-256 versus a password-hashing algorithm instead.
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 actually work, why anyone can read the payload without a key, and the signature-verification mistakes that lead to real auth bypasses.
Markdown's core syntax, where CommonMark standardized it, and why the same .md file can render differently across GitHub, blogs, and static site generators.
What actually makes PDF files large or slow, how merging/splitting/rotating work under the hood, and why client-side PDF tools avoid the privacy risk of 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.
The specific techniques that shrink image files with zero visible quality loss — better lossless encoders, metadata stripping, 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 fine when run manually often fails when scheduled, and the environment, logging, and permission checks that actually 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 runs it at 9 AM. How day-of-week numbering works and why every other Monday needs a workaround.
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 is the Linux equivalent of Windows Task Scheduler for periodic tasks. How their configuration differs, what each can do that the other can't, and where schtasks fits.
CSV is a plain-text format anyone can parse; XLSX is a full spreadsheet application format with formulas, formatting, and multiple sheets — converting between them isn't always lossless.
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.
The practical mechanics of escaping user input before rendering it in HTML, and why the escaping rules change depending on exactly 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 text actually comes from, why it's specifically chosen over real language for layout mockups, and when a different kind of placeholder text fits better.
The practical settings that matter when generating a QR code — error correction level, size, and quiet zone — and how to choose them for how the code will actually be used.
The specific extensions GitHub Flavored Markdown adds on top of CommonMark — task lists, alerts, strikethrough, and autolinking — and where they do and don't render outside GitHub.
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.
Unlike hex-to-RGB, converting hex to HSL genuinely transforms the underlying numbers — here's why, and when HSL's hue/lightness model is worth that extra step.
How Base64 decoding reverses the encoding process, why padding and alphabet mismatches cause decode failures, and how to recover a viewable 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.
The actual algorithmic techniques behind image compression — DCT quantization, color palette reduction, and predictive filtering — and which content type each 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.
The actual compression algorithms behind JPEG and PNG — DCT-based lossy quantization versus deflate-based lossless — and what each means for color depth and transparency.
Why the Content-Type header is what actually tells a server to expect JSON, and the mismatches between declared and actual content type that break 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 attack JSON size in different ways — one removes whitespace, the other exploits repeated patterns — and 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 actually happens inside JSON.parse() — the tokenizer and recursive-descent steps that turn a JSON string into a live object graph — 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 natively. Choosing wrong means either fighting flattening rules or losing spreadsheet compatibility.
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 can be revoked instantly; JWTs push state to the client and trade that revocability for statelessness. Neither is universally 'better'.
How fenced code blocks work, why the language identifier after the triple backticks matters, and the indented-code-block alternative 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's image syntax, why the alt text isn't optional decoration, and why responsive sizing usually needs raw HTML since Markdown itself has no width/height attributes.
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 down to HTML — not a competing format, but a layer designed to cover common formatting without the visual noise of tags.
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.
Why a fully RFC 5322-compliant email regex is enormous and impractical, and why a simpler pattern combined with an actual verification email is the better real-world approach.
Capturing groups extract matched text; non-capturing groups just organize a pattern; backreferences reuse an earlier group's match within the same pattern.
Lookaheads check that something follows the current position without including it in the match — the mechanism behind password-complexity patterns and more.
Lookbehinds check what comes before the current position without consuming it — the mirror image of lookaheads, with a support-compatibility catch worth knowing.
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 a stricter definition than it sounds — trailing whitespace, case, and line-ending differences all make otherwise-identical lines register as distinct.
REST's fixed endpoints versus GraphQL's client-specified queries — what over-fetching and under-fetching actually mean, and the tradeoffs neither approach avoids.
RGB and HEX represent the exact same values — the real difference is where each is easier to use: hand-typing a color versus programmatically manipulating one.
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 and produces a shorter digest; SHA-256 is the one with no known practical collision attack. Speed is the wrong axis to choose on for anything security-relevant.
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 extracts only the objects each page actually needs, why output size scales with content rather than page count, and how it differs from printing a page range.
The real distinction is when the HTML gets generated — at build time versus on every request — and what that timing decides about speed, freshness, and hosting cost.
SVG file size scales with image complexity, not display dimensions — which means a genuinely complex illustration can end up larger than a simple PNG, contrary to the usual assumption.
Why SVG scales infinitely and PNG doesn't, and the specific cases — icons, logos, illustrations — where that resolution independence actually matters.
UTF-8's variable 1-4 byte width versus UTF-16's 2-or-4 byte structure — why the web overwhelmingly chose one and certain runtimes (like JavaScript strings) still use the other internally.
Why random v4 primary keys fragment database indexes under high write volume, and how v7's time-ordering fixes it without giving up decentralized generation.
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.