Tagged articles
frontend performance
98 articles · Page 1 of 1
This article explains the mathematical foundations of JPG and PNG compression, compares their strengths and weaknesses, provides a decision tree for format selection based on use cases, and outlines modern delivery practices using WebP, AVIF, and content negotiation.
AVIFContent NegotiationDCT
0 likes · 23 min read

TanStack Table v9 transforms a React‑centric table library into a framework‑agnostic Table Engine that supports nine major frontend frameworks, offering a single core for sorting, filtering, pagination, virtual scrolling and more, while delivering up to 90% memory savings and 40‑70% performance gains for large‑scale data grids.
Feature ArchitectureTable EngineTanStack Table
0 likes · 8 min read

Vite 8.1 introduces Bundled Dev Mode to address the scaling limits of its unbundled development approach, showing up to 15× faster cold starts and 10× quicker full refreshes in massive React apps, while also unveiling architectural shifts to Rolldown and several experimental features.
Bundled Dev ModeChunk Import MapRolldown
0 likes · 9 min read

The author recounts how using Codex to analyze JavaGuide's performance triggered a site-wide outage, then details the step‑by‑step investigation—from cache misconfigurations and hashed asset handling to a VuePress hydration bug—and shares practical lessons on combining AI assistance with disciplined engineering practices.
AI debuggingCDNClaude
0 likes · 13 min read

WebAssembly extends JavaScript by handling heavy computation, binary processing, cross‑language reuse, and secure sandboxing, making it a practical engineering tool for performance‑critical, privacy‑sensitive, multi‑platform, and plugin‑based web applications while complementing rather than replacing JavaScript.
JavaScript complementWASM use casesWebAssembly
0 likes · 12 min read

Pretext, a TypeScript‑based text layout engine, eliminates the need for DOM measurements by using canvas.measureText and Intl.Segmenter, delivering sub‑0.05 ms height calculations, preventing layout thrashing, and simplifying scenarios like chat bubbles, masonry grids, AI interfaces, and virtual lists.
Intl.SegmenterPretextcanvas.measureText
0 likes · 5 min read

Anthropic engineers replaced SSR with a Vite‑based static stack for Claude.ai, deploying to edge workers and achieving a 65% reduction in p75 TTFB and a 50% faster prompt display, while illustrating why SPA‑oriented AI chat apps may forgo server‑side rendering.
Claude AIEdge WorkersSSR
0 likes · 7 min read

WebGPU and WebAssembly together break the performance ceiling of traditional JavaScript‑WebGL stacks, enabling native‑grade GPU compute, multithreaded workloads, and real‑time AI, video, and 3D rendering in browsers, while offering practical optimization techniques, code examples, and a roadmap of challenges and future trends.
GPU computeWebAssemblyWebGPU
0 likes · 14 min read

The article outlines Vue’s next‑generation Vapor Mode—a compilation strategy that removes the virtual DOM, introduces fine‑grained reactive tracking, and promises faster updates, smaller bundles, and a smoother developer experience for the anticipated Vue 4.0 release.
JavaScriptReactive SystemVapor Mode
0 likes · 5 min read

Web Workers, an often‑overlooked browser API, enable JavaScript to run heavy computations in background threads, freeing the main UI thread, boosting multi‑core utilization, improving memory management, and powering use‑cases such as big data processing, image filtering, AI inference, and encryption, dramatically enhancing frontend performance.
JavaScriptMultithreadingPerformance Optimization
0 likes · 5 min read

Vue 3.6 introduces an experimental Vapor Mode that eliminates the virtual DOM by moving update calculations to compile time and using element‑level targeted updates, promising higher performance while raising concerns about compilation overhead and bundle size.
VDOMVapor ModeVue
0 likes · 8 min read

This article explains Vue 3’s v‑memo directive, how it conditionally skips component updates by tracking dependency arrays, and demonstrates its use to dramatically reduce rendering costs in large v‑for lists compared to traditional v‑if/v‑show approaches.
DirectiveVue.jsfrontend performance
0 likes · 4 min read

