Articles for developers

Encoding

Base64: why encoding is needed and how it works

How Base64 turns binary data into ASCII text and where that is actually needed.

Base32: how it differs from Base64 and when it is more convenient

The case-insensitive Base32 alphabet and scenarios where it beats Base64.

URL Encode/Decode: percent-encoding in links

How special characters in URLs and query parameters turn into %XX sequences.

HTML Entities: how to safely output special characters on a page

Why the characters < > & need escaping and how that prevents broken markup.

JWT: token structure and what "decoding" a JWT actually means

The header, payload, and signature of a JWT, and why decoding is not the same as verifying the signature.

Unicode Escape: what \uXXXX sequences mean

Where \u0041-style sequences in JSON and JS strings come from and what they mean.

ROT13 and the Caesar cipher: simple character substitution

Why shifting by 13 letters makes ROT13 self-inverse, and why anyone still uses it today.

Punycode: how internationalized domains work in DNS

How a domain with non-Latin characters gets converted into an ASCII form with the xn-- prefix.

Morse code: how text becomes dots and dashes

The principle behind encoding letters as dots and dashes, and where Morse code is still used today.

Data URI: when to embed images directly in code

How a data: URI embeds a file’s contents directly in HTML or CSS, and when that is worth it.

Gzip + Base64: compressing data for text-based transfer

Why compressed binary data also gets Base64-encoded before going into a text field.

XML Entities: escaping characters in XML documents

The five required XML entities without which a document breaks during parsing.

JSON

JSON Formatter: formatting, minifying, and validating

Formatting for readability, minifying for size, validating for correctness — three different JSON tasks.

JSONPath: querying JSON data without manual parsing

How JSONPath lets you pull the values you need out of a large JSON document with one expression instead of manual traversal.

JSON Diff: how structural comparison differs from text comparison

Why key order shouldn't affect the comparison of two JSON documents.

JSON Schema: describing and validating JSON structure

How JSON Schema lets you automatically check whether data matches an expected contract.

JSON Flatten: turning a nested structure into a flat list

How deeply nested JSON turns into a flat list of keys like user.address.city.

JSON Sort Keys: why sort an object's keys

Why JSON key order isn't specified, yet sorting is still useful in practice.

JSON Repair: why JSON breaks and how to fix it

Common causes of "broken" JSON, and what automatic repair can and can't fix.

Mock JSON Generator: why fake data is useful

How mock data lets you start building a UI before the backend is ready.

JSON ↔ YAML/CSV/XML/TOML: when and why to convert

What data gets lost converting JSON to CSV, and why YAML and TOML are popular for config files.

Text

Case Converter: why different naming styles exist

Why one project writes variables in camelCase but files in kebab-case, and where these rules came from.

Text Diff: how algorithms find the difference between two texts

How a diff algorithm finds the minimal set of changes between two versions of a text.

Regular expressions: basic syntax and common patterns

How to read a regular expression, and how greedy matching differs from lazy matching.

Sorting and deduplicating lines: why it matters

Why numeric sorting putting "10" before "9" is a mistake, and how to avoid it.

String Escape: why the same text needs escaping differently

Why the same quote character gets escaped differently in a JS string, JSON, and a shell command.

CRLF vs LF: why line ending characters still matter

Why a file written on Windows can show as "entirely changed" in git on Linux.

Counting characters and words: why it's not always trivial

Why an emoji or an accented character can count as several characters at once.

Lorem Ipsum: where the placeholder text came from and why it exists

Why designers deliberately use "nonsense" text instead of real content in mockups.

Slugify: turning arbitrary text into a URL

How a title like "Hello, World!" turns into a URL-safe string like hello-world.

Markdown: why plain-text syntax beat rich text editors

Why developers choose to write documentation in Markdown instead of a rich text editor.

Whitespace and invisible characters: the hidden cause of weird bugs

Why two strings that look identical can fail to match because of an invisible character.

Text Reverse: why "reversing text" is harder than it sounds

Why a naive string reversal can turn an emoji into unusable bytes.

Text frequency analysis: why count how often words repeat

How letter frequency in ciphertext helps crack the simplest substitution ciphers.

Hashes/Crypto

Hash Generator: how MD5, SHA-1, and SHA-256 differ from each other

Why MD5 is still used to verify file integrity, but not for passwords.

Checksum Verifier: how to check that a file isn't corrupted

Why a matching checksum confirms a file's integrity, but not who created it.

HMAC: how a keyed hash differs from a regular hash

Why a plain SHA-256 doesn't protect against message tampering, but HMAC does.

