Fast‑Retry is a high‑performance Java framework that enables asynchronous, multi‑task retries with both programmatic and annotation‑based APIs, dramatically improving throughput for large‑scale retry scenarios compared to traditional synchronous retry libraries.
This article explains the bitmap (BitVec) data structure, its memory efficiency for handling billions of integers, real‑world applications such as bloom filters and permission flags, and walks through Go’s internal BitVec implementation with concrete code examples and performance insights.
This article compares MySQL and PostgreSQL, outlining their histories, architectural differences, benchmark results for SELECT, INSERT, UPDATE operations, and discusses suitable scenarios, advantages, disadvantages, and guidance on selecting the appropriate database for various application needs.
This guide presents essential MySQL configuration and monitoring queries—covering connection limits, Binlog/GTID status, InnoDB settings—plus a one‑click script that consolidates these checks, enabling quick health assessments and more efficient routine inspections of MySQL servers.
This article examines why PHP remains a vital backend language in 2025, reviewing its evolution, new 8.x features such as JIT and Fibers, popular frameworks, cloud‑native capabilities, and future directions for performance and type‑system improvements.
This article demonstrates how to use EasyExcel to efficiently export large volumes of data to Excel by improving performance through pagination, concurrent queries, and custom cell‑merging strategies, including built‑in annotations and WriteHandler implementations, while providing complete Java code examples.
This article analyzes Google’s Tensor Processing Unit (TPU) as a purpose‑built AI ASIC, tracing its evolution from early GPGPU and FPGA solutions, detailing its MXU systolic‑array design, low‑precision advantages, performance benchmarks, power efficiency, cluster interconnect innovations, and software integration with TensorFlow.
The article explains how PyPy’s just‑in‑time compilation dramatically speeds up Python execution, often surpassing native C performance, by contrasting interpreted, ahead‑of‑time compiled, and JIT approaches and presenting a benchmark that shows PyPy completing a 100 million‑iteration loop in 0.22 seconds versus 10 seconds for CPython.
This article walks through nine practical techniques—default filters, smaller page sizes, fewer joins, index tuning, straight_join, data archiving, efficient count(*), ClickHouse offloading, and read/write splitting—to dramatically improve the performance of pagination APIs handling millions of product records.
This article thoroughly examines Apache Kafka’s architecture, covering its macro components, ack strategies, replication mechanisms, high‑watermark handling, leader election, and performance optimizations such as batch sending, compression, PageCache, zero‑copy, mmap and sendfile, while also explaining common pitfalls like data loss and log corruption.
This article explains V8’s compiler pipeline, core components, runtime flags, tagged pointers, object model, hidden classes, inline caches, fast/slow properties, and practical JavaScript performance tips, illustrating how assumptions, feedback, and JIT compilation achieve up to ten‑fold speed improvements.
This article compares four pagination techniques—MySQL LIMIT OFFSET, LIMIT with primary‑key filtering, HasMore scrolling, and Elasticsearch pagination—explaining their implementations, advantages, drawbacks such as deep‑page performance issues, and recommending appropriate scenarios for each method.
The article evaluates WebCodecs‑based video editing for browsers, comparing it to cloud and ffmpeg.wasm approaches, and concludes that its low cost and high extensibility outweigh limited ecosystem and compatibility, while outlining the required modules, OPFS storage, frame decoding, and spatial‑temporal manipulation techniques.
This article explains how databases handle insert operations, compares single‑row and batch inserts, discusses factors such as cache‑to‑disk synchronization, transaction logs, page size, hardware limits, and provides practical MyBatis examples for optimizing bulk data loading.
During performance testing of a Netty-based service, occasional message sends exceeded one second despite low CPU usage, prompting an investigation that identified a blocking ChannelHandler caused by a conditional sleep, leading to NioEventLoop thread stalls and delayed transmissions.
This tutorial walks you through creating a PHP project, initializing Composer, installing the FastRoute library, configuring routes with example code, running the built‑in server, and analyzing how call_user_func and routeInfo work to achieve high‑performance routing.
This article explains what Java virtual threads are, how they differ from regular OS threads, demonstrates configuring Spring Boot to use them, and presents performance benchmarks showing virtual threads dramatically outperform traditional threads in both async service calls and simple HTTP requests.
This article explains FastRoute, a high‑performance PHP routing library created by Nikita Popov, detailing its design, core dispatcher and router mechanisms, feature set, single‑regex compilation technique, code examples, and real‑world usage within the Webman framework.
This guide explains how to use the Linux /usr/bin/time utility to measure program execution time, memory usage, and other resources, covering its syntax, common options, custom format strings, and a comprehensive list of resource specifiers.
Android Dynamic Performance Framework (ADPF) lets apps and games send performance‑hint data—such as target work durations and preferred cores—to the kernel, enabling faster CPU frequency scaling and priority scheduling that mitigates the latency of PELT/WALT and DCVS, while developers use APIs like createHintSession and reportActualWorkDuration, though adoption remains limited.
This article recounts five successive performance optimizations applied to a SpringBoot‑Thymeleaf category‑tree API—adding Redis caching, scheduled async refresh jobs, local Caffeine memory cache, gzip compression via Nginx, and Redis data slimming—transforming query latency and scaling QPS from around 100 to over 500.
This article investigates whether MySQL varchar column length influences storage size and query performance by creating two tables with varchar(50) and varchar(500), inserting one million rows, measuring disk usage, and benchmarking various queries, ultimately revealing that storage is identical while longer columns can degrade performance during sorted scans due to increased temporary file usage.
At the 2024 Cloud Xi Conference, Alibaba Cloud expert Jia Xinyu detailed how Elasticsearch Serverless addresses core log‑analysis pain points with out‑of‑the‑box, high‑performance, pay‑as‑you‑go capabilities, delivering significant cost savings and eliminating operational overhead.
This article explains how MySQL writes data to cache before flushing to disk, compares single‑row versus batch inserts, discusses how hardware limits, transaction size, and lock contention affect performance, and shows how to estimate an optimal batch size with concrete calculations and MyBatis examples.
At the 2024 Alibaba Cloud Yúnxī Conference, senior AI Search expert Xing Shaomin detailed the enterprise‑grade Retrieval‑Augmented Generation (RAG) pipeline, covering critical link architecture, effectiveness, performance, and cost optimizations, as well as practical applications, vector store enhancements, LLM agents, and deployment strategies.
This article examines why and how to use local in‑process caches in Java, compares four implementations—ConcurrentHashMap, Guava Cache, Caffeine, and Ehcache—covers essential cache features, consistency challenges, hit‑rate optimization, and recommends Caffeine as the most performant choice for a two‑level caching architecture.
This article reviews the evolution of HTTP from its early versions to HTTP/3, explains the QUIC protocol and its advantages over TCP, and discusses connection establishment, migration, head‑of‑line blocking, congestion control, and flow control mechanisms that improve modern web performance.
This article explains why reading large Excel files with Pandas can be slow, introduces the Calamine engine as a faster alternative, provides installation and code examples, and suggests using more efficient file formats like CSV, Feather, or Parquet to improve performance and reduce memory usage.
This guide explains how to use the Linux /usr/bin/time utility to measure program resource usage, covering its syntax, useful options, custom format strings, a full list of resource specifiers, and the difference between the external command and the shell builtin.
This article investigates a production issue on Java 21 where virtual threads cause Tomcat to stop processing requests, closeWait sockets to accumulate, and locks to deadlock, detailing the diagnostics, thread‑dump analysis, lock inspection, and the eventual conclusions about virtual‑thread behavior.
Chrome 129’s new scheduler.yield() lets developers pause long‑running JavaScript loops without the 4 ms minimum delay or queue‑end placement of setTimeout(), cutting execution time from ~17 s to ~5.6 s while keeping the page responsive and preserving task priority.
This article explains what Java virtual threads are, compares them with ordinary platform threads, shows how to enable them in SpringBoot, and presents performance benchmarks that reveal virtual threads can be up to two hundred times faster for I/O‑bound workloads.
This article introduces the Caffeine Java caching library, detailing its features, core classes and parameters, various loading strategies—including manual, automatic, and asynchronous loading—eviction policies, removal listeners, and cache statistics, accompanied by practical code examples for integration in backend applications.
This guide introduces Caffeine, a high‑performance Java caching library, explains its core features, configuration options, loading strategies—including manual, automatic, asynchronous, and async loading caches—eviction policies, removal listeners, and statistics collection, providing code examples for each use case.
This article explains the technical differences between GDDR and HBM GPU memory, compares their bandwidth, cost, and use‑case scenarios, and helps engineers decide which memory type best fits their performance and efficiency requirements.
MySQL Innovation Edition 9.1.0, released on October 15 2024, introduces atomic DDL operations, enhanced audit and firewall handling, numerous compiler and SQL function fixes, JavaScript stored‑procedure improvements, new vector support, updated keyring security, pluggable authentication fixes, expanded GROUP REPLICATION logging, and several EXPLAIN and performance‑schema enhancements.
MySQL 9.1.0, released on October 15, 2024, introduces DDL atomicity, improved audit handling, new JavaScript defaults, VECTOR type support, enhanced GROUP REPLICATION logging, expanded EXPLAIN output, and numerous bug fixes across SQL syntax, performance, and security, while the 8.4.3 LTS patch remains feature‑free.
The article explains how using the Function Object Programming pattern in PHP can increase memory usage, introduce late‑binding overhead, and add indirect call costs, and it provides a concrete benchmark comparing traditional functions with function objects.
This article analyzes the performance differences between native Java reflection and Spring Framework's ReflectionUtils by running benchmark tests, examining source code caching mechanisms, and explaining why ReflectionUtils can be faster for repeated method and field access in backend applications.
This article provides a comprehensive technical overview of modern GPU architecture, covering memory hierarchy, compute units, shader execution, rendering pipelines, and performance‑optimisation techniques such as unified shaders, SIMT, warp scheduling, and tile‑based rendering strategies.
The article details MNN’s CPU backend dynamic quantization for Transformer‑type models, describing runtime int8 conversion, block‑wise matrix‑multiply optimizations using ARM SMMLA/SDOT and AVX‑512 VNNI, weight‑group and batch‑wise quantization techniques, and reports up to three‑fold speed‑ups on Snapdragon 8 Gen 3.
This article details the design and optimization of Kola2d, a custom WebGL rendering engine for Docs online spreadsheets, explaining why WebGL was chosen, how the system separates business and rendering layers, and the many performance tricks that enable smooth 50+ FPS rendering of tables with up to a million cells.
Updating billions of rows in a MySQL table can overwhelm binlog replication and cause deep‑pagination inefficiencies, so this article explains the pitfalls of direct UPDATE, explores limit‑based and IN‑based approaches, and presents a production‑ready batch update strategy using NO_CACHE and forced primary‑key indexing.
µExpress is a micro‑Express framework built on µWebSockets that offers full Express 4 compatibility while delivering 5‑10× higher request throughput across routing, middleware, and static‑file scenarios, as demonstrated by detailed wrk benchmarks and best‑practice guidelines.
Intel’s newly released 2023‑2025 Xeon roadmap outlines the upcoming Emerald Rapids, Granite Rapids, Sierra Forest, and Clearwater Forest processors, detailing their core counts, cache sizes, process technologies, and how they aim to compete with AMD’s EPYC line across HPC, AI, and cloud workloads.
This article explores the Jamstack architecture—its core concepts of JavaScript, APIs, and markup, the essential tooling like static site generators and headless CMS, and examines its performance, security, scalability benefits alongside challenges such as dynamic content handling, build times, and SEO, offering practical best‑practice recommendations.
This article examines Go’s internal lock‑free single‑producer multi‑consumer queues—PoolDequeue and its dynamic extension PoolChain—detailing their design, atomic operations, and benchmark comparisons that show they can be up to ten times faster than standard channels in a producer‑consumer workload.
The article analyzes why a high‑concurrency data‑collection service quickly saturates a 100 Mbps uplink due to large TLS handshake payloads, demonstrates the bandwidth savings of switching to plain HTTP or using Keep‑Alive, and highlights practical considerations for secure versus performance‑optimized deployments.
This article walks through a systematic investigation of a slow‑starting Dubbo service built on Spring 3.2, using JProfile to pinpoint costly class‑loading checks, disabling unnecessary annotation processing, and resolving thread‑waiting issues caused by RabbitMQ and other components, ultimately reducing deployment time by about 40%.
This article demonstrates how to create various parameterized decorators in Python—including logging, performance measurement, authentication, caching, and file logging—by providing clear explanations and complete code examples for each use case in practical applications.
This article compiles a comprehensive set of MySQL index interview questions covering index types, usage scenarios, the left‑most prefix rule, optimization techniques, index fragmentation, InnoDB clustered vs. non‑clustered indexes, composite and spatial indexes, full‑text indexes, the concept of "back‑table" lookups, execution plans, EXPLAIN output columns, and practical tips for interpreting and improving query performance.
This article introduces the Astro static‑site framework, explains its island architecture and performance advantages, compares Core Web Vitals with other frameworks, and provides detailed code examples and best‑practice guidelines for integrating Astro with React and Vue in real‑world projects.
This article explains why a pre‑ads loading step is required for Android apps, analyzes the limitations of the current linear startup flow, and details several technical solutions—including system‑API checks, exclusion rules, handler hooking, and initialization reversal—to reliably detect icon‑click launches and reduce startup latency.
While Python dominates data analysis and machine learning with its ease of use, Rust offers memory safety and near‑C performance; this article examines their respective strengths, the challenges of rewriting the Python interpreter in Rust, and how combining both can boost library speed and reliability.
A cloud‑native CI platform called CNB uses a custom git‑clone‑yyds plugin and Copy‑on‑Write overlayfs to reduce cloning of the 124 GB AOSP source tree from 20 minutes to a few seconds while keeping cache safe for high‑concurrency pipelines, dramatically cutting overall build time.
This article shares the most frequent Go middleware pitfalls encountered at Alibaba, explains their root causes—from uneven request distribution and CPU leaks to transaction mishandling and SQL incompatibilities—and provides concrete solutions and best‑practice recommendations to help developers avoid repeating these errors.
This article explains how Kafka achieves ultra‑high throughput and low latency despite being disk‑based, covering its Reactor I/O network model, zero‑copy techniques, partitioning strategies, segment logs with sparse indexes, sequential disk writes, page cache usage, compression, batch processing, and lock‑free offset management.
This article explores Goja, a pure‑Go JavaScript engine, detailing its features, integration with the K6 load‑testing tool, and practical code examples for embedding scripts, passing values, handling structs, invoking Go functions, error handling, and VM pooling to achieve high performance in Go applications.
This article details the discovery, analysis, and fix of a severe thread‑leak issue in a Java Spring MVC service caused by unsafe use of a shared CloseableHttpAsyncClient, showing how multithreaded testing reproduced the problem and how refactoring the client to a local variable eliminated the runaway thread growth.
This guide introduces Alibaba Cloud ARMS RUM, explains its core capabilities, walks through Android and iOS SDK integration, permission and ProGuard setup, and demonstrates how to analyze sessions, resources, API calls, custom events, and logs to optimize user experience across cloud‑native applications.
Cloudflare replaced NGINX with its self‑developed Rust proxy Pingora, detailing why the legacy architecture fell short, the design decisions behind building a new internal proxy, and how Pingora delivers significantly higher performance, efficiency, and security for trillions of daily requests.
Python 3.13, released on October 7, introduces experimental free‑threading to bypass the GIL, a new JIT compiler based on a copy‑and‑patch algorithm, an enhanced interactive REPL, incremental garbage collection, broader platform support, and API stability improvements, all aimed at boosting performance and scalability.
This article introduces RediSearch, compares its memory usage and query performance with Elasticsearch on modest hardware, shows installation steps, demonstrates core index commands and Java integration, and concludes with practical advice on using RediSearch as a lightweight full‑text search engine.
This guide explains how to enable and fine‑tune NGINX Plus content caching, covering cache zones, key definitions, loader settings, cache bypass, purge configuration, byte‑range slicing, and practical examples for optimizing performance and reducing backend load.
This article explains how React Hook Form, a React‑hooks‑based library, reduces form boilerplate, improves readability, and optimizes performance through built‑in validation, smart dependency tracking, and minimal re‑renders, providing code examples and a deep dive into its register implementation.
This guide introduces Swow—a lightweight C core and PHP‑based library for high‑performance network programming—covers its key features, step‑by‑step installation, coroutine concepts, channel communication, and provides practical HTTP and TCP server code samples for PHP developers.
PostgreSQL 17, released on September 26 2024, brings major performance upgrades, enhanced memory management, faster vacuum, improved I/O, new SQL/JSON features, expanded logical replication, stronger security options, and a host of additional tools that modernize database development and administration.
This guide details eleven frequent Jenkins problems—including Performance plugin incompatibility, CSP restrictions, custom URL paths, Git clone timeouts, jar replacement, CSRF disabling, disk‑space optimization, global environment variables, managed scripts, and lightweight backups—along with step‑by‑step solutions and configuration snippets.
This article provides a comprehensive overview of Linux's io_uring, explaining its design goals, shared‑memory mechanism, submission and completion queues, core system calls, performance advantages over traditional I/O models, typical use cases, and includes a complete example of a network server built with io_uring.
PostgreSQL 17, announced on 2024‑09‑26, brings major performance upgrades, extensive SQL/JSON enhancements, improved logical replication, new security and management options, and a host of developer‑friendly features that position it as the world’s most advanced open‑source database.
This article evaluates MySQL's recommendation to avoid UUID or non‑sequential snowflake IDs by benchmarking three tables—auto‑increment, UUID, and random key—using Spring Boot and JdbcTemplate, then analyzes their index structures, insertion speed, and trade‑offs.
This article explains when to use NOT NULL versus NULL in relational database schemas, covering required fields, optional columns, unknown‑state representation, foreign keys, performance impact, versioning, data analysis, migration, default values and JSON types, with concrete SQL examples and practical guidance.
This article explains why and how to migrate a large Vue 2 Webpack codebase to Vite, applying Simon Sinek's Golden Circle model to clarify motivation, method, and concrete steps, and demonstrates the resulting dramatic reduction in build time and bundle size.
When a Linux server shows performance issues, the first minute is critical; this guide walks you through ten standard command‑line tools—uptime, dmesg, vmstat, mpstat, pidstat, iostat, free, sar, and top—explaining what each metric means and how to interpret the output for quick troubleshooting.
A collection of Zhihu users compares SQL Server and MySQL, highlighting SQL Server's superior locking, performance on massive tables, richer backup and restore tools, tighter C# integration, and enterprise adoption, while acknowledging MySQL's free, lightweight nature and its historical limitations.
This article provides a comprehensive overview of Nginx's high‑performance architecture, including its core, basic, and third‑party modules, master‑worker process model, asynchronous non‑blocking I/O mechanisms, FastCGI and PHP‑FPM integration, and practical configuration and tuning tips for optimal server operation.
To accelerate PHP database operations, the article explains how to use persistent connections with mysqli or PDO, implement a connection pool via a custom class, and cache query results using Memcached or Redis, detailing code examples for each technique.
The JD App backend hotkey framework instantly detects bursty hot data, users, and interfaces, pushes the hot keys to all JVMs in the cluster, and dramatically reduces database load while supporting fine‑grained rate limiting and caching across distributed services.
This article presents five practical Java performance tweaks—pre‑allocating HashMap capacity, using object keys, caching Enum values, replacing String constants with Enums, and upgrading the JDK—backed by JMH benchmarks that show up to 9.5× speed gains.
This article explains the design and implementation of MySQL's SQL flow‑control feature, covering its purpose, architecture, external commands, rule management, matching logic, data‑access layer, performance considerations, usage guidelines, and known limitations.
Optimizing database performance is crucial for PHP applications, and this comprehensive guide explores advanced strategies—including efficient query design, indexing, caching, connection pooling, batch processing, sharding, and partitioning—to maximize speed, scalability, and user experience while reducing latency and server load.
This guide explains how to systematically diagnose Linux performance issues using tools such as top, vmstat, perf, and flame graphs, covering CPU, memory, disk I/O, network, and load analysis, and demonstrates a real-world nginx case study with step‑by‑step commands and visualizations.
This article explains why monitoring route changes in React single‑page applications is crucial, compares three primary techniques—useLocation, useNavigate, and withRouter—provides practical code examples, evaluates their pros and cons, and offers performance‑optimisation tips for reliable routing handling.
This article investigates whether defining a VARCHAR column with a larger length (e.g., VARCHAR(500) vs VARCHAR(50)) changes storage consumption and query speed in MySQL by creating two identical tables, inserting one million rows, measuring space usage, and benchmarking various SELECT and ORDER BY operations.
This comprehensive guide explains Python's built‑in logging module, covering basic setup, log levels, handlers, formatters, advanced configurations, performance optimizations, and best‑practice recommendations to help developers create clear, efficient, and maintainable logs for any application.
This article provides a thorough overview of Linux kernel debugging techniques, covering pseudo‑filesystems such as procfs, sysfs, debugfs and relayfs, as well as essential tools like printk, ftrace, trace‑cmd, kprobe, systemtap, kgdb, kgtp, perf, and other modern tracers, helping developers diagnose and optimise kernel behavior.
The article details Didi's comprehensive use of Elasticsearch across all online retrieval scenarios, covering its physical‑machine architecture, gateway and control layers, data synchronization methods, cross‑datacenter replication, JDK17 + ZGC performance upgrades, cost‑saving ZSTD compression, multi‑tenant isolation, custom security, and ongoing stability practices leading to a planned upgrade to Elasticsearch 8.13.
This article explains Rust's Clone‑On‑Write (COW) feature, showing how it reduces unnecessary memory allocations, detailing its internal enum variants, typical use cases, performance benefits, limitations, and providing practical code examples for function return values and string concatenation.
This article explains how the new global function structuredClone() provides a reliable, fast, and simple way to deep‑clone JavaScript objects—including nested structures, circular references, and undefined values—outperforming traditional JSON or manual recursion methods.
This article provides a comprehensive overview of MySQL indexing, covering index classifications, B+Tree and Hash structures, primary and secondary (clustered and non‑clustered) indexes, covering index push‑down, index merge, covering indexes, cost‑based index selection, and common pitfalls that cause index inefficiency.
The article explains JD's technical solution for developing HarmonyOS native applications with the Taro cross‑platform framework, detailing the chosen architecture, CSS adaptations, performance optimizations, and future enhancement plans that resulted in significant rendering speed gains.
Rsbuild 1.0, built on the high‑performance Rspack engine, offers a lightweight, easy‑to‑use TypeScript‑friendly API, dramatically faster dev/startup times, fewer dependencies, and a rich plugin ecosystem, positioning it as the most efficient modern frontend build tool compared to CRA, Vite, and Rspack CLI.
This article explores the modern JavaScript global function structuredClone() as a robust solution for deep cloning objects, comparing it with traditional spread, JSON methods, and custom recursion, and covering handling of circular references, functions, undefined values, performance benchmarks, supported types, and limitations.
This article provides a comprehensive guide to MySQL indexing, covering index types, data structures, clustering and non‑clustering indexes, hash indexes, B+Tree mechanics, index lookup, covering indexes, index push‑down, index merge, cost‑based index selection, common pitfalls, and best practices for designing effective indexes.
This article introduces experienced Python developers to advanced techniques and best practices, covering high‑level data structures from the collections module, custom data structures, decorators and context managers, metaclasses, dynamic class creation, concurrent and asynchronous programming, performance tuning, memory management, coding standards, and testing strategies.
This comprehensive guide walks backend architects through six core optimization methods—caching, batch processing, asynchronous handling, data compression, parallelization, and eliminating unnecessary requests—detailing their problem domains, implementation strategies, real‑world scenarios, benefits, and trade‑offs.
This article walks through a Python solution for quickly counting rows in each sheet of a large Excel workbook, comparing pandas with the Calamine engine, Polars, and optimization tips to cut processing time from dozens of seconds to just a few.
In Android, Bundles backed by memory‑efficient ArrayMap use binary search and shrinkable storage, making them far smaller and faster to transmit than HashMaps, whose fixed‑size growth and lack of shrinkage consume more memory; thus Parcelable Bundles are preferred for IPC, while Serializable remains suited only for persistent storage.
This article provides a comprehensive overview of Java garbage collection, covering the principles of reference counting and reachability analysis, detailing major GC algorithms such as mark‑sweep, copying, and mark‑compact, explaining object allocation strategies, and reviewing traditional and modern collectors like Serial, CMS, and G1, with practical tuning tips for each.
This article explains four typical cache problems—penetration, avalanche, breakdown, and distributed cache efficiency—describing their causes and offering practical mitigation strategies such as top‑level filtering, Bloom filters, staggered expirations, null caching, and locking mechanisms.
