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.
Microsoft’s Faster CPython team, formed with Guido van Rossum and six engineers, aims to accelerate CPython by up to five‑fold through staged improvements, already delivering 10‑60% speed gains in Python 3.11 while emphasizing collaborative development and community value.
This article walks through generating a 10 GB file of age values, reading it line‑by‑line on a 4 GB RAM, 2‑core machine, measuring single‑thread performance, then redesigning the pipeline with a producer‑consumer model, blocking queues and multithreaded string splitting to dramatically boost CPU utilization and cut processing time while managing memory consumption.
Noslate is Alibaba’s new open‑source, cloud‑native serverless JavaScript runtime that combines a custom cold‑start‑optimized Node.js distribution, the Aworker container with Warmfork and V8 startup snapshots for sub‑millisecond launches, a Noslated control plane for flexible worker orchestration, and a Corefile‑based debugger for low‑impact diagnostics.
This article explains MySQL’s three‑tier logical architecture—from client services to core query processing and storage engines—and details the four ANSI SQL transaction isolation levels, highlighting their behavior, advantages, and trade‑offs in MySQL.
This article explains iOS memory architecture, the reasons behind Out‑of‑Memory (OOM) crashes, common sources of memory pressure, and practical approaches—including MLeaksFinder and FBRetainCycleDetector—to monitor, detect, and mitigate memory leaks and abnormal memory growth in iOS applications.
ShaderNN is an open‑source, sub‑2 MB GPU‑shader inference engine that runs TensorFlow, PyTorch and ONNX models directly on mobile graphics textures via OpenGL fragment and compute shaders, delivering real‑time, low‑power AI for image‑heavy tasks while eliminating third‑party dependencies and achieving up to 90 % speed gains.
This article examines the challenges of performing fuzzy searches on encrypted data and compares three categories of solutions—naïve, conventional, and advanced—detailing their implementation methods, performance trade‑offs, storage costs, and security implications for real‑world applications.
This article documents practical experiments comparing four MySQL bulk‑insert techniques—single‑row loop, concatenated SQL, MyBatis‑Plus saveBatch, and loop with batch mode—in a SpringBoot environment, revealing the most efficient approach and key configuration tips.
This guide explains what RAID is, its role in server storage, compares common RAID levels (0, 1, 5, 6, 10) in terms of fault tolerance, performance, and capacity, and offers recommendations for selecting the most suitable RAID configuration based on data safety, speed, and cost considerations.
Python 3.11, the latest official release, brings substantial performance gains, richer error tracebacks, enhanced async task syntax, expanded type‑hint support, built‑in TOML parsing, zero‑cost exceptions, exception groups, faster startup, and numerous other refinements that together make the language both quicker and more developer‑friendly.
This article provides an in-depth overview of Nginx, covering its core concepts, advantages, request handling, load balancing strategies, reverse proxy, static and dynamic resource separation, security, rate limiting, health checks, compression, and practical configuration examples for high‑performance web services.
This article provides a comprehensive walkthrough of Druid's connection‑pool architecture, detailing the initialization, acquisition, validation, eviction, and recycling of connections, while explaining key configuration options, thread‑safety mechanisms, and performance considerations for Java database applications.
The article explains how ByteHouse extends ClickHouse with a full‑featured query optimizer—including rule‑based and cost‑based techniques, analyzer modules, plan construction, and distributed optimization—to overcome ClickHouse limitations and achieve significant performance gains on complex OLAP workloads.
veLinux, an open‑source Linux distribution from Volcano Engine, delivers a stable, high‑performance, and secure operating system for cloud workloads on both x86 and ARM, offering multiple editions, deep kernel optimizations, fast boot, and extensive security features tailored for modern cloud‑native environments.
This article introduces WebAssembly, explains its advantages and compatibility, walks through setting up Rust and wasm‑pack to build a simple demo, compares its performance against JavaScript using a Fibonacci benchmark, and provides guidance on when to adopt WebAssembly in frontend projects.
This guide explains how to monitor Linux system performance by using core commands such as top, vmstat, iostat, and sar to evaluate CPU usage, memory allocation, I/O activity, and network traffic, while also covering load interpretation, cache behavior, huge pages, zero‑copy techniques, and practical command examples.
This article explains the fundamentals of in‑memory caching, introduces Guava's LoadingCache API, discusses cache sizing, eviction policies, common algorithms like FIFO, LRU, LFU, shows a simple LRU implementation using LinkedHashMap, and provides practical guidance on when and how to apply caching for performance optimization.
Oracle’s Enterprise Performance Pack, offered free to Java SE subscribers and OCI users, brings Java 17‑level memory management and performance enhancements—including modern garbage collection, compact strings, and improved observability—to legacy Java 8 applications, delivering up to 40% better memory and CPU efficiency under heavy loads.
This article explains how to assess hardware resources, calculate required Elasticsearch cluster size based on data volume, and perform indexing and search benchmark tests to ensure stable performance and optimal throughput for log and metric workloads in production environments.
This article explains the purpose and proper use of C++'s virtual keyword, illustrating how virtual functions enable polymorphism, detailing class memory layout with vtables and vptrs, comparing performance impacts, and outlining when virtual functions and destructors are truly necessary.
A simple benchmark using Bubble Sort on a 10,000‑element random array compares several popular programming languages, revealing that Python performs the worst while Go (Golang) delivers a striking performance advantage even over Node.js.
This article explains what mapping explosion is in Elasticsearch, why it hurts performance and memory, and presents three practical solutions—strict, false, and runtime dynamic settings—along with code examples and trade‑off discussions.
This article examines the open‑source memory cache Dragonfly, its performance claims against Redis, presents reproduced benchmark results, discusses architectural differences, and outlines Redis’s design principles and testing methodology.
This article explores database optimization from four angles—architecture, hardware, instance parameters, and SQL tuning—detailing practical techniques like distributed caching, read/write splitting, sharding, SSD upgrades, parameter tuning for Oracle, MySQL, PostgreSQL, and DaMeng, and step‑by‑step SQL rewrite with real‑world performance results.
PostgreSQL 15, released on October 13 2022, brings major performance gains such as faster sorting and WAL compression, adds the SQL MERGE command, expands regex and multirange support, improves security with security_invoker, and enhances logical replication, logging, and configuration flexibility for modern data workloads.
This article explains how to employ the Java Virtual Machine Tool Interface (JVMTI) in native Android code to record memory allocation and deallocation events, filter relevant classes, store logs efficiently with mmap, and integrate the agent from the Java layer for comprehensive memory‑leak analysis.
This article walks through what Spring Native is, how it uses GraalVM native images to dramatically reduce Spring Boot startup time, and provides a step‑by‑step setup, performance comparison, and troubleshooting tips for building and running native Spring applications.
This article explains how MySQL 8.0's prefer_ordering_index optimizer switch can be toggled to improve LIMIT queries that involve ORDER BY and GROUP BY, demonstrates the effect with test data, and shows why manual parameter control can yield better execution plans.
This article explains how Java's HashMap stores key‑value pairs using an array of nodes, how hash functions map keys to array indices, how collisions are handled with linked lists and red‑black trees, and why proper hashCode implementations are crucial for performance.
This article details the architectural evolution of China Telecom's Tianyi Account gateway, describing the migration from a Zuul‑based 1.0 system to a Kong‑driven 2.0 and 3.0 platform, the performance improvements, plugin ecosystem, cloud‑native deployment, and operational benefits achieved through each upgrade.
This article details Meituan's real‑world challenges with a 15,000‑node Kafka deployment and explains the application‑layer and system‑layer optimizations—such as disk balancing, migration pipeline acceleration, fetcher isolation, RAID acceleration, cgroup isolation, and an SSD‑based cache—that together dramatically cut read/write latency and simplify large‑scale cluster management.
This article presents thirteen practical guidelines for optimizing Redis performance, covering command selection, key management, data structures, persistence settings, hardware choices, clustering, and memory fragmentation mitigation to achieve significant speed improvements.
The article explains the fundamental differences between row‑based and column‑based storage in databases, compares their write and read performance, presents a practical openGauss experiment showing storage size and insert speed differences, and offers guidance on when to choose each model.
This article explains why Redis delivers high query speed by leveraging its in‑memory architecture, custom data structures such as SDS, linked lists, hash tables, skip‑lists, and intsets, a single‑threaded execution model combined with efficient I/O multiplexing, and recent multithreaded I/O enhancements.
Thor is a unified Android container framework that combines Java and native hooking into a lightweight, dynamically loadable module, ensuring backward compatibility, hot‑plug plugin deployment, fault‑tolerant operation, and cloud‑controlled toggling, while real‑world plugins for threads, I/O, privacy, and memory deliver measurable performance and stability gains.
This article examines the open‑source memory cache Dragonfly, compares its performance and architecture with Redis through detailed benchmark reproductions, discusses the underlying design trade‑offs, and highlights Redis’s continued relevance and future directions in real‑world deployments.
Learn how to use Linux’s top command to dynamically monitor process activity, interpret CPU, memory, and swap statistics, customize displayed columns, and apply useful shortcuts for sorting and filtering, enabling effective real-time system performance analysis and troubleshooting.
This article explains the seven essential configuration parameters of Java's ThreadPoolTaskExecutor, covering thread creation, core and maximum pool sizes, keep‑alive policies, work queues, thread factories, rejection handlers, and practical usage tips with code examples and common pitfalls.
OpenKruise v1.3 introduces the PodProbeMarker CRD for custom probes, adds new features to CloneSet, WorkloadSpread, Advanced DaemonSet, and SidecarSet—including historical version injection and pod annotation policies—while delivering significant performance gains for large‑scale clusters through queue optimizations and reduced CPU/memory usage.
The article analyses the current state of front‑end performance, explains why hybrid solutions fall short of native experiences, and introduces Lath – a pure front‑end container that turns any web page into a seamless SPA with advanced window management, smooth interactions, and progressive enhancement.
This article analyzes traditional POI implementations, compares their strengths and weaknesses, and presents a high‑performance solution using EasyExcel for exporting and importing up to 3 million rows, including batch querying, sheet management, JDBC batch inserts, and detailed performance benchmarks.
This article analyzes the performance pitfalls of Android's SharedPreferences, explains how its apply() method can still cause ANR, introduces Jetpack DataStore as a modern replacement, and provides detailed migration strategies including code examples, coroutine handling, and bytecode transformation techniques.
This article details the challenges of scaling RabbitMQ, the evaluation of RocketMQ versus Pulsar, the design of a new messaging middleware platform with high availability, performance, and rich features, and the step‑by‑step migration strategy that enabled seamless, low‑cost transition for massive business traffic.
The article explains the core performance metrics QPS, TPS, response time (RT), concurrency, and throughput, provides formulas to relate them, demonstrates practical calculations for capacity planning, and discusses how to determine the optimal number of threads for a backend system.
This article explains how to handle large‑scale Excel import and export in Java by comparing traditional POI workbooks, selecting the appropriate implementation based on data volume and requirements, and presenting a high‑performance solution with EasyExcel, batch processing, and JDBC transactions for hundreds of millions of rows.
This article details Meituan's Kafka deployment, describing the current massive scale and associated challenges, and presents a series of optimizations—including read/write latency reductions, application‑ and system‑level improvements, large‑scale cluster management strategies, full‑link monitoring, service lifecycle management, and future directions—to enhance performance, reliability, and scalability of the streaming platform.
This article examines how Zhaunzhuan's product service, a core component of its e‑commerce platform, was optimized by reducing unnecessary data transmission, applying cache‑aside patterns, redesigning Redis storage, and introducing a field‑marking approach, resulting in dramatically lower GC overhead, network traffic, and response times.
This article explains how to build comprehensive system and application monitoring using the USE (Utilization, Saturation, Errors) method, outlines key performance metrics, and details the architecture of tools like Prometheus, Grafana, ELK, and distributed tracing to quickly detect and resolve bottlenecks.
This article introduces RobustDB, a client‑side read‑write splitting framework that replaces the problematic Atlas proxy by routing SQL statements to master or slave databases based on DML/DQL detection, using Spring, AspectJ, thread‑local context, and dynamic data‑source management.
This article presents ten performance‑optimization techniques—including indexing, compression, caching, prefetching, throttling, batch processing, resource squeezing, horizontal scaling, sharding, and lock‑free designs—explained through Naruto‑themed analogies and practical guidance for backend systems.
This article introduces Spring Native, explains how native images built with GraalVM can reduce Spring Boot startup time to under 100 ms, walks through environment setup, project initialization, Docker image creation, performance testing, and provides troubleshooting tips for common issues.
This article explores Java's proxy patterns, detailing static proxy implementation, various dynamic proxy techniques—including JDK, Cglib, Javassist, and ByteBuddy—providing code examples, performance comparisons, and practical guidance for integrating these proxies into backend development for cleaner, more flexible code.
This article documents a hands‑on experiment migrating a Vue 2 project to Vue 2.7 with Vite, covering setup steps, essential plugins, compatibility issues, performance benchmarks against webpack, and practical lessons for both new and legacy frontend applications.
Although a common belief claims that Java's try‑catch blocks severely degrade performance, this article dissects JVM exception handling, bytecode generation, and JIT/AOT optimizations, presents detailed test code and benchmarks, and demonstrates that when no exception occurs, the overhead is negligible.
Effective monitoring combines comprehensive system and application metrics—using the USE (Utilization, Saturation, Errors) method to pinpoint resource bottlenecks, and leveraging tools like Prometheus, Grafana, and ELK stacks for data collection, storage, querying, alerting, visualization, and full‑stack tracing across distributed services.
To replace Elasticsearch, the team built a ClickHouse‑based log platform that uses table‑level TTL and custom storage policies to automatically move data among hot (ESSD PL1), cold (ESSD PL0) and archive (OSS) disks, achieving faster writes, comparable query latency, and over 50 % cost reduction.
The article shares a six-year journey at Taobao, reflecting on front-end architecture principles, the role of a front-end architect, a practical SSR optimization process, and personal insights on becoming a well-rounded architect who balances technical depth, breadth, and business understanding.
This article examines why encrypted data hinders fuzzy queries and compares three categories of solutions—naïve in‑memory decryption, conventional database‑level techniques, and advanced algorithmic methods—highlighting their trade‑offs in security, performance, and storage overhead.
This article introduces Java 19's virtual threads, compares their performance and scheduling with traditional platform threads and Go goroutines, provides practical code examples, benchmark results, and migration guidelines, and explains the underlying M:N scheduling mechanisms that make virtual threads more efficient for high‑concurrency, I/O‑bound workloads.
This article details the systematic analysis and optimization of the 58.com Android app’s startup process, covering profiling, componentized task framework, delayed initialization, merging launch and home activities, layout improvements, monitoring tools, and results that achieved roughly a 50% reduction in cold‑start time.
This article investigates the common belief that Java's try‑catch blocks severely degrade performance by examining JVM exception handling mechanisms, analyzing compiled bytecode, and presenting extensive benchmark tests under various JVM compilation modes to determine the real impact of exception handling on execution speed.
