BestHub
Sign in
Tagged articles

Lazy Loading

92 articles · Page 1 of 1
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 13, 2026 · Backend Development

Spring Boot Startup Optimization: From 6.2s to 1.8s via Profiling, Lazy Loading & Event-Driven Init

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 InitializationHikariCPLazy Loading
0 likes · 22 min read
Spring Boot Startup Optimization: From 6.2s to 1.8s via Profiling, Lazy Loading & Event-Driven Init
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 25, 2026 · Backend Development

Four Ways to Fix Spring Boot JSON Serialization ‘no Session’ Error for Associated Entities

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
Four Ways to Fix Spring Boot JSON Serialization ‘no Session’ Error for Associated Entities
Java Tech Workshop
Java Tech Workshop
Jun 19, 2026 · Backend Development

BeanFactory vs ApplicationContext: The Real Differences You Must Know

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.

ApplicationContextBeanFactoryDependency Injection
0 likes · 9 min read
BeanFactory vs ApplicationContext: The Real Differences You Must Know
James' Growth Diary
James' Growth Diary
Jun 9, 2026 · Backend Development

The 12 ms Secret: How Claude Code Optimizes CLI Startup Performance

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.

BunCLILazy Loading
0 likes · 15 min read
The 12 ms Secret: How Claude Code Optimizes CLI Startup Performance
Sohu Tech Products
Sohu Tech Products
Apr 15, 2026 · Backend Development

How We Scaled Feed Push: From Simple Push to Lazy Loading and Fan Filtering

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.

BackendLazy Loadingcaching
0 likes · 18 min read
How We Scaled Feed Push: From Simple Push to Lazy Loading and Fan Filtering
AI Insight Log
AI Insight Log
Jan 15, 2026 · Artificial Intelligence

How Claude Code’s New MCP Tool Search Slashes Tokens and Solves Context Explosion

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 CodeContext Management
0 likes · 6 min read
How Claude Code’s New MCP Tool Search Slashes Tokens and Solves Context Explosion
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 31, 2025 · Frontend Development

Master Front-End Performance: Load, Run, Build, and Network Optimizations

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 SplittingLazy LoadingTree-shaking
0 likes · 19 min read
Master Front-End Performance: Load, Run, Build, and Network Optimizations
DeWu Technology
DeWu Technology
Jul 14, 2025 · Frontend Development

How We Boosted Ad Page Load Speed by 55% with ISR, Lazy Loading, and Stream Rendering

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.

ISRLazy LoadingLottie
0 likes · 18 min read
How We Boosted Ad Page Load Speed by 55% with ISR, Lazy Loading, and Stream Rendering
JavaScript
JavaScript
Jun 18, 2025 · Frontend Development

How to Implement Ultra‑Efficient Lazy Loading with Only 10 Lines of JavaScript

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.

Lazy Loadingintersection observer
0 likes · 6 min read
How to Implement Ultra‑Efficient Lazy Loading with Only 10 Lines of JavaScript
php Courses
php Courses
May 29, 2025 · Backend Development

6 Practical PHP Performance Optimization Techniques

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.

Backend DevelopmentDatabase OptimizationLazy Loading
0 likes · 5 min read
6 Practical PHP Performance Optimization Techniques
Sohu Tech Products
Sohu Tech Products
May 7, 2025 · Frontend Development

10 Proven React Performance Hacks to Handle 3M+ Users

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 SplittingLazy LoadingLoad Testing
0 likes · 6 min read
10 Proven React Performance Hacks to Handle 3M+ Users
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 7, 2025 · Frontend Development

Optimizing Infinite‑Scroll Waterfall Layouts with CSS Grid, IntersectionObserver, and Modern Browser Features

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
Optimizing Infinite‑Scroll Waterfall Layouts with CSS Grid, IntersectionObserver, and Modern Browser Features
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Feb 16, 2025 · Frontend Development

Creating a Universal Functional Modal Utility for Vue 3

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 ComponentLazy LoadingProvide/Inject
0 likes · 13 min read
Creating a Universal Functional Modal Utility for Vue 3
JavaScript
JavaScript
Feb 10, 2025 · Frontend Development

8 Essential Modularization Techniques to Master Large Frontend Projects

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 ArchitectureDependency InjectionES Modules
0 likes · 8 min read
8 Essential Modularization Techniques to Master Large Frontend Projects
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 16, 2025 · Backend Development

Mastering Spring’s @Lazy: Speed Up Startup and Solve Circular Dependencies

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.

