Tagged articles
lazy loading
96 articles · Page 1 of 1
This article dissects AgentScope's AgentOS workspace architecture, detailing its unified directory contract (.mcp/skills/data/sessions), eight pluggable execution backends, two-level lazy loading with mtime+SHA-256 incremental caching, and fine-grained locking (bind/MCP/skill locks plus Future placeholders) to prevent duplicate workspace creation under concurrent first-session requests.
AgentOSAgentScopeconcurrency control
0 likes · 24 min read

TencentOS EROX introduces a unified data plane that chains kernel direct mount, on-demand fetching, P2P distribution, incremental snapshots, and node-side cost reduction to accelerate AI Agent image startup and snapshot recovery, achieving 50GB workspace readiness in 1 second and 50%+ cold start reduction by enabling read-to-start and replicable state across nodes.
AI agentCapsuleEROFS
0 likes · 31 min read

The author details how adding REA's 130 MCP tools alongside OpenPencil's 150 tools overwhelmed a 256K context window, and explores three optimization strategies — per-project tool filtering, lazy loading via Tool Search, and a custom Meta-MCP proxy — plus REA-specific schema reductions like Evidence ID references and split union types.
DeepSeek HarnessEvidence IDMCP
0 likes · 23 min read

This article presents a complete HarmonyOS solution for eliminating white blocks during fast scrolling in image-heavy lists by combining dynamic prefetching via the prefetcher library with ImageKnife image caching, demonstrating two implementations using LazyForEach and Repeat components with performance benchmarks showing under 5% white block rate and minimal memory overhead.
ArkUIHarmonyOSImageKnife
0 likes · 20 min read

A real-world case study shows how systematic profiling with Spring Boot Actuator and JFR, combined with scan-scope reduction, selective @Lazy on external clients, HikariCP deferred connection, and ApplicationReadyEvent-driven async initialization cut a Spring Boot 3.1.5 order-service startup from 6.2 seconds to 1.8 seconds on Java 17.
Event-Driven InitializationHikariCPSpring Boot
0 likes · 22 min read

This article presents four practical solutions for the Spring Boot 3.5.0 “Could not write JSON: failed to lazily initialize a collection… no Session” error that occurs when serializing bidirectional one-to-many relationships, covering @JsonIgnore, JPQL fetch joins, enabling OpenEntityManagerInView, and using the Jackson Hibernate6 module, with code examples and results.
JPAJSONJackson
0 likes · 7 min read

The article explains how BeanFactory is a minimal, lazy‑loading container that only creates and caches beans, while ApplicationContext extends it with eager pre‑loading, full annotation, AOP, transaction, environment and event support, and outlines their respective use cases and pitfalls.
ApplicationContextBeanFactoryEager Loading
0 likes · 9 min read

This article dissects Claude Code’s 12 ms --version response and its 1.1 MB lazy‑loaded footprint, explaining a four‑layer startup chain that uses fast‑path handling, parallel prefetch, selective lazy imports, memoized global initialization, and compile‑time dead‑code elimination to achieve near‑instant CLI launch.
BunCLITypeScript
0 likes · 15 min read

The article dissects Claude Code's sub‑second cold‑start performance by detailing its lazy‑loading mechanism, compile‑time feature‑gate (DCE) via bun:bundle, runtime gating with GrowthBook, and the engineering trade‑offs of managing over 88 feature flags in a single‑file CLI bundle.
BunCLIdead code elimination
0 likes · 16 min read

This article explains the architecture and evolution of a feed push system, covering the basic push model, its early implementation, performance trade‑offs, and a series of optimizations—including lazy loading, length control, delayed push, active‑inactive fan filtering, and hot‑cold separation—to improve read efficiency, reduce storage costs, and handle massive fan bases.
BackendCachingfan-filtering
0 likes · 18 min read

Claude Code 2.1.69 introduces a lazy‑loaded Tool Search that defers loading of Model Context Protocol (MCP) tools until needed, dropping system‑tool context from around 10% to zero, dramatically reducing token consumption and improving tool selection accuracy.
Claude CodeMCPTool Search
0 likes · 7 min read

