This article explains how excessive use of String.intern can enlarge the JVM's StringTable, causing the Young Generation Garbage Collection (YGC) to take longer, and provides a demo, code analysis, and practical tips for diagnosing and mitigating the slowdown.
The Disruptor library provides a lock‑free, CAS‑driven ring‑buffer queue that eliminates lock contention and false sharing, delivering 4–7× higher throughput and nanosecond‑level latency compared to Java’s built‑in queues, and is employed by systems such as Log4j 2, Apache Storm, and Meituan‑Dianping.
This guide compiles a comprehensive set of Oracle SQL statements and explanations for detecting fragmented tables, index fragmentation, high clustering factor tables, session and process mapping, DML lock analysis, DDL lock inspection, active SQL tracking, resource usage statistics, and various performance‑related metrics, helping DBAs diagnose and tune database behavior efficiently.
This article explains how Tencent's Mars framework provides a cross‑platform, high‑performance logging module (xlog) for mobile apps, covering its architecture, the evolution from V1.0 to V2.0, mmap usage, compression, encryption, and practical implementation details.
This article details a telecom operator's journey to cloud‑native operations, outlining the challenges of scaling monitoring, the design of a five‑level visual monitoring framework, the integration of open‑source tools like Ganglia, Nagios and JVMTI, and concrete implementation steps and results.
Node.js v6 introduces a suite of powerful enhancements over v4, including integrated Chrome DevTools debugging, EventEmitter event introspection, revamped Buffer APIs, unhandled Promise rejection warnings, secure temporary directory creation, symlink preservation, process warning handling, timing-safe crypto, V8 profiling shortcuts, and detailed CPU usage reporting.
The article recounts a real‑world incident where a complex SQL query took over 20 seconds, explains how to pinpoint whether the slowdown originates from joins or nested subqueries, and shares practical steps and insights for diagnosing and fixing such performance issues.
This article compares several Java techniques—using List, Set, a simple loop, Arrays.binarySearch, and Apache Commons ArrayUtils—to determine whether an unordered array contains a specific value, analyzes their time complexities, and presents benchmark results for arrays of different sizes.
An objective comparison of Go, Java, and C/C++ (including C++98 and C++11) examines concurrency, performance, syntax, type systems, initialization, error handling, ecosystem, tooling, and industry adoption, offering practical insights for language selection without bias.
This article outlines ten frequent errors that Node.js developers make—such as blocking the event loop, misusing callbacks, and neglecting monitoring—and explains the impact of each mistake while offering practical strategies to prevent them and keep applications performant and reliable.
The article explains how unnoticed database issues often cause system slowness, outlines key diagnostic questions for operations teams, and presents a three‑step approach—discover, solve, prevent—to regularly health‑check and optimize databases for reliable performance.
The article introduces React Web, a framework that extends React Native components and APIs to the browser, allowing a single codebase to run unchanged on iOS, Android, and web, thereby improving development efficiency, reducing costs, and addressing performance and compatibility challenges.
This article outlines comprehensive MySQL best practices, covering naming conventions, storage engine selection, data type choices, timestamp handling, NOT NULL enforcement, indexing strategies, query optimization, and safe schema evolution to improve reliability and performance of database systems.
This article compares Android's RecyclerView and ListView caching mechanisms, explains their multi‑level caches, shows how RecyclerView enables efficient partial refreshes, and concludes when each widget is appropriate based on performance and animation needs.
This article examines the caching mechanisms of Android's RecyclerView and ListView, comparing their hierarchical caches, view holder strategies, and partial refresh capabilities, and concludes when each component is preferable based on performance, animation support, and data update frequency.
This article benchmarks four widely used RPC frameworks—Dubbo, Motan, rpcx, gRPC, and Thrift—by measuring throughput, average latency, median latency, and maximum latency under varying client concurrency levels, revealing rpcx’s superior performance and the impact of serialization choices.
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.
A multi‑person technical discussion explores the reasons behind low cache hit rates, examines memcached LRU mechanisms, proposes AOP‑based caching strategies, and shares practical solutions such as proactive cache invalidation, lock‑based stampede protection, and workload‑aware configuration for backend systems.
This article examines the design of WeChat's cross‑platform XLog module, detailing how it balances performance, reliability, and security through memory buffering, mmap usage, and efficient compression to provide smooth, loss‑less logging for mobile applications.
This guide compiles 34 practical Oracle SQL optimization techniques—from selecting the optimal table order and rewriting WHERE clauses to leveraging indexes, avoiding costly operators, and fine‑tuning execution plans—helping developers dramatically reduce query execution time and resource consumption.
A production MySQL 5.5 instance suffered intermittent latency and bursts of slow queries, which were traced to an oversized enabled query cache that caused mutex contention during frequent DML operations, and disabling the cache resolved the issue.
This article outlines a comprehensive set of front‑end optimization strategies—including resource merging, lazy loading, DNS prefetch, CSS/JS best practices, DOM rendering improvements, and image compression—to enhance performance on mobile networks such as 2G/3G/4G.
This article summarizes Alipay’s evolution into a super‑app, detailing its multi‑stage architecture, performance and power optimizations, stability improvements, and the comprehensive operations system that monitors and mitigates issues across millions of users.
This guide explains MySQL's numeric, temporal, and string data types, their storage implications, and how to choose appropriate types, while detailing index types, creation rules, and optimization tips such as prefix lengths and B+Tree versus HASH strategies for faster queries.
This article breaks down Linux file I/O from high‑level architecture to low‑level system calls, explains how data moves through application buffers, C library buffers, page cache and disk, and offers practical tips for improving throughput, consistency, and safety.
Firefox can write 10‑30 GB of data to an SSD each day due to its default session‑store settings, but a simple change to the browser.sessionstore.interval parameter can dramatically reduce this wear, extending SSD lifespan.
This guide explains how to verify and configure Oracle's automatic optimizer statistics collection, customize collection windows, tailor statistics for large and partitioned tables, detect stale statistics, and decide when to gather histograms, providing practical SQL and PL/SQL examples.
Peter Marton, co‑founder and CTO of RisingStack, argues that Node.js excels for microservices due to its efficiency, performance, and developer happiness, citing PayPal’s reduced codebase, Netflix’s faster startup and scaling, and GoDaddy’s hardware savings after migrating from .NET.
Android’s Data Binding framework links code and XML UI elements through compile‑time generated binding classes, supporting one‑ and two‑way bindings, reducing boiler‑plate, improving performance via a single view‑hierarchy traversal, offering expressive layout expressions, event binding, observable data models, dirty‑flag rebinds, and built‑in null safety.
This guide shares ten practical MongoDB performance tips—including proper index ordering, using explain() and hint(), avoiding costly query operators, leveraging capped collections, upsert, sorting limits, aggregation, drop vs remove, batch inserts, and optimal indexing for arrays and range queries—to help developers boost database efficiency.
This guide explains how to interpret Redis INFO output, monitor client connections, memory usage, persistence stats, replication CPU metrics, configure eviction policies, understand the LRU algorithm, and perform performance analysis to keep your Redis instance healthy and efficient.
This article analyzes Meituan’s Robust hot‑patch solution, detailing its Instant Run‑inspired code injection, patch generation, production issues like method‑count limits and ProGuard inlining, performance impact, and real‑world deployment metrics, offering practical insights for Android developers.
This article examines why MongoDB's WiredTiger storage engine experiences intermittent write hangs, detailing the eviction cache design, hazard pointer concurrency, eviction thread model, checkpoint interactions, performance bottlenecks, and practical mitigation strategies.
This article presents a detailed overview of mobile app performance testing, covering the importance of performance metrics for video applications, the prioritized dimensions such as smoothness, crash, memory and power consumption, and practical methods and tools for acquiring Android and iOS system metrics.
The article details Dangdang's 15‑year evolution from a monolithic platform to a distributed, SOA‑based architecture, describing system tiering, front‑end and back‑end scaling techniques, asynchronous processing, data‑flow optimization, and operational practices that enable stable handling of ten‑fold traffic spikes during major sales events.
The article highlights four dangerous regular expression patterns that can cause severe performance degradation in Node.js, turning millisecond operations into minutes, potentially leading to timeouts, event‑loop blocking, and broader security risks, and points to additional encoding and cookie safety recommendations.
The article analyzes the technical challenges of massive e‑commerce traffic spikes such as Double 11 and presents a three‑pillar architecture—fast front‑end delivery, stable back‑end services, and dazzling real‑time analytics—using CDN caching, database optimizations, load‑balancing, system decoupling, and cloud‑native components.
The article analyzes the trade‑offs of lowering gzip compression levels for high‑traffic activity pages, proposes pre‑compressing HTML and storing it in APC's user cache, discusses cache placement options, configuration parameters, testing results, and practical implementation details to boost QPS while managing bandwidth and latency.
This article outlines comprehensive mobile performance testing practices for Baidu Video, covering background, key performance dimensions such as smoothness, crash, memory, power, CPU, and network, and detailing metric collection methods on Android and iOS using command‑line tools, Xcode Instruments, and third‑party utilities.
This article outlines essential MongoDB document best‑practice guidelines, including key naming restrictions, collection organization, avoiding custom _id values, pitfalls of array fields, compression of large fields, using MD5 hashes for long strings, case‑sensitivity handling, and index size limits, illustrated with real‑world cases.
This article explains what WebP is, its performance benefits, common server‑side and client‑side integration methods, and shares a complete practical implementation—including image conversion tools, JavaScript detection, CSS mixins, and a Node.js monitoring script—to help developers adopt WebP efficiently in their front‑end workflows.
This article explains what ANR is, outlines its three trigger conditions, describes the system's ANR execution flow, compares FileObserver and WatchDog monitoring techniques, shows how to analyze ANR logs and main‑thread stack traces, and provides practical guidelines to avoid ANR in Android applications.
Benchttp is a minimal‑weight Go‑based load‑testing utility that lets you measure QPS, duration, and concurrency with simple command‑line flags, and the article explains its usage, common parameters, and step‑by‑step installation on Linux.
Learn how to reduce MySQL replication delay by examining the three key stages—binary log writing, log transmission, and slave SQL replay—and applying tactics such as breaking large transactions, ignoring unnecessary databases, and enabling multi‑threaded replication in MySQL 5.7.
This article presents a detailed technical guide on optimizing Android applications across UI smoothness, memory management, network efficiency, power consumption, and code structure, illustrating practical tools, metrics, and real‑world case studies from Ctrip’s large‑scale mobile platform.
PhxRPC is a compact, 450KB RPC framework from the WeChat backend team that uses Protobuf for IDL, offers semi‑sync/async processing with Epoll‑based IO threads, provides built‑in overload protection, and includes performance benchmarks, usage instructions, and code generation details.
This article details a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx/OpenSSL stack, covering debugging strategies, custom traffic‑control testing, distributed load generation, use of valgrind and AddressSanitizer, performance profiling with perf, and the mindset needed to solve such high‑concurrency bugs.
This article shares the experience of a Qunar hotel team refactoring their hotel homepage with React Native, detailing the initial native‑style approach, challenges with Redux, robustness and animation performance, and the subsequent architectural redesign that improved maintainability and user experience.
This article explains how to design a complete mobile app monitoring framework that covers problem discovery through key quality metrics and user feedback, systematic log instrumentation, effective issue localization methods, and rapid damage‑control strategies such as cloud‑based feature toggles and hot‑fix mechanisms.
This article explains how WeChat's iOS client tackled SQLite performance bottlenecks by introducing multi‑handle threading, enabling WAL mode, redesigning the Busy‑Retry mechanism, and applying I/O enhancements such as preserving WAL size and mmap usage, resulting in over 90% reduction in perceived lag.
The article outlines typical mobile app quality problems such as adaptation, user experience, and traffic consumption, discusses their characteristics and impact assessment, and emphasizes the need for a comprehensive monitoring system to quickly detect, locate, and mitigate issues in production.
This article recounts the Qunar hotel team's experience refactoring a hotel page using React Native, detailing the initial native‑mindset pitfalls, robustness and animation issues, and how adopting a more React‑centric architecture with Redux, connect, and native animation APIs dramatically improved performance, maintainability, and developer experience.
This article explores RAID and replication strategies in distributed storage, detailing stripe concepts, RAID0/1/10/5/6 configurations, the typical three‑node architecture with metadata and data servers, performance bottlenecks, reconstruction experiments, and practical mitigation techniques to ensure data integrity and high availability.
This article provides a comprehensive overview of the Linux sar command, explaining its syntax, common options, example use‑cases for CPU, memory, I/O and process monitoring, and how to interpret the output fields to identify system bottlenecks.
The article reviews Red Hat Ceph Storage 2’s major updates—including multi‑site support, enhanced authentication, S3 compatibility, and performance gains with InfiniFlash—explains its pivotal role in OpenStack deployments, and mentions the 2016 China Open Source Storage Summit.
This article details the evolution of Taobao's home page over a year and a half, covering its background, migration from PHP to Node, modular architecture, performance tuning, stability mechanisms, and agile operational practices that keep a billion‑scale front‑end service reliable and fast.
This guide shows how to diagnose a flood of MySQL TIME_WAIT sockets, adjust Linux kernel parameters (or Windows registry) to shorten the wait period, verify the improvement, and understand why improper connection handling can cause the issue.
Since mid‑2015 Meitu has been integrating Golang to build high‑performance, highly‑available online services, creating supporting components and infrastructure, and after a year of production use the team identified numerous pitfalls, gathered practical insights, and now shares deployment challenges, architectural decisions, and best‑practice recommendations.
This article examines the performance challenges of a 700‑node Redis Cluster used by Youku, analyzes bandwidth and latency impacts of cluster communication, and presents practical tuning methods—including adjusting cluster‑node‑timeout, reducing replicas, disabling AOF, limiting cluster‑nodes commands, and tuning the hz parameter—to improve throughput and stability in massive Redis deployments.
This article examines MySQL's network communication stack—from the high‑level MySQL packet protocol down to the socket layer—detailing session creation, NET/VIO handling, result‑set transmission, metadata overhead, and performance measurements using MySQL 5.7.
This guide presents twenty indispensable Linux/Unix command‑line tools—from top and vmstat to Nagios and Collectl—that enable system and network administrators to monitor processes, memory, I/O, network traffic, and overall performance, helping quickly identify and resolve performance issues across any Linux distribution.
This article compares MySQL query optimization and caching for a greenfield project, outlining their respective advantages and disadvantages, and concludes with guidance on when to prioritize database tuning over cache implementation.
This article examines Apache Spark's interactive mode performance, revealing that while small datasets respond within seconds, processing beyond about 1 TB dramatically increases latency, and it discusses practical limits, hardware considerations, and the need to preload large datasets from disk.
The article explains why traditional LIMIT OFFSET pagination becomes inefficient on large MySQL tables, analyzes the performance impact of counting rows and using SQL_CALC_FOUND_ROWS, and presents several optimized techniques—including index‑based counting, keyset pagination, page‑number caching, and temporary‑table approaches—to achieve fast and scalable pagination.
This article compares JavaScript's var and let declarations, showing how let provides block scope, avoids hoisting pitfalls, and delivers noticeable performance gains in loops, illustrated with clear code examples and benchmark results.
This article explains how to use Android Studio’s Allocation Tracker, automate its start/stop via code using the ddmlib library, and directly access Dalvik’s internal allocation records to retrieve object size, type, and stack information with minimal performance impact, while discussing limitations and compatibility concerns.
The article outlines how to design a custom message queue by first identifying appropriate use‑cases such as decoupling, eventual consistency, broadcasting and peak‑shaving, then examining push versus pull models, high‑availability, ordering, duplicate handling, storage choices, batch processing, flow‑control and performance optimizations, with advanced topics reserved for a follow‑up.
This report analyzes client‑side traffic consumption caused by app icon downloads, proposes a DPI‑based icon size selection algorithm, evaluates its impact across various device resolutions, and presents data‑driven conclusions on traffic savings and user experience for Android applications.
This article explains Java’s HashMap internals, compares JDK 1.7 and 1.8 implementations, details the bucket array, linked‑list‑to‑red‑black‑tree conversion, resizing logic, performance gains of up to 100 % in 1.8, and warns against using HashMap in concurrent contexts.
This article walks through a systematic, multi‑stage approach to identifying, reproducing, and fixing server‑side problems using Linux tools such as strace, lsof, and netstat, illustrated with real‑world case studies and practical command examples.
Guido van Rossum discusses Python’s roadmap, noting challenges and progress in mobile deployment, the potential of WebAssembly, ongoing performance improvements, reasons for its popularity, and his vision for a self‑sustaining community that can carry the language forward without his direct involvement.
This guide explains how operations engineers can systematically map online business architecture, implement comprehensive multi‑dimensional monitoring, and create effective data dashboards to gain full visibility and quickly resolve issues.
This article shares a detailed post‑mortem of debugging extremely rare core dumps and memory leaks in a high‑concurrency Nginx HTTPS implementation, covering root‑cause analysis, custom stress‑test frameworks, and the use of tools such as gdb, valgrind, AddressSanitizer, perf and flame graphs to locate and fix the issues.
The article describes a real‑world investigation of extremely low‑probability core dumps and memory leaks in a heavily modified Nginx + OpenSSL stack, detailing the debugging workflow, custom high‑concurrency test harness, use of tools such as GDB, perf, Valgrind, AddressSanitizer, and the performance‑hotspot analysis that ultimately resolved the issues.
This post examines why repeated memcpy operations on non‑contiguous destination buffers exhibit non‑linear timing, presents benchmark code and results on an i5 laptop, discusses possible alternatives such as memmove, kernel APIs, and remap_file_pages, and shares community insights.
This article walks through a real‑world payment service’s performance evolution, detailing the server environment, a dozen common bottlenecks such as database deadlocks, long‑running transactions, CPU saturation, thread‑pool misuse, logging overload, cache issues, and provides concrete code‑level optimizations, architectural changes, and monitoring tips that raised throughput and stability.
This article chronicles the evolution of Taobao’s home page—from its early PHP implementation to a modern Node‑based platform—detailing architecture, module building, performance optimizations, stability safeguards, and agile practices that enable it to serve billions of daily page views.
This article examines typical C/C++ memory problems, classifying them into memory leaks and performance issues caused by fragmentation, explains root causes such as lost pointers, improper releases, unbounded allocations, and provides diagnostic examples and mitigation strategies using memory pools like tcmalloc.
BitMap, a space‑saving bit‑array structure, can replace costly I/O‑heavy Spark jobs for computing user active‑day distributions by converting joins and distinct operations into fast bitwise logic, enabling efficient 30‑day rolling metrics with minimal memory and superior performance, as demonstrated by real‑world benchmarks.
This article presents a comprehensive set of Java performance optimization techniques, covering proper use of singletons, avoiding static variables, minimizing object creation, leveraging final modifiers, using local variables, selecting appropriate data structures, reducing synchronization, and employing efficient coding patterns such as System.arraycopy and bit‑shift operations.
This guide covers essential front‑end techniques—from using ::before and ::after pseudo‑elements and optimizing fonts, images, and SVGs, to mastering CSS3 animations, responsive breakpoints, reflow/repaint performance, and effective class‑naming conventions—providing practical resources and best‑practice tips for modern web development.
The article shares practical techniques such as on‑demand loading, lazy loading, caching, asynchronous processing, merge handling, visual deception, unit testing, and comprehensive logging that transformed a sluggish monitoring client into a fast, stable C# WinForms application.
The article recounts a year‑and‑a‑half of evolving Taobao’s massive home page, detailing its shift from a PHP‑based rendering system to a Node‑powered architecture, the modular building platform, dynamic data integration, performance optimizations, stability measures, and agile deployment practices that keep billions of daily visits smooth.
A MySQL master crashed while its sync_binlog was set to 0, causing the binlog cache to lose data and making the slave’s binary log longer than the master’s, highlighting the importance of configuring sync_binlog for durability versus performance.
This article reviews how Tmall’s product‑detail and other browsing systems evolved from early static‑page caching to a unified web‑cache layer and finally a CDN‑based static architecture, detailing the technical challenges, design decisions, cache invalidation mechanisms, and performance gains that enabled the platform to handle the massive traffic spikes of the Double‑11 shopping festival.
This article details the end‑to‑end migration of the QQ Membership Activity Management System from an outdated PHP 5.2/Apache 2.0 stack to PHP 7 and Apache 2.4, covering pre‑research on HHVM and JIT, architectural choices, upgrade risks, step‑by‑step implementation, debugging techniques, API changes, and the resulting performance improvements.
Oracle’s UPDATE and MERGE statements can both modify data, but depending on indexing, join conditions, and query complexity their execution speed varies dramatically; this article explains when each is appropriate, outlines their drawbacks, and provides real‑world examples with execution plans and optimization techniques.
This guide surveys more than twenty essential Linux monitoring utilities—covering system, network, log, and infrastructure tools such as top, htop, ntopng, Nagios, and Zabbix—to help administrators efficiently diagnose performance issues and maintain reliable services.
This article presents a comprehensive set of MySQL performance optimization techniques for web applications, covering query cache usage, EXPLAIN analysis, LIMIT 1, proper indexing, join optimization, avoiding ORDER BY RAND(), selective column retrieval, proper primary keys, ENUM usage, PROCEDURE ANALYSE, NOT NULL fields, prepared statements, unbuffered queries, IP storage as unsigned int, fixed‑length tables, vertical partitioning, batch DELETE/INSERT, column size reduction, storage engine selection, ORM usage, and careful handling of persistent connections.
This article explains the design and implementation of InnoDB‑based physical replication for MySQL, covering background concepts, advantages over native binlog replication, high‑level architecture, log file handling, instance roles, MVCC handling, failover procedures, and performance test results.
The article outlines how to boost system performance through algorithmic refinements, hardware and software resource upgrades, interaction optimizations between algorithms and resources, and effective caching techniques, while acknowledging trade‑offs and the need for balanced decisions.
This article compiles essential Android performance optimization tools and practical tips, covering layout inspection, GPU profiling, memory monitoring, code best practices, view rendering, power management, and APK slimming to help developers identify and resolve bottlenecks for smoother, more efficient applications.
The article details how to set up isomorphic ReactJS server‑side rendering using ReactDOMServer, Redux for shared state, and React Router for universal routing, covering data fetching, Webpack builds for client and Node, code‑splitting, and performance trade‑offs such as CPU overhead and caching strategies.
The April 2016 Trusted Cloud report shows overall host availability at 99.83%, an improvement over March, with 60 compliant hosts (71% compliance) across 84 IDC data centers, and outlines the monitoring methodology and provider performance.
The article explains how proper cache usage can dramatically improve resource utilization, response time, and reliability in high‑concurrency front‑end and back‑end systems, while also addressing cache hit‑rate optimization, data consistency, and mitigation techniques for cache penetration and avalanche scenarios.
This article outlines a practical workflow for diagnosing and fixing memory leaks in Node.js applications, covering essential concepts of V8 garbage collection, recommended tooling such as devTool, heapdump, and memwatch, and detailed steps for reproducing issues, capturing heap snapshots, analyzing them, and applying fixes.
A high‑load MySQL server was investigated, revealing that a seemingly simple subquery caused full table scans, but rewriting it as a JOIN or using an equality subquery enabled index usage, and newer MySQL versions have fixed the optimizer bug.
This article benchmarks fourteen PHP sorting algorithms across various array sizes, ranking them by execution speed, detailing test setups, presenting performance charts for 1,000 to 2,000,000 elements, and concluding which algorithms are efficient or unsuitable for practical use.
This article examines a real‑world Oracle query where outdated or incorrect table and index statistics caused the optimizer to choose a costly index range scan instead of a partition full‑table scan, and it outlines diagnostic steps and practical solutions to restore accurate cost estimates.
MySQL normally loads an entire query result into memory, which can cause out‑of‑memory errors on large tables, but by adding the -q option in the console, enabling useCursorFetch in JDBC URLs, and setting stmt.setFetchSize(Integer.MIN_VALUE), you can switch to a streaming mode that returns rows one at a time.
