This article explains how to use SSE2 SIMD instructions to optimize string replacement operations, demonstrating a 16-character batch processing technique that significantly improves performance for longer strings.
This article explains what the Container Network Interface (CNI) is, how Kubernetes uses CNI plugins, guides the step‑by‑step configuration process, compares Overlay, Routing and Underlay implementations, and provides practical criteria for selecting or building a CNI plugin that fits specific environments and performance needs.
This article explains what a sync.Pool object pool is, when it should be used, details the Go 1.12 implementation with its internal structures and algorithms, describes the enhancements introduced in Go 1.13, and analyzes the resulting performance improvements for high‑concurrency backend applications.
This article compares Kotlin Multiplatform and Flutter, outlining their benefits, drawbacks, market popularity, performance, ecosystem support, and suitability for various platforms, helping developers decide which cross‑platform framework best fits their mobile development needs.
This article introduces Kafka's role as a message system, explains its fundamental components such as topics, partitions, producers, consumers, and replicas, and dives into cluster architecture, consumer groups, Zookeeper coordination, and performance optimizations like sequential writes, zero‑copy, log segmentation, and network design.
The article introduces Alibaba's open‑source web server Tengine, explains its Dubbo integration that enables HTTP‑to‑Dubbo proxying, compares it with traditional Java gateway architectures, highlights performance and stability advantages, and provides practical examples and future roadmap details.
This article explains the core mechanisms of HBase—Flush and Compaction—detailing why they are needed, the conditions that trigger Flush, the types and triggers of Compaction, and provides practical recommendations for tuning the most important configuration parameters to improve write and read performance.
This guide details a step‑by‑step process for creating, debugging, and scaling JMeter scripts, performing sandbox tests on BlazeMeter, configuring engine user limits, building clusters, and using master‑slave mode to achieve a 50 k concurrent‑user load test.
This guide introduces the Siege HTTP/HTTPS load‑testing tool, explains how to install it on CentOS 7, details its configuration options and command‑line flags, and provides practical examples with performance metrics for benchmarking web services.
This guide introduces JProfiler, explains how to attach it to a running JVM, choose profiling modes, capture CPU and memory data, generate and analyze heap dumps using both JProfiler and jmap, and details the various views such as Memory, CPU, Thread, Monitor, and Telemetry for comprehensive Java performance troubleshooting.
A detailed performance comparison shows that using input redirection to load a huge MySQL dump is roughly three times faster than piping the file through cat, because the redirection reads the data only once while the pipe incurs extra reads and a context switch, as demonstrated with SystemTap tracing.
This article describes how Alibaba's HandCat team analyzed the growing startup latency of their Android app, identified static initialization bottlenecks, and implemented a data‑driven, per‑user and per‑device task orchestration using AOP instrumentation and algorithmic scheduling, achieving up to 1.6 s faster launches on low‑end devices.
This guide shows how to accelerate a PHP website on Ubuntu by mounting a tmpfs RAM disk, using Anything‑Sync‑Daemon to keep the nginx root synchronized, and configuring systemd timers so that changes are safely written back to persistent storage.
This article details the redesign of Ctrip's domestic flight booking module to a dual‑column layout and shares the React Native gesture, animation, and performance optimization techniques that raised frame rates from ~40 fps to ~59 fps while handling double the data volume.
This article compares two common MySQL import techniques—piping a large dump through cat versus using input redirection—by measuring execution time and tracing system calls with SystemTap, revealing that redirection can be roughly three times faster due to fewer reads and context switches.
This article details how a mobile team adopted Flutter for the majority of its app development, compares it with React Native, outlines training, collaborative and hybrid development strategies, presents iOS and Android integration steps, and shares the performance, debugging, and disaster‑recovery benefits achieved.
This article presents a thorough performance comparison of Java Stream API versus traditional for-loop iteration across simple, object, and complex reduction tasks, revealing when serial or parallel streams excel and offering practical recommendations for developers.
Linux reduces RAM pressure through three main compression mechanisms—zSwap, which caches compressed pages before writing to swap; zRAM, a RAM‑backed compressed block device; and zCache, a file‑page compressor—each paired with specialized allocators (zsmalloc, zbud, z3fold) and configurable algorithms, offering trade‑offs in speed, ratio, CPU load, and fragmentation.
This article explains Java 8's commercial licensing, highlights Java 11's performance gains, outlines major language and API enhancements from Java 8 to 11, provides code examples, discusses HTTP client usage, removed components, container support, and recommends Amazon Corretto as a free JDK alternative.
This article presents a collection of practical Python tips—from concise imports and the handy '_' placeholder to efficient string joining, powerful uses of zip(), elegant swapping, enumeration, multi‑exception handling, list chunking, and clean file handling—helping developers write more readable and performant code.
This page provides a detailed table of contents linking to over 200 original articles covering API testing, unit and integration testing, performance testing, Java, Groovy, Python, web crawling, automation tools, and various technical and non‑technical topics for software engineers and testers.
This article explains the concept of zero‑copy, how Netty implements it through sendfile, FileChannel.transferTo and CompositeChannelBuffer, and provides detailed code analysis of CompositeChannelBuffer's internal structures and lookup algorithms to improve network I/O performance.
Optimizing MySQL tables with tens of millions of rows requires a systematic approach that considers data volume, table type, and performance goals, and involves design standards, business‑layer tactics, architectural strategies, and database‑specific tweaks such as proper indexing, configuration, and management practices to maintain efficiency.
The article presents a detailed solution for load‑testing two login mechanisms—username/password and phone‑code—by creating a thread‑safe user pool, using AtomicInteger for proportion control, marking each request, and providing complete Java scripts for the test framework, login APIs, and password encryption.
The article explains why API‑testing threads sometimes pause for milliseconds during parameter signing, proposes pre‑signing all data and using a LinkedBlockingDeque to store signed maps, and provides a complete Java implementation that dramatically reduces per‑request overhead.
This article chronicles the design, evolution, and performance evaluation of Bond, a distributed‑lock SDK used internally at Youzan, covering its multi‑phase roadmap, storage choices, timeout‑retry strategies, lock‑TTL recommendations, and practical pitfalls for reliable operations.
This article explains how JDK and CGLib dynamic proxies work in Java, provides complete implementation examples, compares their mechanisms, usage scenarios in Spring, and discusses performance differences across JDK versions.
This article describes how to replace the JavaScript‑based JSZip decompression in a Three.js 3D viewer with a C‑based Zip library compiled to WebAssembly via Emscripten, run inside a Web Worker, and demonstrates measurable performance gains through detailed testing.
This article explains how to replace JSZip with a C‑based WebAssembly unzip module using Emscripten, integrate it via a Web Worker, and achieve faster decompression for Three.js 3D assets, complete with performance test results and detailed code examples.
This article explains how to replace SpringBoot's default embedded Tomcat with Undertow, shows configuration steps, compares their performance and memory usage through benchmarks, and concludes that Undertow is the superior choice for high‑concurrency Java web applications.
This article chronicles Ziqian’s journey from university web projects to senior front‑end engineering at Alibaba, highlighting how passion, breaking conventions, productizing expertise, and proactive teamwork transformed personal experience into organizational capability and high‑impact front‑end solutions.
This article explains why Python is popular yet slower than compiled languages, introduces PyPy as a drop‑in replacement for CPython that uses JIT compilation to accelerate code by an average of 7.6×, and outlines its workings, benefits, and limitations.
The article explains PostgreSQL 11’s new JIT expression compiler, describes how it was benchmarked using the TPC‑H Q1 query on a 22 GB dataset, presents performance improvements over PostgreSQL 10, and provides details on the testing environment, configuration files, and future expectations.
The article explains how Alibaba introduced systematic capacity planning, four‑stage capacity assessment, various single‑machine stress‑test techniques, and a full‑link stress‑testing platform to reliably handle the massive traffic spikes of the Double‑11 shopping festival, while also describing a flexible traffic‑control framework to prevent overload and avalanche effects.
A high‑traffic promotion system suffered massive thread‑pool exhaustion and service outages due to an incorrectly configured HttpClient connection pool, leading to port binding failures, CPU spikes, and instance crashes; the post details the diagnosis, root cause, and concrete mitigation steps.
The article explains how using LIMIT with a large offset on a MySQL table forces the engine to scan hundreds of thousands of index rows and cluster‑index pages, dramatically increasing I/O, and shows a sub‑query join technique that reduces the scan to just the needed rows, cutting execution time from minutes to fractions of a second while also illustrating the impact on the InnoDB buffer pool.
During a performance test a query API failed on the second request because the Redis cache was written before asynchronous tasks finished, causing missing fields; the article explains the root cause, shows the original and fixed code, and details the debugging process.
An unexpected CPU spike in a Java service was traced to a complex URL‑validation regex whose NFA backtracking caused catastrophic performance, and the article explains the regex engine’s behavior, identifies the problematic pattern, and shows how to refactor the expression to eliminate excessive backtracking.
The article provides a detailed comparison between ARM's RISC-based processors and Intel's x86 CISC architecture, covering design philosophy, performance, power consumption, expansion capabilities, operating system compatibility, software development tools, and cost considerations for various terminal applications.
This article details the challenges and solutions encountered while implementing inline video playback, audio handling, canvas snow effects, progressive animations, and performance optimizations for a Christmas-themed year‑end activity page, providing practical code snippets and best‑practice recommendations for front‑end developers.
The author experienced unusually long stage transitions in a Jenkins pipeline, traced the slowdown to differences between a manually built Kubernetes cluster using CephFS on an older Linux kernel and an automated Ansible‑deployed cluster using Ceph RBD, and discovered that switching to NFS or proper Ceph configuration restored fast execution.
This article demonstrates how to enable DBLE's trace function, view detailed execution timing with `show trace`, and analyze performance bottlenecks across client, middleware, and MySQL layers, including a real‑world case study and optimization tips.
This article demonstrates how rewriting a MySQL LIMIT OFFSET query to first fetch primary keys in a sub‑query and then join the main table can cut execution time from over 16 seconds to under one second by avoiding massive random I/O and buffer‑pool pollution.
This article examines FIBJS's transition from callback‑based asynchronous code to coroutine‑based sync style, compares its ORM refactor and worker‑thread handling with NodeJS, and presents performance metrics that show memory and throughput improvements across various workloads.
This article introduces five relatively unknown testing tools—including Endtest, Postman, Apache JMeter, Grabber, and Litmus—detailing their key features and how they can help improve automation, API, performance, security, and email testing workflows.
This article describes the design, implementation, and deployment of a PHP extension that enables automated, low‑overhead monitoring of web API performance, detailing its flexible configuration, high resource efficiency, concurrency handling, and successful production rollout within the 58 rental business platform.
In 2019, both Windows 10 and Chrome OS integrated full Linux kernels—via WSL 2 and native Linux support—delivering dramatic performance gains, Docker compatibility, and the ability to run Linux GUI apps, signaling a major shift toward Linux on the desktop.
This article presents seven practical Go performance optimization techniques—including using sync.Pool, avoiding pointer‑heavy maps, generating marshal code, leveraging strings.Builder, preferring strconv over fmt, pre‑allocating slices, and passing byte slices—to reduce garbage collection overhead, improve allocation efficiency, and achieve up to 97% faster execution.
The article investigates a sporadic iOS app startup timeout where the process is killed by the system, analyzes crash logs showing a SIGKILL (0x8badf00d) watchdog termination, traces the issue to excessive UIPasteboard calls made by OpenUDID in both main and background threads, validates the hypothesis with multi‑threaded tests, surveys SDK usage of OpenUDID, and proposes moving the identifier storage to the keychain to avoid clipboard‑induced hangs.
This article explores how recent Python performance improvements and the ultra‑fast Japronto microframework enable handling over a million HTTP requests per second, detailing benchmark results, HTTP pipelining optimizations, C extensions, memory management tricks, and the underlying technologies that make such throughput possible.
The article demonstrates that Kotlin coroutines on the JVM are merely a convenient API layered on traditional Java threads rather than true lightweight coroutines, contrasting them with Go’s M:N goroutine scheduling, and discusses experimental Kotlin‑Native and OpenJDK Loom projects that aim to provide genuine coroutine support.
The Apache Dubbo 2.7.5 release introduces application‑level service registration, native HTTP/2 (gRPC) and Protobuf support, a 30% performance uplift, TLS security, an optimized consumer thread‑pool, a new Bootstrap API, multi‑registry load balancing, and numerous other enhancements aimed at cloud‑native microservice development.
TubeMQ is a trillion‑level, Java‑based distributed message‑queue middleware designed for massive‑data ingestion, offering 140 k TPS with sub‑5 ms latency, high reliability, low cost, and horizontal scalability, and is being open‑sourced to the Apache foundation to foster community collaboration and future expansion beyond traditional MQ functions.
An engineer recounts how a high‑traffic promotion system suffered port exhaustion and thread‑pool overload due to a default max‑connections‑per‑host setting of two, leading to CPU spikes, process crashes, and a cascading failure, and outlines the investigation steps and preventive measures.
The study traced severe Redis latency spikes in an 8‑core container to the Go runtime mistakenly reading the host’s CPU count, which created hundreds of threads and scheduler contention; limiting GOMAXPROCS to the container’s quota eliminated the jitter, while further gains were suggested by reducing HMGET calls, tuning GC, and upgrading Go.
This article examines why Java applications experience high CPU usage, covering infinite loops, frequent Young GC, thread count and state, user‑space versus kernel‑space metrics, and provides a step‑by‑step troubleshooting guide illustrated with a real incident.
The article addresses a junior backend developer's concerns about how to start learning given the vastness of topics like algorithms, OS, networking, concurrency, middleware, and databases, and discusses when to prefer Java wrapper classes over primitive types, including performance considerations.
This article presents a comprehensive collection of Java code optimization techniques, covering topics such as using final modifiers, object reuse, local variables, proper resource management, loop improvements, lazy loading, exception handling, collection sizing, and efficient map traversal to enhance performance and reduce memory usage.
This article explains what database indexes are, why they are needed, the various index types and their characteristics, guidelines for choosing columns to index, and compares the performance of hash and B‑tree indexes in MySQL.
This article compares various AI server architectures—CPU, GPU, FPGA, TPU, and ASIC—by evaluating performance versus programmability, and outlines practical guidelines for choosing GPU servers based on workload, cost, power, and deployment scenarios.
This article explains the architecture of Elasticsearch and Lucene, outlines common performance bottlenecks, and provides concrete indexing and query optimization techniques—including shard routing, refresh intervals, doc values, and hardware considerations—to achieve sub‑second query responses on billions of records.
The article examines the emerging Storage Class Memory (SCM) market, outlines its various technologies, discusses performance and cost trade‑offs, and highlights how SCM can accelerate AI training, enable fast data recovery, reduce data‑center power consumption, and presents the challenges of latency and system integration.
Meituan’s MRN framework extends React Native with a layered hybrid architecture, custom component library, multi‑bundle build strategy, and automated release pipeline, enabling rapid deployment of over 60 RN pages, cutting package size, improving productivity by over 50 %, and delivering high‑stability performance across Android and iOS.
This article explains the performance drawbacks of using UUIDs as primary keys in MySQL InnoDB tables, analyzes their impact on storage, I/O and CPU, and presents several mitigation strategies such as time‑ordered UUIDs, integer mapping, and alternative identifier schemes.
This article answers a developer's question about Node.js performance optimization by outlining major optimization areas, listing practical techniques such as using streams, clustering, and load balancing, and describing typical bottlenecks and essential performance metrics to monitor.
This tutorial walks you through preparing a virtual‑machine environment, generating workload and AWR snapshots with HammerDB, capturing and exporting SQL tuning sets, performing a manual upgrade from Oracle 11.2 to 19c, and comparing performance before and after the upgrade, all with detailed commands and screenshots.
This article presents a comprehensive collection of 50 practical Java performance tips, covering constants, variables, objects, methods, expressions, strings, arrays, collections, exceptions, buffers, and threading, each illustrated with clear examples of inefficient code and its optimized counterpart to help developers write high‑efficiency Java applications.
This article documents a hands‑on experiment that allocates a 50 GB Redis instance on a 64 GB dual‑node machine, explores NUMA behavior, demonstrates how memory affinity can trigger swap, and concludes with practical recommendations for Redis memory sizing and NUMA binding.
This guide walks you through seven practical optimization methods for Kunpeng‑based servers—including compiler flags, buffer selection, result caching, memory‑copy reduction, lock refinement, jemalloc integration, and cache‑line alignment—to fully exploit the hardware’s capabilities.
WebAssembly, officially standardized by W3C in December 2019 as the fourth core web language, offers a secure, portable, high‑performance binary format that runs in browsers, enabling near‑native execution for tasks like audio, video, graphics, 3D, and AI, while introducing features such as threads, shared memory, and direct host object access.
This article details Alibaba's large‑scale Service Mesh deployment for Double‑11 core applications, covering the three‑plane architecture, key challenges such as SDK‑free mesh, complex routing, rate limiting, Envoy overhead, and the performance impact on latency, CPU and memory, while outlining future roadmap and open‑source collaboration.
System refactoring succeeds when the Dao—clear, measurable goals and incremental, risk‑controlled planning—guides the Shu of concrete techniques such as service‑oriented design, judicious caching, asynchronous processing, and sharding, while evaluating performance, availability, scalability, elasticity, security, and operability to balance trade‑offs.
This article examines the JD.com product detail page backend architecture, analyzes memory, thread, and CPU usage, and outlines a three‑stage optimization roadmap—including parallelization, JVM/Tomcat upgrades, thread‑pool tuning, and asynchronous refactoring—to handle massive traffic spikes.
This article explains how Alibaba’s JVM team introduced ElasticHeap, static compilation, Wisp2 coroutines, feedback‑directed optimization, and ZGC to dramatically reduce Java heap usage, startup time, CPU load, and pause times, delivering cloud‑native performance improvements demonstrated during the Double‑11 traffic peak.
The article explains why using the KEYS command on large Redis datasets can cause service blockage and demonstrates how the SCAN command with MATCH and COUNT options provides a non‑blocking, incremental way to list keys, including syntax and practical examples.
This article presents a comprehensive collection of Java performance best practices, covering topics such as using final modifiers, object reuse, local variables, stream handling, avoiding repeated calculations, lazy loading, exception handling, collection sizing, bit‑shifts, loop optimizations, reflection avoidance, resource pooling, buffered I/O, and proper map traversal, all aimed at reducing code size and boosting runtime efficiency.
This article explains how Redis implements its own string type using Simple Dynamic Strings (SDS), details the internal structure and dynamic expansion mechanism, and highlights the performance benefits such as O(1) length retrieval, buffer‑overflow protection, and reduced memory allocation overhead.
The article explains that MySQL's count(1) and count(*) perform identical full‑table scans with negligible performance difference, while count(column) only counts non‑NULL values, and it discusses execution‑plan effects and optimal usage depending on primary keys and table size.
This article examines a Java utility for generating unique transaction order numbers, identifies performance inefficiencies caused by repeatedly creating SimpleDateFormat instances, proposes a static formatter optimization, presents benchmark code and results, and discusses alternative string concatenation methods for random code generation.
The article explains what Redis cache avalanche, penetration, and breakdown are, illustrates real‑world incidents, and provides pre‑, during‑, and post‑incident solutions such as high‑availability setups, local caches with rate limiting, fallback mechanisms, and placeholder writes to prevent database overload.
This article demonstrates how compiling OpenCV 3.2 with CUDA 8.0 enables GPU‑accelerated template matching in Python, reducing average processing time from 0.299 seconds on CPU to 0.181 seconds on GPU—a 39.4% performance gain for automated testing image‑recognition APIs.
This article explains how to compile OpenCV‑Python with CUDA support to speed up image template matching, compares CPU and GPU execution times, and shows a practical Python example demonstrating a 39.4% performance improvement using OpenCV 3.2.0 and CUDA 8.0.
This article introduces the fundamentals of time‑series databases, explains why InfluxDB was chosen, describes the TSM storage engine and shard concepts, outlines the internal 360 InfluxDB‑HA architecture, compares its performance with a single node, and provides integration and future‑development guidelines.
The IntelliJ IDEA 2019.3 update brings faster startup, reduced memory usage, enhanced UI responsiveness, support for new microservice frameworks like Micronaut, Quarkus, Helidon, added MongoDB integration, numerous quality improvements, and a host of important bug fixes across platforms.
IntelliJ IDEA 2019.3 has been officially released, delivering faster startup, reduced memory usage, enhanced UI responsiveness, dynamic plugin installation, expanded support for modern micro‑service frameworks like Micronaut, Quarkus, Helidon, and the long‑awaited MongoDB integration, along with numerous bug fixes and quality improvements.
This article analyzes a use‑case where each user must keep up to 10,000 historical IDs, compares two Redis‑based implementations—using a List and a String—by presenting code samples and benchmark results, and explains why understanding underlying data structures can dramatically improve performance.
This article explains how React's virtual DOM and diff algorithm work, identifies situations where renders become costly, and presents practical techniques such as shouldComponentUpdate, PureComponent, higher‑order components, React.memo, and component splitting to reduce unnecessary renders and improve front‑end performance.
A Java service suffered near‑100% CPU usage because a URL‑validation regular expression caused catastrophic backtracking, and the article explains the NFA engine behavior, identifies the regex flaws, and shows how to rewrite the pattern with possessive quantifiers to dramatically improve performance.
This article examines four common database architecture patterns—primary‑standby, dual‑primary, master‑slave read/write separation, and a hybrid dual‑primary + master‑slave—evaluating each against high availability, performance, consistency, and scalability, and then presents practical consistency‑resolution techniques and cache strategies.
This article provides comprehensive best‑practice guidelines for using Redis, covering data classification, key naming, size and connection limits, cache TTL, recommended client‑hash sharding, and a strict list of prohibited commands and operations to ensure performance, reliability, and maintainability.
This article explains how to use MySQL's EXPLAIN command, describes each column in its output—including id, select_type, table, type, possible_keys, key, key_len, ref, rows, filtered, and Extra—provides syntax examples, discusses join type rankings, and outlines the command's limitations for query performance analysis.
This guide walks you through a systematic, step‑by‑step process for diagnosing and resolving poor‑performance or failure incidents on Linux servers, covering everything from gathering context and checking who is logged in to inspecting processes, network services, hardware, I/O, logs, cron jobs and application‑level diagnostics.
This article presents a detailed case study of intermittent container timeout problems in a Kubernetes environment, examining kernel upgrades, NUMA configurations, CPU affinity bindings, kubelet behavior, cadvisor overhead, and hardware faults, and outlines the investigative steps and solutions applied.
This article investigates the implementation of Java's System.currentTimeMillis() on Windows, macOS, and Linux, measures its execution speed, explores the underlying native methods and OS time‑source mechanisms such as TSC, HPET, and RTC, and discusses performance implications and best practices for high‑frequency timestamp retrieval.
This article examines the architectural design of flash‑sale (seckill) systems, covering high performance through dynamic‑static separation, hotspot optimization, consistency handling for inventory deduction, and high‑availability techniques such as traffic shaping, queuing, and fallback plans.
This article introduces Xiaomi's open‑source SOAR tool, explains how to download and install the binary or source versions, walks through quick‑start commands, details key YAML configuration options and output formats, and describes four typical usage scenarios for SQL optimization and rewriting.
This article provides a detailed comparison between ARM's RISC-based processors and Intel's CISC‑based x86 CPUs, covering design philosophies, performance, power consumption, expansion capabilities, operating‑system compatibility, software development tools, cost factors, and suitable application scenarios.
This weekly roundup highlights advanced frontend topics, including an in‑depth analysis of Promise micro‑tasks, a translation on Intersection Observer usage, an overview of browser fingerprinting techniques, the current state and future of modern web development, V8’s JavaScript execution pipeline, and Node.js applications at WeDoctor.
The article details how Ctrip engineers diagnosed sporadic Redis timeouts in containerized deployments, traced the problem to kernel scheduling delays caused by an APIC‑ID bug that inflated the possible‑CPU count, and resolved it by applying a kernel patch, offering verification steps for affected systems.
This article describes how the M page’s user‑perceived performance was dramatically improved by applying techniques such as SSR, skeleton screens, image compression, and a video‑frame analysis testing method that delivers millisecond‑level response‑time measurements, enabling sub‑second load times and eliminating white‑screen delays.