@LazyDependency InjectionLazy Loading
0 likes · 10 min read
Mastering Spring’s @Lazy: Speed Up Startup and Solve Circular Dependencies
php Courses
php Courses
Nov 27, 2024 · Backend Development

New Features in PHP 8.4: Property Hooks, Asymmetric Visibility, Array Functions, Simplified Instantiation, Explicit Nullable Types, and Lazy Objects

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.

BackendLazy LoadingNew Features
0 likes · 7 min read
New Features in PHP 8.4: Property Hooks, Asymmetric Visibility, Array Functions, Simplified Instantiation, Explicit Nullable Types, and Lazy Objects
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 29, 2024 · Frontend Development

Optimizing ECharts Integration in Vue and React with Lazy Loading, Theme Switching, and DOM Observation

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.

Lazy LoadingMutationObserverReAct
0 likes · 18 min read
Optimizing ECharts Integration in Vue and React with Lazy Loading, Theme Switching, and DOM Observation
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 15, 2024 · Frontend Development

How to Supercharge E‑commerce Page Speed with Simple Image Optimization Techniques

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.

Image OptimizationLazy LoadingResponsive Images
0 likes · 18 min read
How to Supercharge E‑commerce Page Speed with Simple Image Optimization Techniques
Huolala Tech
Huolala Tech
Mar 21, 2024 · Backend Development

How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It

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
How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 31, 2024 · Frontend Development

Optimizing Image Loading in WeChat Mini Programs: WebP Conversion, Resolution Adjustment, Sprites, and Lazy Loading

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.

Image OptimizationLazy LoadingOSS
0 likes · 10 min read
Optimizing Image Loading in WeChat Mini Programs: WebP Conversion, Resolution Adjustment, Sprites, and Lazy Loading
JD Tech
JD Tech
Dec 28, 2023 · Backend Development

Optimizing Spring Application Startup Speed and Performance: Analysis, Tools, and Best Practices

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.

Lazy LoadingProfilingSpring
0 likes · 16 min read
Optimizing Spring Application Startup Speed and Performance: Analysis, Tools, and Best Practices
Alibaba Terminal Technology
Alibaba Terminal Technology
Dec 27, 2023 · Frontend Development

Cut Page Load to 1 Second: Frontend Performance Strategies for Feitian Service Platform

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.

Lazy LoadingOptimizationWeb
0 likes · 11 min read
Cut Page Load to 1 Second: Frontend Performance Strategies for Feitian Service Platform
php Courses
php Courses
Dec 21, 2023 · Frontend Development

Implementing Image Lazy Loading in PHP: A Step‑by‑Step Guide

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.

Image OptimizationJavaScriptLazy Loading
0 likes · 5 min read
Implementing Image Lazy Loading in PHP: A Step‑by‑Step Guide
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 15, 2023 · Frontend Development

Understanding and Using IntersectionObserver for Lazy Loading, Scroll Animations, Infinite Scrolling, and Virtual Lists

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.

IntersectionObserverLazy LoadingScroll Animation
0 likes · 11 min read
Understanding and Using IntersectionObserver for Lazy Loading, Scroll Animations, Infinite Scrolling, and Virtual Lists
php Courses
php Courses
Oct 31, 2023 · Backend Development

Using Generators in PHP 7 for Efficient Data Processing

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.

Backend DevelopmentLazy LoadingMemory Optimization
0 likes · 5 min read
Using Generators in PHP 7 for Efficient Data Processing
php Courses
php Courses
Oct 7, 2023 · Backend Development

Improving Website Image Load Speed with PHP-FPM Optimization: Compression, Lazy Loading, CDN, Parallel Loading, and Browser Caching

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.

CDNImage OptimizationLazy Loading
0 likes · 5 min read
Improving Website Image Load Speed with PHP-FPM Optimization: Compression, Lazy Loading, CDN, Parallel Loading, and Browser Caching
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 25, 2023 · Frontend Development

Optimizing a Web Frontend Workflow Engine: Reducing Load Time, Input Lag, and Memory Usage

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.

Lazy LoadingMemory LeakOptimization
0 likes · 9 min read
Optimizing a Web Frontend Workflow Engine: Reducing Load Time, Input Lag, and Memory Usage
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 23, 2022 · Frontend Development

Front‑end Performance Optimization: Lazy Loading Techniques (Route, Image, and Module)

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.

Lazy LoadingPerformance Optimizationintersection observer
0 likes · 12 min read
Front‑end Performance Optimization: Lazy Loading Techniques (Route, Image, and Module)
Java Architect Essentials
Java Architect Essentials
Sep 27, 2022 · Backend Development