Claude Code introduces MCP Tool Search, a lazy‑loading mechanism that dynamically loads only needed tools, cutting token usage by over 67,000 tokens in large MCP setups, preventing context bloat, improving performance, and offering developers regex and BM25 search options with defer_loading support.
BM25Claude CodeMCP
0 likes · 6 min read

This article provides a comprehensive guide to Python descriptors, explaining their protocol, types, basic usage, real‑world applications such as type‑checking, lazy loading, observer patterns, ORM‑like fields, and best‑practice tips for safe and efficient attribute management.
DescriptorPythonattribute-access
0 likes · 19 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 details a comprehensive set of front‑end performance optimizations—including ISR, component lazy loading, image preloading, Lottie animation upgrades, low‑end device handling, and streaming rendering—that together increased ad page exposure by 10% and first‑screen instant load from 15% to 65%, dramatically improving user experience and conversion rates.
ISRLottiefrontend
0 likes · 18 min read

Learn how to replace complex scroll listeners and getBoundingClientRect calculations with the modern Intersection Observer API, using just ten lines of JavaScript to create a clean, high‑performance lazy‑loading solution that swaps placeholder images for real content and even supports preloading via rootMargin.
intersection observerlazy loading
0 likes · 6 min read

This article explains how using getters and setters in PHP can improve code organization, reduce coupling, and enhance performance through techniques like lazy loading and result caching, illustrated with clear code examples.
Cachinggetterslazy loading
0 likes · 5 min read

This article outlines six practical PHP performance optimization techniques—including opcode caching, database query tuning, reducing redundant calculations, choosing efficient data structures, employing lazy loading, and leveraging built‑in functions—to help developers significantly improve the speed and scalability of their backend applications.
OPcachePHPbackend development
0 likes · 5 min read

This article outlines ten concrete React optimization techniques—including lazy loading, image compression, memoization, code splitting, CDN usage, API throttling, server‑side rendering, WebSockets, minification, and load testing—demonstrating how each step dramatically improves performance and scalability for traffic spikes exceeding three million concurrent users.
Code SplittingReactSSR
0 likes · 6 min read

This article explains how to build a high‑performance infinite‑scroll waterfall layout for e‑commerce using CSS Grid, IntersectionObserver, native lazy‑loading attributes, asynchronous decoding, React's useTransition, content‑visibility, and the AVIF image format to reduce load time and improve smoothness.
AVIFCSS GridContent-Visibility
0 likes · 13 min read

This article demonstrates how to build a highly reusable, function‑based modal system in Vue 3 that supports lazy loading, prop passing, event binding, provide/inject data injection, custom slots, and method exposure, allowing developers to display any modal component with a single function call.
Functional ComponentProvide/InjectTypeScript
0 likes · 13 min read

This article presents eight practical modularization strategies—including ES Modules, componentization, separation of concerns, conventions, bundlers, dependency injection, lazy loading, and versioning—to help developers transform sprawling frontend codebases into clean, reusable, and maintainable systems.
Component ArchitectureES Modulesdependency-injection
0 likes · 8 min read

This article introduces Spring's @Lazy annotation, explains its purpose and scenarios such as improving startup speed, breaking circular dependencies, and correctly injecting prototype beans, and provides five practical code examples while also announcing a continuously updated Spring Boot 3 case collection with a PDF ebook and source code.
@LazySpring Bootdependency-injection
0 likes · 10 min read

The article explains how PHP getters and setters encapsulate private properties, reduce coupling, and enable lazy loading and result caching, providing code examples that demonstrate improved code clarity, maintainability, and system performance.
lazy loading
0 likes · 5 min read

This article details a comprehensive performance optimization of a Taro‑based mini‑program for the Double‑11 promotion, covering measurement methods, problem analysis, Skyline rendering engine migration, lazy loading, image sizing, API parallelization, and the resulting speed improvements.
SkylineTaROlazy loading
0 likes · 9 min read

PHP 8.4 introduces property hooks, asymmetric visibility, new array functions, simplified object instantiation, explicit nullable types, and lazy objects, providing cleaner syntax, better control, and performance improvements for developers across skill levels.
BackendNew Featuresarray-functions
0 likes · 7 min read