This article systematically explores front‑end performance optimization across loading, runtime, build, and network stages, offering practical techniques such as resource compression, code splitting, tree shaking, CDN acceleration, render‑blocking reduction, lazy loading, Web Workers, and monitoring tools to dramatically improve page speed and user experience.
Code Splittingcdn accelerationfrontend performance
0 likes · 19 min read

This article explores the challenges of traditional monitoring in cross‑platform front‑end development and presents Hippy Monitor’s plugin‑based architecture, intelligent sampling, multi‑environment configuration, and AI‑driven roadmap as a comprehensive solution for full‑chain observability and proactive performance management.
AI-driven opsPlugin Architecturecross-platform monitoring
0 likes · 18 min read

Facing the challenges of a billion‑user membership platform, we analyzed front‑end performance metrics, applied resource slimming, lazy loading, network optimizations, and SSR/pre‑rendering techniques, achieving up to 73% LCP reduction and dramatically improving page load speed and user retention.
Resource OptimizationSSRfrontend performance
0 likes · 15 min read

This article explains why Chinese web fonts can be huge, compares TTF and WOFF2 sizes, and provides practical steps—including font subsetting with Python fontTools and on‑the‑fly loading via the FontFace API—to reduce font files from megabytes to a few kilobytes and dramatically speed up page rendering.
Font SubsettingPythonWOFF2
0 likes · 9 min read

Tree shaking in React.js leverages ES6 static imports and named exports to eliminate dead code, reducing bundle size and improving load performance, while best practices such as modular design, avoiding side effects and dynamic imports ensure optimal dead‑code elimination across components and libraries.
ES6 ModulesReact.jsbundle size
0 likes · 7 min read

This article reviews the evolution of skeleton screens, explains their underlying principles, shares real-world case studies from Huolala, and provides practical guidelines for creating responsive, fine‑grained, and visually appealing skeleton screens that improve perceived performance without sacrificing actual load speed.
User Experiencefrontend performanceloading optimization
0 likes · 15 min read

For small front‑end projects, the Vite + Svelte stack replaces heavyweight Vue with a lightweight solution that delivers near‑instant hot‑module replacement, 38 % smaller bundles, roughly 46 % faster first‑contentful‑paint and 14 % quicker startup, while requiring only a few days to become productive.
Build ToolsSvelteVite
0 likes · 16 min read

The article explains why browsers limit concurrent connections per domain for performance and security reasons, compares HTTP/1.1 and HTTP/2 handling of these limits, and outlines practical frontend optimization strategies such as domain sharding, CDN usage, resource bundling, and lazy loading.
HTTP/2Optimizationbrowser
0 likes · 5 min read

This article analyzes Meituan's Recce solution for dynamic front‑end containers, detailing performance bottlenecks, architectural classifications, interpreter and language choices, UI framework design, rendering layer decisions, optimization techniques, and future directions to achieve native‑level speed while retaining dynamic capabilities.
RecceRustUI framework
0 likes · 28 min read

This article explains a lightweight approach to detecting and reporting front‑end white‑screen incidents, outlines common scenarios, describes a sampling detection algorithm using document.elementsFromPoint, and provides practical guidelines for handling edge cases and reducing false alarms.
error-detectionfrontend performanceweb reliability
0 likes · 12 min read

The MTSC 2024 Shanghai conference gathered top testing experts to discuss AI‑driven testing, full‑chain 3D rendering ecosystems, UI automation for graphics software, and front‑end performance assurance, offering a comprehensive look at emerging quality‑assurance practices and future collaborations.
3D renderingAI testingconference recap
0 likes · 3 min read

This article explores React 19's new React Compiler, explains how it automatically memoizes components to cut redundant renders, and walks through three practical examples that compare its behavior with traditional React.memo, useMemo, and useCallback techniques.
Next.jsReactReact Compiler
0 likes · 8 min read

This article outlines the challenges of front‑end performance troubleshooting for a 2D design tool, proposes systematic approaches for identifying issues, describes monitoring metrics such as load time and frame rate, and presents real‑world case studies demonstrating effective optimization and baseline management.
MetricsPerformance Monitoringfrontend performance
0 likes · 11 min read


