Page 2 (English) | yceffort

20 POSTS

Page 2

◆ OG Scraping Server Design Notes · Part 1
#web-scraping#backend#nodejs
Building an OG Scraping Server in Node.js (1): From Runtime Choice to Error Rate and Latency
The "10% error rate" of a link preview server is a single number that five different kinds of failure got mashed into. This post works out why this workload is I/O bound at that TPS, where runtime choice actually diverges across four points, and then moves on to lowering the error rate with User-Agent and encoding. Node built-in TextDecoder turns CP949 extension characters into different characters without raising an error, and a scraped og:title is not an API response but user input. It also covers cache stampedes, negative caching, and a two-million-run simulation that verifies "P95 under one second" by working backwards from the cache hit rate. The first post of a two-part design note on OG scraping servers.
2026-08-2233 min read
#debugging#bundler#nextjs
Next.js Turbopack Turned One Singleton into Two: A Scope Hoisting Bug and a Circular Import
In a Next.js 16 Turbopack production build, a module-scope singleton became two live instances at runtime. Inside the same synchronous block, one condition contradicted the other, and responses that arrived in 30ms still timed out. This is the record of tracing the cause through the bundle output: a partial scope hoisting merge, a circular import, an upstream bug that had already been fixed, and the single-variable experiment I ran too late.
2026-08-1916 min read
#animation#web-performance#debugging
Killing Frame Drops in a framer-motion Banner: Two Wrong Turns and One Easing Function
A banner built with framer-motion made the entire home screen stutter for the 0.6 seconds it took to open. The record of guessing the cause from the code, having that guess overturned twice by measurement, and finally removing the reflow with a single easing function. Plus what the work left behind: the gap between declaration and execution, the principle that properties decide performance, preserving mechanisms, suspecting your instruments first, and proving sameness with a curve.
2026-08-1530 min read
◆ Service Worker Caching Deep Dive · Part 1
#service-worker#caching#browser
How Service Worker Caching Works: The Proxy, the Lifecycle, and Five Strategies
A service worker is a programmable proxy standing between your site and the network. Where does it stand, why does the cache rot, why am I seeing the old version after deploying, what goes in under which strategy, and so, should you use it? Holding on to five questions you actually meet in practice, this post goes down to the details of state transitions and to a real measurement in which a 104KB opaque response was accounted as 6.6MB of storage. It is the general theory that did not fit into the cache chapter of Frontend Performance Optimization Deep Dive (published in Korean), and the first post of the Service Worker Caching Deep Dive series.
2026-08-12Updated 2026-09-0224 min read
◆ Improving number-flow · Part 1
#browser#animation#oss
Porting number-flow to Old Browsers: Five Decisions and Two Reversals
The minimum versions where number-flow turns animations on are Chrome 125 and Safari 17.2. A record of the decisions made while building a fork that lowers this floor to Chrome 66 and WebKit 16.4, the two judgment calls I ended up reversing, and the Safari bug investigation that made me give up on automatic downgrading.
2026-08-11Updated 2026-10-0726 min read
#typescript#blogging#npm
What Happens When You Install typescript@7: A Blog Monorepo Migration Log
I dropped typescript 7.0.2 into a monorepo where pnpm lint took 12 minutes 32 seconds. Type checking passed quietly, but next build broke and lint crashed. A record of the chain reaction from one day of swapping eslint and prettier for oxlint and oxfmt, with before-and-after measurements. To say it up front, the build did not get any faster.
2026-08-1011 min read
◆ Kubernetes for Frontend Developers · Part 5
#kubernetes#devops#web-performance
Autoscaling Is Automatic but Not Instant: HPA's Timeline, Measured Segment by Segment
Raise traffic 12x and it takes 31.5 seconds for a new pod to receive its first request. I pulled an itemized bill for those 31.5 seconds with a stopwatch: the structure dominated by the detection window, the conditions under which the autoscaler goes blind in the five minutes right after a deploy, the scale-down staircase, why memory-based HPA misfires on Node, and KEDA's preemptive scaling. Part 5 of the Kubernetes for frontend developers series.
2026-08-1025 min read
◆ Kubernetes for Frontend Developers · Part 4
#kubernetes#devops#debugging
How Do Pods Terminate? Measuring the Causes and Fixes of Deploy-Time Errors
Even a deploy that changes not a single line of code leaks errors. This is a measured record of tagging every failure that leaks during rolling deploys by type and timestamp, performing an autopsy on four causes, and stacking prescriptions one layer at a time until the count reaches zero. Includes the actual Next.js shutdown code, hostage draining, and the real CrashLoopBackOff timetable. Part 4 of the Kubernetes for frontend developers series.
2026-08-08Updated 2026-08-0920 min read
◆ Kubernetes for Frontend Developers · Part 3
#kubernetes#networking#devops
How Does Traffic Reach My Pod? From ClusterIP to port-forward
A Service's ClusterIP is an IP attached to no machine, yet curl reaches it. iptables rules and conntrack, EndpointSlice, cluster DNS and ndots, Gateway, and port-forward: a record of opening up the entire path a request takes to a pod, directly in a kind cluster. Part 3 of the Kubernetes for frontend developers series.
2026-08-0627 min read
◆ Kubernetes for Frontend Developers · Part 2
#kubernetes#docker#devops
How My Next.js App Becomes a Pod: A Record of Opening Up Containers and Pods
The same Next.js app produced one 1.72GB image and one 208MB image. This post traces the missing 1.5GB back through the layers, and verifies with PIDs and cgroup files that a container is an isolated process. The second post of the Kubernetes for frontend developers series.
2026-08-05Updated 2026-08-0919 min read
◆ Kubernetes for Frontend Developers · Part 1
#kubernetes#devops
A Kubernetes Concept Map for Frontend Developers: From Pods to Autoscalers
The Kubernetes vocabulary and structure that frontend developers running SSR actually encounter, organized in the order of real work: the overall cluster structure, what makes up a deploy, pod state and resources, the traffic path, and autoscaling. The first post of the series and the reference map for the rest.
2026-08-05Updated 2026-08-0922 min read
◆ Kubernetes for Frontend Developers · Part 6
#memory#nodejs#kubernetes
Why Is Your Node.js Pod That Size? Sizing Measured Firsthand, from NODE_OPTIONS to Pod Count
I added one GC tuning flag to the same workload and peak RSS jumped from 201MB to 593MB, while the live data stayed the same. This post traces back through V8 New Space with direct measurements to show why that result is exactly what should happen, and lays out the three axes frontend developers can use to size a Node.js pod.
2026-08-03Updated 2026-08-0945 min read
#essay#ai#design-patterns
Where Frontend Came From, and Where It Goes After Agents
Why the layers piled up, why we returned to the server, and why the stack survives even after agents. And why the survival of a stack and the value of the people who know it are two separate things
2026-07-22Updated 2026-10-1918 min read
◆ Judgment in the AI Era · Part 3
#essay#ai#career
When Was the Last Time You Read Code Seriously?
The friction that made judgment expensive is the same friction that taught it. Why the skill growing most valuable in the AI era is the one being cultivated least
2026-06-21Updated 2026-10-1913 min read
◆ Judgment in the AI Era · Part 1
#ai#essay#career
If the Code Meets Spec and the Bugs Get Fixed, Does It Matter That You Can't Read It?
If the spec is satisfied and the bugs get fixed, do you still need to be able to read the code? Understanding doesn't disappear: this essay traces where it moves.
2026-06-1221 min read
◆ Judgment in the AI Era · Part 2
#ai#essay#software-engineering
If AI Erases the Boundaries Between Planning, Development, and Design, What Remains?
The claim that job boundaries are collapsing is only half true. What collapses is production; judgment and responsibility remain.
2026-06-12Updated 2026-10-1920 min read
#react#caching
React cache() Deep Dive: Request-Scoped Memoization, Read from the Source
Every odd rule of React's cache() falls straight out of a ~30-line implementation. We trace the dispatcher, getCacheForType, and the WeakMap/Map tree at the source level to see exactly how request-scoped memoization works.
2026-05-30Updated 2026-06-0322 min read
#security#ci-cd#npm
The TanStack npm Supply Chain Attack: Why pull_request_target Is Dangerous
Analysis of the @tanstack/* supply chain incident. The risks of pull_request_target, GitHub Actions cache, and OIDC trusted publishers, and how to defend against them.
2026-05-1624 min read
#oss#ai#essay
Bun rewrite Exposed Something: OSS Could Only Stop External AI
Bun moved roughly 960,000 lines from Zig to Rust in six days using Claude Code. The meaning here is not code quality but OSS governance and resource asymmetry.
2026-05-15Updated 2026-05-1928 min read
#npm#essay#oss
What makes a package you can keep using for years different
A good package has to be user-friendly not just in features, but in dependencies, version bumps, compatibility, and release policy.
2026-05-0920 min read