How to Combine Redis and Guava for Lazy‑Loading Cache in Java

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.

GuavaJavaLazy Loading
0 likes · 11 min read
How to Combine Redis and Guava for Lazy‑Loading Cache in Java
MoonWebTeam
MoonWebTeam
Sep 25, 2022 · Frontend Development

How Qwik Achieves Ultra‑Fine Lazy Loading to Boost Web Performance

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.

Lazy LoadingQwikSSR
0 likes · 18 min read
How Qwik Achieves Ultra‑Fine Lazy Loading to Boost Web Performance
DaTaobao Tech
DaTaobao Tech
Sep 20, 2022 · Frontend Development

Understanding Intersection Observer API and Its Polyfill Implementation

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.

IntersectionObserverJavaScriptLazy Loading
0 likes · 16 min read
Understanding Intersection Observer API and Its Polyfill Implementation
Top Architect
Top Architect
Jun 18, 2022 · Backend Development

Combining Redis with Local Guava Cache for Efficient Lazy Loading

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 CacheJavaLazy Loading
0 likes · 11 min read
Combining Redis with Local Guava Cache for Efficient Lazy Loading
Architect
Architect
Jun 15, 2022 · Backend Development

Redis Lazy Loading Cache and Local Cache Integration: Design, Implementation, and Trade‑offs

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.

GuavaJavaLazy Loading
0 likes · 10 min read
Redis Lazy Loading Cache and Local Cache Integration: Design, Implementation, and Trade‑offs
Programmer DD
Programmer DD
Jun 15, 2022 · Frontend Development

How to Efficiently Render 100,000 Records in the Frontend: Tips and Code

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.

Lazy LoadingfrontendrequestAnimationFrame
0 likes · 11 min read
How to Efficiently Render 100,000 Records in the Frontend: Tips and Code
ELab Team
ELab Team
May 19, 2022 · Frontend Development

Boost Web Performance: Mastering Image Optimization with WebP and Lazy Loading

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.

CompressionImage OptimizationLazy Loading
0 likes · 18 min read
Boost Web Performance: Mastering Image Optimization with WebP and Lazy Loading
政采云技术
政采云技术
May 17, 2022 · Frontend Development

Performance Optimization: Image Compression, Loading Strategies, and Format Selection

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.

CDNLazy LoadingOSS
0 likes · 12 min read
Performance Optimization: Image Compression, Loading Strategies, and Format Selection
ByteFE
ByteFE
Mar 23, 2022 · Frontend Development

Effects of Too Much Lazy Loading on Web Performance

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 OptimizationLazy LoadingSEO
0 likes · 7 min read
Effects of Too Much Lazy Loading on Web Performance
Alibaba Terminal Technology
Alibaba Terminal Technology
Jan 24, 2022 · Mobile Development

How Lazada Cut 250ms from App Startup: Mobile Performance Secrets

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.

Lazy LoadingMobile DevelopmentPerformance Optimization
0 likes · 15 min read
How Lazada Cut 250ms from App Startup: Mobile Performance Secrets
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 3, 2021 · Frontend Development

Image Resource Optimization Strategies for E-commerce Frontend

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.

Image OptimizationLazy LoadingNode
0 likes · 15 min read
Image Resource Optimization Strategies for E-commerce Frontend
Tencent Cloud Developer
Tencent Cloud Developer
Sep 17, 2021 · Frontend Development

Ten Vue.js Performance Optimization Techniques

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.

JavaScriptLazy LoadingVue.js
0 likes · 13 min read
Ten Vue.js Performance Optimization Techniques
Qunar Tech Salon
Qunar Tech Salon
Jul 29, 2021 · Mobile Development

Deep Dive into Flutter CustomScrollView: Architecture, Rendering Process, and Performance Optimizations

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
Deep Dive into Flutter CustomScrollView: Architecture, Rendering Process, and Performance Optimizations
Ctrip Technology
Ctrip Technology
Jul 15, 2021 · Mobile Development

In-depth Analysis of Flutter CustomScrollView Architecture and Implementation

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
In-depth Analysis of Flutter CustomScrollView Architecture and Implementation
58 Tech
58 Tech
Mar 26, 2021 · Mobile Development