ByteFEMay 29, 2024 · Frontend Development
This article details a comprehensive set of frontend performance optimization techniques—including startup speed, resource loading, CPU/GPU rendering, dynamic FPS, batch merging, Spine animation, and memory profiling—applied to the 2024 Douyin Laughing China Year interactive projects to improve FMP, reduce draw calls, and prevent overheating and crashes on mobile devices.
Spine optimizationbatch mergingdynamic FPS
0 likes · 16 min read

The Growth Frontend Team’s self‑developed afx transparent‑video solution splits RGB and alpha channels, caches videos via IndexedDB, and leverages OpenGL to deliver high‑fidelity, low‑cost animations in WebView with up to 60 FPS, cutting development time by 75 %.
Alpha ChannelOpenGL renderingVideo Optimization
0 likes · 8 min read

This article explains the image‑processing workflow used for the Double Eleven event, covering format selection, CDN scaling and quality parameters, WebP conversion, practical URL suffix rules, and additional front‑end tips that together dramatically improve page load speed and user experience.
CDNFrontend DevelopmentResponsive Images
0 likes · 10 min read

The case study details how the Cloud Editing team tackled severe waveform loading delays, zoom lag, and inefficient IndexedDB storage by refactoring the processing pipeline, standardizing multi‑transaction storage, adding monitoring and cleanup tools, and rigorously testing releases, ultimately cutting processing times by over half and dramatically improving user experience.
IndexedDBTechnical Case Studyaudio processing
0 likes · 9 min read

This article details the design evolution and performance optimization of Vivo's Agile BI cross‑tab component—from a jQuery prototype to a React‑based solution—highlighting worker‑offloaded preprocessing, virtual scrolling, and micro‑frontend integration that enable sub‑second rendering of massive data sets and match or surpass competing BI tools.
Cross TabReactVirtual Scroll
0 likes · 16 min read

This article explores code‑level front‑end performance optimization, covering how CSS can replace JavaScript for animations and components, deep analysis of JS constructs like if‑else, switch and loops, front‑end algorithms, diff‑algorithm tricks, and low‑level computer concepts such as memory caching and bitwise operations.
CSS AnimationJavaScript optimizationfrontend performance
0 likes · 18 min read

This article explains how to use the four resource‑hint APIs—prefetch, preload, preconnect, and DNS‑prefetch—along with the crossorigin attribute and a custom npm tool (resource‑hint‑generator) to dramatically reduce page load times, improve web‑vitals, and increase cache‑hit rates, providing code examples, tables, and validation steps.
Preconnectfrontend performancenpm
0 likes · 17 min read

This article presents a detailed case study on how Qunar's front‑end team reduced the Time to Interactive of the hotel‑detail page by introducing pre‑fetching, cache‑key redesign, view‑model batching and longer cache lifetimes, achieving up to a 70% TTI improvement on Android devices.
Mobile AppTTIcaching
0 likes · 10 min read

This article explains Cloudflare’s new Fragments Architecture for micro‑frontends, detailing how parallel, streaming responses from Workers eliminate common bottlenecks, provide eager interactivity, improve security, and achieve extreme first‑paint performance through innovative fragment hosting and communication mechanisms.
Cloudflare WorkersMicro Frontendsfragment architecture
0 likes · 14 min read

ice.js 3 merges MPA and SPA concepts to deliver per‑page HTML, parallelizes block and data loading, introduces SSG and out‑of‑the‑box SSR with streaming and Server Components, supports multi‑end development, and upgrades the runtime with swc and esbuild to dramatically improve web performance and developer experience.
ReactSSRfrontend performance
0 likes · 17 min read

This article explains how to create a Vite plugin that persists the module graph cache across dev‑server restarts, uses ETag comparison to serve 304 responses, and integrates custom middleware to dramatically improve first‑page load times in development mode.
dev serverfrontend performancemoduleGraph
0 likes · 11 min read