This article presents a comprehensive solution for integrating ECharts into Vue and React projects, addressing bundle size, API complexity, and lack of CSS‑variable support by introducing custom imports, a draw helper, MutationObserver‑based resizing, theme‑aware color replacement, lazy loading, and usage examples for both frameworks.
MutationObserverReactTheme Switching
0 likes · 18 min read

Optimizing images is crucial for e‑commerce web performance, and this guide explores practical methods such as early loading of above‑the‑fold images, reducing image size through compression, format selection, responsive delivery, lazy loading, and modern browser features like fetch‑priority and content‑visibility to improve LCP and overall user experience.
Responsive ImagesWeb Performanceimage optimization
0 likes · 18 min read

A production incident where a poorly implemented lazy‑loading mechanism for KMSClient caused repeated initialization, blocking threads, exhausting the shared thread pool, and triggering RejectedExecutionException alerts, was investigated step‑by‑step, leading to a concrete code fix, improved monitoring, and better thread‑pool isolation.
ConcurrencyJavaKMS client
0 likes · 16 min read

This article demonstrates how to dramatically reduce image size and loading time in a WeChat mini‑program by converting to WebP, adjusting resolution via OSS parameters, using CSS sprites, and implementing lazy‑load placeholders, with before‑and‑after performance data and reusable component code.
OSSWeChat Mini-ProgramWebP
0 likes · 10 min read

This article details a year‑long front‑end performance optimization effort for the Tongtian Tower project, covering analysis tools, caching strategies, code splitting, lazy loading, and business‑logic refinements that together delivered a 58.8% reduction in first‑screen load time.
CDNlazy loadingnetwork analysis
0 likes · 17 min read


JD TechDec 28, 2023 · Backend Development
This article explores the challenges of slow Spring application startup in large Java projects, presents detailed analysis techniques, visualizations, and a suite of tools—including Spring Startup Analyzer, Arthas, and Async Profiler—to identify bottlenecks, and provides step‑by‑step optimization methods such as bean lazy loading, jar slimming, and configuration tweaks that can reduce startup time by up to 80% while improving resource utilization and deployment efficiency.
SpringStartup Optimizationlazy loading
0 likes · 16 min read

Facing heavy load times on the Feitian Service Platform’s customizable homepage, the team applied a three‑stage front‑end performance overhaul—shrinking resources, prioritizing critical paths with progressive loading, and leveraging caching via SWR and Service Workers—resulting in sub‑second page renders and a smoother user experience.
CachingWebfrontend
0 likes · 11 min read

This article explains how to implement image lazy loading in PHP by extracting image URLs, generating placeholder tags with data-src attributes, monitoring scroll events via JavaScript, and applying CSS transitions, providing a step‑by‑step guide with complete code examples to improve page load performance.
JavaScriptPHPfrontend
0 likes · 5 min read

This article introduces the IntersectionObserver API, explains its constructor, options, and entry properties, and demonstrates practical applications such as lazy loading images, scroll‑triggered animations, infinite scrolling, and virtual list rendering with complete code examples.
IntersectionObserverScroll AnimationWeb API
0 likes · 11 min read

This article explains PHP 7 generators, describing their concept, memory‑saving benefits, and how to implement them with a practical example that reads a large file and yields squared numbers, demonstrating efficient data processing and lazy loading in backend development.
Memory OptimizationPHPbackend development
0 likes · 5 min read

This article demonstrates how to accelerate website image loading by applying PHP‑FPM performance optimizations such as image compression with GD, jQuery lazy loading, CDN acceleration, multithreaded parallel fetching, and proper browser‑cache headers, providing complete code examples for each technique.
CDNPHPWeb Performance
0 likes · 5 min read

This article details a systematic investigation and optimization of a web‑based workflow engine, addressing slow initial rendering, input lag in Element UI components, and excessive memory consumption that caused browser crashes, and presents concrete solutions such as data pruning, Object.freeze, lazy loading, and event cleanup.
Memory Leakfrontendlazy loading
0 likes · 9 min read

Using AntV’s F2 4.0, the team revamped Alipay’s Fund Index section with a multi‑dimensional scatter‑plot tool that lets users explore returns vs volatility, featuring refined touch gestures, adaptive bubble sampling, lazy loading, and a layered M‑C‑V architecture for reusable components.
Chart LibraryF2bubble sampling
0 likes · 10 min read

