Articles & Guides
Original tutorials and hands-on guides about encoding, encryption, networking and productivity — each paired with an online tool.
Jev generates no text: it turns decisions into structured values software can use directly. What it is, why it appeared, and when not to use it.
There is no universally best option, only a scenario-matched one. Compare privacy, capability, cost and ops — plus a practical hybrid path.
A model does not know your internal docs or recent events. The minimal RAG pipeline, context-window trade-offs, and five common pitfalls.
Same prompt, different result? The requirement was never constrained. Five prompt modules, few-shot examples, and hard output rules.
Hallucination cannot be prompted away. Four high-risk scenarios and a six-step checklist: models propose, tools and humans confirm.
Copy-pasting is not "using AI". A four-step workflow for turning an LLM into a pair programmer: context, decomposition, evidence, verification.
Retries turn a blip into an avalanche when idempotency and budgets are missing. Three timeout layers, retryable errors, jittered backoff, idempotency keys.
Not all datacenter routes perform the same. Reading the ASNs in a traceroute tells you whether traffic uses CN2, 163, 9929 or CMI.
Wrong branch, deleted branch, overwritten work? Recovery through reflog, everyday commands, and three rules for teams.
Positional notation explains every base conversion in one idea — and why #FF5733 is just hex. Big-number and float pitfalls included.
401 vs 403? 301 vs 308? Status code confusions, four caching headers, and ready-to-use strategies for assets, HTML and APIs.
Watermarks do more than stop reposting: attribution, tracing and branding. Choosing a style and cleaning privacy data before upload.
Reusable recipes for emails, phone numbers and log dedup — plus greedy vs lazy, groups, lookaround, catastrophic backtracking, and when not to use regex.
Ten digits or thirteen? Why timestamps never change with timezones? How Unix time works and where conversions go wrong.
Mojibake is not lost data — it is bytes read with the wrong rule. Character sets vs encodings vs byte order, common symptoms, and a four-step fix.
Why does a space become %20 or a plus sign? The difference between encodeURI and encodeURIComponent, and the root of mojibake.
Three steps to verify the SHA-256 checksum of a downloaded file, plus the most common comparison mistakes.
Trailing commas, single quotes, comments, unquoted keys — the usual reasons JSON validation fails, plus a fast debugging routine.
Adding symbols is not always stronger. Password strength is about entropy — and length matters most. Practical rules and myths.
Five fields or six? What happens when day-of-month and day-of-week are both set? Cron formats and frequent mistakes.
Encoding your password with Base64 does not make it safe. The real difference between encoding, encryption and hashing.
Can an IP locate your doorstep or reveal your name? The real limits of IP lookups, plus common privacy misconceptions.
Poor accuracy is rarely the engine alone: resolution, skew, contrast and language packs all matter. A checklist you can apply today.
A JWT is not encrypted: anyone holding it can read the payload. Its three segments, signing vs encryption, and what never to put inside.
Three kinds of crypto work together in every HTTPS connection: asymmetric key exchange, symmetric encryption, hashing. Step by step.
Asymmetric crypto is not for bulk data. Key-size equivalents, RSA vs ECC trade-offs, and the split between encryption and signing.
AES is just a block cipher: the wrong mode or a reused IV breaks it. How GCM and CBC differ, and how to use them correctly.
Why SHA-256 is not enough for password storage: what salting fixes, what slow hashing fixes, and how to size bcrypt/Argon2.
A UUID is not just a random string. v1, v4 and v7 differ in time semantics, information leakage and index performance.
Why does one colour have three notations? When HSL helps most, when contrast matters, plus a WCAG cheat sheet.
Uploading a file to a server and computing it in your browser have very different security boundaries. Comparing both architectures.
Why piles of UI end-to-end tests are slow and flaky. The unit / integration / e2e ratio and where to spend effort.
An image is read-only, a container is a running instance. Layers, size optimization, and why data belongs in volumes.
You cannot fix what you cannot see. The distinct roles of logs, metrics and traces, and how to pinpoint failures fast.
Why the browser blocks cross-origin requests. Same-origin policy, simple requests vs preflight, and common misconfigurations.
Collect minimally, don't store secrets in plaintext, support erasure. Compliance is not just legal's job; it starts at data modeling.
How to change an API without breaking old clients. URL vs header vs media-type versioning, plus deprecation and migration cadence.
Some patterns explode exponentially on certain input. Why nested quantifiers are dangerous, how to spot and avoid them, plus a timeout fallback.
UUID v4 is random, v1 carries time. Pros and cons as a primary key, and why "not unique" is not the same as "guessable".
What each color model is for. HEX is just RGB in hex, why HSL is better for tweaking, and how alpha is represented.
What the number after the slash means: subnet masks, private ranges, and how to tell if two IPs are on the same network.
Caches absorb load but also serve stale data. Cache-key design, TTL strategy, and the three failure modes: penetration, stampede, avalanche.
String-built SQL is the most common breach entry. How injection works, why parameterized queries win, and the limits of ORMs and escaping.
Use Base64 only to put binary into a text channel. It is not secret, it grows the size, and here is where it is misused.
MD5 / SHA are wrong for password storage. Salting and slow hashes like bcrypt / Argon2, plus what to do on a leak.
Unvalidated input is where bugs and injection enter. What JSON Schema can and cannot do, plus where in the stack to apply it.
HTTPS is HTTP plus TLS, not a new protocol. What certificate validation checks, common myths, and why internal traffic needs it too.
Make review useful, not noise: give context, constrain output, separate facts from guesses, and respect the privacy line for private code.
When a model reads web pages, email and documents, attackers can plant instructions inside them. Direct vs indirect injection, plus a defence checklist.
Backup is not the goal; recovery is. The 3-2-1 rule, RPO/RTO, verification and restore drills, plus the most common failures.
Edge cases and trade-offs of four rate-limit algorithms, plus distributed counting, 429s and retry backoff.
What HSTS, CSP and X-Content-Type-Options actually protect, plus a launch-day checklist you can copy.
Photos, screenshots, icons and animations each want a different format. Lossy vs lossless, transparency, animation, and where to set quality.
Why a 6-digit code helps, and what it does not. TOTP internals, three tiers of 2FA strength, and how to use them well.
The same character has several representations, so naive comparison fails. NFC, NFD and NFKC explained, plus correct storage, comparison and hashing.
When does a change deserve a MAJOR bump? What is the difference between ^ and ~? Version semantics, the 0.x rules, and four dependency traps.
Why set -euo pipefail is standard, how $var differs from "$var", and the four places scripts most often break.
Why ed25519? How to write a useful ~/.ssh/config? Key deployment, host aliases, and four common pitfalls.
What do 755, 644 and 600 mean? Why is the execute bit special on directories? Three identity groups, octal notation, and five frequent mistakes.
CPU-bound or IO-bound? Need isolation? Compare four concurrency models across key dimensions, with a selection order and common traps.
Retransmit or not? Ordering? Jitter tolerance? Compare TCP and UDP across five dimensions, and what you must rebuild on top of UDP.
What A, AAAA, CNAME, MX and TXT each do, the cache chain a lookup walks, how to pick TTLs, plus debug commands and three common traps.
From typing a URL to a rendered page: parsing, DNS, connecting, sending, processing, responding, sub-resources — plus where time goes and how to debug.
One server certificate is not enough: the browser must follow the chain to a root it trusts. Chains, intermediate certs, trust anchors and common mistakes.
Do not push the new version to everyone at once. Canary by percentage, blue-green instant switch, and how to roll back fast.
Polling wastes requests, long-polling is semi-real-time, WebSocket is a bidirectional long connection. When each fits, plus heartbeat and reconnect.
Requests are routed to the nearest edge node. DNS-based routing, cache hits versus origin fetch, purge and prefetch, and what belongs on a CDN.
A forward proxy represents the client going out; a reverse proxy represents the server facing users. Position, use, and the gateway role.
Head-of-line blocking, multiplexing, header compression. HTTP/2 gains, and why HTTP/3 moves to QUIC over UDP.
Endless retries on a slow downstream only cause an avalanche. The three breaker states, half-open probing, and serving a fallback instead of blocking.
The producer drops a task in the queue and returns; the consumer handles it later. Async, peak buffering, decoupling, plus duplicate and ordering caveats.
Without an index the database scans the whole table. B+tree indexes, the return-to-table step, leftmost prefix, and why more indexes are not always better.
Processes isolate, threads share memory, coroutines schedule in user space. Their costs, switching overhead, and when to favour coroutines or async.
Why "log in with WeChat" never gives your password to the app. The authorization-code flow, access vs refresh tokens, and what PKCE adds.
Cookies live in the browser, sessions on the server. How login state relies on both, why JWT is mistaken for a session, and the security flags.
GET can be cached, sits in history, has length limits; POST carries a body and is not cached. Semantics, safety, idempotency, and when it matters.
Treat things as resources and HTTP methods as actions. Resources, status codes, pagination, versioning, and the verb-in-path anti-pattern.