This article explains why virtual lists are needed for long scrollable data, defines the concept, walks through a step‑by‑step implementation for fixed‑height items, extends the solution to handle variable heights, and shares practical tips and code snippets for Vue developers.
Vuedynamic heightfrontend performance
0 likes · 11 min read

This guide details how a massive music‑artist web application reduced its full build time from 140 seconds to 55 seconds and its incremental compile time from up to 80 seconds down to about 1 second by migrating from Webpack 4 to Webpack 5, including preparation steps, configuration changes, and common pitfalls.
Build OptimizationJavaScriptfrontend performance
0 likes · 17 min read

This article explores typical big-data use cases such as real-time bullet comments and massive server-side data lists, analyzes why rendering thousands of DOM elements can cause page lag, and presents front-end solutions—including dynamic element creation, document fragments, and virtual scrolling libraries—to improve performance.
DOM optimizationReactVue
0 likes · 9 min read

This article explains the bundle‑less approach—including splitting bundles, no‑bundle development, and modular dependency distribution—presents performance tests that suggest an optimal chunk count of 10‑25, evaluates Vite’s advantages and drawbacks, and outlines a self‑built import‑map‑based solution with code examples.
Vitebundle-lessesbuild
0 likes · 19 min read

This comprehensive guide walks you through the entire front‑end performance optimization lifecycle—from understanding why performance matters and setting measurable goals, to building metrics, implementing concrete strategies across caching, networking, rendering, and finally validating results with monitoring and retrospectives.
Performance Monitoringcritical rendering pathfrontend performance
0 likes · 18 min read


ByteFEJul 8, 2022 · Frontend Development
This comprehensive frontend development digest explores the evolution of JavaScript frameworks, introduces WebAuth for secure authentication, details browser rendering principles and performance optimization, examines ES2022 features and Module Federation, and provides practical insights into web image handling and live streaming protocols.
ES2022HLS StreamingJavaScript
0 likes · 6 min read

This article explains a step‑by‑step method for troubleshooting a web page that fails to load after entering its URL, covering network checks, DNS resolution, TCP/HTTP handshakes, status‑code analysis, and front‑end resource inspection to pinpoint issues such as blocked CDNs.
CDNDNSWeb Debugging
0 likes · 5 min read

This article explains the various web caching mechanisms—including database, CDN, proxy, browser, and application‑level caches—why browser caching matters for performance, how ETag and Cache‑Control headers work, and practical checklist items for effectively managing cache in modern web applications.
Browser CacheCache ControlETag
0 likes · 12 min read

This guide explores systematic image optimization for web applications, covering formats like WebP, lossless vs lossy compression, lazy loading, placeholder strategies, format fallback, monitoring, and practical code implementations to reduce image size, memory usage, and improve loading speed and user experience.
CompressionResponsive ImagesWebP
0 likes · 18 min read

Alibaba Cloud Security’s front‑end team tackled the “1‑second battle” by redefining performance with the PCP metric and leveraging PWA techniques—service workers, skeleton screens, aggressive code‑splitting, and micro‑frontend architecture—to shrink perceived load times from seconds to sub‑400 ms across eight products.
PCP metricPWAService Worker
0 likes · 9 min read

This article explains the internal multi‑process structure of Chrome, covering CPU/GPU basics, browser and renderer processes, the benefits of process isolation, the step‑by‑step navigation flow, how the renderer parses, styles, layouts and composites pages, and how user input events are handled to keep interactions smooth.
Browser architectureChromeProcess Model
0 likes · 23 min read

This article explains how B‑end designers can quantify page experience using Google Core Web Vitals—introducing metrics such as Most Meaningful Paint, First Operation Delay, and Cumulative Design Difference—and provides practical steps for setting thresholds, collecting data, and continuously optimizing performance.
B2B designCDDFOD
0 likes · 9 min read

The T7 browser kernel’s ResourceScheduler lets developers assign importance=high to IMG tags and CSS background images (as well as JS and link resources), adjusting sub‑resource loading priority so critical images load faster on the first screen, especially when many concurrent requests compete for the same domain.
ChromiumT7-kernelbrowser-kernel
0 likes · 9 min read