This article introduces front‑end lazy‑loading strategies—including route lazy loading, three image lazy‑loading methods (native, scroll‑event, and IntersectionObserver), and module lazy loading—explaining their principles, showing complete React/Vue code examples, and demonstrating how they reduce initial load time and improve user experience.
intersection observerlazy loadingperformance optimization
0 likes · 12 min read

This article explains how to reduce Redis read/write pressure by introducing a Guava local cache for lazy loading, presents design diagrams, provides complete Java code examples for both simple lazy caching and a microservice‑oriented device‑increment cache, and discusses the advantages, disadvantages, and practical considerations of each approach.
CachingGuavaJava
0 likes · 11 min read

This article examines Builder.io's performance optimization case, reviews the evolution of lazy‑loading techniques in front‑end development, and explains how Qwik implements ultra‑fine-grained lazy loading and prefetching to eliminate costly hydration and improve page interactivity.
QwikSSRWeb
0 likes · 18 min read

The article explains how the Intersection Observer API offloads visibility detection from scroll events to improve performance, details its creation, options, callback structure, and entry data, and describes a polyfill that mimics native behavior using event listeners, mutation observers, and geometric calculations for broader browser support.
IntersectionObserverJavaScriptPolyfill
0 likes · 16 min read

This article introduces a Redis lazy‑loading caching strategy combined with Guava local cache, presents design diagrams and Java code examples, analyzes its advantages and disadvantages, and discusses suitable scenarios such as precise query workloads and micro‑service architectures.
CacheGuavaJava
0 likes · 10 min read

This article explains how to combine Redis lazy‑loading caching with Guava local cache in Java, presenting design diagrams, full code examples, and a discussion of the advantages, disadvantages, and suitable scenarios for this hybrid caching strategy.
Guavalazy loadinglocal cache
0 likes · 9 min read

This article explains how to combine Redis lazy‑loading caching with Guava local cache to reduce I/O pressure, improve read performance, and balance memory usage, providing code examples, pros and cons, and suitable scenarios for backend and microservice architectures.
Guava CacheJavaRedis
0 likes · 11 min read

This article explains how to reduce Redis read/write pressure by using a lazy‑loading cache pattern together with Guava local cache, provides Java code examples, discusses advantages and disadvantages, and shows practical scenarios such as device ID generation in high‑frequency streaming systems.
CacheGuavaJava
0 likes · 10 min read

This article explains how to integrate Redis with a Guava‑based local cache to achieve lazy‑loading of high‑frequency data, reduces Redis I/O pressure, provides code examples, discusses advantages and drawbacks, and outlines suitable microservice scenarios.
Guava CacheJavaRedis
0 likes · 11 min read

This article explains how to combine Redis lazy‑loading caching with a Guava local cache to reduce Redis read/write pressure in high‑frequency data scenarios, provides Java code examples, discusses advantages and disadvantages, and offers practical guidance for backend developers.
CacheGuavaJava
0 likes · 11 min read

This article explains how to combine Redis lazy‑loading cache with a Guava local cache to minimize memory usage while ensuring precise query performance, provides Java code examples for both lazy loading and device‑increment caching, and discusses the advantages, disadvantages, and suitable scenarios of the approach.
CacheGuavaJava
0 likes · 10 min read

This article walks through creating a simple Node server, building a basic HTML/JS front‑end, and applying performance techniques such as pagination with setTimeout, requestAnimationFrame, document fragments, and lazy‑loading to render massive data sets smoothly.
frontendlazy loadingrequestAnimationFrame
0 likes · 11 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


政采云技术May 17, 2022 · Frontend Development
This article explains why image resources dominate front‑end performance, describes how binary depth relates to color representation, compares common image formats (JPEG, PNG‑8/24, SVG, WebP, Base64), and provides practical techniques such as compression tools, CDN/OSS deployment, and lazy‑loading code to dramatically improve page load speed.
CDNOSSWeb Performance
0 likes · 12 min read


ByteFEMar 23, 2022 · Frontend Development
While lazy loading can reduce initial page load time and save resources, overusing it can slow scrolling, cause layout shifts, hinder SEO, and ultimately degrade overall web performance, so developers need clear guidelines on when and how to apply it effectively.
Frontend OptimizationSEOWeb Performance
0 likes · 7 min read

