yceffort
17 POSTS

Browser 1

  • ◆ Improving number-flow · Part 4
    #web-performance#animation#debugging

    How Far Will Agents Fix number-flow?

    I compared number-flow as fixed by five coding agents against my fork v0.2.1 once more. Performance reports changed with the font, the code went through a review with the authors hidden, and a follow-up experiment ended with keeping the mask default.

    Updated 31 min read
  • ◆ Improving number-flow · Part 3
    #web-performance#browser#debugging

    Reducing Forced Synchronous Layout in the number-flow Update Path

    Every time the value of number-flow changed, style and layout were being recalculated several times over. This post records the performance change observed after 0.2.1 reordered how the library reads and writes the DOM, and the costs that remain.

    Updated 26 min read
  • ◆ Core Web Vitals 직접 수집하기 · Part 3
    #web-performance#devops#debugging

    Sending the Core Web Vitals of an App Webview to a Shared Observability Platform

    Sent the Core Web Vitals measured in an app webview to an observability platform shared by many teams. The webview gave no signal on leaving, and tail sampling, delta-to-cumulative conversion and Tempo queries each dropped values in their own way without raising an error. For every setting that could not be changed, re-measured what was lost in a reproduction environment.

    Updated 37 min read
  • ◆ Core Web Vitals 직접 수집하기 · Part 2
    #web-performance#debugging#browser

    Sending Core Web Vitals at the Moment of Leaving the Page

    Traced why CLS and INP go missing when the page is left, through the transport of OTel JS and the order in which flush runs.

    Updated 22 min read
  • ◆ Core Web Vitals 직접 수집하기 · Part 1
    #web-performance#debugging#browser

    When Does web-vitals Report Core Web Vitals

    Checked the conditions under which web-vitals 6.2.3 reports each metric, and why INP goes missing when the page is left right after a click.

    Updated 33 min read
  • ◆ Improving number-flow · Part 2
    #web-performance#animation#browser

    Improving number-flow Performance: Moving Animations onto the Compositor Thread

    In the number-flow fork I built to support old browsers, animations in modern browsers were still recalculating styles on every frame. In 0.2.0 I moved the motion built with additive compositing into transform and opacity keyframes, but costs remain in the mask and in interruptions.

    Updated 24 min read
  • #pwa#caching#service-worker

    Saving Marp Slides from a Next.js App for Offline Use

    I built offline saving into a Marp slide viewer. This post follows the process from the first attempt to run the existing viewer offline as-is to fixing, one at a time, the problems that deploys, networks, and the presenter window exposed.

    Updated 23 min read
  • #web-performance#javascript#browser

    I Grew Never-Executed JavaScript to 10MiB

    How much do you lose when 10MiB of functions you never call ships to the browser? I ran 855 measurements to separate the cost of file size from the cost of code shape. Uncalled declarations cost about 21ms per MiB, while initialization code that runs the moment the file is read took 201ms per MiB on the main thread. With real libraries, merely importing a module was enough to evaluate it.

    32 min read
  • #browser#design-patterns#css

    Running One Web on Multiple WebViews: Folding Environment Branches into Adapters

    We supported the iOS and Android WebViews of our own app and of a partner app, and gathered the scattered environment branching into adapters. The post covers how we organized insets, the bridge, and CSS, and the problems we hit with the SSR seed and hydration.

    Updated 27 min read
  • ◆ Service Worker Caching Deep Dive · Part 3
    #service-worker#web-performance#caching

    Measuring the Cost of Going Through a Service Worker: Building in the Lab the Control Group GA4 Could Not Give Me

    I set out to confirm the 500 ms that part 2 left as the cost of going through the worker, but the hard reloads that would form the control group arrive at under one a day. With a control group built from Playwright and a shaping proxy, going through the worker cost 2 ms on a navigation. Most of the extra time on a post click came from the worker saving the post HTML in the background over the same connection, and the gap between lab and field data was a measurement definition difference caused by 103 Early Hints.

    Updated 50 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. My guess at the cause from reading the code was overturned twice by measurement, and in the end a single easing function removed the reflow.

    30 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

    This post covers the service worker material that did not fit into the cache chapter of Frontend Performance Optimization Deep Dive (published in Korean). It works through why caches go stale, why the old version shows up after a deploy, what to store under which strategy, and whether you should use one at all, and measures a 104KB opaque response being counted as 6.6MB of storage.

    Updated 24 min read
  • ◆ Improving number-flow · Part 1
    #browser#animation#oss

    Porting number-flow to Old Browsers: Five Decisions and Two Reversals

    number-flow turns animations on starting from Chrome 125 and Safari 17.2. While building a fork that lowers this floor to Chrome 66 and WebKit 16.4, I reversed two decisions, and after investigating a Safari bug I gave up on automatic downgrading.

    Updated 26 min read
  • #animation#react#browser

    React's <ViewTransition>: Browser-Native Animation, Done the React Way

    What happens when React wraps the View Transition API

    16 min read
  • #memory#web-performance#design-patterns

    Preventing Memory Leaks with IntersectionObserver Singleton Pattern and WeakMap

    How to efficiently observe hundreds of elements while preventing memory leaks

    13 min read
  • #browser#web-performance#ai

    WebGPU Is Finally Available in Every Browser

    In July 2025, the browser GPU API changed generations for the first time in 14 years

    12 min read
  • ◆ Web Service Performance Analysis · Part 4
    #web-performance#browser

    Web Service Performance Analysis (4)

    If you find yourself thinking "maybe I should try this too..." — reach out right now!!

    21 min read