This article explains how a large cloud‑based project reduced its 14‑minute Webpack build to a fraction of the time by upgrading Node, enabling Webpack 5's filesystem cache, adopting Rust‑based SWC, and applying advanced cache strategies such as unsafeCache, safeCache, and LRU management.
Build OptimizationNode UpgradeSWC
0 likes · 8 min read

This article analyzes why npm installations are slow, compares traditional flattening, pnpm, and cnpm approaches, and details Ant Group’s tnpm rapid mode optimizations—including server‑side dependency graphs, HTTP pre‑heating, tar merging, Rust‑based download, and a FUSE‑backed filesystem—that together achieve up to three‑fold speed improvements.
FUSERustdependency graph
0 likes · 21 min read

The article explains how browsers build render trees and use GPU‑accelerated compositing layers—created by properties like transform, will‑change, or media elements—to improve performance, avoid repaint glitches such as iOS timer flicker, and offers best‑practice tips for using these layers efficiently without excess memory use.
CSS OptimizationGPU renderingbrowser rendering
0 likes · 10 min read

This article explains the concept of requestIdleCallback, its limitations, and how React Fiber implements a custom idle‑time scheduler using requestAnimationFrame and MessageChannel, complete with code demos and analysis of the underlying React source.
FiberJavaScriptMessageChannel
0 likes · 12 min read

This article explains the concept of virtual DOM, its structure, and how Vue's diff (patch) algorithm works, including detailed code walkthroughs, optimization strategies, key usage, and differences between Vue2 and Vue3 implementations, helping readers fully grasp the underlying principles and performance improvements.
Diff AlgorithmOptimizationVirtual DOM
0 likes · 28 min read

This article details how a micro‑frontend architecture and a series of performance‑focused techniques—including full‑link tracing, interface caching, parallel rendering, and template‑based snapshot rendering—were applied to dramatically improve shop page load times across devices.
frontend performancemicro-frontendparallel rendering
0 likes · 14 min read

This article details a comprehensive performance overhaul of a Taobao acquisition page—targeting low‑end phones and unstable networks—by centralizing APIs, prefetching data, and deploying static SSR, ultimately reducing first‑screen render time from several seconds to under one second.
SSRWeb Performancefrontend performance
0 likes · 11 min read

This article explores image‑related concepts such as CSS pixels, device pixels, device‑independent pixels, DPR and PPI, explains how to calculate image memory usage, compares img tag, background‑image and canvas rendering performance, and offers practical optimization directions for web developers.
CanvasMemory usagedevicePixelRatio
0 likes · 17 min read


ByteFEMar 22, 2021 · Frontend Development
This article examines the challenges of virtualizing large Ant Design tables in a React+Umi stack, outlines three internal implementation strategies, discusses common pitfalls such as blank flicker and column fixing, and recommends open‑source alternatives for efficient table rendering.
Ant DesignReactTable Virtualization
0 likes · 13 min read

This article explains the purpose of the key attribute in Vue, demonstrates why using the array index or random numbers as keys breaks the virtual‑DOM diff algorithm, and provides best‑practice recommendations for stable, unique keys to ensure efficient component updates.
Diff AlgorithmVue.jsfrontend performance
0 likes · 12 min read

This article walks through why frontend performance matters for user experience and SEO, then presents a comprehensive toolbox—including Chrome DevTools, Lighthouse, webPageTest, webpack plugins, HTTP caching, service workers, preload/prefetch, lazy loading, skeleton screens, and virtualization techniques—plus concrete code snippets and best‑practice rules to dramatically reduce load times and improve perceived responsiveness.
Lighthousefrontend performanceweb-optimization
0 likes · 18 min read

This article explains the challenges and solutions for drawing and selecting seats in venues with up to 100,000 seats, covering architecture, canvas and WebGL optimizations, data compression, lazy loading, and future directions such as VR and WebAssembly.
canvas optimizationfrontend performancelarge‑scale venues
0 likes · 16 min read

