This article examines the rapid rise of Serverless in 2019, analyzes the specific front‑end challenges it creates, explores framework and rendering adaptations such as Egg.js, Next.js and Umi SSR, and proposes architectural upgrades and future directions for more efficient, empowered front‑end development.
The Xianyu Fishpond mini‑program was optimized by keeping its instance alive, pre‑rendering first‑screen data, reducing costly setData calls, using $spliceData for long lists, staging tab‑switch updates, and integrating native video with cover‑view, which together cut loading time, eliminated scroll jank, and slashed tab‑switch latency, delivering markedly improved performance.
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.
This article walks developers through the complete WPF rendering pipeline, detailing the three-layer architecture, message loop handling, Dispatcher processing, DirectX integration, and how drawing commands travel from OnRender to the screen, while providing code examples and references to deepen understanding.
This article walks through the concept sketching, abstract design, low‑poly 3D modeling, rigging with Mixamo, Octane rendering setup, lighting techniques, hair cloth simulation, and post‑processing steps used to create a promotional video for the youth‑focused FoxFriend social app.
This comprehensive guide walks developers through OpenGL fundamentals—including contexts, framebuffers, attachments, textures, vertex and index buffers, shader programs, per‑fragment operations, and buffer swapping—providing clear explanations and visual diagrams to help beginners grasp modern graphics programming.
This article explains the browser's critical rendering path, detailing how HTML, CSS, and JavaScript are transformed into pixels through DOM construction, CSSOM creation, render tree generation, layout, and painting, and discusses how JavaScript can block and delay these stages.
The article explains how evolving runtime interaction requirements have shifted front‑end development from simple jQuery scripts to modern declarative frameworks like Vue, React and Angular, detailing the differences between imperative and declarative approaches, rendering mechanisms, and the role of virtual DOM.
This article outlines practical techniques for improving WeChat Mini Program performance, covering startup loading, first‑screen experience recommendations, and rendering optimizations, with detailed steps on code size control, subpackage loading, data management, and UI rendering best practices.
This article provides an in‑depth exploration of browser rendering mechanisms, covering engine architecture, multi‑process models, DOM and event handling, RenderObject/RenderLayer construction, software vs hardware rendering, and practical JavaScript performance monitoring tools such as Benchmark.js and JsPerf.
Flutter reduces CPU/GPU overhead in multi‑video calls by separating drawing from presentation, using a unified LayerTree and external textures that share OpenGL contexts between Flutter and native code, allowing direct Skia rendering of native pixel buffers on iOS and Android with significantly lower latency and memory use.
The article compares Flash and HTML5, explains Canvas 2D and WebGL rendering modes, and presents performance tests showing WebGL’s superior speed across browsers, while also discussing practical implications for web game development.
This article explores the architecture of a WebGL‑based map engine, detailing its core rendering pipeline, essential modules such as data handling, shader management, buffers, and event‑driven rendering loops, while highlighting performance considerations and best practices for efficient, on‑demand map visualization.
This article explains how GPU acceleration can keep web pages within the 16 ms frame budget, details the browser rendering pipeline, shows how to use Chrome DevTools to inspect composited layers, and outlines practical steps and pitfalls for enabling GPU‑accelerated animations.
iOS renders views and animations through a multi‑stage pipeline—layout, backing image creation, preparation, commit, then GPU OpenGL compositing—so excessive layers, overdraw, off‑screen rendering, or image decompression can cause frame drops, while marking views opaque, reducing transparency, and using Instruments’ Core Animation and GPU Driver tools help diagnose and optimize performance.
Vue.js 2.0 initializes a component via the _init method, merges options, and mounts it with $mount, which creates a render function—whether from a custom function, template, or element—producing a Virtual DOM VNode that the patch algorithm diffs against the previous VNode to efficiently update the real DOM.
Hardware acceleration in Android shifts intensive floating‑point UI work from the CPU to the GPU by building DisplayLists on the CPU and rasterizing them on the GPU, allowing parallel processing, selective redraw of unchanged elements, and significantly higher frame rates for animations and complex graphics.
This article explains what FPS and 60 fps mean, walks through the browser's rendering pipeline from HTML/CSS to the render tree and layers, and provides practical techniques such as avoiding forced synchronous layout, using transform/opacity, GPU acceleration, requestAnimationFrame, and proper event handling to achieve fluid animations.
This article explains how to quantify Android app frame rates, understand FPS concepts, calculate frame timing, and apply three practical methods—including GPU rendering profiling, adb gfxinfo, and SurfaceFlinger latency commands—to monitor and improve smoothness across multiple devices without rooting or API restrictions.
Even high‑end Android devices can feel sluggish due to overdraw, where the GPU renders the same pixel multiple times; this article explains Android’s rendering pipeline, how to detect excessive drawing, and practical techniques—such as simplifying layouts, using transparency, and merging views—to cut draw calls and achieve smooth 60 FPS performance.
This article explains why web pages become sluggish, breaks down the browser's rendering pipeline, details how reflow and repaint affect performance, and provides nine practical techniques—including batching DOM operations, using requestAnimationFrame and requestIdleCallback—to dramatically improve page speed and achieve smooth 60 FPS animations.
This article explains why web pages can suffer from poor performance due to costly reflow and repaint operations, outlines the page rendering process, and provides nine practical techniques—including batching DOM reads/writes, using off‑screen DOM, and leveraging requestAnimationFrame or requestIdleCallback—to reduce rendering overhead and achieve smoother 60 FPS animations.
This article analyzes why the browser engine's CPU usage does not converge to zero when a page becomes invisible or the app is backgrounded, presents a lightweight testing methodology, identifies dynamic‑element and Blink‑kernel bugs, and proposes concrete fixes that restore proper CPU convergence.
This article explains iOS's view and animation rendering pipeline, identifies common performance pitfalls such as excessive layers, overdraw, off‑screen drawing, and image decompression, and provides practical optimization techniques using Core Animation and GPU Driver tools.
This article explains iOS’s event processing pipeline—from hardware events through the RunLoop’s observer, source, timer, and dispatch mechanisms—detailing why UI must run on the main thread, how CALayer and Core Animation render, and the roles of CADisplayLink, NSTimer, and async display techniques.
This article explains the browser rendering pipeline, the differences between repaint and reflow, and provides practical tips and code examples to minimize costly layout recalculations for smoother web page performance.
