Kategorya
Encoding at data
Lahat ng kagamitan at artikulo sa kategoryang ito, tinipon sa isang lugar.
Mga Kagamitan
Base64, Base32, Hex & Percent Codec
I-encode ang teksto sa Base64, URL-safe na Base64, Base32, hexadecimal, o percent-encoding, at i-decode ang alinman sa mga ito pabalik. Pasensya sa kulang na padding at whitespace, at minamarkahan nito ang mga resultang binary (hindi UTF-8). Tumatakbo nang buo sa iyong browser.
JSON ↔ YAML Converter
Convert JSON to block-style YAML or YAML back to JSON, entirely in your browser. Parse errors point to the exact line and column, and conversion notes flag the lossy edges like dropped comments and expanded anchors.
JSON Formatter & Validator
Validate, pretty-print, minify, and sort JSON. Parse errors point to the exact line, column, and path; duplicate keys are flagged; and large numbers are preserved exactly. Runs entirely in your browser.
Multi-time-zone meeting planner
One instant, read in every attendee's IANA time zone: local time, UTC offset, day shift, and a working-hours flag. DST is whatever the zone database says for that date, which is exactly why you plan with a real one.
Roman numerals converter
Numbers to numerals and back, with the canonical subtractive form, the place-by-place construction, and honest validation: IIII is accepted and explained, IL is refused with the rule it breaks.
Time calculator
Exact time arithmetic: the span between two instants, or an instant plus or minus a duration, in ISO 8601 or plain shorthand. Months and years are refused honestly: they are calendar units with no single exact length.
Unix time converter
Mag-type ng Unix timestamp — segundo, milliseconds, microseconds, o nanoseconds, awtomatikong natutukoy — o isang ISO-8601 na petsa, at basahin ito sa lahat ng karaniwang format. Lahat sa iyong browser.
Mga Artikulo
JSON vs YAML: What Converts Cleanly and What Does Not
YAML was designed so that every JSON document is also valid YAML, which is why conversion between them usually just works. The interesting part is the edges: comments, anchors, multiple documents, and YAML-only types that have no JSON equivalent.
BasahinMga byte, code point, at UTF-8
Ang pagkakaiba ng isang karakter at isang byte, bakit may Unicode at UTF-8, at ano ang kaugnayan nito sa Base64.
BasahinThe Anatomy of a URL
Every URL is built from the same handful of parts defined by RFC 3986: scheme, authority (userinfo, host, port), path, query, and fragment. What each part means, how a parser tells them apart, and where the boundaries actually fall.
BasahinThe JSON Grammar: Six Types and a Few Strict Rules
JSON is smaller than it looks. The whole format is six value types and a handful of structural characters, governed by rules that are stricter than most people remember: no comments, no trailing commas, and keys that must be quoted strings.
BasahinWhat Unix Time Actually Is
Unix time is a single integer: the number of seconds since 1970-01-01T00:00:00Z, the epoch. It is time-zone independent, compact, and sortable, which is why it underpins almost every system clock, log line, and API timestamp. Converting it to a calendar date is pure arithmetic.
BasahinBase64 at Base64URL, ipinaliwanag
Paano nagiging ligtas-ipadalang teksto ang binary data, bakit may padding, at ano ang nagbabago sa variant na ligtas-sa-URL.
BasahinJSON Numbers and the Precision Trap
JSON puts no limit on the size or precision of a number, but most parsers quietly convert every number to a 64-bit float. That mismatch silently corrupts large integers and exact decimals, which is why a formatter should preserve the original digits.
BasahinQuery Strings: Parameters, Plus Signs, and Repeated Keys
The part of a URL after the question mark looks simple but hides real ambiguity: how parameters are separated, why a plus sign sometimes means a space, how repeated keys behave, and why there is no single governing standard.
BasahinSeconds, Milliseconds, Microseconds, Nanoseconds: Telling Epoch Units Apart
The same instant can be written as 1700000000, 1700000000000, or larger, depending on whether the timestamp counts seconds, milliseconds, microseconds, or nanoseconds. Mixing them up is a classic bug. You can almost always tell which is which from the number's magnitude.
BasahinYAML Type Coercion and the Norway Problem
YAML guesses the type of every unquoted scalar, and its guesses are surprising: the country code NO becomes false, a version like 1.0 becomes a number, and a zero-padded code loses its zeros. Knowing the rule is the key to safe conversion.
BasahinBase64URL at ang alpabetong ligtas-sa-URL
Bakit gumagamit ang mga JWT at PKCE ng ibang alpabetong Base64, ang dalawang karakter na nagbabago, at ano ang nangyayari sa padding.
BasahinDuplicate Keys in JSON: Legal, Dangerous, and Worth Catching
JSON syntax allows the same key to appear more than once in an object, but the specification does not say what that means. Different parsers resolve it differently, which makes duplicate keys a quiet source of bugs and even security issues.
BasahinJSON and YAML in Practice: APIs, Declarations, and Orchestration
The split is not random: APIs and machine-to-machine declarations tend to be JSON, while human-authored orchestration and pipeline files tend to be YAML. Understanding why each domain chose what it did explains when converting between them is useful.
BasahinThe Year 2038 Problem
A signed 32-bit integer can count seconds only up to 2147483647, which falls on 2038-01-19T03:14:07Z. One second later it overflows and wraps to a negative number, throwing affected systems back to 1901. It is Y2K's quieter successor, and the fix is a wider integer.
BasahinURL Encoding and Internationalized Hosts
URLs are restricted to a small set of ASCII characters, so everything else is encoded. Percent-encoding handles paths and queries; punycode handles non-ASCII host names. How both work, and why internationalized hosts are a phishing concern.
BasahinISO 8601, RFC 3339, and the HTTP Date
Once a Unix timestamp is turned back into a human date, it gets written in one of a few standard text formats. ISO 8601 is the broad standard, RFC 3339 is its strict internet profile, and the HTTP date is the odd one out. Knowing the difference saves a lot of parsing grief.
BasahinJSON String Escapes and Unicode
Inside a JSON string, a few characters must be written as escapes, and any character at all can be written as \uXXXX. The rules are small but strict, and the one that catches people is how characters beyond the basic plane, like emoji, need a surrogate pair.
BasahinSaan lumilitaw ang Base64: data URI, MIME, PEM, at Basic auth
Ang mga tunay na lugar kung saan binabalot sa teksto ang binary, ang halaga sa sukat nito, at bakit hindi pag-encrypt ang Base64 sa isang authentication header.
BasahinYAML Anchors, Aliases, and Merge Keys
YAML can define a value once and reuse it with an anchor and alias, and merge one mapping into another with a merge key. None of this exists in JSON, so converting expands and duplicates it. This covers the syntax, what happens on conversion, and the denial-of-service trap they enable.
BasahinBase32, ipinaliwanag
Kung bakit ipinagpapalit ng Base32 ang laki para sa isang hindi malabo at case-insensitive na alpabeto, kung paano gumagana ang 5-bit na paggrupo nito, at kung saan ito lumilitaw (mga TOTP secret, onion address, DNS).
BasahinTrailing Commas, Comments, and the JSON5 Family
Strict JSON has no comments and no trailing commas, which surprises people whose editor accepts both. The reason is that JSON is a minimal interchange format, and the tolerant variants (JSONC, JSON5) are separate things. Knowing which is which avoids config files that break in another tool.
BasahinWhy Unix Time Ignores Leap Seconds
UTC occasionally inserts a leap second to stay aligned with the Earth's rotation, but Unix time pretends every day is exactly 86,400 seconds long. That deliberate simplification means a Unix timestamp is not a true count of elapsed seconds since the epoch — and it is the right trade-off for civil time.
BasahinYAML Block Scalars and Multiline Strings
YAML has two ways to write a multiline string, and they treat newlines differently: literal style keeps them, folded style turns them into spaces. Chomping indicators then decide what happens to the trailing newline. Getting these wrong is why an embedded script or certificate comes out subtly mangled.
BasahinFormatting, Minifying, and Canonical JSON
Whitespace does not change what JSON means, so pretty-printed and minified JSON are the same data. But when JSON is signed or hashed, the exact bytes matter, and that is where canonical JSON comes in: a deterministic way to serialize the same data to exactly the same string every time.
BasahinHexadecimal encoding (Base16), ipinaliwanag
Kung paano kinakatawan ng hexadecimal ang bawat byte gamit ang dalawang character, kung bakit ito ang default na paraan ng pag-print ng raw na byte, at kung paano ito kumukumpara sa Base64 at Base32.
BasahinRelative URLs and How They Resolve
A relative URL leaves out the scheme and host and is completed against a base URL. The rules for how a browser fills in the rest, and how ./ and ../ and a leading slash change the result, explain a lot of broken links and a few security surprises.
BasahinRoman Numerals: How the System Actually Works
Seven symbols, no zero, and one subtraction rule that arrived a thousand years after Rome. Why IIII is on your watch and IV is in your textbook, what IL breaks, and why the classical system runs out of road at 3999.
BasahinDeceptive URLs: Reading Past the Tricks
URLs are a favorite tool for phishing because the real destination is easy to disguise. The userinfo trick, redirect parameters, and look-alike characters all make a hostile link look friendly. This shows the common disguises and the one reliable habit for finding the real host.
BasahinPercent-encoding (URL encoding), ipinaliwanag
Kung bakit ineescape ng mga URL ang ilang character bilang %XX, kung aling mga character ang ligtas iwanan kung ano sila, at kung paano naiiba ang percent-encoding sa Base64.
BasahinTime Arithmetic and Time Zones: Exact Durations, Honest Meetings
Why 'plus one month' has no exact answer, what ISO 8601 durations actually promise, and how one UTC instant becomes four different wall clocks. The DST trap, the day-shift trap, and the case for planning meetings with a real date.
BasahinBase16, Base32, Base64 at percent-encoding, inihambing
Isang magkatabing tingin sa apat na text encoding: ang kanilang mga alpabeto, size overhead, pagiging nababasa, at kung kailan lalapit sa bawat isa.
BasahinHow text diff works
A diff finds the smallest set of insertions and deletions that turns one text into another. Underneath is the longest common subsequence: the lines both versions share, in order, form the unchanged backbone, and everything else is an add or a remove.
BasahinReading a diff
How to read a line-by-line diff: unchanged, added, and removed lines, the plus and minus markers, both sides' line numbers, inline word highlighting, and what ignore-whitespace and ignore-case actually change. Plus the things a diff cannot tell you.
BasahinWord and Character Level Diffs
A line diff marks a whole line as changed even when a single character moved. Word-level and character-level diffs highlight the exact part of the line that changed, which is far easier to read for prose, long lines, and small edits. This covers the difference and when each is the right lens.
BasahinThree-Way Diffs and Merge Conflicts
A normal diff compares two versions and cannot tell which one changed. A three-way diff adds a common ancestor, which is what makes automatic merging possible and what produces the <<<<<<< ======= >>>>>>> conflict markers. This explains the third input and how to read and resolve a conflict.
BasahinMinimal Edits: Why a Diff Can Look Wrong
A diff shows the smallest set of insertions and deletions that turns one text into the other. Because the smallest set is not unique and the algorithm has to choose, a diff can align lines in ways that look counterintuitive, blaming the wrong block or splitting a moved section. Knowing this makes odd diffs readable.
BasahinReading XML Structure
XML is a tree of elements built from a handful of parts: an optional declaration, elements with attributes, text, and a few special constructs. Once you can name each part and see how they nest, reading an unfamiliar document top to bottom becomes routine rather than a guessing game.
BasahinXML Namespaces Explained
When two XML vocabularies use the same element name for different things, namespaces keep them apart by binding a prefix to a unique URI. The prefix is just a local shorthand; the URI is the real identity. Understanding that split resolves most namespace confusion.
BasahinWell-Formed vs Valid XML
Well-formedness is XML's baseline: one root, properly nested and matched tags, quoted attributes, and escaped specials. Validity is a stronger, separate claim that a document also follows a schema. A parser rejects ill-formed XML outright, which is why these rules come first.
BasahinCDATA, Comments, and Processing Instructions
Not everything in XML is an element. CDATA sections hold raw text that would otherwise need escaping, comments annotate without affecting content, and processing instructions carry directions for an application. Recognizing these three keeps them from looking like mysterious noise.
BasahinHTML Forms and Request Encoding: How the Web Ships Your Input
A form is a contract between a page and a server: which fields, which verb, which wire format. GET puts the answers in the URL; POST puts them in the body; and enctype picks the body's dialect - urlencoded's key=value chains, multipart's boundary-delimited parts built for files. What each choice means for logs, caches, size limits, and debugging, plus the fetch-era footnote: FormData kept the formats alive after forms stopped being the only sender.
BasahinURI, URL, URN: What's Actually the Difference?
The three acronyms everyone uses interchangeably encode one clean idea: identify vs locate vs name. URI is the umbrella - any identifier in the standard grammar; URL is the identifier that also tells you where and how to fetch; URN was the scheme for pure, location-free names (urn:isbn:...). Why the W3C itself declared the classical trichotomy obsolete, what 'URI' means in specs vs 'URL' in conversation, and the naming lesson this site keeps collecting.
Basahin