This article explains Redis 6.0's shift from a single‑threaded network model to threaded I/O, outlines the performance reasons behind the change, describes the new execution flow, and provides step‑by‑step instructions for configuring multithreading in redis.conf.
The article investigates frequent HttpClient connection‑pool exhaustion caused by excessive CLOSE_WAIT sockets in a high‑traffic Java service, explains the underlying TCP and HttpClient mechanisms, presents diagnostic commands and code snippets, and offers concrete configuration and architectural recommendations to prevent similar issues.
This article presents twenty practical MySQL optimization techniques—from selecting specific columns and avoiding OR in WHERE clauses to proper indexing, join strategies, and using EXPLAIN—helping developers improve query speed, reduce resource consumption, and write more maintainable SQL code.
This article investigates why upgrading the Feishu Android project's CI build environment from JDK 8 to JDK 11 caused a 50% increase in build time, analyzes JVM, Gradle, and Docker interactions, and presents concrete JVM flag and environment‑variable solutions that restored parallelism and reduced build duration back to pre‑upgrade levels.
An in‑depth comparison shows that while Dragonfly claims to be the world’s fastest memory cache, Redis 7.0 often delivers higher throughput and lower latency across multiple benchmark scenarios, highlighting architectural trade‑offs and the potential for future feature adoption from Dragonfly into Redis.
After a recent deployment a backend update operation became extremely slow, revealing RPC retry, thread‑pool misconfiguration, and row‑lock contention between services, which were analyzed and resolved through thread‑pool tuning and transaction separation.
An in‑depth guide explains why using MyBatis’s foreach for bulk inserts can cause severe performance degradation, especially with large tables, and demonstrates how switching to ExecutorType.BATCH or limiting batch sizes to 20‑50 rows dramatically reduces insertion time from minutes to seconds.
This article details a five‑month performance project that reduced the heart‑beat app’s average launch time from over eight seconds to around four seconds by dissecting cold‑start phases, optimizing Application initialization, streamlining the launch chain, and applying home‑page, lock, and monitoring strategies.
This article dissects why a well‑tuned Kafka cluster can process up to 20 million messages per second, examining producer batching and custom protocols, broker page‑cache, file layout and zero‑copy techniques, as well as consumer group strategies that together unlock its high throughput.
This article compares the open‑source memory cache Dragonfly, created by a former Google and Amazon engineer, with Redis 7.0, analyzing benchmark results, architectural differences, and community reactions to determine which system delivers superior performance and scalability.
MapStruct dramatically outperforms Spring's BeanUtils for Java object mapping by generating compile-time code that avoids reflection, achieving roughly ten-to-thirty times faster conversions—even across dozens of fields—while requiring only simple PO/Entity definitions and optional @Mapping annotations, making it a superior, low-learning-curve replacement.
This article details a step‑by‑step optimization of a Java backend that imports massive Excel files into MySQL, covering library switches, data caching, batch INSERT statements, and parallel stream insertion to cut processing time from minutes to under two minutes.
This article explains why Kafka can handle up to 20 million messages per second and 600 MB/s throughput by detailing producer batching and custom protocols, broker page‑cache, file layout and zero‑copy techniques, as well as consumer group strategies for efficient message consumption.
This guide surveys more than a dozen Linux command‑line utilities—including nethogs, nload, iftop, slurm, netstat, and many others—explaining their unique features, typical use cases, and installation commands so administrators can effectively monitor bandwidth, connections, and overall network health.
This article compares the MySQL binlog parsing tools my2sql and binlog2sql, detailing their parameters, performance benchmarks on 2 GB binlog files with varying thread counts, feature differences, usage constraints, and provides practical guidance for selecting the appropriate tool.
When trying to change a table’s primary key from int to bigint, a 500‑million‑row MySQL table required data archiving and a bulk MODIFY, but parallel DELETE statements caused lock‑wait timeouts; experiments reveal that under REPEATABLE READ the range scan locks the boundary row, leading to contention.
This article defines software performance as executor + (process + IO + computation), explains when performance should be considered, and presents a comprehensive framework of executor, I/O‑type, and generic optimizations—including concurrency, sharding, caching, compression, async, batching, and algorithmic improvements—supported by cross‑domain case studies.
The jQuery 3.6.1 maintenance update introduces infrastructure improvements, a focus‑related bug fix, significant performance gains for jQuery.trim, and removes outdated links, while also preparing the library for native String#trim support in older browsers.
This article explains the four key techniques—page‑cache usage, sequential disk writes, zero‑copy transfers, and partitioned segment indexing—that enable Kafka to achieve exceptionally high write performance, detailing how each mechanism reduces latency and maximizes throughput.
Alibaba's Big‑Taobao team describes how shifting data‑assembly logic to front‑end Function‑as‑a‑Service transformed engineers into business partners, cut integration costs, boosted development speed, and required careful cost‑benefit analysis, incremental migration, traffic safety measures, and a low‑code orchestration platform to ensure stable, scalable adoption.
This article explains the mmap system call’s core concepts, mapping process, kernel mechanisms, differences from traditional file I/O, performance benefits, and practical usage details, helping readers understand how memory‑mapped files work in Linux and why they’re advantageous for high‑performance applications.
The article explains why MyBatis foreach‑based batch inserts can cause extreme CPU usage and long execution times, demonstrates how combining multiple VALUES into a single INSERT or using ExecutorType.BATCH dramatically improves performance, and provides practical code examples and sizing recommendations.
This guide explains what CPU context switches are, how to monitor them with vmstat and pidstat, analyzes a sysbench‑generated load case, examines interrupt sources, and provides practical thresholds and troubleshooting steps to improve Linux system performance.
This article explores the fundamentals and practical benefits of buffering in Java applications, covering file I/O streams, Logback asynchronous logging, and Kafka producer batching, while providing code examples, configuration tips, optimization strategies, and cautions to avoid data loss.
A comprehensive AWS benchmark reveals that RedisJSON dramatically outperforms MongoDB and ElasticSearch across isolated writes, isolated reads, mixed workloads, ops‑per‑second, and latency, maintaining sub‑millisecond response even under high update rates, while the other databases suffer significant slowdowns.
This article examines how modern SSDs demand higher data rates and IOPS, compares the SATA, SAS, and PCIe storage interfaces, and discusses performance trade‑offs, compatibility considerations, and latency factors to help choose the most suitable interface for a given system.
This article examines how excessive logging, AsyncAppender queue saturation, JVM reflection optimizations, and Lambda class loading can cause thread blocking in Log4j2, analyzes root causes with code examples, and provides practical guidelines and best‑practice configurations to prevent performance degradation in high‑throughput Java services.
This article examines why encrypted data is unfriendly to fuzzy queries, categorizes three implementation approaches—naïve, conventional, and advanced—and evaluates their security, performance, and storage trade‑offs while providing practical code examples and reference resources.
This article introduces a curated list of Linux command-line utilities—including nethogs, nload, iftop, slurm, netstat, and more—explaining their unique features, typical use cases, and installation commands to help system administrators and developers effectively monitor network traffic and bandwidth.
This article presents practical Python performance optimization techniques—including using local variables, minimizing function calls, pre‑computing loop conditions, preferring direct iteration, employing generator expressions, compiling code objects, and structuring modules—to improve speed and reduce memory usage.
The article systematically analyzes why backend APIs become slow—covering database slow queries, complex business logic, thread‑pool misconfiguration, lock design flaws, and machine problems—and presents practical Java‑based optimization techniques such as pagination fixes, index tuning, multithreading, proper thread‑pool sizing, lock refinement, caching, and asynchronous callbacks.
The article examines how design patterns serve as intermediate code conventions, discusses their performance impact, class‑explosion risk, team skill gaps, project environment, and agile constraints, and offers practical advice for balancing code quality with business realities.
This article explains how adding a method breakpoint in IntelliJ IDEA can increase Java application startup time by thousands of percent, explores the JVM and JPDA reasons behind the slowdown, and provides practical steps to remove or mitigate the performance impact.
Facing heavy GC overhead and slow model inference in a Java compute service, the authors explore using Java Native Interface to offload file loading and regression calculations to C++, detailing environment setup, Maven integration, native method implementation, common pitfalls, performance testing with JMH, and achieving up to 80% latency reduction.
The article shares a senior architect's experience improving a legacy multi‑service web system's performance by 3000% by fixing a DB connection leak, adopting tail‑latency metrics, and investing in load testing, monitoring, logging, and dedicated SRE resources.
This article explains how to collect comprehensive MySQL performance metrics—including connections, buffer cache, locks, statement counts, throughput, server variables, and slow‑query analysis—using only MySQL's native SHOW commands, providing a fast, low‑overhead monitoring solution.
This article shares a real‑world case study of how a hidden database‑connection leak in a pod’s health‑check caused severe latency, and outlines four key lessons on performance metrics, testing, legacy system maintenance, and the critical impact of every line of code.
This article explains how MySQL processes LIMIT with an offset, why large offsets cause slower queries and deep‑pagination problems, and presents practical optimization techniques such as id‑based pagination, sub‑queries, and index‑aware strategies to improve performance.
A backend engineer shares a step‑by‑step case study of diagnosing a 20‑second batch‑score query API, then applying three optimizations—index tuning, multithreaded execution, and request‑size limiting—to bring the response time down to under 500 ms.
From a front‑end developer’s viewpoint, this article examines Rust’s learning curve, pros and cons compared with JavaScript/TypeScript, performance benchmarks, multithreading, testing, and real‑world application scenarios such as tooling, WebAssembly, and desktop clients, while also providing learning resources and reference links.
This article details how a hidden 100 ms latency in a Spring Boot channel service was identified and resolved by tracing request flow, using the Arthas Java diagnostic tool, and ultimately fixing a Tomcat‑embed bug caused by Swagger‑ui resources.
This article provides a detailed, line‑by‑line analysis of a chart comparing FPGA and ASIC across dimensions such as upfront costs, unit cost, time‑to‑market, performance, power consumption, field updates, density, design flow, granularity, verification needs, upgrade paths, and additional features, helping engineers decide which technology best fits their high‑performance AI workloads.
An in‑depth analysis of a production incident where HttpClient connections accumulated in CLOSE_WAIT, covering symptom identification, TCP state inspection, root‑cause debugging, HttpClient pool internals, and practical configuration tweaks to prevent similar outages.
Facing massive AP‑heavy analytics workloads, 58 Group evaluated TiFlash, ClickHouse and StarRocks, chose StarRocks for its superior write/read performance and ease of operation, built internal tools for topology, cluster, Kafka import and slow‑SQL management, and migrated to cloud‑native Docker deployments, achieving up to 90% query speedup and massive data‑volume reductions.
This article introduces Arthas, Alibaba's open‑source Java diagnostic tool, explains its installation via wget and java‑jar, and provides detailed usage of common commands such as stack, jad, sc, watch, trace, jobs, logger, dashboard, and redefine for real‑time JVM monitoring and debugging.
This comprehensive guide explains why TiDB upgrades are essential, compares offline, forced, and smooth upgrade methods, outlines detailed step‑by‑step procedures, highlights advantages and risks, and shares practical check‑points and real‑world case studies to help DBAs ensure a safe, performant migration.
This article explains why oversized logs hurt system performance, presents three practical log‑shrinking strategies—printing only necessary logs, merging duplicate entries, and simplifying content—illustrates them with Java code snippets, and evaluates their impact through a real‑world case that cuts daily log volume from 5 GB to under 1 GB.
This article examines a MySQL InnoDB pitfall where a unique index fails to block duplicate rows—especially when indexed columns contain NULL values or when logical deletion is used—and presents practical solutions such as adjusting index columns, adding timestamps, delete status counters, hash fields, and proper bulk‑insert strategies.
This article outlines the major new features of PHP 8 and PHP 7, explains why PHP 7 outperforms PHP 5, describes the execution flow, web‑request lifecycle, underlying architecture, data structures, garbage‑collection mechanism, and the PHP‑FPM master‑worker model with optimization tips.
This article explains Java object pooling concepts, introduces the Commons Pool 2 library and its usage with Redis's Jedis client, compares it with the high‑performance HikariCP database connection pool, and presents JMH benchmark results demonstrating significant throughput gains, while also covering configuration parameters and interview questions.
Fury is a JIT‑based native multi‑language serialization framework that automatically handles shared and cyclic references, offers zero‑copy support, and delivers 20‑200× speed improvements over existing solutions, making it a high‑performance drop‑in replacement for Java, Python, Go, and C++ serialization needs.
This article chronicles the architectural evolution of China Telecom's Tianyi Account gateway from its initial Zuul‑based 1.0 version through successive upgrades to a Kong‑powered 2.0 and 3.0 system, highlighting performance bottlenecks, technology selections, plugin development, CP/DP separation, cloud‑native deployment, and the resulting high‑concurrency capabilities.
Go 1.19 has been released, bringing toolchain, runtime, and library enhancements such as refined generics, improved documentation comments, a formally aligned memory model with new atomic types, security changes to os/exec, soft memory‑limit garbage collection, a new unix build constraint, and numerous performance optimizations, all while preserving full Go 1 compatibility.
Go 1.19, released on August 2, 2022, brings extensive toolchain, runtime, and library enhancements—including memory model refinements, LoongArch support, improved doc comments, new atomic types, security changes to os/exec, GC soft memory limits, and performance upgrades—while maintaining full backward compatibility with Go 1.
This article explains why logging is essential for maintainable software, outlines best‑practice guidelines for readable, performant, and secure log output, and details Log4j components, log level hierarchy, and practical macro examples for each level.
ByteDance engineers have contributed a series of Linux kernel patches that enable uncompressed kernels and other optimizations, reducing Kexec reboot latency from roughly 500 ms to just 15 ms, thereby minimizing server downtime for their high‑traffic services like Douyin.
This article summarizes the author's experience optimizing backend interface performance, covering common causes such as slow MySQL queries, complex business logic, thread‑pool and lock design flaws, and offers practical solutions including pagination tricks, indexing, caching, multithreading, and asynchronous callbacks.
When a Linux server suddenly spikes in load, this guide shows how to pinpoint the root cause within a minute by running ten key commands that reveal CPU, memory, disk I/O, and network metrics, enabling rapid performance troubleshooting.
This article outlines seven major areas of Java backend performance optimization—including reuse, computation, result‑set, resource‑conflict, algorithm, efficient implementation, and JVM tuning—explaining concepts, techniques, and practical examples to help developers improve application speed and resource utilization.
This article walks through a real MySQL deadlock scenario, explaining the four necessary deadlock conditions, illustrating how Next‑Key locks on non‑unique indexes cause gap locks, and presenting step‑by‑step analysis, experimental verification, and practical recommendations to avoid such deadlocks in production systems.
Since JDK 8, HotSpot’s garbage collectors have undergone extensive refinements—introducing G1 as default, adding ZGC and Shenandoah, and optimizing Parallel GC—resulting in notable gains in throughput, reduced pause latency, and lower auxiliary memory usage, as demonstrated by SPECjbb2015 benchmarks across JDK 8 to JDK 18.
This guide explains how to monitor Linux CPU usage, scheduler queues, lock contention, network I/O, and disk I/O using graphical tools and command‑line utilities such as gnome‑system‑monitor, vmstat, pidstat, nicstat, and iostat, with syntax, parameters, example outputs, and installation steps.
This article presents ten useful Python techniques—including string joining, list comprehensions, enumerate, zip, itertools, Counter, dictionary creation, generators, multiple return values, and the sorted function—each explained with clear examples and performance comparisons to help developers write cleaner and faster code.
Using thread pools in Java reduces resource consumption, speeds up response, and enhances system stability, while the optimal thread count depends on task type—IO‑bound tasks use roughly twice the CPU cores, CPU‑bound tasks match the core count, and mixed workloads follow a calculated formula.
This article discusses practical methods for reducing log volume in backend applications, including printing only necessary logs, merging log entries, simplifying messages, and applying these techniques in a real-world Java case to shrink daily log size from several gigabytes to under one gigabyte while preserving debugging capability.
This article explains that Spring Boot 3.0 requires Java 17 and Spring Framework 6, outlines the 14 new features of Java 17, and presents benchmark results showing Java 17's performance advantages over Java 11 and Java 16 with different garbage collectors.
The article outlines practical approaches to monitor and resolve performance bottlenecks in backend applications, covering database slow‑query logs, interface latency, message‑queue backlogs, segmentation timing, caching, batch calls, multithreading, and database tuning techniques such as indexing and transaction isolation.
The article explains the performance problems of using OFFSET and LIMIT for large‑scale database pagination, demonstrates their inefficiency with full‑table scans, and presents a faster cursor‑based alternative that relies on storing the last primary key and using LIMIT instead of OFFSET.
To overcome Go’s per‑connection goroutine memory and GC limits at massive scale, the article designs a three‑layer Reactor‑based network library that uses epoll/kqueue, lock‑protected file descriptors, zero‑copy buffers, and load‑balanced sub‑reactors, enabling stable operation with up to a million concurrent connections.
This article recounts a backend team's experience of addressing numerous slow API endpoints, detailing root causes such as MySQL slow queries, complex business logic, thread‑pool and lock misconfigurations, and offers practical solutions including pagination fixes, indexing, query refactoring, concurrency improvements, and caching strategies.
This article walks through real‑world API performance complaints, identifies root causes such as slow MySQL queries, thread‑pool misconfiguration, lock contention and machine issues, and presents practical solutions ranging from pagination rewrites and index tuning to multithreading, caching and async callbacks.
The article examines how a large transaction in MySQL 5.7 can block the SHOW MASTER STATUS command by holding the lock_log during the commit's flush stage, analyzes the commit and SHOW MASTER STATUS code paths, and proposes mitigation strategies such as avoiding big transactions and using SELECT @@global.gtid_executed.
This roundup spotlights cutting‑edge front‑end developments, including Vue’s upcoming no‑virtual‑DOM mode inspired by Solid.js, a practical guide to hardware‑accelerated HEVC decoding in Chromium, user‑experience advice from industry leaders, latency‑reduction techniques for TikTok live streams, and insights on measuring R&D efficiency.
This newsletter curates recent technical insights covering the high‑performance Bun JavaScript runtime, ESM Loader Hooks for module processing without bundlers, deep dives into Canvas and CSS graphics, practical guides on unit testing, serverless deployment, and advanced JavaScript features like Proxy and Reflect, offering developers a comprehensive overview of modern frontend engineering trends.
This article explains the concept of locks in iOS, describing their purpose, the actions of acquiring and releasing, common lock types such as spin locks, mutexes, semaphores, and their implementations using OSSpinLock, pthread_mutex, NSCondition, NSLock, recursive locks, and read‑write locks, along with performance considerations and underlying principles.
Redis 7.0.3 has been released with medium‑urgency upgrades that improve performance and resource utilization, add new INFO fields and module APIs, enhance CLI clustering support, and fix a range of bugs including TLS handling, cluster failover, and command‑line configuration issues.
The investigation revealed that repeatedly creating XStream objects generated thousands of CompositeClassLoader instances, inflating the JVM’s SystemDictionary and causing extremely long Ext Root Scanning during G1 Young GC pauses, which was resolved by caching XStream per class and reducing YGC pauses from seconds to milliseconds.
Bun, a modern JavaScript runtime built on WebKit's JavaScriptCore, offers faster execution, built‑in Web APIs, TypeScript support, bundling, and npm compatibility, positioning itself as a high‑performance alternative to Node and Deno for server, edge, and local development.
A low‑overhead monitoring solution for iOS apps resets the global malloc_logger to capture every allocation, filters large allocations exceeding a configurable threshold, records lightweight stack traces using dyld image maps, and sends address‑only data for offline symbolication, enabling developers to identify and fix memory‑heavy code, reducing OOM crashes.
This article explains Redis's low‑level data structures—including ziplist, skiplist, intset, quicklist, zipmap and stream—detailing their memory layouts, implementation code, use‑case selection criteria, performance trade‑offs, and configurable parameters that balance speed and space.
This article explains Linux storage hierarchy, the roles of user‑space and kernel caches, the three‑layer I/O stack, page‑cache synchronization policies, file‑operation atomicity, locking mechanisms, and performance testing techniques for HDD and SSD devices.
This article explains the fundamental differences between JavaScript's for loop and forEach method, covering their syntax, behavior, performance characteristics, iterator concepts, usage scenarios, and practical code examples for array traversal and manipulation.
This guide explains what caching is, why it’s essential for database‑driven applications, and how MyBatis implements first‑level and second‑level caches, including configuration steps, sample code, execution results, and key considerations to ensure effective cache usage.
This article explains Java 8 Stream fundamentals, compares intermediate and terminal operations, outlines its advantages over collections, and presents benchmark results showing when streams outperform iterator loops, especially with large data sets and parallel execution.
This article presents thirty practical tips for optimizing SQL queries—covering index creation, avoiding costly operators, rewriting predicates, using set‑based logic, and managing temporary objects—to dramatically reduce full table scans and improve overall database performance.
This article explores Rust's rapid rise in front‑end infrastructure, data visualization, Node, Web3, and automotive software, highlighting its performance, safety, and growing industry adoption while acknowledging its steep learning curve and future importance for developers.
This article explains how to embed Jetpack Compose within an existing RecyclerView using ComposeView, examines the default DisposeOnDetachedFromWindow strategy, its impact on view recycling, and presents alternative composition strategies such as DisposeOnViewTreeLifecycleDestroyed and the newer pooling-aware strategy to improve performance.
This article examines Fastjson2's performance compared to Fastjson, detailing environment setup, benchmark results, GC analysis, and a deep dive into the library's serialization and deserialization source code to explain why memory settings dramatically affect speed.
This article explains how MySQL COUNT() works under different storage engines, why counting rows becomes slow on large InnoDB tables, and presents practical methods such as using EXPLAIN rows, auxiliary count tables, batch processing, and transaction‑based updates to obtain approximate or exact row counts efficiently.
This article explains how to replace Spring Boot's default embedded Tomcat with Undertow, outlines the configuration steps, compares their performance and memory usage through benchmark results, and concludes that Undertow offers superior throughput and lower resource consumption for high‑concurrency Java web applications.
Vim 9.0, dedicated to the late maintainer Sven Guckes, introduces Vim9 Script—a compiled, high‑performance scripting language that boosts execution speed up to 100×, modernizes syntax, retains compatibility with traditional scripts, and adds features like export/import and # comments while planning future class support.
This article explains how to replace Spring Boot's default embedded Tomcat with the high‑performance Undertow container, details the configuration steps, and presents benchmark comparisons showing Undertow’s superior throughput and lower memory usage under high‑concurrency workloads.
Over the past four years Kuaishou's data grew dozens of times, prompting scalability and storage‑cost challenges, and this article details the architectural evolution, performance and cost optimizations, cross‑region expansion, and future plans of Kuaishou's HDFS system.
WebAssembly, a portable binary format, is evolving into a mature platform; this article surveys its motivations, language support (C/C++, Rust, Go, Java, AssemblyScript, etc.), toolchains, and major runtimes such as Wasmtime, Wasmer, WasmEdge, and WAMR, highlighting performance, security, and integration aspects.
This article details Huolala's self‑developed H5 offline‑package SDK for iOS, explaining its safe, maintainable architecture, implementation steps, performance optimizations, reliability mechanisms, and measurable benefits such as halving page load time and achieving 100% load success rate.
This article walks through a real‑world backend API performance case, describing how the author identified a slow batch‑score query, applied index tuning, introduced CompletableFuture‑based multithreading, and limited batch sizes, ultimately reducing response time from 20 seconds to under 500 milliseconds.
This article explains how to replace the default embedded Tomcat container in SpringBoot with Undertow, compares their performance and memory usage through benchmark tests, and recommends Undertow for high‑concurrency Java web applications.
Vim 9.0 marks a major release that introduces Vim9 Script—a compiled, high‑performance scripting language with modern syntax, improved execution speed, and new features such as typed variables, streamlined function definitions, module export/import, and plans for class support, while preserving compatibility with existing Vim scripts.
Vim9 Script, the new major version of Vim's scripting language, brings dramatic performance gains, modern syntax, and features like typed functions, module imports, and class‑like structures while maintaining compatibility with existing Vim scripts.
Git 2.37 introduces a built‑in file‑system monitor for faster status checks, supports sparse checkout to avoid downloading whole repositories, adds performance‑enhancing stash improvements, and tightens credential‑in‑URL security, offering developers a more efficient and safer version‑control experience.