Lazada’s Southeast Asian e‑commerce app achieved major performance gains by reorganizing startup tasks, merging launch pages, implementing full‑link dynamic prefetch, incremental cart updates, checkout pre‑rendering, and request merging, resulting in up to 250 ms faster launches and significant reductions in network latency across Android and iOS.
app startupe-commercelazy loading
0 likes · 15 min read

The article explains how modern browsers assign priority to assets, defines critical requests that affect Core Web Vitals, and provides practical techniques such as preload, lazy‑loading images, and font‑display to control request ordering and improve page load speed.
ChromeWeb Performanceasset priority
0 likes · 15 min read

This article presents practical techniques for optimizing image resources in e‑commerce front‑end projects, covering lazy loading of ordinary images, progressive and skeleton loading for high‑fidelity assets, and server‑side splitting of long graphics using Node.js, with detailed code examples and performance considerations.
Nodefrontendimage optimization
0 likes · 15 min read

This guide outlines ten Vue.js performance optimization techniques—including using stable keys in v‑for, freezing immutable data, defining component data as a function, lazy‑loading components, separating non‑reactive data, employing event delegation, leveraging functional components, and using provide/inject—to boost rendering speed, cut memory usage, and simplify maintenance.
JavaScriptVue.jslazy loading
0 likes · 13 min read

Learn how to eliminate page lag when handling large datasets in Element UI's transfer component by applying lazy loading, infinite scroll, and pagination techniques, separating display from logic, and adding custom scroll handling for both downward and upward navigation.
Element UIinfinite-scrolllazy loading
0 likes · 7 min read

This article provides an in‑depth analysis of Flutter’s CustomScrollView component, covering its three‑layer architecture, rendering pipeline, scrollable mechanics, pinned header implementation, lazy‑loading strategy, and memory reuse techniques, illustrated with practical examples from Ctrip hotel app development.
CustomScrollViewlazy loadingmobile development
0 likes · 22 min read

This article provides a comprehensive technical breakdown of Flutter's CustomScrollView component, covering its three-layer widget‑element‑render object structure, scroll mechanics, pinned header logic, lazy‑loading and memory‑reuse strategies, and shares practical insights from Ctrip's hotel app migration.
CustomScrollViewlazy loadingmobile-development
0 likes · 22 min read


ByteFEApr 26, 2021 · Frontend Development
This article explains how to improve performance of long React pages by rendering components screen‑by‑screen using viewport detection (getBoundingClientRect or Intersection Observer), grouping data, debouncing scroll handlers, and applying React.memo to prevent duplicate data requests.
ReactReact.memointersection observer
0 likes · 9 min read


58 TechMar 26, 2021 · Mobile Development
This article details how 58 Tongcheng improved iOS app startup speed by defining launch time, building automated measurement tools, detecting slow methods via hooking, applying binary reordering with Clang sanitizers, and implementing dynamic library lazy loading, achieving significant reductions in launch latency and page faults.
Binary Reorderingapp startupiOS
0 likes · 25 min read

This article explains why excessive or large images hurt page load speed in e‑commerce sites and provides a comprehensive guide to selecting proper image formats, applying lossless and lossy compression, using tools, configuring webpack, employing CSS sprites, icon fonts, base64, CDN, lazy loading, preloading, responsive and progressive image strategies to improve web performance.
Responsive ImagesWeb Performancefrontend
0 likes · 22 min read

PowerScrollView is a high‑performance Flutter flow‑layout framework that composes section‑based slivers for lists, grids and waterfalls, adds automatic exposure, scroll‑to‑index, fine‑grained refresh and element‑reuse optimizations, and uses frame‑by‑frame rendering to deliver smooth scrolling across Xianyu’s core pages.
FlutterUI optimizationlazy loading
0 likes · 15 min read

NetEase’s XRN platform boosts Web and React Native performance by eliminating duplicate bundles, pruning unused code, importing only needed polyfills, using dynamic imports and bundle splitting, pre‑loading assets, lazily loading images and lists, limiting first‑screen rendering, and applying memoization, raising Lighthouse scores from 50.3 to 80.4 and cutting RN load time by 40 %.
Code SplittingReact Nativelazy loading
0 likes · 13 min read