This article explains how Webpack's asynchronous loading mechanisms such as require.ensure and dynamic import() work, demonstrates practical examples for splitting bundles, discusses route lazy‑loading in Vue, and provides optimization techniques including splitChunks, CDN externals, and bundle analysis to improve frontend performance.
Code SplittingVue lazy loadingasync loading
0 likes · 13 min read

This article walks through a practical approach for front‑end engineers to cut down a sluggish legacy API from over three seconds to under a second by adding a Node.js proxy layer that leverages GraphQL field selection, Redis caching, and a scheduled cache refresh.
API optimizationGraphQLNode.js
0 likes · 10 min read


WecTeamSep 11, 2020 · Frontend Development
This week’s WecTeam Front‑end newsletter showcases a WebGL implementation of Conway’s Game of Life that treats the GPU as a parallel for‑loop accelerator, and introduces the CSS content-visibility:auto property, which lets browsers defer layout and rendering of off‑screen elements to dramatically improve initial page load performance.
Content-VisibilityConway's Game of LifeGPU acceleration
0 likes · 2 min read

This article examines the unique memory‑leak challenges of desktop front‑end applications, explains JavaScript memory management, presents analysis methods using Chrome's Memory panel and a binary‑search approach, and offers practical optimization, verification, and monitoring techniques to keep memory usage low during rapid feature iterations.
Performance Optimizationdesktop applicationfrontend performance
0 likes · 9 min read

This article comprehensively explains web caching fundamentals, HTTP cache mechanisms, strong and negotiated caching stages, cache control headers, and advanced strategies like IndexedDB, Service Workers, and CDN caching, helping front‑end developers design optimal cache policies for faster, more efficient web applications.
Browser CacheHTTP headersIndexedDB
0 likes · 15 min read


政采云技术May 31, 2020 · Frontend Development
This article describes how to achieve fast online PDF preview by splitting PDF files into chunks, using PDF.js to load and render only visible pages on demand, and optimizing memory by clearing off‑screen content while supporting rotation, zoom, and page navigation.
PDF previewPDF.jschunk loading
0 likes · 17 min read


WecTeamApr 30, 2020 · Frontend Development
This article presents a comprehensive front‑end performance checklist covering network optimizations like OCSP stapling, IPv6 adoption, HTTP/2 deployment, HTTP/3 readiness, HPACK compression, security hardening, testing workflows, continuous monitoring, and quick‑win tactics to dramatically improve page load times and user experience.
accessibilityfrontend performancehttp2
0 likes · 20 min read


WecTeamApr 29, 2020 · Frontend Development
This article presents an in‑depth front‑end performance checklist covering transfer optimizations, script loading strategies, IntersectionObserver lazy loading, critical CSS inlining, resource hints, service‑worker caching, connection‑aware components, and techniques to prevent layout shifts and improve rendering speed.
Service Workercritical CSSfrontend performance
0 likes · 36 min read

This article explains why reducing initial load resources is crucial for web performance, shows how to measure code utilization with Chrome DevTools, and provides detailed guidance on static and dynamic code splitting, magic comments, and webpack configurations to create faster, smoother front‑end applications.
Code Splittingfrontend performanceweb-optimization
0 likes · 10 min read


WecTeamFeb 12, 2020 · Frontend Development
By combining automatic pagination, removal of heavy scroll-view components, strategic data preloading, caching, and backend logic offloading, the JD mini‑program shopping cart page reduced first‑screen render time by over 50%, lowered CPU and memory usage, and delivered a smoother user experience across devices.
automatic paginationbackend logic offloadcaching
0 likes · 18 min read

This guide walks through front‑end performance optimization, covering DNS resolution, TCP connection, HTTP request/response, server response techniques like compression and CDN, and browser rendering improvements such as reducing reflows, using lazy loading, and best practices to shrink request time and improve perceived speed.
DNSRenderingTCP
0 likes · 7 min read