Startup Optimization Practices for 58 Tongcheng iOS App: Measurement, Method Timing Detection, Binary Reordering, and Lazy Loading

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 ReorderingLazy LoadingPerformance Optimization
0 likes · 25 min read
Startup Optimization Practices for 58 Tongcheng iOS App: Measurement, Method Timing Detection, Binary Reordering, and Lazy Loading
Sohu Tech Products
Sohu Tech Products
Feb 17, 2021 · Frontend Development

Image Optimization Techniques for Frontend Development

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.

Image OptimizationLazy LoadingResponsive Images
0 likes · 22 min read
Image Optimization Techniques for Frontend Development
Xianyu Technology
Xianyu Technology
Jan 14, 2021 · Mobile Development

PowerScrollView: A High‑Performance Flow Layout Solution for Flutter

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.

FlutterLazy LoadingMobile Development
0 likes · 15 min read
PowerScrollView: A High‑Performance Flow Layout Solution for Flutter
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Nov 16, 2020 · Frontend Development

Performance Optimization Practices for the XRN Platform (Web and React Native)

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 SplittingLazy LoadingPerformance Optimization
0 likes · 13 min read
Performance Optimization Practices for the XRN Platform (Web and React Native)
WecTeam
WecTeam
Apr 29, 2020 · Frontend Development

Master Front‑End Performance: Transfer Optimizations, Lazy Loading & Critical CSS

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.

Lazy LoadingService Workercritical CSS
0 likes · 36 min read
Master Front‑End Performance: Transfer Optimizations, Lazy Loading & Critical CSS
21CTO
21CTO
Nov 12, 2019 · Frontend Development

Boost Vue App Performance: Practical Code, Webpack, and Web Techniques

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.

Lazy LoadingOptimizationSSR
0 likes · 19 min read
Boost Vue App Performance: Practical Code, Webpack, and Web Techniques
政采云技术
政采云技术
Nov 10, 2019 · Frontend Development

Comprehensive Guide to Web Image Optimization and Performance Techniques

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/2Image OptimizationLazy Loading
0 likes · 26 min read
Comprehensive Guide to Web Image Optimization and Performance Techniques
MaoDou Frontend Team
MaoDou Frontend Team
Sep 12, 2019 · Frontend Development

How to Supercharge Front-End Performance: From DNS to Rendering

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.

DNSLazy LoadingRendering
0 likes · 7 min read
How to Supercharge Front-End Performance: From DNS to Rendering
Architect's Tech Stack
Architect's Tech Stack
Aug 27, 2019 · Backend Development

Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and Queue‑Based Synchronization

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.

BackendLazy LoadingQueue
0 likes · 11 min read
Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and Queue‑Based Synchronization
21CTO
21CTO
Jul 7, 2019 · Backend Development

How to Prevent Cache‑Database Consistency Issues in High‑Concurrency Systems

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.

High ConcurrencyLazy Loadingcache consistency
0 likes · 10 min read
How to Prevent Cache‑Database Consistency Issues in High‑Concurrency Systems
Java Captain
Java Captain
Apr 6, 2019 · Backend Development

MyBatis Q&A: #{} vs ${}, Pagination Techniques, Caching, Lazy Loading, Executors, and Custom Plugin Development

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.

Backend DevelopmentLazy LoadingMyBatis
0 likes · 8 min read
MyBatis Q&A: #{} vs ${}, Pagination Techniques, Caching, Lazy Loading, Executors, and Custom Plugin Development
Qunar Tech Salon
Qunar Tech Salon
Feb 26, 2019 · Frontend Development

Implementing Lazy Loading for Frontend Performance Optimization

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.

Lazy Loadingfrontendperformance
0 likes · 10 min read
Implementing Lazy Loading for Frontend Performance Optimization
Ctrip Technology
Ctrip Technology
Dec 6, 2018 · Frontend Development

Implementing Lazy Loading in React: Techniques, Components, and Higher‑Order Functions

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.

Code SplittingComponentLazy Loading
0 likes · 7 min read
Implementing Lazy Loading in React: Techniques, Components, and Higher‑Order Functions
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Nov 6, 2018 · Frontend Development

Master Image Lazy Loading: From Scroll Events to IntersectionObserver

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.

Image OptimizationIntersectionObserverJavaScript
0 likes · 9 min read
Master Image Lazy Loading: From Scroll Events to IntersectionObserver
UC Tech Team
UC Tech Team
Nov 1, 2018 · Frontend Development

Web Performance Optimization: Lessons from the Oodles Theater App

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 SplittingImage OptimizationLazy Loading
0 likes · 23 min read
Web Performance Optimization: Lessons from the Oodles Theater App
Beike Product & Technology
Beike Product & Technology
Nov 27, 2017 · Frontend Development