This article explains Spring Boot's global lazy initialization feature, showing how to enable it, the code changes required, its benefits for reducing startup time, and the trade‑offs such as longer first request latency and delayed error detection.
lazy loadingspring-boot
0 likes · 4 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


21CTONov 12, 2019 · Frontend Development
This article presents a comprehensive guide to improving Vue application performance, covering code‑level tricks such as proper use of v‑if/v‑show, computed vs watch, key handling, lazy loading, and SSR, alongside webpack configuration tweaks, image compression, source‑map tuning, and fundamental web optimizations like gzip and CDN usage.
SSRlazy loadingoptimization
0 likes · 19 min read


政采云技术Nov 10, 2019 · Frontend Development
This article systematically explains web image optimization, covering image formats, request and volume reduction techniques such as HTTP/2, lazy loading, caching, sprites, Base64, multi‑resolution handling, and accessibility considerations, providing practical code examples and tool recommendations for front‑end developers.
HTTP/2accessibilityfrontend
0 likes · 26 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.
CachingDNSRendering
0 likes · 7 min read

The article explains how distributed cache consistency problems arise with read‑write operations, introduces the Cache‑Aside pattern and lazy‑deletion strategy, analyzes simple and complex inconsistency scenarios, and proposes a queue‑driven, serial processing solution with practical considerations for high‑concurrency backend systems.
BackendCache AsideQueue
0 likes · 11 min read


21CTOJul 7, 2019 · Backend Development
This article explains why cache‑database double‑write introduces consistency problems, introduces the Cache‑Aside pattern and lazy‑loading strategy, and proposes a queue‑based serialization approach to safely handle updates and reads in high‑concurrency backend systems.
Cache AsideCache Consistencyhigh concurrency
0 likes · 10 min read

This article explains MyBatis fundamentals including the difference between #{} and ${} placeholders, various pagination approaches, logical versus physical pagination, first‑ and second‑level caching, lazy‑loading mechanisms, executor types, pagination plugin principles, and how to create a custom MyBatis plugin with code examples.
CachingMyBatisPagination
0 likes · 8 min read

This article explains the concept of lazy loading in front‑end development, covering placement of placeholder elements, scroll event listening, viewport detection methods, detailed JavaScript implementations, and advanced optimizations such as throttling, vertical‑only checks, and extending lazy loading to other resource types.
frontendlazy loadingperformance
0 likes · 10 min read

This article explains the Singleton design pattern in Java, outlines its characteristics, compares it with static classes, clarifies common misconceptions, and presents multiple thread‑safe and non‑thread‑safe implementation techniques with code examples.
Design PatternJavalazy loading
0 likes · 10 min read

This article explains why lazy loading is needed for React front‑end projects, demonstrates several code‑first implementations—including a custom LazyComponent, prop‑forwarding tricks, and a higher‑order lazy() function—showing how to improve first‑screen rendering while handling state updates correctly.
@ComponentCode SplittingReact
0 likes · 7 min read

This article explains why loading all images in a long list hurts performance, presents step‑by‑step lazy‑loading techniques—including placeholder images, scroll calculations, getBoundingClientRect, and the modern IntersectionObserver API—provides full code samples, and discusses optimization tips for smoother front‑end experiences.
IntersectionObserverJavaScriptimage optimization
0 likes · 9 min read

This article walks through practical web performance optimization techniques—such as removing unused resources, effective caching, code splitting, image compression, lazy loading, and resource hints—demonstrated on the Oodles Theater demo app, showing how Lighthouse audits guide measurable improvements.
Code SplittingLighthouseimage optimization
0 likes · 23 min read

This article explains how to replace traditional pagination with scroll‑triggered lazy loading, using a 200 px threshold, 60 ms event throttling, a loading‑state lock, UI feedback, error handling, and cross‑platform scroll compatibility to improve user experience on web and mobile pages.
JavaScriptPaginationevent-throttling
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.
CDNCachingHTTP Compression
0 likes · 28 min read