Bcrypt: why passwords are hashed slowly, not quickly

Why fast SHA-256 is a bad choice for passwords, and slow bcrypt is the right one.

UUID: how identifiers that almost never repeat are generated

Why UUID v4 can be generated independently on millions of machines without collision risk.

Password Generator: what actually makes a password strong

Why a long dictionary-word password is stronger than a short one with symbols and digits.

AES: how symmetric encryption works

Why the same key both encrypts and decrypts data in AES, and how that differs from asymmetric encryption.

Argon2: why this algorithm won the password hashing competition

How Argon2 defends better against GPU-based attacks than older password hashing algorithms.

Scrypt: why the algorithm needs so much memory

Why scrypt deliberately demands a lot of memory to make cracking on ASIC devices harder.

TOTP: how one-time codes in authenticator apps work

Why the code in Google Authenticator works offline and syncs with the server only via time.

PBKDF2: the oldest key-stretching standard

Why the recommended PBKDF2 iteration count keeps growing every year.

X.509: what's inside an SSL certificate

What exactly the browser checks in a site's certificate before showing the green padlock.

PGP: how public-key and private-key encryption works

Why you can freely share a PGP public key but never the private one.

Time/Numbers

Unix time: why computers count time from 1970

Why January 1, 1970 became the reference point for time in most computer systems.

Cron expressions: how to decode a task schedule

How to decode an expression like */15 * * * * and know exactly when the job will run.

Number systems: why binary, octal, and hexadecimal exist

Why the color #FF5733 in CSS is written in hexadecimal digits instead of decimal.

Bitwise operations: how AND, OR, and XOR work at the bit level

How bitwise AND differs from logical AND, and why you'd operate on individual bits of a number at all.

Date difference: why counting days is trickier than it looks

Why naively subtracting dates can give the wrong result because of leap years.

Age calculation: why it's not just subtracting years

Why simply subtracting birth years can give an age one year higher than the real one.

Time zones: why UTC isn't the same thing as GMT

Why UTC never changes twice a year, while London time (GMT/BST) does.

Duration calculator: how to correctly add up hours, minutes, and seconds

Why adding minutes and seconds requires "carrying" the remainder to the next place, just like in decimal addition.

ISO 8601 duration: how to write a duration in a standard format

Why PT1H30M means "1 hour 30 minutes," not "1 minute 30 hours."

Week number: why different countries count weeks differently

Why January 1 sometimes falls into week 52 or 53 of the previous year under the ISO 8601 standard.

Roman numerals: how a system with no zero and no place value works

Why IV means 4, not 6, and how the subtraction rule works in Roman numerals.

IEEE 754: why 0.1 + 0.2 doesn't equal 0.3 in code

Why almost every programming language prints 0.1 + 0.2 as 0.30000000000000004.

Number to words: why turn digits into text

Why bank documents write an amount both in digits and in words at the same time.

Network/HTTP

URL breakdown: what parts make up a web address

Why a URL has a part after the # symbol that the server never even receives.

Query string vs. JSON: why GET parameters are so limited

Why passing an array or a nested object through a URL query string isn't as simple as through JSON.

User-Agent: why this string is such a mess

Why Chrome, Safari, and Edge all contain the words "Mozilla" and "Safari" in their User-Agent at the same time.

Basic Authentication: how the simplest way to protect an HTTP resource works

Why Basic Auth absolutely requires HTTPS, since Base64 is encoding, not encryption.

HTTP headers: what's hidden in every request and response

Why the Content-Type header determines how the browser interprets the server's response body.

Cookies: how a small piece of text keeps track of session state

Why the HttpOnly attribute protects a cookie from being stolen by malicious JavaScript.

CORS: why the browser blocks "normal-looking" requests to another domain

Why a CORS error happens in the browser, not on the server, and who's actually blocking the request.

Email headers: how to trace a message's path from sender to you

Why you need to read Received headers from bottom to top to trace a message's route.

SEO

Meta tags: which ones actually affect search and social media

Why a search engine sometimes ignores your meta description and generates its own snippet from the page text.

robots.txt: how search bots decide what they can crawl

Why a Disallow rule in robots.txt doesn't hide a page from search results if something else links to it.

Sitemap.xml: why search engines need a map of your site

Why being listed in sitemap.xml doesn't guarantee a search engine will index a page.

Favicon: why a single icon needs so many sizes and formats

Why a single favicon.ico is no longer enough to display correctly on every device.

Generating sitemap.xml: how to build a site map automatically

Why search engines mostly ignore the priority field in sitemap.xml even though it's part of the spec.