This article analyzes a MySQL 8.0 deadlock caused by an update that locks an auxiliary index followed by a delete that locks the primary key, explains the lock sequence that leads to a circular wait, and offers a practical solution of using primary‑key updates to avoid the deadlock.
This article analyzes Tencent Cloud’s DLC lakehouse solution, explaining the unified data lake‑warehouse architecture, the performance hurdles of object‑storage‑based analytics, and the multi‑dimensional caching, virtual‑cluster elasticity, and advanced filter techniques that enable second‑level analysis on petabyte‑scale data while reducing costs.
The article details the design, core features, and real‑world performance of the DragonF MPP DB, a cloud‑native, compute‑storage‑separated database that overcomes traditional MPP limitations, supports millions of daily jobs, and outlines its future roadmap for ultra‑large‑scale data platforms.
The article explores a wide range of performance‑optimization strategies—including indexing, caching, compression, prefetching, peak‑shaving, and batch processing—explaining their trade‑offs, practical applications, and how they relate to hardware latency and system design in modern computing environments.
This article compares Elasticsearch and ClickHouse in terms of write throughput, query speed, and server cost, then provides a step‑by‑step deployment guide for a private data pipeline using Zookeeper, Kafka, FileBeat, and ClickHouse, along with common issues and their solutions.
This comprehensive guide explores Kafka as a distributed messaging middleware, detailing its core concepts, architecture, producer and consumer mechanisms, configuration options, Zookeeper integration, controller responsibilities, network model, performance optimizations such as zero‑copy, page‑cache usage, batching, compression, and partition concurrency.
The article provides a hands‑on migration guide for moving an internal gateway service from Java 8 to JDK 11 with the G1 garbage collector, detailing a checklist of tool and dependency updates, showcasing up to 105 % performance gains, outlining new language features, virtual‑thread usage, and best‑practice recommendations for a smooth, cost‑effective upgrade.
This article explains the Android boot sequence from the boot ROM to the SystemServer, shows how to analyze boot time using logs, bootchart and boottrace, and provides practical optimization steps to reduce the startup delay, especially focusing on the Zygote and AudioService bottlenecks.
This article demonstrates how to locate the source of abnormal MySQL connection traffic by identifying the offending socket, tracing its system‑call stack with strace, and correlating the activity to specific application logic such as create/drop database and workload tasks.
This article explains the internal differences of Java's String implementation from JDK 8 to JDK 9+, demonstrates how to use sun.misc.Unsafe and trusted MethodHandles.Lookup to build zero‑copy String objects, and provides practical code examples for high‑performance string handling.
This article explains how ice.js 3 improves web performance by combining MPA and SPA loading strategies, parallelizing component and data fetching, leveraging SSG and SSR, and exploring cloud‑based prefetch and zero‑bundle concepts to deliver smoother user experiences.
The article explains how software performance is limited by the time spent in CPU, memory, storage and network operations and by the space consumed by data structures, JVM object headers, thread stacks and protocol overhead, illustrating the need for careful time‑space trade‑offs to achieve efficient optimization.
The article explains how to correctly handle MethodChannel bridge calls, avoid async/await concurrency pitfalls, interpret FPS metrics beyond raw frame rates, and get started with Flutter’s new Impeller rendering engine, highlighting its setup, benefits, and current limitations.
This article details the four‑year development of SpriteJS, a high‑performance, cross‑platform graphics system that supports WebGL and Canvas2D rendering, DOM‑like APIs, responsive design, WebWorker integration, and extensive performance optimizations for visualisation and game applications.
It introduces a series of front‑end engineering articles covering comprehensive monitoring architecture, CSS‑based click throttling, drag‑and‑drop implementation, 30 essential JavaScript concepts, and a simple responsive data‑dashboard solution, aiming to deepen developers’ skills and showcase resume‑worthy expertise.
This article presents six practical performance‑optimization methods—indexing, compression, caching, prefetching, peak‑shaving, and batch processing—explains their principles, trade‑offs, and real‑world applications, and then dives into four advanced strategies for scaling and parallelism, all illustrated with memorable analogies.
This article explains what eBPF (extended Berkeley Packet Filter) is, compares it with related tracing tools, describes its core mechanisms and common applications such as network monitoring, security filtering and performance analysis, and provides step‑by‑step Python examples with installation instructions and further reading resources.
The article explains Go’s caller‑callee model, stack‑frame layout, and how parameter and return‑value passing shifted in Go 1.17.1—using registers for up to nine arguments or results and the stack for any beyond—highlighting the impact on performance and optimization.
PostgreSQL 15 introduces a safer permission model, up to four‑fold sorting speed improvements, a MERGE command, enhanced logical replication with two‑phase commit, parallel query execution, JSON logging, Zstandard/ZL4 compression, new regex functions, and shared‑memory server statistics, making it a compelling upgrade for developers and DBAs.
Cache stores frequently accessed hot data in memory to reduce database load, improving performance and handling high‑concurrency scenarios; this article explains cache fundamentals, why Redis is preferred, classifications such as local, distributed, and multi‑level caches, their advantages, drawbacks, and implementation tips.
This article describes a Redis 5.0 memory leak scenario where 20 million keys with expiration caused memory not to be released, details the investigation steps, findings about the activeExpireCycle, and concludes that memory will eventually be freed, followed by a promotional announcement for a PHP online live class.
This article investigates MySQL's recommendation against using UUID or non‑sequential keys, builds three tables with auto‑increment, UUID, and random (snowflake) primary keys, runs insertion and query benchmarks using Spring Boot and JdbcTemplate, analyzes index structures, and discusses the advantages and drawbacks of each approach.
This article details several real‑world Flutter performance problems encountered at Soul—including excessive memory usage for emojis, iOS 14 debug launch restrictions, high CPU consumption of Lottie animations, background‑foreground flickering, and PlatformView memory leaks—and provides concrete mitigation strategies with code examples.
Dewu transitioned from a single‑instance MySQL setup to a distributed TiDB architecture—using three TiDB, PD, and TiKV/TiFlash nodes, automated backups, Prometheus monitoring, and chaos‑engineering controls—which delivered linear scalability, eliminated slow queries, cut infrastructure costs by about 58 % and maintained stable performance during major sales events.
GaiaX, Alibaba Entertainment’s cross‑platform dynamic UI framework, adopts Flexbox implemented with the Rust‑based Stretch engine to deliver millisecond‑level layout latency on phones, tablets, OTT, Macs and IoT devices, while fixing iOS 32‑bit crashes, redefining aspect‑ratio logic, adding thread‑safe wrappers and extensive tests, and open‑sourcing the extended library.
This article explains the Linux kernel’s packet‑receiving workflow, the role of hardware and soft interrupts, how ksoftirqd processes deferred work, includes key code excerpts, and shows how to monitor softirqs to diagnose performance issues.
This first practical installment of the OKR Sword series explains how the 3C formulation principles—Concentrated, Challenging, Controllable—guide objective creation, outlines three sources of goals, and presents a four‑step process (background input, collaborative drafting, alignment, personal definition) for aligning team cognition, motivation, and performance.
Janus is Baidu’s high‑throughput, multi‑purpose gateway that complements BFE, supporting traffic, business, and hybrid routing for dozens of internal services; the article explains its motivations, architecture, three‑tier routing rules, variable and conditional expressions, plugin system, performance benchmarks, and future extensions.
This comprehensive guide walks front‑end developers through the entire SEO workflow—from understanding search engine mechanics and optimizing site structure, URLs, and TDK, to performance tuning, sitemap and API submission, link building, structured data, and monitoring—offering practical tactics to increase organic traffic.
This article explains how modern browsers use multi‑process architectures, detailing the evolution from single‑process models, the roles of browser, renderer, GPU, network, and plugin processes, and walks through the navigation and rendering pipelines—including DOM construction, style calculation, layout, layering, painting, rasterization, compositing, and their impact on performance.
This article introduces the concept of rate limiting, explains three core algorithms—fixed window, sliding window, and leaky bucket—along with the token bucket approach, provides Java code examples for each, discusses their principles, advantages, and pitfalls, and outlines practical implementation considerations.
The article introduces Pond, a high‑performance Python object‑pool library that reduces memory consumption and GC pressure by reusing objects, explains its design components, automatic eviction strategy, thread‑safe borrowing and returning mechanisms, and provides detailed usage examples with code snippets.
This article explains the concept of CPU turbo boost, why single‑core performance metrics can be misleading, how different CPUs vary in base frequency and cache, and how turbo technology automatically raises clock speeds within safe limits to improve overall processing power.
This article explains how to enable detailed GC logging in the JVM, interpret both Young and Full GC log entries, configure heap parameters, and use the online visualizer gceasy.io to analyze performance metrics such as throughput, pause latency, and memory usage for effective JVM tuning.
This article surveys modern front-end engineering topics, covering plugin-based design, AST-driven compilation, sandbox performance tricks, techniques to reduce complex if‑else structures, a single‑div CSS football field demo, and essential insights into automated testing for developers.
This article explores Kafka's performance secrets by examining network, disk, and algorithmic factors, detailing sequential writes, zero‑copy techniques, page‑cache usage, Reactor‑based networking, batching, compression, partition concurrency, and file‑structure optimizations, and provides practical guidance for high‑throughput deployments.
This guide explains Linux performance fundamentals—including throughput, latency, average load, CPU context switching, memory management, swap behavior, and the essential monitoring tools such as vmstat, pidstat, perf, and strace—while providing concrete command examples and troubleshooting steps.
This article explains the principles and practical implementation of in‑memory caching using Guava’s LoadingCache, covering cache initialization parameters, put and loading strategies, eviction policies, common algorithms such as LRU, LFU, FIFO, and tips for avoiding memory issues and monitoring cache performance.
This guide explains the benefits of caching, defines key DNS concepts, and provides language‑specific investigations and code samples to help developers implement client‑side DNS caching, reduce lookup latency, and improve overall network performance.
This article introduces Java's Disruptor framework as a high-performance, lock-free queue, explains its core components such as RingBuffer, Sequencer, and WaitStrategy, provides sample code for producers and consumers, and discusses how it avoids lock contention and false sharing.
This article analyzes ClickHouse distributed DDL execution by presenting typical failure scenarios, dissecting the underlying Zookeeper‑based workflow, and offering practical mitigation steps to avoid DDL timeouts and improve cluster stability for large‑scale data operations.
This guide walks front‑end developers through the complete SEO workflow—from understanding search‑engine crawling and indexing to optimizing URLs, TDK tags, site structure, performance, sitemaps, API pushes, and monitoring—using real‑world examples from the Xigua video hotspot project.
This article describes how combining Redis and RabbitMQ to implement an asynchronous cache refresh mechanism significantly improves interface performance and stability for a high‑traffic used‑car platform, meeting strict tp99 latency requirements while maintaining data freshness.
This article presents a detailed overview of five commonly used MyBatis and MyBatis-Plus batch insertion methods, including code examples, configuration steps, and performance measurements for inserting ten thousand records, helping developers choose the most efficient approach for large‑scale data insertion in Java backend projects.
This article provides an in‑depth tutorial on configuring and using the Caffeine caching library in Java, covering cache creation, property settings such as initial capacity, maximum size, weight, expiration policies, statistics collection, custom listeners, and advanced features like removal listeners and cache writers.
This article explains how to identify Redis latency problems, measure baseline performance, monitor slow commands, and address common causes such as network RTT, forked RDB snapshots, transparent huge pages, swap usage, AOF configuration, key expiration bursts, and big keys, providing practical solutions and a checklist for remediation.
This article outlines the technical strategies and best practices for guaranteeing high‑quality user experiences during large‑scale mobile event rollouts, covering background, core guarantees, business characteristics, performance metrics, high‑concurrency handling, dynamic configuration, loading optimization, runtime safeguards, and monitoring.
This article details a frontend team's decision to migrate from Vue 2/3 to Svelte, covering the motivations, performance benchmarks, type‑checking improvements, code‑size analysis, migration workflow, and the practical benefits and trade‑offs observed after the transition.
This article explains the purpose and advantages of MySQL indexes, compares MyISAM and InnoDB storage engines, details B+‑tree, full‑text, and hash indexes, and provides practical optimization techniques to improve query performance while noting their trade‑offs.
Fury is a JIT‑compiled, multi‑language native serialization framework that fully implements JDK custom serialization, delivering 20‑200× speed improvements over JDK, Hessian, and Kryo, while preserving compatibility across Java, Python, Go, C++, and JavaScript, as demonstrated by detailed protocol analysis and performance benchmarks.
This article explains how to collect extensive MySQL performance metrics—including connections, buffer cache, locks, SQL status, statement counts, throughput, server configuration, and slow‑query logs—using only MySQL's native SHOW commands and the performance_schema, providing practical code snippets and optimization tips.
The article details Chromium’s rendering pipeline, tracing how network bytecode becomes on‑screen pixels through 13 stages—from parsing and style calculation to layout, painting, compositing, tiling, rasterization, activation, aggregation, and final display—while explaining process models, component formulas, and synchronous versus asynchronous raster strategies.
A data‑service company migrated 20,000 customers to a microservice architecture, initially gaining visibility, lower deployment costs, and easier scaling, but later faced queue head blocking, shared‑library version chaos, load‑pattern challenges, and management overhead, ultimately prompting a return to a monolith with a new "Centrifuge" component.
This article presents a comprehensive investigation of Svelte, detailing its dramatic bundle size reduction, performance improvements, compilation-based architecture, core implementation, advantages, drawbacks, and practical usage guidelines, supported by real project data, npm and GitHub statistics, and code examples to help developers confidently adopt Svelte.
This article analyzes Elasticsearch’s three pagination methods—from/size, scroll, and search after—explaining their internal query and fetch phases, performance trade‑offs for deep paging, and provides Java implementation examples and practical recommendations.
Sonic‑CPP, an open‑source C++ JSON library co‑developed by ByteDance’s STE and Service Framework teams, leverages SIMD vectorization, optimized memory layout, on‑demand parsing, and a compact DOM design to achieve up to 2.5× faster parsing than RapidJSON and competitive serialization performance, with extensive benchmark results and production‑grade usage.
This article explains the fundamentals of caching, why caches like Redis are essential for high‑performance and high‑concurrency backend systems, and compares local, distributed, and multi‑level cache architectures, including their advantages, drawbacks, and typical implementation approaches.
Explore a curated collection of frontend articles covering bundler tree‑shaking, code readability tricks, precision handling with big.js, hidden CSS features, Apple‑style scrolling effects, ready‑made visual dashboard demos, and performance insights like reducing jank and mastering LightHouse workflows.
This article outlines practical strategies for guaranteeing high‑concurrency, high‑flexibility, and stable performance of large‑scale mobile event pages, covering user experience goals, technical indicators, load and runtime optimizations, dynamic configuration, and monitoring to keep millions of users satisfied.
This comprehensive guide explains what Redis is, its core data structures, typical scenarios such as caching, counters, message queues and leaderboards, installation steps on Linux, configuration options, advanced features like pipelines, Lua scripting, persistence mechanisms, replication, caching strategies, consistency challenges, and distributed locking techniques.
The article explains Go’s channel implementation as a lock‑protected FIFO queue composed of a circular buffer, send and receive wait queues, detailing creation, send/receive mechanics, closing behavior, a real‑world memory‑leak example, and why this design offers safe, performant concurrency comparable to mutexes.
This article examines the limitations of traditional big‑runtime and Virtual DOM frameworks, explores community solutions like pre‑compile, Islands, and React Server Components, and explains how Qwik’s Resumable approach and Partytown can dramatically improve first‑paint speed and reduce client‑side overhead.
A heated dispute erupts between senior Twitter engineers and Elon Musk as the latter imposes a sweeping code freeze and criticizes the platform's microservice‑driven architecture, prompting debates over RPC counts, technical debt, and the impact on app performance across regions.
This article explains how to overcome the limitations of traditional Apache POI when handling massive Excel import/export tasks by comparing POI workbook types, selecting the appropriate one, and using EasyExcel together with batch database queries and JDBC transactions to process up to three million rows efficiently.
This article explores MySQL InnoDB table size limits, explains how page and B+ tree structures affect performance, provides scripts for generating massive test data, and derives a practical recommendation of around 20 million rows based on storage and index calculations.
This article details Xiaomi's multi‑year journey in building a group‑wide Business Intelligence platform, covering its historical evolution, technical challenges in performance, modeling, visualization and permissions, the current four‑layer architecture, and future plans to make the platform more business‑centric and simpler.
This article explains how to efficiently import and export massive datasets (up to millions of rows) between Excel and databases using Apache POI, SXSSF, and Alibaba's EasyExcel, comparing workbook types, outlining performance considerations, and providing Java code examples for batch processing, paging, and transaction management.
Adding more RAM can improve performance only when memory is a bottleneck; if your system already has sufficient memory, extra RAM won’t make the CPU run faster, though it does allow more programs to run simultaneously, while insufficient memory can severely slow down tasks.
This article explains the differences between row-based and column-based storage, comparing their write and read performance, outlining advantages and disadvantages, and describing suitable scenarios such as OLAP queries, column families, compression, and indexing, to help choose the appropriate storage model.
This guide surveys essential frontend topics—including deep dives into lodash usage, iterator and generator concepts, Web3D visualizations, hybrid remote debugging, long‑task performance optimization, Chrome DevTools measurement, and creative image‑loading effects—offering practical insights for modern web developers.
This article explains why specifying an initial capacity for Java's HashMap matters, illustrates common misuse cases, walks through the source code to show how capacity and resizing thresholds are calculated, and provides guidelines for choosing the correct capacity to avoid unnecessary rehashing.
This article examines the challenges of scaling JD's shopping cart, proposes a paginated loading strategy for auxiliary product information to reduce backend load and improve user experience, and details the technical design, pagination options, pre‑loading mechanisms, and measured performance benefits.
This article explains the mechanics behind React re‑rendering, how state and props changes trigger renders, common pitfalls that cause multiple renders in class and function components, and practical strategies—including batching, state merging, useReducer, and refs—to minimize unnecessary updates.
This article explains the requestIdleCallback web API, its syntax, execution timing, task‑queue handling, performance characteristics, compatibility issues, and practical integration with React and requestAnimationFrame to off‑load low‑priority work without blocking UI rendering.
The article introduces DuckDB, a high‑performance embedded analytical database, outlines its new release’s storage, performance, and memory improvements, describes its C/C++ integration and build process, and lists key feature changes such as parallel execution, novel compression methods, and enhanced SQL capabilities.
This article explains why MySQL's count(*) can become a performance bottleneck, especially with InnoDB, and presents practical optimization techniques such as Redis caching, second‑level in‑memory caches, parallel execution, reducing unnecessary joins, and using column‑store databases like ClickHouse.
Bigkeys—Redis values over 1 MB or structures with more than 2,000 elements—cause memory imbalance, command blocking, network overload, and migration failures, so DBAs must detect them using built‑in commands or RDB analysis, split or partition oversized keys, and tune migration settings to preserve performance and availability.
This article explains why MySQL's count(*) can be slow on InnoDB, compares different count variations, and presents practical optimization techniques such as Redis caching, second‑level caches, multithreading, reducing joins, and using ClickHouse for massive datasets.
A high‑CPU anomaly on a Spark‑enabled machine was traced through application checks, network TIME_WAIT analysis, and Airflow inspection, leading to kernel tweaks and an Airflow configuration change that finally restored normal CPU usage.
This comprehensive guide explains Linux performance optimization by defining key metrics such as throughput and latency, interpreting average load, analyzing CPU context switches, memory management, and I/O behavior, and recommending practical tools and techniques—including vmstat, pidstat, perf, and dstat—to identify and resolve bottlenecks.
After Elon Musk apologized for Twitter’s sluggish performance, a heated exchange erupted on the platform as engineers disputed his claim of over 1,200 RPC calls per request, revealing internal tensions, firings, and debates over microservice usage and GraphQL knowledge within Twitter’s backend architecture.
This article details a multi‑phase approach to dramatically improve iOS app launch performance, especially on low‑end iPhone models, by analyzing slow functions, applying image compression, lazy loading, run‑loop monitoring, and eliminating unnecessary background tasks, achieving launch times under 3 seconds for 99.7% of users.
Microsoft assembled a six‑engineer team, including Guido van Rossum, to accelerate CPython according to a multi‑phase plan, resulting in Python 3.11 delivering 10‑60% speed improvements and showcasing how coordinated open‑source effort can overcome Python’s historic performance limitations.
Using a step‑by‑step example program, this article shows how to dramatically improve Linux pipe read/write performance—from an initial 3.5 GiB/s to 65 GiB/s—by applying zero‑copy techniques, ring buffers, paging insights, vmsplice/splice system calls, huge pages, and busy‑loop optimizations.
The article presents a detailed performance comparison between auto‑increment integer primary keys and UUID string primary keys in MySQL, including table definitions, 5‑million‑row and 10‑million‑row test results for read, range, write, backup, and storage efficiency, and offers practical recommendations for choosing the appropriate key strategy in distributed environments.
The 2022 TOP500 report reveals that Japan's Fugaku remains dominant, while China leads in system count, Intel and NVIDIA still dominate processors and accelerators, and the industry is shifting toward data‑intensive AI and big‑data workloads, reshaping the supercomputing landscape.
This collection highlights essential frontend topics—including Vite's performance debate, low‑code concepts, functional programming fundamentals, JMeter performance testing, strategies for managing module dependencies and theme switching, as well as practical guidance on preventing XSS and CSRF attacks—offering developers a concise roadmap to modern web development.
This article provides a comprehensive guide to Redis persistence, covering the theory and configuration of both RDB snapshotting and AOF append‑only logging, their advantages, drawbacks, practical setup commands, recovery procedures, and performance‑tuning tips for reliable data durability.
This article explains how to prevent UI blocking in Flutter by moving intensive calculations to background isolates using the compute helper and raw Isolate APIs, demonstrates code examples for task execution, progress reporting, and inter‑isolate communication, and discusses performance considerations and best practices.
This article details why 360 selected StarRocks as its OLAP engine, compares its performance and resource usage against MySQL, Hive, Spark, Druid, ClickHouse and Doris, and describes the concrete deployment scenarios and data products built on StarRocks within the company.
This guide explains how to analyze and troubleshoot situations where Linux systems show high load averages despite low CPU usage, covering common load analysis methods, key commands like top, vmstat, iostat, sar, and ps, and practical solutions for I/O bottlenecks and D‑state processes.
This article explains the fundamentals of in‑memory caching, compares it with buffering, introduces Guava's LoadingCache configuration and operations, discusses eviction strategies, illustrates common cache algorithms (FIFO, LRU, LFU), provides a simple LRU implementation using LinkedHashMap, and offers practical guidelines for when and how to apply caching to improve backend performance.
This guide details key Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—along with practical commands, configuration settings, and code snippets to help operators efficiently track and troubleshoot Redis instances.
This article presents a thorough, multi‑part exploration of software performance optimization techniques—including indexing, compression, caching, prefetching, peak‑shaving, and batch processing—explaining their principles, trade‑offs, practical applications, and how they relate to hardware constraints and system design.
This article details how JD's retail shopping‑cart team tackled growing business complexity by fully converting the cart service to an asynchronous architecture, addressing challenges such as increasing RPC dependencies, pagination, and resource costs, and achieving a 30% reduction in core interface latency.
This article details comprehensive strategies for handling massive seat‑selection data on mobile devices, covering data modeling, interface pre‑loading, static and dynamic compression, view hierarchy tweaks, bitmap reuse, drawing optimizations, hardware acceleration, and multithreaded task handling to dramatically improve load times and frame rates.
Elasticsearch offers several pagination strategies—simple from/size, scroll, scroll‑scan, sliced scroll, and the newer search_after with point‑in‑time—each with distinct performance trade‑offs and use‑case suitability, and this guide explains their mechanics, limitations, and best‑practice recommendations for handling deep pagination.
This article explains how a high‑traffic e‑commerce system reduced database QPS by over 80% and response latency by more than 40% through a systematic DAO‑level caching solution, detailing the background, design trade‑offs, implementation steps, global cache architecture, deployment practices, and observed limitations.
This article presents a comprehensive collection of Python coding principles, idioms, library usage guidelines, design patterns, internal mechanisms, tooling recommendations, and performance profiling techniques to help developers write clean, efficient, and maintainable code.
The new RocksDB 7.5.3 release dramatically reduces write‑stall time, lock contention and CPU usage while improving OPS and latency compared with 6.2.9.x, as shown by detailed memtier benchmark tests on a 4‑CPU, 32 GiB VM with NVMe storage.