Implementing Scroll-Based Lazy Loading, Event Throttling, and Request Locking for Frontend Pagination

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.

JavaScriptLazy Loadingevent-throttling
0 likes · 6 min read
Implementing Scroll-Based Lazy Loading, Event Throttling, and Request Locking for Frontend Pagination
BiCaiJia Technology Team
BiCaiJia Technology Team
Sep 25, 2017 · Frontend Development

30 Essential Front‑End Performance Hacks Every Developer Should Know

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 CompressionLazy Loading
0 likes · 28 min read
30 Essential Front‑End Performance Hacks Every Developer Should Know
21CTO
21CTO
Mar 20, 2017 · Frontend Development

How to Speed Up Page Load Times: Practical Front‑End Optimization Techniques

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.

Lazy LoadingOptimizationcaching
0 likes · 23 min read
How to Speed Up Page Load Times: Practical Front‑End Optimization Techniques
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 7, 2017 · Frontend Development

Boosting Taobao Home Page Speed: Front‑End Strategies for Personalization

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.

Lazy LoadingTaobaocaching
0 likes · 20 min read
Boosting Taobao Home Page Speed: Front‑End Strategies for Personalization
JavaScript
JavaScript
Jan 15, 2017 · Frontend Development

How to Implement Efficient Image Lazy Loading with Vanilla JavaScript

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.

Image OptimizationJavaScriptLazy Loading
0 likes · 4 min read
How to Implement Efficient Image Lazy Loading with Vanilla JavaScript
Aotu Lab
Aotu Lab
Jul 8, 2016 · Frontend Development

How WebP Can Cut Image Size and Boost Page Speed: A Practical Guide

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.

Lazy LoadingWebPbrowser compatibility
0 likes · 9 min read
How WebP Can Cut Image Size and Boost Page Speed: A Practical Guide
21CTO
21CTO
Jun 10, 2016 · Frontend Development

How I Cut a 4‑Minute Client Load Time to 2 Seconds: Practical Performance Hacks

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#Lazy Loading
0 likes · 18 min read
How I Cut a 4‑Minute Client Load Time to 2 Seconds: Practical Performance Hacks
Aotu Lab
Aotu Lab
Apr 15, 2016 · Frontend Development

How to Slash Front‑End Image Requests by 80% with Iconfont, Sprites, and Lazy Loading

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.

Lazy Loadingiconfontprogressive enhancement
0 likes · 17 min read
How to Slash Front‑End Image Requests by 80% with Iconfont, Sprites, and Lazy Loading
dbaplus Community
dbaplus Community
Apr 14, 2016 · Frontend Development

How Taobao Optimized Its Homepage Performance: Key Front‑End Strategies

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.

Lazy LoadingPerformance OptimizationTaobao
0 likes · 12 min read
How Taobao Optimized Its Homepage Performance: Key Front‑End Strategies
Aotu Lab
Aotu Lab
Mar 9, 2016 · Frontend Development

Master Image Optimization for Touch Pages: Reduce Size, Merge Requests, and Smart Loading

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.

Lazy Loadingfrontend performancepreloading
0 likes · 5 min read
Master Image Optimization for Touch Pages: Reduce Size, Merge Requests, and Smart Loading
Java High-Performance Architecture
Java High-Performance Architecture
Jan 3, 2016 · Frontend Development

17 Proven Techniques to Speed Up Your Web Pages

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.

CDNFrontend OptimizationGZIP
0 likes · 2 min read
17 Proven Techniques to Speed Up Your Web Pages
21CTO
21CTO
Oct 6, 2015 · Frontend Development

Inside JD.com’s Front‑End: Seajs, Lazy Loading, and Smart Caching

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.

JavaScriptLazy LoadingSeaJS
0 likes · 8 min read
Inside JD.com’s Front‑End: Seajs, Lazy Loading, and Smart Caching
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
May 19, 2015 · Fundamentals

Why the Singleton Pattern Matters: Lazy Loading, Thread Safety, and Real‑World Java Examples

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
Why the Singleton Pattern Matters: Lazy Loading, Thread Safety, and Real‑World Java Examples
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
May 8, 2015 · Backend Development

Optimizing Data Fetching in J2EE Applications Using Lazy Loading, Fetch Strategies, and AspectJ

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 StrategyLazy Loading
0 likes · 12 min read
Optimizing Data Fetching in J2EE Applications Using Lazy Loading, Fetch Strategies, and AspectJ