This article explains how Ceph cache pools work, compares read‑only and write‑back cache types, provides step‑by‑step commands for creating and configuring cache pools, adjusting CRUSH rules to target SSDs, and outlines safe removal procedures for both cache modes.
This article introduces JMH, explains why it outperforms simple loops or other tools, and provides step‑by‑step Maven setup, benchmark creation, execution, and advanced annotations such as @Warmup, @Fork, @Setup, Blackhole usage, and SpringBoot integration for accurate Java micro‑benchmarking.
This article explains Java virtual threads introduced in Java 19, compares them with traditional OS threads, shows how to enable them in Spring Boot, and presents performance benchmarks that demonstrate dramatic latency reductions for I/O‑bound workloads.
This article investigates whether defining a VARCHAR column with a larger length affects MySQL storage space and query performance by creating two tables with VARCHAR(50) and VARCHAR(500), inserting one million rows, and measuring storage usage and execution times for various queries.
This article presents ten practical Java 17 tips—ranging from using Optional and String.valueOf() to leveraging Arrays.copyOf, isEmpty(), pre‑compiled regex, and generics—to avoid common pitfalls, improve performance, and write more readable and robust backend code.
This article explores how the depth of a webpage's DOM tree influences memory usage, style calculations, and rendering performance, presenting experiments that compare shallow and deeply nested structures and offering practical tips for monitoring and optimizing DOM depth.
The article discusses a top architect's interview with a game company about microservice adoption, explains why real‑time performance and stateful requirements often make microservices unsuitable for game servers, and presents multiple expert opinions highlighting latency, network overhead, and team size considerations.
This article explains how Java's parallelStream uses the shared ForkJoinPool, why developers may need to customize the thread pool for better performance and isolation, and provides two approaches—setting the system property and creating a dedicated ForkJoinPool—along with complete code examples and execution results.
This article explores essential Linux I/O techniques, covering basic file operations with system calls like open, read, write, and close, advanced methods such as memory‑mapped files and asynchronous I/O, network programming with sockets and multiplexing, plus performance‑tuning strategies for efficient resource utilization.
To handle high‑traffic web workloads, the default Linux kernel settings must be adjusted; this guide explains the key sysctl parameters—such as file‑max, tcp_tw_reuse, tcp_keepalive_time, and buffer sizes—and how to apply them for optimal Nginx concurrency.
This article explains the common slow approach of reading Excel files with POI and inserting rows via JDBC, then presents three practical optimizations—caching data, using asynchronous multithreaded reads, and per‑file async processing—along with thread‑pool configuration tips and EasyExcel examples to dramatically reduce import time from minutes to seconds.
This article details Zhihu's migration of massive Spark and MapReduce shuffle workloads from the External Shuffle Service (ESS) to a push‑based Remote Shuffle Service (RSS) powered by Celeborn, covering background problems, evaluation of open‑source implementations, deployment architecture, encountered issues, solutions, performance gains, and future plans.
Claude 3.5 Sonnet, Anthropic’s latest large language model, is evaluated across a range of Chinese‑language tasks, visual reasoning, coding, and game creation, showing faster, cheaper, and often superior results compared to GPT‑4o, while also revealing occasional failures in simple games and math problems.
This article explains the subtle differences between the hostname localhost and the IP address 127.0.0.1, covering their definitions, resolution processes, performance impact, IPv6 considerations, practical usage scenarios, and best‑practice recommendations for developers.
This article details the motivation, design, implementation, testing, and rollout of a refactored Kubernetes DNS solution that replaces the default kube-dns → CoreDNS chain with a node‑local q‑dnsmasq cache and parallel upstream queries to achieve higher availability, faster resolution, and better cache hit rates in large‑scale clusters.
This article provides a detailed comparison of InfiniBand and RoCEv2 network architectures, examining their technical features, flow‑control mechanisms, performance, cost, and suitability for AI compute environments to guide designers in selecting the optimal solution.
The article measures the exact time cost of establishing and closing a MySQL connection from Java, breaks down each network and protocol step with Wireshark captures, and shows how these latencies add up to hundreds of milliseconds, making connection pooling essential for high‑traffic web services.
This article explains the cache‑stampede problem when hot Redis keys expire under massive traffic, illustrates why simple caching fails, and presents a mutex‑lock solution with Go code to safely rebuild caches while protecting the database.
To keep a WeChat mini‑program under the 2 MB limit and improve both startup and runtime performance, the article proposes splitting the main bundle into async sub‑packages, removing unused code, pre‑fetching data, using on‑demand imports, and implementing a backend‑driven size‑control and CI release gate.
Learn how to boost Node.js application performance using the popular lru-cache package, covering the LRU algorithm fundamentals, basic installation and usage, advanced features like peek, fetchMethod, and custom disposal, plus an in‑depth look at its internal Map and doubly‑linked list implementation.
This article explains the concept of API gateways, compares popular solutions such as Kong, Zuul, Spring Cloud Gateway and Tyk, details Kong's architecture, features, performance benchmarks, deployment scenarios, monitoring setup, and the practical problems encountered with their resolutions.
The MoonWebTeam Frontend Tech Monthly curates the latest front‑end frameworks, performance optimization case studies, AI innovations, domain‑driven design insights, and practical best‑practice techniques, offering developers a comprehensive snapshot of cutting‑edge web development trends.
This article investigates the mysterious "prevent gc" comment in RocketMQ source code, explains how Thread.sleep(0) interacts with JVM safepoints and counted loops, and demonstrates practical fixes by changing loop indices or inserting explicit safepoint calls.
At PyCon 2024, experts demonstrated how static typing, Cython compilation, static‑linked C extensions, and sub‑interpreter architectures can dramatically accelerate Python code, reduce runtime overhead, and mitigate GIL limitations, offering practical pathways for faster, more scalable Python applications.
This article walks through a series of practical performance‑boosting techniques for Vue‑based web applications, covering Webpack bundle analysis, Gzip compression, WebP image conversion, HTTP/2 configuration, Nginx tweaks, and OSS/CDN integration, with concrete code snippets and step‑by‑step guidance.
This article compares Google’s Protocol Buffers and the Swagger/OpenAPI framework, detailing their features, data formats, use cases, flexibility, development workflows, and why Google created protobuf, helping developers choose the right tool for high‑performance data serialization or comprehensive API documentation.
The article analyzes Nvidia’s historic advantage, the massive performance and energy efficiency gains from Pascal to Blackwell GPUs, the economics of training large language models like GPT‑4, and the detailed roadmap of upcoming GPU, memory, and interconnect technologies shaping the future of data‑center AI.
This article explains common scenarios that cause MySQL or Java processes to consume 900% CPU, walks through step‑by‑step diagnosis using Linux tools, and provides concrete optimization techniques such as indexing, caching, thread analysis, and code adjustments to bring CPU usage back to normal levels.
This article examines the performance differences between using the '+' operator and StringBuilder for string concatenation in Java, presenting JUnit benchmark tests for simple concatenations and looped concatenations, analyzing compiled bytecode, and concluding that '+' is suitable for simple cases while StringBuilder excels in loops.
This article compiles seven hands‑on Linux performance optimization experiences, covering key performance factors, rapid troubleshooting steps for CPU, memory, disk and network issues, load‑average analysis, top‑process identification, memory‑stat discrepancies, swap usage scenarios, and detailed TCP kernel tuning recommendations.
The author benchmarked Go's standard HTTP library against PHP frameworks Workerman, Webman, and Swoole (including coroutine mode) on a 4‑core Ubuntu 20.04 Aliyun instance using ApacheBench with and without keep‑alive, revealing that Workerman and Webman often outperform Go in raw request‑per‑second throughput.
This guide introduces Memray, a powerful Python memory analysis tool, explains how to install it, run command‑line profiling, integrate it into code with the Tracker API, interpret detailed reports, and apply advanced filtering and merging techniques while noting its runtime overhead.
This article explains Hugging Face's KV cache quantization technique, detailing how it reduces memory usage for long‑context LLM generation, the underlying quantization methods, implementation steps in 🤗 Transformers, benchmark results versus fp16, and the trade‑offs between speed, memory, and accuracy.
This article presents twelve practical guidelines for Java logging, covering interface‑layer usage, avoiding separator lines, preventing logging‑induced exceptions, leveraging Fastjson features, preserving exception stacks, limiting message length, merging stack traces, skipping costly placeholders, avoiding console output, discarding redundant utilities, and adhering to Alibaba's logging specification.
Traditional LAMP stacks, relying on php‑fpm and nginx, suffer from synchronous blocking and high CPU usage, limiting throughput for IO‑intensive microservice workloads, while benchmarks show that upgrading to PHP 7 and using a modern, asynchronous PHP framework like Webman can dramatically improve QPS and reduce latency.
The article examines Peter Zaitsev’s critique of Oracle’s stewardship of MySQL, debunks long‑standing myths, evaluates recent MySQL Heatwave features and performance gaps, and compares MySQL’s trajectory with PostgreSQL and other open‑source databases.
This guide compiles practical Nginx performance‑tuning directives, FastCGI settings, Linux kernel parameter adjustments, security hardening tips, and monitoring configurations, providing concrete examples and command‑line snippets to help sysadmins and developers optimize high‑concurrency web services.
This article analyzes MySQL's recommendation to avoid UUID or non‑sequential random primary keys by benchmarking insert performance across three tables—auto_increment, UUID, and random key—explaining the underlying index structures, observed speed differences, and the trade‑offs of each approach.
This article examines four common WeChat red packet distribution algorithms—simple random, double‑mean, line‑segment division, and array_rand optimization—explaining their principles, PHP implementations, performance characteristics, and how to verify randomness, providing code samples and comparative analysis for developers.
This article explains how to design a MySQL table for product sales statistics, initialize massive test data, and compare several query strategies—including loop queries, OR‑concatenated dynamic SQL, mixed filtering, and the SQL‑92 row‑comparison technique—to efficiently retrieve sales figures for multiple business units and their products without violating development constraints.
This guide introduces Uber’s open‑source Zap library for Go, explains its performance‑focused features, shows how to install and configure it, and provides step‑by‑step code examples for basic logging, sugared logging, level control, file output, and log rotation.
This article analyzes the performance bottlenecks of an H5 map built with the AMap JS‑SDK, explains the causes of frame drops on low‑end devices, and presents a step‑by‑step refactor using data‑fetching tweaks, DistrictCluster aggregation, and conditional rendering to achieve smoother interactions.
Microsoft’s Windows now runs on Qualcomm’s ARM processors through a combination of native kernel adaptations, driver and library recompilation, and an x86‑to‑ARM emulation layer, balancing performance gains from direct ARM execution with compatibility‑driven overhead, while outlining ongoing optimization efforts and future prospects.
The article explains how Fast‑Retry, an asynchronous multi‑task retry framework, dramatically outperforms synchronous retry libraries like Spring‑Retry and Guava‑Retry when handling massive workloads, and provides step‑by‑step code examples, performance benchmarks, and integration tips for Java developers.
This whitepaper examines the industry trend of moving data‑intensive analytics workloads to cloud‑native platforms, analyzes the unique cost model of cloud storage, and presents case‑study findings from Uber's Presto production environment to guide efficient I/O design and cost‑effective performance optimization.
The article explores how Nordic programmers like Linus Torvalds, Andreas Kling, and Ville Turjanmaa have built full operating systems—from Linux to SerenityOS and the assembly‑only MenuetOS—highlighting their motivations, technical achievements, performance gains, and the cultural environment that fuels such ambitious open‑source projects.
Tencent News upgraded its recommendation architecture by consolidating data platforms, redesigning index and feature services, adopting DDD and Lambda/Kappa patterns, and adding robust debugging and stability measures, which boosted availability to 99.99%, cut CPU, memory and cost by over 60%, and accelerated development and experiment cycles.
This article explains Java virtual threads, compares them with traditional OS threads, shows how to enable them in SpringBoot 3, and presents performance benchmarks demonstrating up to 200‑fold speed improvements for I/O‑bound workloads.
This article compares Java's standard ThreadLocal with Netty's FastThreadLocal, explains their internal mechanisms, shows practical code examples, runs a JMH microbenchmark, and discusses performance, memory management, and usage scenarios to help developers choose the right thread‑local storage solution.
This article introduces several MySQL performance‑diagnostic utilities—including mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explains how to download and run them, interprets their reports, and also contains promotional material for unrelated AI services.
The article defines large database transactions, explains their performance and replication risks, offers practical guidelines to avoid them, demonstrates a MySQL example that creates and repeatedly inserts data to illustrate growing execution time, and discusses challenges and solutions for handling massive tables in high‑traffic environments.
An in‑depth postmortem of a costly MySQL data‑migration failure caused by using INSERT INTO SELECT without proper indexing, detailing the OOM issue, full‑table scans, lock contention, and best practices to safely employ the statement.
FrankenPHP, a Go‑based PHP application server built on Caddy, claims to double web request performance and halve developer/DevOps workload, offering container‑ready deployment, automatic HTTPS, native PHP extensions, in‑memory mode, structured logging, Prometheus metrics, and experimental HTTP/3 support.
This article outlines seven typical cache problems—including cache penetration, breakdown, avalanche, large keys, hot keys, hit‑rate issues, and data inconsistency—and provides practical solutions such as parameter validation, Bloom filters, null‑value caching, locking, auto‑renewal, random expiration, high‑availability setups, compression, and cache warming to improve system reliability and performance.
This article explains the concept of the Virtual DOM, its performance benefits in front‑end development, and presents several open‑source implementations such as Million.js, Snabbdom, virtual‑dom, blockdom, Maquette, and additional lightweight libraries, each with brief descriptions and GitHub links.
This article dissects Pulsar’s storage layer by examining the Bookie component, detailing its architecture, the sequential write‑ahead log, ledger management, journal handling, caching mechanisms, and the complete read/write call chains with concrete code examples and performance considerations.
This article investigates two real‑world performance incidents—one caused by excessive disk I/O from a misconfigured Filebeat and another by kernel memory‑fragmentation bugs triggered by a trace feature—detailing observations, Linux diagnostic commands, analysis, and practical remediation steps.
GraalVM Native Image now supports Native Memory Tracking (NMT), allowing developers to monitor off‑heap memory allocations, compare Java and native execution, integrate with JFR, and assess performance impact through detailed reports and experimental events.
This article explains how to use a custom CommonContext with conditional logging and lambda‑based delayed evaluation to quickly trace issues in high‑concurrency Java back‑end systems without degrading performance, and demonstrates the performance improvements through before‑and‑after measurements.
This article documents the author's practical migration from JDK 8 to JDK 11, covering motivations such as performance, compatibility, and industry trends, detailed upgrade steps, GC tuning, resolved issues, and showcases significant performance gains and new Java 11 language features with code examples.
This article explains database sharding concepts, reasons for using it, various sharding strategies, and demonstrates implementation with ShardingSphere, including configuration and Java code examples, while also offering additional resources for advanced architecture and interview preparation.
This article compares the Go web frameworks Echo and Gin, detailing their main features, performance, API design, middleware and routing capabilities, community support, and provides side‑by‑side code examples to help developers choose the most suitable framework for their projects.
Zero‑copy is an optimization technique that eliminates unnecessary memory copies between kernel and user space by leveraging DMA, memory‑mapping and specialized system calls, thereby reducing CPU load, latency and improving throughput for high‑performance networking, storage and multimedia workloads.
This article introduces Python decorators tailored for mathematical functions, presenting four practical examples—a timing decorator, a simple automatic differentiation decorator, a result‑caching decorator, and a random‑noise decorator—each accompanied by complete code snippets and explanations.
This article explains the essential conditions, metrics, and scenario classifications for building high‑concurrency systems, then details common solutions such as database read/write separation, local and distributed caching, cache‑eviction policies, handling master‑slave lag, preventing cache penetration and avalanche, and applying CQRS to achieve scalable, high‑performance back‑end services.
This article examines the main algorithms behind WeChat's red‑packet distribution—plain random, double‑mean, and segment‑split (including an optimized version), explains their PHP implementations, validates array_rand's randomness, and compares their performance and fairness through code examples and timing tests.
This article explains how Go's garbage collector manages adjusted, old, and new stacks, detailing the stack adjustment process, expansion and contraction steps, and practical techniques—including debugging tools, stack printing, memory profiling, and stress testing—to verify correct behavior.
The article explains why using IN and NOT IN in SQL queries can lead to poor performance, index bypass, unexpected results with NULL values, and subtle bugs, and it recommends safer alternatives such as EXISTS, NOT EXISTS, and JOIN constructs.
This article presents a systematic benchmark comparing ClickHouse local (single‑node) tables and distributed tables across three data volumes—≈60 billion, 5 billion and 50 million rows—using a variety of aggregation and filter queries, and reveals that distributed tables dominate at large scale while the gap narrows as the dataset shrinks.
This guide details how to fine‑tune Linux kernel parameters—covering sysctl configuration, network stack adjustments, local port range, shared memory limits, swap behavior, and disk scheduler choices—to dramatically improve server performance and stability.
This article demonstrates how to refactor a complex, production‑level SQL query used in a routing system by formatting, decomposing into layers, merging temporary tables, pushing predicates, optimizing joins, and validating performance, ultimately reducing nesting from four levels to one and cutting execution time from 4.75 s to 0.6 s.
This article explains common scenarios of implicit type and charset conversions in MySQL, demonstrates how they cause index loss and performance degradation through detailed examples and EXPLAIN output, and provides practical guidelines to prevent such conversions in production environments.
This article explores the proper usage of Java's Optional class, debunks common misconceptions, examines its internal implementation, compares methods like map, orElse, orElseGet, and provides practical code examples to help developers avoid null‑pointer pitfalls and write cleaner backend code.
This comprehensive guide explains how to use essential Linux monitoring commands—top, free, vmstat, iostat, mpstat, sar, netstat, uptime, ps, watch, strace, and lsof—detailing their purpose, key parameters, interactive shortcuts, and how to interpret their output for effective system performance analysis.
A MySQL‑driven data‑migration using INSERT INTO SELECT caused full‑table scans, lock contention and lost payment records, leading to a $10,000 loss and the engineer’s dismissal; the post‑mortem explains the root cause and how proper indexing can prevent it.
This article explains common Redis performance pitfalls—including per‑command network latency, expensive commands like SUNION and KEYS, mass key expiration spikes, and big‑key deletions—and provides practical techniques such as MSET batching, randomizing expirations, and using UNLINK to keep your backend fast.
This guide explains how to replace slow synchronous HTTP calls with Guzzle's asynchronous requests in PHP, showing code examples, performance measurements, and practical tips for installing and using promises to achieve faster concurrent API calls.
This article explains what monkey patching is in Python, demonstrates how to replace the standard json module with the faster ujson module using a simple runtime patch, and shows performance measurements before and after the patch to illustrate the speed improvement.
This article presents a comprehensive collection of MySQL performance guidelines, covering query writing, index usage, join strategies, data types, batch operations, and execution plan analysis to help developers write faster and more reliable SQL statements.
The article explains that software performance is measured in milliseconds to nanoseconds, describes core hardware components—CPU, caches, and DRAM—shows how cache hierarchy speeds differ, defines a clock cycle as the basic time unit, and provides typical latency figures for operations ranging from a single CPU cycle to a full system reboot.
The study benchmarks Kotlin, JavaScript, Dart, C++ and Swift across iOS, Android and HarmonyOS using 237 protobuf files, finding Kotlin’s performance and binary size rival native Swift, JavaScript slower with higher memory, while C++/Rust excel but need more effort, leading to a recommendation of Kotlin Multiplatform with a three‑repo structure for optimal reuse and maintainability.
This article documents a month‑long effort to replace Fastjson with Gson in Java projects, analyzing security vulnerabilities, comparing performance and features of Fastjson, Jackson and Gson, and providing detailed migration steps, code examples, and solutions to common issues such as date handling, SpringBoot integration, Swagger compatibility and numeric type conversion.
The article analyzes a real‑world MySQL data‑migration failure caused by an INSERT INTO SELECT operation that triggered full‑table scans and row‑level lock contention, leading to massive data loss and highlighting the need for proper indexing and cautious use of this command.
This article explains various server‑side caching strategies—including full‑page static caching, fragment caching, data and query caching, time‑based and content‑change invalidation, as well as memory caches like Memcached and Redis, Apache modules, APC, and opcode caches—providing PHP code examples for each method.
In 2023, leading cloud giants like Google and Amazon publicly questioned the value of microservices, presenting new “Microservices 2.0” principles and monolithic alternatives that promise dramatically lower latency, cost, and operational complexity while reshaping backend architecture debates.
A developer used MySQL’s INSERT INTO SELECT to migrate millions of rows, causing full‑table scans, OOM errors and lost payment records, leading to a costly incident; the post analyzes the root causes, explains transaction locking behavior, and offers practical indexing and testing safeguards.
This article explains how to quickly locate the MySQL statements that cause sudden CPU spikes by inspecting per‑thread usage with top, correlating threads to SQL via performance_schema, and using a Python script to list and optionally kill the offending queries.
This article describes Zhihu's hybrid cloud architecture—including offline, online, and GPU data centers—its self‑built UnionStore cache, the performance and latency challenges faced during large‑scale AI model training, and the subsequent evaluation and migration to Alluxio community and enterprise editions to achieve higher throughput, stability, and lower operational overhead.
The article reviews Amazon MemoryDB, a Redis‑based in‑memory database that uses a distributed transaction log to achieve strong consistency and durable persistence for high‑throughput, latency‑sensitive workloads, and compares its architecture and performance with open‑source Redis.
This article details the investigation of sporadic interface timeouts in the Sirius real‑time pricing service, revealing a weekly pattern linked to RAID controller consistency checks that cause IO spikes, logback queue blockage, and ultimately Dubbo client‑side timeouts, and proposes mitigation steps and general performance‑troubleshooting guidelines.
This article examines PHP’s evolution over the past two decades, outlines its present strengths such as performance gains in PHP 7 and community vitality, and explores emerging trends—including modern language features, cloud‑native integration, serverless adoption, and performance optimization—that will shape its future role in backend web development.
A MySQL data‑migration task using INSERT INTO SELECT triggered a full‑table scan, leading to lock contention, payment‑record loss, and ultimately the developer's dismissal, highlighting the dangers of unindexed bulk operations and the need for proper indexing and testing.
This article compares common API communication styles—including SOAP, RESTful, GraphQL, gRPC, WebSocket, and Webhook—explains their strengths and trade‑offs, shows how gRPC operates, outlines when to use short polling versus webhooks, and provides practical tips for boosting API performance and security.
This article systematically examines seven typical cache problems—penetration, breakdown, avalanche, data inconsistency, big‑key, hot‑key, and low hit rate—explaining their root causes, illustrating concrete scenarios with diagrams and code, and presenting step‑by‑step mitigation techniques such as parameter validation, Bloom filters, locking, auto‑renewal, random expirations, high‑availability setups, and cache warm‑up.
This article explains the principles of Redis Pipeline, compares Lettuce and Redisson client implementations in Spring Boot, presents performance tests showing dramatic speed gains over single commands, discusses practical usage scenarios, common pitfalls, and provides detailed source code examples for both clients.
In today's digital era, Laravel queues enable backend applications to offload time‑consuming tasks, improve performance, enhance scalability, and deliver a smooth, responsive user experience, making them an essential tool for modern web development.
This article explains how integrating Go with assembly language can overcome Go's performance and low‑level control limits for system and driver development, covering basic concepts, integration methods, multi‑CPU architecture support, practical code examples, and the resulting performance and portability benefits.
This article explains the rules of platform coupons, demonstrates a concrete example, and details three generations of algorithms—from a Cartesian‑product approach to Map‑based and array‑index methods—highlighting their implementations, performance trade‑offs, and a comparative benchmark.
A real‑world MySQL case study shows how using INSERT INTO SELECT for large‑scale data migration without proper indexing caused full‑table scans, lock contention, and data loss, highlighting the need for careful query planning and performance testing.
This article explains how MySQL table‑level locks and metadata locks (MDL) can block both reads and writes, describes the two lock implementations, their types, the interaction with LOCK TABLES and FLUSH TABLES, and provides practical queries for diagnosing lock‑related blocking issues.
