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 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.
This report analyzes performance bottlenecks caused by serialization in a search‑recommendation system, presents detailed measurements of request latency, evaluates multiple optimization strategies—including Redis caching, lazy metric handling, and custom byte‑array serialization—and documents the resulting latency reductions and implementation considerations.
This article walks you through a systematic approach to identify the root cause of a Linux server's CPU hitting 100%, from pinpointing the high‑load process with top, tracing the responsible business code, to using a custom shell script that streamlines thread analysis and resolves the overload.
This article explains why traditional Python multithreading tutorials are often overly complex, introduces the concise map‑based approach using multiprocessing and multiprocessing.dummy ThreadPool, demonstrates performance gains with real‑world examples, and provides ready‑to‑run code snippets for efficient parallel execution.
Bun v1.1.25 boasts a benchmark of 1.29 million HTTP requests per second and adds node:cluster support, V8 C++ API bindings, a five‑fold S3 upload boost, standalone worker executables, Windows OMGJIT for WebAssembly, plus numerous Node.js compatibility fixes, all illustrated with code examples.
Laravel’s Benchmark tool enables developers to measure execution time of code snippets, compare multiple scenarios, run iterative tests for accuracy, retrieve results with execution duration, and apply these insights to optimize queries and improve overall application performance.
This article compares Maven and Gradle, outlining their core concepts, build performance, flexibility, learning curve, and stability to help Java developers choose the most suitable build tool for their projects.
This article examines why storing a string's length in a variable can improve loop performance in JavaScript, explains primitive data types and their wrapper objects, and demonstrates the underlying mechanisms with code examples and timing tests.
The Daily Must‑Grab mini‑program order system evolved from a DX XML‑based UI to a React‑like Rax framework and finally to a native Ao Chuang solution, delivering cross‑platform support, smaller bundles, faster launches, better async handling, and extensible plug‑in architecture while leveraging Taobao’s transaction core.
This article explains how MySQL uses B‑tree‑based indexes, covering balanced binary trees, B‑trees, B+‑trees, various index types, data‑type effects, and best practices for creating and using composite indexes to optimize query performance.
This article examines the migration from Thanos to VictoriaMetrics for large‑scale metric storage, detailing background challenges, VictoriaMetrics architecture and storage engine, data write and read processes, and a comparative analysis of performance, scalability, and operational costs between the two systems.
This article analyzes four major performance problems of UI rendering on HarmonyOS—excessive view hierarchy, long communication pipelines, poor list rendering, and secondary layout—and presents a C‑based native component solution with code examples to improve cross‑platform UI performance.
A growing movement among web developers, highlighted by Pieter Levels and Alex Russell, argues that relying on basic HTML, PHP, lightweight jQuery, and progressive‑enhancement principles can outperform heavyweight JavaScript frameworks in speed, maintainability, and accessibility.
This article walks through Elasticsearch’s licensing history, version selection, installation, cluster health monitoring, shard routing, storage mechanisms, refresh and translog processes, segment merging, and practical performance optimizations such as disk choices, index settings, and JVM tuning.
The article compares Maven and Gradle, detailing their histories, core concepts, advantages, disadvantages, and performance differences, and offers practical advice for Java developers on choosing the most suitable build tool for their projects.
The article analyzes a production out‑of‑memory crash triggered by a pagination bug that misused the OFFSET parameter, explains why the error escaped testing and code review, and presents corrected pagination techniques for Oracle, MySQL and MyBatis to prevent similar failures.
This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.
Testing 150 popular domains from four Chinese cities shows OneDNS public version consistently leads with 9‑19 ms latency, followed closely by Alibaba DNS, while 114DNS, Tencent DNSPod and 360DNS lag behind, prompting users to seek free alternatives as Alibaba’s unlimited service becomes paid.
StarRocks 3.3.1 introduces a cloud‑native persistent index that moves index files to object storage, eliminates local‑disk constraints, and supports elastic scaling, delivering up to ten‑fold latency improvement over local‑disk indexes in elastic scheduling while matching performance in batch and real‑time imports.
This article explains why a direct full‑table UPDATE on a massive MySQL table can overwhelm binlog replication, explores the pitfalls of deep pagination and IN‑clauses, and presents a batch‑processing strategy using NO_CACHE and FORCE INDEX to achieve efficient, low‑impact updates.
This article traces the evolution of Java string concatenation from the simple '+' operator through JDK 8’s StringBuilder implementation, the JDK 9+ StringConcatFactory with invokedynamic, and Alibaba’s PR 20273 that introduces hidden‑class bytecode generation, highlighting performance gains and startup‑time improvements.
A Fastly engineer discovered that increasing CPU cores can degrade Go channel performance due to lock contention, and this article reproduces the benchmarks, explains why goroutine count—not CPU count—is the real culprit, and offers practical optimization techniques.
Rspack 1.0, the Rust‑implemented next‑generation JavaScript bundler compatible with webpack APIs, launches with major performance gains, broader plugin compatibility, smaller bundle sizes, Module Federation 2.0 support, and a roadmap that includes faster HMR, portable caches, and deeper TypeScript integration.
This article introduces Python decorators—such as retry, timeout, logging, caching, response validation, parameterization, exception handling, performance monitoring, permission checking, and composite usage—and provides complete code examples showing how they simplify and strengthen automated API testing.
This article dissects the massive 5‑万‑line checker.ts file in the TypeScript compiler, explaining why the team packed the entire type‑system logic into a single file, how low‑level decisions like named‑parameter comments, heavy use of const enum, ESM/CJS export patterns, var usage, and lack of try‑catch affect V8 performance, and what these choices reveal about TypeScript’s evolution.
This article explains how pandas loc and iloc work, demonstrates their slow performance when used inside loops, and shows that using the at and iat accessors provides a dramatically faster alternative for scalar assignments in DataFrames.
This article explains why Python may run slower than compiled languages, introduces methods for detecting performance bottlenecks, and presents six practical techniques—including using timeit, memory_profiler, line_profiler, built‑in functions, f‑strings, list comprehensions, and lru_cache—to significantly speed up Python programs.
This article traces Elasticsearch's transformation from a pure text search engine to a versatile hybrid platform that integrates structured, geospatial, aggregation, and vector search capabilities, highlighting its AI-driven innovations, performance optimizations, and growing adoption across enterprises and academia.
This article explains why pandas loc/iloc operations inside Python loops are extremely slow, demonstrates the performance difference with concrete examples, and shows that using the scalar‑access methods at and iat can speed up the same task by dozens of times.
This article provides a step‑by‑step analysis of MySQL 8.0.32 InnoDB deadlock logs, covering preparation, log extraction, auxiliary information, transaction details, row‑lock structures, and the final summary, with full SQL examples and code snippets for deep understanding.
This article introduces the high‑performance Caffeine caching library for Spring Boot 3.2, explains its core features, demonstrates detailed performance benchmarks, and provides practical code examples covering synchronous and asynchronous operations, eviction policies, removal listeners, refresh mechanisms, and statistics collection.
The article explains how PHP getters and setters encapsulate private properties, reduce coupling, and enable lazy loading and result caching, thereby improving code clarity, maintainability, and overall system performance.
The article shares a developer’s experience migrating two large Webpack projects to Rspack, covering why Rspack was chosen, detailed lessons on TypeScript handling, CSS extraction, service‑worker support, plugin compatibility, CLI differences, performance benchmarks, and future expectations for the Rust‑based bundler.
This article presents a practical guide for backend developers to troubleshoot Linux performance problems, covering essential analysis tools, a systematic diagnosis method, and detailed checklists for CPU, memory, disk I/O, and network I/O issues.