This article explains how to identify oversized JavaScript bundles with webpack‑bundle‑analyzer, split protobuf‑generated code into business‑specific modules, and apply Babel’s parser, traverse, types, and generator tools to automatically remove redundant commons code and restructure module patterns, dramatically reducing bundle size and improving frontend performance.
BabelBundle OptimizationProtobuf
0 likes · 9 min read

At the 2019 GMTC Beijing Global Front‑End Conference, Beike engineers shared practical approaches to extreme front‑end performance optimization, Node.js service stability, comprehensive mobile crash and network monitoring, and the challenges and solutions of integrating Flutter into their existing mobile apps.
FlutterNode.jsfrontend performance
0 likes · 15 min read

This article explains what a Progressive Web App (PWA) is, how Service Workers enable caching of static, dynamic, and HTML resources, and provides practical techniques such as precaching, offline‑package replacement, update strategies, and a webpack plugin to streamline integration for faster first‑screen loads.
CachePWAService Worker
0 likes · 12 min read

This article explains how front‑end developers can analyze and shrink their JavaScript bundles by using Chrome DevTools, Lighthouse’s unused‑code audit, and visual tools such as Webpack Bundle Analyzer, and provides practical tips for removing unused or unnecessary libraries.
Code SplittingLighthousebundle analysis
0 likes · 6 min read

This article explains why an MP4 video can trigger three separate network requests in browsers, how the placement of the moov box causes the issue, and provides practical steps using HandBrake or ffmpeg to reposition the moov box so only a single request is needed.
FFmpegHTML5 videoHandBrake
0 likes · 6 min read

The article explains H5 front‑end performance bottlenecks—white‑screen delays and interaction lag—by detailing the page loading stages, showing how to measure first‑paint and load times with Chrome DevTools and device debugging, and recommending solutions such as server‑side rendering, touch‑area optimization, script debugging and memory‑leak prevention to improve first‑screen speed and overall smoothness.
First PaintH5Mobile Web
0 likes · 9 min read

The article explains how Webpack's SplitChunksPlugin enables effective code splitting for shared libraries and components, reducing initial bundle size, improving caching, and speeding up page loads, with practical configuration examples and usage tips from Snowball's front‑end architecture.
Bundle OptimizationCode SplittingSplitChunksPlugin
0 likes · 7 min read

This article explains how React decides when to re‑render components, why default behavior can be costly, and how developers can use state changes and the shouldComponentUpdate method to control rendering and improve performance.
ReactVirtual DOMfrontend performance
0 likes · 6 min read

This article compiles a comprehensive checklist of front‑end performance techniques—ranging from reducing HTTP requests and using CDNs to caching Ajax, lazy loading, minimizing DOM size, avoiding redirects and iframes, and applying compression and caching headers—to help developers build faster, more responsive web pages.
CDNHTTP Compressioncaching
0 likes · 28 min read


21CTOSep 16, 2017 · Frontend Development
This article explains how various web caching techniques—including browser, proxy, CDN, and storage APIs—work together through HTTP headers, expiration policies, and validation mechanisms to dramatically improve frontend load times and reduce bandwidth usage.
Browser CacheCDNCache Control
0 likes · 8 min read

This article walks through analyzing Webpack bundle output, identifying oversized or duplicated modules, applying code‑splitting with async imports, and adjusting CommonsChunkPlugin settings to produce leaner, more cache‑friendly builds for traditional non‑SPA pages.
Bundle Optimizationcommonschunkpluginfrontend performance
0 likes · 7 min read


21CTOJun 13, 2017 · Frontend Development
The article reviews Google’s Guetzli JPEG compressor, shares real‑world testing on a large high‑resolution image, discusses memory and CPU requirements, shows size reductions across quality settings, and offers practical advice for integrating it into web projects.
GuetzliJPEG optimizationfrontend performance
0 likes · 7 min read

This article delves into React’s diff mechanism, explaining how the framework transforms the naïve O(n³) tree‑edit distance into an O(n) solution through layered tree diff, component diff, and element diff strategies, and offers practical insights on key usage and performance pitfalls.
Diff AlgorithmReactfrontend performance
0 likes · 14 min read

