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.
The article introduces Alibaba’s Weex framework, announced at QCon 2016, detailing its motivation, cross‑platform architecture, performance benchmarks, testing strategies, and three deployment modes—full‑page, native component, and H5 component—aimed at balancing performance and dynamic capabilities in mobile development.
The article explains the design, operation, and performance characteristics of Java's G1 (Garbage‑First) collector, covering its parallelism, generational approach, space‑efficiency, pause‑time predictability, implementation details, execution phases, benchmark results, and practical recommendations for choosing a collector.
This article highlights the two most critical performance mistakes identified by Martin Thompson—excessive logging and poorly designed APIs—illustrating how logging threads can linearly increase latency and proposing better API signatures such as returning iterators or using caller‑provided collections to boost efficiency.
This guide presents twelve practical Hive tuning techniques—including avoiding MapReduce, limiting string concatenation, steering clear of subqueries, choosing the right file formats, managing vectorization, sizing containers, enabling statistics, and optimizing joins—to dramatically improve query speed on Hadoop.
The article explains how building low‑latency applications relies on simplicity, minimizing data transformations, using lightweight libraries, and separating business from infrastructure code to achieve high performance, maintainability, and reduced operational costs.
This article highlights thirteen often‑overlooked MySQL details—including case‑insensitive column names, LIKE pattern rules, REPLACE and INSERT ON DUPLICATE KEY syntax, EXPLAIN usage, index limits, replication methods, partitioning, slow‑query logging, binlog, advanced objects, and useful client tools.
This article explains how to use jQuery’s chaining and .end() method, correctly employ HTML5 data‑* attributes, improve selector performance by caching and preferring native loops, understand the CSS box model and box‑sizing, apply efficient float and absolute positioning techniques, and follow best‑practice CSS formatting and feature detection.
This article examines the performance challenges of Taobao's personalized homepage and presents a series of frontend optimization techniques—including module prioritization, lazy loading, image compression, caching, and smooth rendering—to achieve faster first‑screen loads and smoother scrolling experiences.
This article explains how to accelerate HTTPS access, reduce computational load, and harden security by applying protocol‑level tweaks such as TCP Fast Open, HSTS, session resumption, OCSP stapling, false start, SPDY/HTTP2, as well as practical deployment strategies like full‑site HTTPS, domain planning, connection reuse, and handling common migration issues.
This article explains the challenges of caching static resources in frontend development, especially in environments like WeChat, and presents a solution using MD5 fingerprinting, Gulp preprocessing, manifest generation, and RequireJS mapping to automatically update only changed files while preserving cache efficiency.
This article explores two PHP multi‑process architectures for rapidly retrieving page titles from hundreds of URLs, comparing a simple socket‑based server with a threaded URL‑batch processor, and discusses performance trade‑offs, memory usage, and scalability considerations.
This article details JD.com's front‑end engineering practices for its 2015 PC homepage, covering challenges, static page generation, overall architecture, modular widget system, build tools, performance optimizations, disaster‑recovery strategies, and a Q&A session that reveals practical implementation insights.
This article provides a comprehensive technical summary of large‑scale distributed website architecture, outlining characteristics, architectural goals, patterns, and detailed strategies for high performance, high availability, scalability, extensibility, security, and agility, supplemented with illustrative examples and practical insights.
This article provides a comprehensive, structured overview of modern front‑end technologies, covering frameworks, component design, build tools, debugging techniques, responsive layout, performance optimization, as well as related resources and soft‑skill recommendations for developers.
This article examines the various scenarios that cause Redis to block—such as expensive commands, fork‑induced overhead, and persistence operations—and provides practical architectural and configuration solutions to keep the event loop responsive even with large data volumes.
A benchmark on a test server comparing Redis and SSDB using one million SET, GET, HSET, and HGET requests with 1,000 concurrent clients shows SSDB delivering far lower QPS than Redis, contradicting the performance figures advertised by SSDB.
This article details Dangdang Marketplace's comprehensive performance optimization—including component-based design, proactive data generation, asynchronous loading, lazy rendering, multi‑domain and CDN strategies, GZIP compression, and Nginx fastcgi/proxy caching—showing how these measures reduced first‑screen time to under three seconds and dramatically lowered CPU and load during high‑traffic events.
This article details the comprehensive performance optimization strategies applied to Dangdang's marketplace, covering componentization, data generation and loading improvements, front‑end techniques such as lazy loading and script placement, network enhancements like DNS prefetch and CDN, and server‑side caching with Nginx and PHP asynchronous requests, along with measured CPU and load reductions.
When a PHP process suddenly consumes near‑100% CPU, this guide shows how to locate the exact file, function and line causing the spike by inspecting Zend executor globals with GDB, using both manual commands and a ready‑made .gdbinit script.
This article introduces nine Java performance profiling tools—including NetBeans Profiler, JProfiler, GC Viewer, VisualVM, Patty, JRockit Mission Control, Eclipse Memory Analyzer, Java Interactive Profiler, and Profiler4J—explaining their features, usage scenarios, and how they can help developers improve Java application efficiency.