This article walks through Angular’s evolution, covering core concepts such as data binding, modular architecture, dependency injection, routing with lazy loading, RxJS versus Promise, and the benefits of Ahead‑of‑Time compilation, while comparing its approach to React and Vue.
AOTAngulardata binding
0 likes · 17 min read


21CTOMar 20, 2017 · Frontend Development
This article explains why page‑load speed matters, shows how to measure ready and load times, and provides concrete front‑end strategies—including reducing render‑blocking scripts and CSS, using responsive and lazy‑loaded images, applying gzip compression, cache‑control, ETag headers, DNS prefetching, and code‑level tweaks—to dramatically improve user experience and reduce bandwidth usage.
Cachingfrontendlazy loading
0 likes · 23 min read

Taobao’s redesigned home page faces heavy personalization demands, multiple data sources, and numerous modules, prompting a series of front‑end performance techniques—including prioritized loading, lazy execution, image compression, caching, and request consolidation—to improve FPS, DOMContentLoaded, and overall user experience.
CachingTaobaofrontend
0 likes · 20 min read

This guide explains the concept of image lazy loading, how to detect when an image enters the viewport, and provides a complete vanilla‑JavaScript implementation with throttled scroll handling to improve page performance and reduce bandwidth usage.
JavaScriptfrontendimage optimization
0 likes · 4 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


21CTOJun 10, 2016 · Frontend Development
This article shares practical techniques—on‑demand fetching, lazy loading, caching, asynchronous operations, merge handling, visual tricks, unit testing, and logging—that transformed a sluggish desktop monitoring client into a fast, stable, and responsive application, reducing startup from minutes to seconds.
Asynchronous ProgrammingC#Caching
0 likes · 18 min read

The article shares practical techniques such as on‑demand loading, lazy loading, caching, asynchronous processing, merge handling, visual deception, unit testing, and comprehensive logging that transformed a sluggish monitoring client into a fast, stable C# WinForms application.
CachingUI optimizationasynchronous
0 likes · 17 min read


Aotu LabApr 15, 2016 · Frontend Development
By analyzing the old and new JD Cloud homepages, this guide demonstrates practical front‑end performance techniques—retina image handling, iconfont conversion, sprite merging, lazy loading, placeholder images, progressive enhancement, and focus styling—showing how to reduce image requests by 80% and improve load experience.
iconfontlazy loadingprogressive enhancement
0 likes · 17 min read

The article examines the performance challenges of Taobao's personalized homepage—multiple data sources, numerous modules, and heavy image loads—and outlines concrete front‑end techniques such as critical‑module prioritization, lazy loading, lazy execution, image compression, caching, and easing animations to achieve faster first paint and smoother scrolling.
CachingTaobaofrontend
0 likes · 12 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

Discover 17 essential strategies—from merging and compressing JS/CSS to leveraging CDNs and lazy-loading images—that developers can implement to significantly overall improve website overall load times, reduce render blocking, and enhance user experience.
CDNCachingFrontend Optimization
0 likes · 2 min read

The article examines JD.com’s homepage front‑end architecture, detailing its use of SeaJS, a custom jQuery build, lazy‑loading, localStorage caching, module organization, and code‑splitting strategies, and compares these techniques with typical web development practices.
CachingSeaJSWeb Performance
0 likes · 8 min read


21CTOOct 6, 2015 · Frontend Development
While browsing JD.com with Chrome’s console, the author uncovers the site’s front‑end architecture, revealing the use of Seajs, a custom jQuery build, lazy‑loading modules, localStorage caching, and a modular project structure that together deliver fast page loads and efficient updates.
CachingJavaScriptSeaJS
0 likes · 8 min read

This article explains the Singleton design pattern in Java, illustrates why a single instance is essential for configuration classes, compares eager and lazy initialization, shows thread‑safe implementations, and demonstrates extensions that limit the number of instances with practical code samples.
Design PatternJavalazy loading
0 likes · 12 min read

This article examines the challenges of lazy loading in J2EE ORM tools, compares eager fetching and pre-fetching, and proposes a modular solution using Aspect‑Oriented Programming to inject custom fetching strategies at the repository level, reducing SQL queries, connection usage, and code bloat.
AspectJFetching StrategyORM
0 likes · 12 min read
