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.
The article investigates why altering a MySQL VARCHAR column from a length that fits within 255 bytes to one that exceeds this limit (e.g., VARCHAR(63) to VARCHAR(64) in utf8mb4) triggers a costly copy operation, analyzes the storage mechanics, reproduces the issue, and provides practical recommendations to avoid performance penalties.
This article explains how the hierarchical security model in Microsoft Dataverse extends existing security mechanisms by introducing manager and position hierarchies, details their configuration, access rules, performance tips, and how to include or exclude records of disabled users.
This article explores why Redis delivers ultra‑high performance by examining its in‑memory design, single‑threaded event loop, efficient data structures such as hash tables, SDS strings, ziplist, quicklist, and skiplist, as well as its encoding strategies and I/O multiplexing model.
This article compiles detailed technical Q&A about NVIDIA's Quantum‑2 InfiniBand platform, covering compatibility of CX7 NDR ports, cabling options, switch connections, UFM deployment, PCIe bandwidth limits, and performance considerations for high‑performance computing clusters.
This article explores Go's experimental arena library, detailing its design principles, core features such as fast allocation and memory reuse, suitable use cases like object pools and game development, provides a practical code example, and discusses performance benefits and limitations for high‑concurrency applications.
This article explores Java String internals across JDK versions, explaining its memory representation, immutability, substring behavior, and how techniques like StringBuilder, intern(), and shared objects can dramatically reduce memory usage from gigabytes to megabytes in high‑scale applications.
This guide introduces essential Linux monitoring commands such as top, htop, vmstat, iostat, sar, netstat, iftop, tcpdump, and Glances, explains their usage with example code, and shows how to analyze logs and create custom scripts for comprehensive system performance tracking.
This article explains the behavioral and performance differences of positioning a try‑catch block either outside or inside a Java for‑loop, illustrating each case with code examples, execution results, memory analysis, and practical recommendations for handling exceptions during batch processing.
The article explains the limitations of Spring's BeanUtils.copyProperties—such as type mismatches, null overwriting, and reflection overhead—and demonstrates how MapStruct provides a faster, compile‑time generated alternative for copying properties between Java objects, with usage examples and Maven setup.
This article explains why read‑heavy internet services use MySQL master‑slave replication for read/write separation, describes the asynchronous replication process, discusses latency side‑effects, and offers practical strategies such as data redundancy, caching, and direct master queries to mitigate delays.
This guide walks you through installing the wrk load‑testing tool on Unix‑like systems, explains its core command‑line options, shows how to interpret benchmark results, and demonstrates advanced customization using Lua scripts for POST requests, dynamic parameters, authentication, and HTTP pipelining.
This article presents a systematic benchmark comparing Go's new generic types with the traditional interface{} approach, measuring execution time and memory allocation on identical hardware to determine whether generics provide a measurable performance advantage.
This guide covers practical MySQL performance improvements, detailing SQL-level optimizations such as limit pagination, proper LIKE usage, UNION ALL, EXISTS vs IN, TRUNCATE, batch inserts, early filtering, function placement, data type minimization, CHAR/VARCHAR choices, indexing strategies, force index, as well as server parameter tuning for buffer pool and redo log settings.
This comprehensive guide explores Rust’s signed and unsigned integer types, detailing their ranges, appropriate use cases, performance considerations, and provides practical code examples for type selection, conversions, arithmetic, and bitwise operations to help developers write efficient, safe Rust code.
This article explains where MySQL stores auto‑increment values, why gaps appear after failed inserts, duplicate‑key errors, rollbacks or batch inserts, and how different innodb_autoinc_lock_mode settings and MySQL 8.0 improvements can mitigate the issue.
This article explains Go's unsafe package, covering its core concepts—Pointer, Sizeof, and Offsetof—provides practical code examples, outlines suitable scenarios such as system calls and performance tuning, and highlights the associated risks and best‑practice precautions.
This article presents practical Go performance tips, covering memory‑allocation strategies, slice and map pre‑allocation, stack management, GC reduction, goroutine‑pool usage, avoiding blocking syscalls, and efficient string handling to minimize latency and resource consumption.
React 16 feels smoother than React 15 because its new Fiber architecture breaks state updates into small, priority‑aware units that the Scheduler runs asynchronously, allowing high‑priority user input to render first while lower‑priority work is paused and resumed, eliminating the lag seen in full‑tree re‑renders of React 15.
Fast‑Retry is a high‑performance, multi‑task asynchronous retry framework for Java that outperforms traditional synchronous retry libraries like Spring‑Retry and Guava‑Retry, offering flexible APIs, annotation support, and easy integration for massive retry workloads.
MySQL, born in the 1990s as a free open‑source database, became a core component of the LAMP stack and remains widely used; the article explains why indexes are needed, compares binary trees, B‑trees and B+‑trees, and describes how modern cloud‑based MySQL services improve performance and reliability.
The article reviews a year of experience with Go generics, explains the gcshape implementation, shows why generic code can be slower than ordinary code, and provides practical advice on object creation, pointer handling, method sets, and copying with concrete examples and benchmarks.
This article provides a comprehensive introduction to Redis, covering its core features, supported data types, common caching use cases in Spring Boot, typical cache‑related problems such as consistency, avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence mechanisms, master‑slave replication, and Sentinel high‑availability architecture.
This comprehensive guide explores Linux memory architecture, address spaces, allocation strategies like the buddy and slab allocators, user‑ and kernel‑level memory management, DMA, and practical tips to avoid common memory bugs and performance issues.
A detailed post recounts a production outage caused by improper index handling in a massive MySQL table, walks through MySQL lock diagnostics, compares index behavior on MySQL and TiDB, and distills practical recommendations for safe DML, DDL, and index management.
This article explains why using IN and NOT IN in SQL queries often leads to poor performance and incorrect results, and demonstrates safer alternatives such as EXISTS, NOT EXISTS, and JOINs with practical code examples.
This article explains how Go's runtime/trace package and the new APIs introduced in Go 1.20 and 1.21 reduce overhead, improve scalability, simplify trace control, and better link trace data to source code, making concurrency debugging more effective for Go developers.
The article analyzes why Android 14's debuggable runtime became significantly slower due to a change from the nterp interpreter to the switch interpreter, explains the underlying ART modifications, and presents the Google‑provided fixes that restore performance to Android 13 levels.
This article warns developers about several Redis commands—such as KEYS, FLUSHDB/FLUSHALL, SAVE/BGSAVE, and DEBUG SLEEP—that can cause performance degradation, data loss, or security issues in production environments, and encourages careful usage to avoid serious operational risks.
This guide walks you through checking CPU usage, system load, resource consumption, problematic processes, system logs, and performance bottlenecks on a Linux server using common command‑line tools such as top, uptime, pidstat, strace, tail, and perf.
This article explains why using OFFSET and LIMIT for pagination becomes inefficient on large tables, illustrates the performance impact with examples, and proposes a cursor‑based pagination alternative that leverages indexed primary keys to achieve faster, scalable queries.
Despite perceptions of PHP as outdated, this article explains why its flexibility, strong community, performance improvements in PHP 8.1, rapid deployment, scalability, and clean-code frameworks like Laravel make it a practical and efficient backend solution for web development in 2024, while noting cases where other languages may be preferable.
2023 saw a wave of high‑profile tech leaders—Google’s engineers, Amazon Prime Video, and DHH—questioning the microservices paradigm, presenting data‑driven case studies that show dramatic latency and cost reductions when moving to monolithic or runtime‑managed architectures, and urging architects to reassess scalability versus complexity trade‑offs.
This article presents four practical Python techniques—including list reversal, tuple swapping, loop placement, and function‑call reduction—that together can shave roughly 10‑20% off typical script execution times while keeping the code clear and maintainable.
This article explains how to boost MySQL insertion speed by adjusting server hardware, tuning database parameters, choosing the MyISAM engine, and especially applying three batch‑insert techniques—SQL concatenation, MyBatis‑Flex saveBatch, and manual transaction batching—while showing test results and configuration tips.
This article analyzes how Redis pipelining works, compares Lettuce and Redisson clients under Spring Boot, presents performance benchmarks for batch inserts, discusses practical pitfalls, and explains the internal implementation of pipeline support in both clients to help developers avoid common issues.
This guide explains why MySQL or Java processes can consume 900% CPU, outlines step‑by‑step diagnostics using tools like top, show processlist, jstack, and provides concrete fixes such as adding indexes, disabling slow logs, using caches, and optimizing thread handling.
Facing a 50‑million‑row financial transaction table that grew 6 million rows per month, the team analyzed the problem, set clear split goals, evaluated sharding middleware, designed a custom pagination algorithm, built a hybrid data‑migration plan, and executed a three‑stage rollout to safely replace the monolithic table with multiple 10‑million‑row shards.
This article presents a comprehensive analysis of the ZhaiZhai financial system's growing data volume and slow‑query issues, evaluates four storage solutions—including sharding, hot‑cold separation, TiDB, and OceanBase—selects TiDB as the optimal choice, and details the migration steps and Elasticsearch integration to improve performance and scalability.
This article explains the core principles of Spring Boot startup configuration, demonstrates how to intervene using ApplicationContextInitializer, SpringApplicationRunListener, ApplicationRunner, and CommandLineRunner, and provides practical optimization techniques to significantly reduce application launch time.
A 2024 survey of Go developers reveals strong interest in building AI applications but frustration over Python's dominant ecosystem, highlighting performance priorities, tooling gaps, and a desire for Go libraries comparable to Python's, while also showing cloud platform preferences and IDE usage trends.
This article explains Go's memory escape phenomenon, why variables move to the heap, its impact on garbage collection performance, and practical techniques—including pointer usage, closure avoidance, and compiler tools—to minimize escape and improve program efficiency.
This article presents thirty practical SQL optimization techniques, ranging from avoiding SELECT * and using LIMIT 1 to proper indexing, join strategies, and query rewriting, each illustrated with code examples and clear explanations to help developers write faster, more efficient database queries.
The severe jank observed in Android 14 debug builds stems from the DEBUG_JAVA_DEBUGGABLE flag triggering DeoptimizeBootImage, which forces boot‑image methods onto the slow switch interpreter; a temporary hook clearing the flag and a permanent fix using UpdateEntrypointsForDebuggable restore performance, with Google planning an official fix in Android 15.
This article explains how to design ranking systems for games and social apps, compares database sorting and client‑side approaches, and provides step‑by‑step Java code for implementing Redis‑based counters, leaderboards, performance optimizations, and real‑world use cases.
This article explains why performance optimization is essential for growing systems, introduces key metrics such as response time and concurrency, outlines systematic thinking and concrete techniques—including caching, parallelism, and async processing—and demonstrates a live‑streaming case study with actionable solutions.
This article compares PostgreSQL and MySQL across history, ACID compliance, performance, scalability, advanced features, tooling, security, backup strategies, and Linux installation steps, helping full‑stack developers choose the most suitable open‑source relational database for their projects.
Redis achieves its remarkable speed through in‑memory storage, an efficient hash table design, single‑threaded execution that eliminates context switches, epoll‑based I/O multiplexing, progressive rehashing, and cached timestamps, all of which together enable near O(1) operations and minimal latency.
This article analyzes why MySQL recommends auto‑increment primary keys over UUIDs or random snowflake IDs by designing three tables, running insert‑select benchmarks with Spring Boot's JdbcTemplate, presenting the test results, and discussing the underlying index‑structure impacts and trade‑offs.
Apache Shenyu is a high‑performance, open‑source API gateway built on the reactive WebFlux framework that unifies API management and security through a flexible plugin architecture offering authentication, traffic control, circuit breaking, request rewriting, logging, and monitoring, while delivering extensibility, low latency, and future cloud‑native integration.
The article examines how Spring Boot’s Lettuce and Redisson clients implement Redis pipelining, explains the batch‑request principle, benchmarks 100 000 set inserts showing pipeline speeds of 0.5–1.4 seconds versus 162 seconds for single commands, demonstrates Spring Data Redis callback usage, warns of high‑cost command pitfalls, and details Redisson’s RBatch internals, concluding that pipelining dramatically boosts throughput when command costs are modest.
The article details Higress's migration of its Wasm plugin runtime from V8 to the WebAssembly Micro Runtime (WAMR), showing up to 50% average performance gains and up to double speed for complex plugins, while outlining technical reasons, benchmark results, and migration steps.
This article examines PHP's 2024 relevance by reviewing its historical rise, current market share, developer adoption, ecosystem strengths such as CMS dominance and modern frameworks, performance challenges, emerging technologies, and why the language remains a viable backend choice despite newer alternatives.
This article explains what SQL Server deadlocks are, why they occur, demonstrates a reproducible deadlock scenario with T‑SQL code, and provides practical strategies such as proper schema design, indexing, query optimization, shorter transactions, appropriate isolation levels, and monitoring to minimize deadlock occurrences.
This article explains the principles of object pools, details the internal implementation of Go's sync.Pool, and demonstrates through benchmarks how using an object pool can dramatically reduce memory allocation and latency for high‑traffic menu services in a restaurant ordering application.
This article analyzes a slow NOT IN subquery that OceanBase rewrites into a NESTED‑LOOP ANTI JOIN, explains why HASH ANTI JOIN is not chosen due to NULL‑sensitive semantics and missing NOT NULL constraints, compares the behavior with Oracle's Null‑Aware Anti Join, and provides practical rewrite and hint‑based optimization recommendations.
This article examines why HikariCP, the default Spring Boot 2.0 connection pool, achieves high performance by exploring its design concepts such as dual HikariPool instances, FastList, custom ConcurrentBag, thread‑local caching, and bytecode optimization, and includes sample Maven configuration and Java code.
