This article investigates the performance differences between the Connection and Template modes of Venus‑cache, presenting test scenarios on physical and cloud servers, analyzing throughput, lock contention, and thread behavior, and offering a solution to improve QPS by optimizing connection handling.
This article walks through turning a pure‑Python great‑circle distance function into a Cython‑accelerated version, compares timings, shows how to replace Python's math calls with C library functions, and demonstrates how pure C code can achieve up to a five‑fold performance boost.
This article provides a comprehensive technical guide to Tomcat, covering its kernel implementation principles, server models, distributed clustering strategies, production deployment parameters, JVM tuning, request processing flow, servlet mechanisms, filter chains, Comet and WebSocket modes, as well as performance monitoring and optimization techniques.
This article explains the essential concepts of blockchain testing, covering its unique characteristics, testing difficulties, required technical knowledge, key test scenarios, performance metrics, and future directions toward automated and unified testing across industries.
HTTP/2 replaces the text‑based HTTP/1.x with a binary, multiplexed protocol that reduces latency, eliminates head‑of‑line blocking, compresses headers, enables server push, and improves security, offering REST APIs faster, more efficient communication while preserving familiar semantics for developers.
This article examines the fundamental distinctions between Single Level Cell (SLC) and Multi Level Cell (MLC) NAND flash, covering bit density, cost, device‑level and system‑level performance, endurance, error rates, and the suitability of each technology for industrial applications.
This article chronicles Bilibili’s 2017 front‑end transformation, detailing the shift from a backend‑centric MVC workflow to a decoupled architecture with Node middleware, Vue SSR, Docker deployment, configuration management, caching strategies, and performance testing, illustrating lessons learned and future directions.
This article details how Youku rebuilt its Double‑11 live‑streaming platform with Weex, covering the overall architecture, component modularization, interactive feature support, gesture conflict resolution, screen‑rotation handling, video corner rendering, performance optimizations, and the impressive results achieved during the event.
The article shows that replacing reflection‑heavy Gson with lightweight JSONObject for manual serialization and a compile‑time annotation‑processor generated library called Mson can cut JSON parsing and writing time to about one‑tenth, while maintaining compatibility and eliminating ProGuard rules for performance‑critical Android apps.
Metrics act as health checks for applications, enabling developers to monitor performance, track changes, and assess stability; this article explains Pandora.js’s metric naming conventions, types like Gauge, Counter, Histogram, and Meter, and provides practical Node.js code examples for implementing these measurements.
This article explains how JavaScript performance impacts web applications and provides practical optimization strategies—including the RAIL model, load time statistics, parsing and compilation overhead, bundle size reduction, code splitting with Webpack, and modern transpilation techniques—to help front‑end developers deliver faster, more responsive sites.
This article explains how dynamic rate limiting can automatically compute throttling thresholds using system load metrics such as CPU usage, load average, and response time, and demonstrates its effectiveness through real‑world testing on a flight‑price service.
This article provides a comprehensive overview of Java's garbage collection mechanism, memory regions, object access methods, allocation strategies, GC algorithms, and the various collectors used in the HotSpot JVM, helping developers understand and optimize Java memory usage.
The article introduces WCDB Swift, a pure‑Swift rewrite of Tencent's mobile database, detailing its model binding via Codable, language‑integrated queries, thread‑safe concurrency, encryption, full‑text search, and innovative use of Swift’s KeyPath and Mirror to achieve high performance and stability on iOS.
This article explains how Java's synchronized keyword works internally, covering its implementation via monitorenter/monitorexit, the role of object headers and monitors, and the various lock optimizations introduced in JDK 1.6 such as spin locks, biased locks, lightweight locks, lock elimination, and lock coarsening.
This article evaluates popular front‑end frameworks by measuring real‑world performance, bundle size, and source‑code line counts using a medium‑scale blog project, providing practical insights to help developers choose the most suitable framework for their applications.
The article analyzes why dropping large InnoDB tables in MySQL can drastically degrade overall database performance due to buffer‑pool mutex and file‑system I/O bottlenecks, and presents both operational work‑arounds and source‑code modifications to alleviate the issue.
This article shares practical experience deploying MariaDB ColumnStore for offline OLAP, covering its MPP‑based architecture, user‑experience benefits, high‑availability options, numerous syntax and data‑type limitations, and detailed scripts for schema conversion and incremental data extraction using pt‑archiver.
This article explains MySQL's logical architecture, the step‑by‑step query execution process, and provides practical performance‑tuning advice—including schema design, data‑type choices, index strategies, and specific query optimizations such as COUNT, JOIN, LIMIT pagination, and UNION—backed by code examples and diagrams.
This article explains the evolution from asm.js to WebAssembly, compares their performance, outlines implementation strategies—including AssemblyScript, hand‑written asm.js, and C/C++ compilation with Emscripten—and provides practical code examples and tips for integrating WebAssembly into web applications.
This article explains the classification of Oracle data dictionary objects, demonstrates how to query static and dynamic dictionary tables and views, lists common view families and permission views, and provides numerous SQL examples for inspecting users, tables, indexes, sequences, constraints, and PL/SQL objects.
This article explains how to fine‑tune PHP‑FPM by choosing the optimal Process Manager mode—static, dynamic, or ondemand—combined with CPU governor settings to achieve higher throughput, lower latency, and stable CPU/memory usage on web servers.
This article explains how to achieve smooth iOS list scrolling by avoiding repeated cell height calculations and using asynchronous text rendering with YYText, providing code examples, performance trade‑offs, and profiling tips for mobile developers.
This article explains why Linux appears to consume most of the memory, clarifies the meaning of the free command’s buffers/cache fields, and demonstrates through a simple experiment how Linux’s caching dramatically speeds up repeated file reads.
This guide explains Redis's core characteristics, practical key‑naming conventions, and detailed application scenarios for each data type—including strings, hashes, lists, sets, and sorted sets—complete with code examples and performance tips.
This article introduces four Python CPU profiling tools—cProfile, line_profiler, pprofile, and vprof—explaining their installation, usage on CPython and PyPy, interpreting their outputs, and visualizing results with graphviz, helping developers identify performance bottlenecks such as costly list.append calls.
Learn a comprehensive methodology for SQL performance tuning, from identifying resource bottlenecks and understanding query processing stages to applying practical optimization tactics such as efficient joins, index usage, avoiding costly operations, and best‑practice guidelines that improve execution speed and resource consumption.
This article outlines essential database design principles and a comprehensive set of query optimization techniques, covering row size limits, appropriate data types, field length choices, index usage, avoiding costly WHERE clause patterns, and best practices for temporary tables, transactions, and result set handling to boost SQL performance.
Java’s JIT compilation transforms bytecode into optimized machine code at runtime, offering benefits like hardware-specific optimization and portability, and the article explains compilation types, JVM flags for tracing JIT activity, inlining, and other optimizations such as dead code elimination and loop transformations.
This guide explains how network bandwidth, quality, switch convergence, server CPU, memory, disk, NIC, Linux kernel parameters, and Nginx compilation and configuration choices together affect Nginx throughput, and provides concrete optimization steps for each layer.
This article explains how to monitor PHP memory and CPU usage, demonstrates functions for measuring peak memory, shows line‑by‑line and generator‑based file reading techniques, and compares traditional copying with stream‑based piping to reduce memory consumption on large files.
The second part of the Elasticsearch search‑tuning series explains how to pre‑index data, choose appropriate keyword or text mappings, minimize script use by preferring Painless or Lucene expressions, and efficiently force‑merge read‑only indices into single segments for better performance.
This article examines the requirements for globally unique IDs in distributed systems, compares classic generation schemes such as UUID, Flickr, Snowflake and TDDL, and details a customized Snowflake‑based implementation with ZooKeeper‑managed worker IDs, clock‑rollback handling, deployment optimizations, and JVM tuning to achieve high performance and reliability.
Dragonfly is Alibaba's P2P‑based infrastructure that dramatically accelerates massive file and container image distribution by forming peer networks, applying smart compression and flow‑control, and reducing registry traffic by over 99%, enabling tens of thousands of servers to receive multi‑gigabyte files simultaneously during peak events.
Alibaba’s Dragonfly P2P file distribution platform, built to handle massive file and container image delivery during peak events like Double‑11, combines peer‑to‑peer networking, smart compression, flow‑control and security features to achieve billions of transfers, petabyte‑scale traffic, and up to 99.9% reduction in registry outbound bandwidth.
Alibaba’s Dragonfly (蜻蜓) leverages P2P networking, intelligent compression, and flow control to dramatically accelerate large‑scale file and container image distribution, reducing bandwidth usage by over 99%, achieving up to 57× speedup, and supporting tens of thousands of concurrent hosts during peak events like Double 11.
This guide presents thirty‑four practical Oracle SQL optimization techniques—from choosing the most efficient table order and rewriting WHERE clauses to leveraging indexes, avoiding SELECT *, using DECODE, and replacing costly operations—helping developers dramatically improve query speed and resource usage.
This article outlines essential principles for building extensible, high‑performance online services, covering interface design, coding standards, caching strategies, and logging practices to reduce bugs and simplify development and maintenance.
The article examines why a MySQL DELETE statement with a composite index on biz_date and status still triggers a full‑table scan, shows EXPLAIN output, tests forced index usage, and ultimately demonstrates that narrowing the date range in the query dramatically reduces rows examined and improves performance.
This guide reveals Pythonic techniques for iterating over ranges, lists, dictionaries, and multiple collections, showing how to write concise, readable loops, use built‑in functions like zip and enumerate, and apply advanced tools such as defaultdict, ChainMap, and context managers for cleaner and faster code.
A customer’s Oracle 11g RAC experienced chronic high CPU usage; deep AWR analysis revealed that massive parse time was attributed to mutex waits and a hidden hard‑parse failure caused by a missing column, which triggered Bug 16175381 and forced process spin, ultimately resolved by correcting the faulty SQL.
This article explains the concept and implementation of virtual DOM, focusing on Vue's use of the Snabbdom algorithm, detailing its node structure, creation, update process, lifecycle hooks, and code examples to illustrate how virtual DOM optimizes front‑end performance.
Meituan's Hermes project demonstrates how a large‑scale front‑end team achieved better developer experience and maintainability by adopting front‑back separation, ES6‑based modular and Vue component architecture, automated build pipelines, local mock services, comprehensive monitoring, network and offline optimizations, and outlines future plans for server‑side rendering and service‑worker migration.
This article summarizes the most compelling MySQL 8.0 enhancements—including a unified Data Dictionary, revamped Information Schema, role‑based privilege management, persistent configuration, auto‑increment fixes, InnoDB histogram and invisible index support, mutex refinements, row‑cache improvements, temporary‑table changes, character‑set updates, default parameter tweaks, and atomic DDL operations—providing practical guidance for DBAs and developers.
This guide lists twelve Linux tools and commands—including /proc/meminfo, atop, free, GNOME System Monitor, htop, KDE System Monitor, memstat, nmon, ps, smem, top, and vmstat—detailing how each provides real‑time or summarized insights into RAM consumption and overall system performance.
This article argues that clean, readable C++ code should be the default, explaining the difference between performance and efficiency, why premature optimization can be harmful, and how thoughtful data structures and libraries can deliver both simplicity and speed when needed.
This article explains how Node.js’s built‑in cluster module and external tools like PM2 can be used to improve stability and load capacity through three scaling strategies—cloning, decomposing, and splitting—allowing applications to fully leverage multi‑core CPUs and achieve zero‑downtime restarts.
This article details the evolution of a transaction‑related testing framework, describing its background, objectives, development stages—including all‑in‑one code, method extraction, project separation, data construction, checklist and performance testing—and outlines various test case categories and the lightweight release workflow.
This guide explains MySQL B+Tree index structures, their advantages, how to create primary, unique, ordinary, full‑text, composite and prefix indexes, and provides practical rules and tips for designing efficient indexes, query patterns, and sorting strategies to dramatically improve database performance.
This article presents a comprehensive overview of a universal FPGA‑based CNN accelerator, detailing its motivation, flexible architecture, compiler workflow, memory and compute unit designs, and performance comparisons that demonstrate significant latency and cost advantages over CPU and GPU solutions for real‑time AI inference.
The USE Method provides a concise, structured framework for quickly locating resource bottlenecks and errors in complex systems by examining utilization, saturation, and error metrics across hardware, software, and cloud environments, enabling practitioners to prioritize and resolve performance issues efficiently.
The article examines why PHP is often labeled the worst mainstream language, highlighting its chaotic function naming, inconsistent APIs, lack of async I/O and multithreading, historical design flaws, community attitudes, and recent improvements like PHP 7, while acknowledging its early deployment advantages.
This article walks through diagnosing a sluggish Oracle search query with many optional filters, removing unnecessary joins and function calls, applying conditional MyBatis joins, and creating composite indexes to dramatically lower the execution plan cost from 13902 to under 100.
This guide details practical MySQL performance enhancements across hardware BIOS settings, disk I/O choices, filesystem and kernel tuning, and MySQL configuration—including version selection, key innodb parameters, schema design rules, and operational best‑practices—to achieve substantial IOPS and query speed gains.
The article explains why Linux appears to consume most memory when using the free command, clarifies the roles of buffers and cache, shows how to interpret free’s output, and demonstrates through experiments how caching dramatically speeds up repeated file reads.
This article explains how to identify, extract, and inline critical CSS using the Critical Node.js module and a custom Webpack plugin, while deferring non‑critical CSS loading to improve first meaningful paint and overall page performance.
This article recounts the discovery, root‑cause analysis, and engineering solution for a severe Android WeChat chat freeze bug, detailing a custom TextView layout that improves text alignment, handles edge‑case languages, and delivers near‑native performance.
This article explains Vim’s powerful, extensible features, presents benchmark comparisons of memory consumption and operation speed against editors like Emacs, Nano, VS Code, Atom, Sublime, and shows why many developers still prefer Vim for efficient text editing.
The article reviews Oracle's high‑availability and sharding advances in 18c, including RAC Sharding 2.0 and Active Data Guard features, and examines MySQL 8.0's major improvements such as the removal of MyISAM, data‑dictionary optimizations, self‑tuning, enhanced security, and new performance capabilities, while also comparing MySQL with PostgreSQL.
This article explains the Android ANR mechanism, common scenarios that trigger it, how the system detects and logs ANR events, and provides step‑by‑step methods for locating and fixing ANR issues, illustrated with a recent WeChat bug example.
This guide presents twenty practical Python performance tips—from algorithmic complexity and data structure choices to generator usage, loop optimizations, C extensions, parallel processing, and profiling tools—each backed by concrete code examples and timing benchmarks.
This article explains Redis's five core data structures, their internal representations, practical use‑cases, memory‑saving configuration parameters, and the four persistence mechanisms, providing concrete examples and recommendations to improve performance and stability.
This article reviews Java 9’s extensive new features—including the module system, jshell REPL, performance and security enhancements—explains their impact on development practices, and discusses the challenges and future directions for the Java platform.
The article investigates a performance regression in MySQL 5.7.18 where partitioned tables cause excessive InnoDB row locking, leading to lock timeouts and slower updates, explains the root cause through source‑code analysis, reproduces the issue, validates the findings, and confirms it as a MySQL bug.
The article introduces Android’s ConstraintLayout, explains how it solves performance and nesting problems of RelativeLayout, LinearLayout, and TableLayout, guides developers through setup and step‑by‑step conversions—including proportional spacing, aspect‑ratio, gone margins, and chains—present a modest 10 % performance gain versus claims, and shares practical developer insights.
The article answers twelve Java concurrency questions, covering Meituan’s simple Akka use, when to prefer ReentrantLock or synchronized, queue rejection policies, Java 8 ConcurrentHashMap internals, ThreadPoolExecutor workflow, read‑write locks and Conditions, interview preparation, beginner resources, volatile ordering nuances, and notes on unclear flash‑sale overselling safeguards.
When you need to diagnose a Linux server performance issue, this guide shows the ten most useful command‑line tools you should run in the first minute, explaining what each metric means and how it helps you spot CPU, memory, disk, or network bottlenecks.
Lottie, Airbnb’s open‑source animation library, parses After Effects‑exported JSON to render vector animations natively on Android, iOS, and React Native, letting developers share a single asset across platforms, simplify code, manage assets from assets, SD card or network, while balancing modest APK size increase against performance limits for complex scenes.
The article analyzes a lottery‑service bottleneck caused by massive concurrent database reads and writes and presents a comprehensive set of backend optimization techniques—including caching, queue‑based peak‑shaving, optimistic locking, asynchronous processing, read‑write splitting, and semaphore‑based rate limiting—to improve throughput and stability under high load.
This article investigates the performance degradation and lock timeout issues observed in MySQL 5.7.18 partition tables, reproduces the problem with test cases, analyzes InnoDB lock behavior through source code debugging, validates the root cause related to partition scan locking, and confirms it as a regression bug in MySQL 5.7.
This article examines the client‑server architecture of Memcached, the slab‑based memory management of both Memcached and Redis, compares their performance, memory efficiency, persistence, data structures and networking models, and presents practical Redis use cases such as caching, ranking, pub/sub, queues, and real‑time analytics.
This article explains why caching is essential for backend services, outlines common cache problems such as penetration, concurrency, and avalanche, and compares cache-aside, read/write‑through, and write‑back patterns with practical guidance on choosing and updating caches.
This article explains how Go’s compiled single‑binary output, static type system, superior performance, built‑in libraries, and strong IDE support helped a micro‑service platform replace a Python/Django stack, cutting code by 64% and boosting backend speed by up to 30%.
The article explains how set‑based SQL queries outperform procedural, row‑by‑row approaches by showing concrete examples, AUTOTRACE statistics, and PL/SQL function alternatives, highlighting massive differences in consistent gets, recursive calls, and overall resource consumption for large production data sets.
The article outlines essential software architecture concerns—including functionality, variability, performance, capacity, ecosystem integration, modularity, buildability, productization, and security—while also discussing evaluation methods and scaling strategies for large‑scale systems such as MMOs.
This article compiles a Java club’s Q&A covering backend development essentials—from network bandwidth checks and static‑method hooking to JNI choices, OSGi modularity, plugin performance, CPU‑heavy thread analysis, ConcurrentHashMap improvements, micro‑service frameworks, cross‑data-center protocols, JVM GC mechanisms, inheritance alternatives, ThreadLocal pitfalls, career advice, cloning, generics erasure, JVM tuning, multithreading strategies, lock upgrades, monitoring tools, database failure handling, Spring Data JPA design, and distributed transaction practices.
This article reviews the compatibility of various Node.js versions with ES6 features, explains key ES6 constructs such as let, const, template literals, default parameters, destructuring, and classes, and presents performance benchmarks comparing these features to their ES5 equivalents, concluding with practical recommendations for developers.
This article compiles ten classic MySQL error scenarios—from connection limits and replication conflicts to charset issues and file‑open limits—explaining the root causes, diagnostic commands, and step‑by‑step solutions so beginners and seasoned DBAs can troubleshoot confidently.
This article compares FMDB and WCDB, detailing smooth migration steps, benchmark results showing WCDB's superior write and multithreaded performance, reduced code complexity, built‑in encryption, statistics and repair tools, and provides practical guidance for developers considering a database switch.
This guide explains how to analyze MySQL performance with EXPLAIN statements, composite indexes, slow‑query logging, storage engine locking differences, and transaction settings, providing practical examples and detailed descriptions of each EXPLAIN output column.
At HBaseCon 2017 Asia, Alibaba showcased a series of groundbreaking HBase enhancements—including strong synchronous replication, SQL-on-HBase capabilities, cross‑cluster range data copy, and read/write path optimizations—that dramatically improve performance, reliability, and usability for large‑scale big‑data storage.
This article provides a comprehensive guide to server performance optimization, covering the fundamentals of CPU, memory, and I/O analysis, practical methodologies, essential tools, and real‑world case studies to help operations engineers identify bottlenecks and improve system stability.
This article explains key website performance metrics such as response time, concurrency, and throughput, presents typical values for various operations, and outlines practical optimization strategies for front‑end, application‑server, and storage layers, including caching, CDN, reverse proxy, clustering, and code improvements.
The article explains the fundamental architectural factors of large‑scale web systems—performance, availability, scalability, extensibility, and security—detailing practical optimization techniques, measurement metrics, and design principles that guide robust software architecture decisions.
This article explains Oracle's system structure, the physical files used by RAC and ASM, their I/O patterns for OLTP and OLAP workloads, and provides detailed recommendations for ASM diskgroup design, redundancy, AU sizing, RAID choices, and SSD optimization for read and write intensive database operations.
This guide introduces the powerful sysstat suite, explains how to install sar, outlines its key features and statistics, and provides step‑by‑step commands for troubleshooting CPU, memory, I/O, and network problems on Linux servers.
This article details the QQ Membership front‑end team's performance, componentization, and continuous‑integration practices for hybrid H5 pages on Mobile QQ, covering challenges of load speed, development efficiency, high availability, and the solutions they implemented to keep page loading around one second.
This article lists ten classic MySQL error scenarios—from connection limits and replication conflicts to startup failures and charset issues—explaining each problem, showing the exact error output, and providing step‑by‑step commands and configuration tweaks to resolve them.
A production MySQL incident showed sudden system CPU spikes and many running threads despite low query throughput, which was traced to the server's time_zone=system setting causing timestamp conversion to lock a global mutex, leading to excessive spin‑locks, context switches, and degraded performance that was resolved by changing the time_zone to a fixed offset.
This guide presents ten practical MySQL performance techniques—from workload profiling and resource awareness to smart indexing, pagination, and monitoring—offering concrete steps, tool recommendations, and common pitfalls to help database administrators keep their servers fast, stable, and scalable.
This article introduces essential live‑streaming terminology and outlines a step‑by‑step testing process—including test case design, execution, and verification—to ensure that a live streaming application launches and operates reliably.
This article explains the motivations, scenarios, architecture, core components, performance characteristics, and future roadmap of Sharding-JDBC, a lightweight Java framework that enables transparent database sharding and scaling for high‑volume, high‑concurrency applications.
The article defines dynamic image formats, traces their history from GIF to WebP, compares GIF, APNG and WebP features and Android decoding performance, showing WebP offers smaller files and faster loading at higher CPU cost, while GIF remains most compatible and CPU‑efficient.
This article details JD.com's front‑end architecture for its homepage, covering the challenges of massive DOM growth, static page generation via CDN, layered page loading strategies, disaster‑recovery measures, performance optimizations, and the JDF engineering toolchain that enables modular development, automated builds, and efficient deployment in a high‑traffic e‑commerce environment.
The article examines why the author favors React for server‑side rendering despite the rise of lightweight libraries like Preact and Inferno, discussing checksum handling, compatibility, maintainability, future roadmap, and presenting benchmark data that shows React@16’s performance gains.
This article explains how to enable SSL encryption for MySQL 5.7, details the necessary configuration steps, demonstrates security testing versus unencrypted connections, and measures the resulting performance penalty, helping DBAs decide when to use SSL in production.
These ten essential Java programming commandments—ranging from adding comments and avoiding hard‑coding to proper GUI design, unit testing, and performance‑aware coding—provide developers with practical guidelines to write clearer, more maintainable, and efficient code while preventing common pitfalls.
This guide explains how to fine‑tune Linux kernel parameters and NGINX directives—such as backlog queues, file descriptors, worker processes, keep‑alive settings, access‑log buffering, sendfile, and request limits—to achieve optimal web server performance for high‑traffic sites.
This article explores a scrolling issue caused by a CSS ::after‑generated line that creates an unexpected rendering layer, explains how will‑change and transform can influence layer creation, and documents the puzzling paint/composite behavior observed during debugging.
This article translates and expands on Mark Callaghan’s sysbench benchmark, revealing that MySQL 5.6‑5.7 suffers the steepest QPS drop in low‑concurrency tests, compares configurations across versions, presents detailed charts, and concludes that most performance regressions are isolated to the 5.7 release.