Mobile pages load about 40% slower than PC pages, users abandon sites after three seconds, and this article offers practical frontend techniques—reducing HTTP requests, compressing assets, leveraging caching, and adopting HTTP/2—to dramatically improve mobile web performance.
Mobile WebOptimizationcaching
0 likes · 5 min read

This article explores how to optimize Babel usage to reduce bundle size and improve performance by addressing helper duplication, third-party module handling, and import optimization through transform-runtime, include patterns, and import transformation plugins.
BabelBundle OptimizationES6
0 likes · 9 min read

React’s diff algorithm, the engine behind Virtual DOM, optimizes UI rendering by comparing tree, component, and element structures using strategies like tree diff, component diff, and element diff, enabling efficient updates that minimize DOM operations and boost performance.
Diff AlgorithmReactVirtual DOM
0 likes · 7 min read

This article explains how React’s diff algorithm works with the Virtual DOM, detailing tree, component, and element diff strategies, optimization assumptions, and practical guidelines to achieve high‑performance UI rendering while minimizing unnecessary DOM operations.
Diff AlgorithmReactVirtual DOM
0 likes · 7 min read


Aotu LabJul 8, 2016 · Frontend Development
This article explains the WebP image format, compares its size and quality against JPEG/PNG, shows how to install command‑line tools, presents performance test results, and provides JavaScript and Nginx PageSpeed solutions for serving WebP to supported browsers.
Browser CompatibilityWebPfrontend performance
0 likes · 9 min read


21CTOMar 23, 2016 · Frontend Development
This article explains how modern front‑end performance challenges—especially JavaScript garbage collection, closure‑induced memory waste, and the need for page pre‑fetching—can be mitigated with techniques like Emscripten‑based memory management and strategic use of dns‑prefetch, pre‑fetch, and pre‑render tags.
EmscriptenGarbage CollectionJavaScript optimization
0 likes · 8 min read


Aotu LabMar 9, 2016 · Frontend Development
This guide explains practical image‑optimization techniques for touch‑screen web pages, covering file‑size reduction, request merging via sprites or Data URLs, and three loading strategies—normal, explicit/implicit preloading, and lazy loading—to improve performance and user experience.
frontend performancelazy loadingpreloading
0 likes · 5 min read

This article explains why JavaScript’s single‑threaded nature can freeze the UI during heavy calculations like recursive Fibonacci, and demonstrates how using HTML5 Web Workers moves such tasks to background threads, keeping the interface responsive and allowing multiple workers for intensive operations.
JavaScriptMultithreadingWeb Workers
0 likes · 3 min read


21CTOJan 26, 2016 · Frontend Development
This article explains the fundamentals of browser caching, compares strong and negotiated cache mechanisms, shows how Expires and Cache‑Control headers work, provides Java code examples for managing cache, and offers practical tips for avoiding stale resources during development.
Cache ControlHTTP headersbrowser caching
0 likes · 19 min read

This article explains the evolution of static asset management from simple overwrites to cache‑busting version strings, highlights the problems caused by version‑based updates in large web systems, and presents hash‑based filenames as an optimal solution to ensure reliable upgrades and efficient caching.
MD5 hashingcache bustingfrontend performance
0 likes · 5 min read

Embedding images as base64‑encoded Data URIs can dramatically cut the number of HTTP requests, improving page performance, though it enlarges the HTML size—a trade‑off that can be softened with gzip compression and is best suited for frequently used static assets.
Base64data URIfrontend performance
0 likes · 2 min read

This guide explains how configuring the Nginx expires directive for CSS files can prevent redundant network requests by letting browsers rely on local cache for a specified period, improving page load performance.
HTTPcachingexpires
0 likes · 3 min read

This guide presents eighteen practical methods—including image optimization, GZip compression, server response improvements, browser caching, CDN usage, and script handling—to dramatically accelerate page loading, boost SEO rankings, and enhance overall user experience.
GZIP Compressionfrontend performancepage speed
0 likes · 11 min read
