This article enumerates the most frequent Java OutOfMemoryError scenarios—including heap space exhaustion, GC overhead limits, oversized array allocations, PermGen/Metaspace depletion, thread creation failures, and native method errors—detailing their causes and practical JVM flag or code fixes to resolve them.
This article presents a detailed case study of how the Qingju Bike mini‑program, serving hundreds of millions of daily users, adopted the Chameleon cross‑platform framework to achieve high performance, stability, multi‑entry support, and maintainable code across multiple mini‑program ecosystems such as WeChat, Alipay, and Baidu.
This article details a real‑world performance test of loading over two billion rows from a big‑data platform into MySQL using XeLabs TokuDB, covering requirements, TokuDB features, table schema, bulk‑load commands, results, and practical recommendations for high‑throughput data ingestion.
This article explains how Youku processed billions of daily logs, migrated from Hadoop to Alibaba Cloud MaxCompute in 2017, and achieved lower compute and storage costs, faster data delivery, and greater operational flexibility through a robust big‑data platform tailored to its complex business needs.
This article explains why monitoring is essential for Node.js applications, outlines the most important performance metrics such as CPU usage, memory usage, garbage collection, event‑loop latency, clustering, and request/response latency, and introduces several ready‑to‑use open‑source monitoring tools.
Android activity startup latency stems from three phases—Pause, Launch, and Render—so optimizing only onCreate often leaves perceived delays; developers can measure each phase via system logs or AOP hooks (Instrumentation, Looper‑Printer, or ActivityThread handler) to pinpoint and reduce bottlenecks.
A friend needed to import over 2 billion records from a big‑data platform into MySQL for next‑day reporting, so we evaluated InnoDB versus XeLabs TokuDB, configured TokuDB parameters, created test tables, used LOAD DATA, measured write speed, file size, and discovered TokuDB can achieve about 570 k rows per second, roughly three to four times faster than InnoDB, especially when avoiding auto‑increment columns.
This article explains how leveraging HBase's SnapshotScanMR feature to create a custom hbase2hiveBySnapshot task dramatically reduces region server pressure, halves ETL execution time, and improves cluster stability for large‑scale data back‑fill operations.
This article debunks the myth that COUNT(1) is faster than COUNT(*), explains how MySQL engines handle these functions, compares their performance with COUNT(column), and offers practical tips for avoiding costly full‑table counts.
This article introduces MXFlutter, a JavaScript‑based dynamic framework that enables full‑runtime UI updates for Flutter apps on iOS, explains its architecture, code implementation, performance advantages over Dart VM, and discusses rendering optimizations, memory management, threading, and developer ergonomics.
This article explains the fundamentals of Serverless architecture, its pros and cons, and provides a detailed, practical walkthrough for migrating a lightweight web application to Tencent Cloud's Serverless Cloud Function platform, covering architecture redesign, data storage, performance tuning, debugging, deployment, logging, and monitoring.
This article examines how integrating Non‑volatile Memory (NVM) with Redis can replace traditional RDB/AOF persistence, offering a hybrid design that improves durability, reduces recovery time, and maintains high write performance, while discussing implementation details, performance benchmarks, and future optimization challenges.
This article describes how Ctrip's hotel query home page evolved through three architectural versions—1.0, 2.0, and 3.0—detailing the motivations, design choices, performance considerations, and the final unified module‑based structure that leverages VLayout for improved scalability and maintainability.
Gatling‑Dubbo 2.0 is a Gatling‑based load‑testing plugin that replaces generic Dubbo invocations with real API calls, offering richer scenario orchestration, traffic models, native throttling, lower resource use, and higher concurrency, while providing Action, Check, and DSL components illustrated through a complete mixed‑scenario simulation.
Printing a Java exception stack trace with e.printStackTrace() can exhaust the non‑heap string pool, causing request threads to block and the entire web application to appear dead‑locked, especially under heavy load.
This article analyzes why MySQL LIMIT pagination becomes increasingly slow with larger offsets, presents six optimization techniques—including using primary keys, covering indexes, prepared statements, subqueries, and composite indexes—and provides experimental results that demonstrate dramatic performance improvements.
This article details the WeChat client team's evolution from early C99‑based cross‑platform components to a mini‑program‑centric architecture, examines performance challenges on Android, and describes how integrating native rendering, the LV‑CPP C++ layer, and Flutter dramatically improved UI consistency, efficiency, and maintainability across iOS and Android.
This article details Tencent's online‑education mini‑program ecosystem, covering business matrix, native framework selection, engineering practices, audio/video integration, automated release pipelines, performance optimization through sub‑packages, and a comparison of WeChat and QQ mini‑program platforms.
The article explores how bitwise operations can dramatically speed up counting the number of set bits in a 32‑bit integer, presenting a naive O(n) solution and four successive optimizations that reduce runtime from about two seconds to under a tenth of a second, while sharing practical low‑level coding tricks.
The article outlines 19 practical MySQL optimization methods—from using EXPLAIN and limiting IN clause size to proper pagination, index usage, and JOIN strategies—providing clear explanations and example SQL snippets to help developers improve query performance and reduce resource consumption.
This article analyzes MongoDB sort operation memory limits, explains why queries may exceed the 32 MB in‑memory sort threshold, demonstrates how to inspect and adjust server parameters, create appropriate compound indexes, and use allowDiskUse in aggregation pipelines to avoid sort‑related errors.
This article examines Druid 1.1.5 connection‑pool settings—maxWait, connectionProperties, keepAlive, maxActive—illustrates real‑world cases of misconfiguration, provides recommended values, and shares a step‑by‑step investigation of a DB slow‑query incident to help engineers prevent performance and stability issues.
This article explains why MySQL queries can become slow—covering occasional delays from dirty‑page flushing or lock contention and persistent slowness caused by missing, unused, or mis‑chosen indexes—while offering practical tips such as checking process lists, correcting index usage, and refreshing statistics.
The article investigates why a DELETE without a WHERE clause on a 500k‑row MySQL table takes over ten hours to replay on a slave, analyzes row‑mode binlog replay mechanisms, compares different slave_rows_search_algorithms, presents test results, and offers practical recommendations for improving replication performance.
This article recounts the evolution of the Class Optimization Master Android project—from a dual‑end, no‑design prototype to an MVP‑based implementation and finally a modularized architecture—highlighting pain points, solutions, and practical steps for improving code boundaries, build times, and reusable modules.
This article examines Xianyu's adoption of Flutter, detailing its benefits for small and Android‑focused teams, the technical hurdles of integrating Flutter into existing apps, memory‑optimized engine sharing, video rendering improvements, the evolution of the Fish Redux framework, and the automation pipeline that drives efficient, data‑backed development.
The article analyzes a slowdown issue in the 58 Cloud Platform caused by an overloaded API Server and uneven Etcd load, explains the root causes—including load‑balancing failure and missing namespace segmentation—and presents concrete remediation steps such as DNS round‑robin, namespace partitioning, Etcd client upgrade, and cache‑enabled queries.
This article explains MySQL's Instant Add Column feature, describing the traditional costly column‑addition process, the instant method’s internal mechanics, how data is read and written before and after the change, and the practical constraints that limit its usage.
This article examines why MySQL LIMIT pagination becomes slower as the offset grows, presents six practical methods—including direct LIMIT, primary‑key indexing, ordered index scans, prepared statements, sub‑queries, and joins—provides benchmark results on large tables, and distills actionable guidelines for designing covering and composite indexes to achieve fast, stable pagination.
In a Docker‑based test environment, a Dubbo‑called RPC timed out due to a MySQL deadlock caused by missing indexes, and the issue was resolved by monitoring with Druid, remote JMC inspection, killing blocking threads, and adding proper indexes to the locked table.
This article explains why JavaScript developers often avoid bitwise operators, highlights the specific scenarios where they provide performance and code‑size benefits—such as fast integer conversion with x|0, using ~ for -1 checks, creating bit fields, and leveraging them in databases and BigInt.
This article explains the browser rendering pipeline—from network communication and HTML/CSS parsing to DOM and render tree construction—highlighting common misconceptions, performance bottlenecks, and practical optimization strategies such as DNS reduction, TCP reuse, HTTP/2 features, efficient CSS selectors, and JavaScript loading techniques.
This resource compiles a complete series of articles on distributed system theory covering consistency, consensus, high availability, scalability, performance, testing, and operations, offering both quick overviews for newcomers and in‑depth readings for practitioners seeking to master modern distributed architectures.
The article explains how using the KEYS command on large Redis datasets can block the single‑threaded server and cause outages, and demonstrates how the incremental SCAN command safely retrieves keys without impacting performance, including syntax, options, and practical examples.
This article explains the principles, advantages, and drawbacks of various RAID configurations—including RAID 0, 1, 10/01, 3, 5, 6, 50, and 60—illustrated with diagrams, to help you choose the right storage solution for speed and data protection.
This article introduces SG, a lightweight PHP syntax‑sugar extension that simplifies access to superglobal variables, outlines its features, configuration, usage examples, performance testing, and provides the GitHub project link for developers seeking more efficient and readable backend code.
This article explains how to handle 20,000+ concurrent SQL requests by moving from a simple single‑instance setup to multi‑instance sharding and finally to read‑write separation, detailing the architectural decisions, routing algorithms, and practical limits for high‑traffic e‑commerce systems.
SG is a PHP syntax‑sugar extension that introduces a new way to retrieve and manipulate superglobal variables, offering simplified, zero‑copy access, customizable preprocessing, and configurable global lookup depth, while maintaining performance and compatibility across major PHP versions.
This guide walks you through practical Linux performance troubleshooting steps, covering how to inspect CPU details, list boot‑time services, monitor CPU load, check free memory, and analyze disk I/O, with concrete commands and solutions to improve system speed.
This article explores MySQL performance when storing and querying billions of financial transaction records, detailing table creation, massive data generation, the impact of indexes on query and insert speed, pagination limits, and a practical time‑based sharding approach for bank‑level cash‑flow logs.
MySQL 8.0's histogram feature provides column value distribution statistics that help the optimizer choose better execution plans, and the article demonstrates how to create, view, and leverage histograms to significantly reduce query costs for range predicates.
The case study shows how Qingju Bike’s high‑traffic bike‑sharing mini‑program was built with the Chameleon cross‑platform framework, delivering consistent UI across WeChat, Alipay and other entry points, meeting strict performance and security demands while cutting development time by half and simplifying maintenance.
This article presents a comprehensive collection of Java backend performance best practices, covering singleton usage, static variables, object creation, final modifiers, local variables, primitive vs wrapper types, synchronization, resource cleanup, efficient data structures, and many other optimization techniques to help developers write faster, more memory‑efficient code.
The article explores TiDB’s evolution philosophy, detailing its core beliefs, early user stories, and the three‑step "Make it work, make it right, make it fast" approach, while covering technical choices such as cloud‑first design, hardware‑agnosticism, formal verification, massive testing, performance tuning, and cost‑effective scaling.
This article explains the MySQL 5.6 slave_rows_search_algorithms parameter, reproduces the HASH_SCAN bug that causes "Can't find record" errors during row‑based replication, analyzes why it occurs, and provides practical solutions such as adjusting keys, changing the algorithm setting, or upgrading MySQL.
This guide introduces a collection of practical Linux operations tools—including Nethogs, IOZone, IOTop, IPtraf, IFTop, HTop, NMON, MultiTail, Fail2ban, Tmux, Agedu, NMap and Httperf—providing concise installation commands, basic usage examples, and key options to help system administrators monitor performance, security and resources efficiently.
Discover the most common MyBatis pitfalls—from # vs $ usage, handling nulls, resultMap quirks, and dynamic SQL issues—to master safe query practices, optimize performance, and avoid runtime errors, while comparing its strengths and weaknesses against Hibernate for effective Java backend development.
This article examines the pause behavior of various OpenJDK garbage collectors by running a memory‑allocation benchmark, presenting detailed GC logs for G1, Parallel, CMS, Shenandoah, and Epsilon, and drawing conclusions on how to choose the appropriate collector for a given workload.
This guide walks you through essential Linux performance diagnostics—examining CPU details, startup services, load averages, memory usage, and disk I/O—providing commands and practical solutions to identify bottlenecks and improve system responsiveness for your workstation.
This article introduces five classic bitwise operation examples in Java—including checking odd/even, swapping variables without a temporary, finding a unique number, fast exponentiation, and determining the greatest power of two not exceeding N—explaining the underlying binary logic, code implementations, and their efficiency advantages.
This article explains HBase's compaction mechanism, covering why it is needed, the differences between minor and major compaction, the conditions that trigger compaction, key configuration parameters, thread‑pool handling, compaction policies, and how compaction influences read and write performance in a large‑scale NoSQL database.
This article explains why traditional MySQL pagination (ORDER BY … LIMIT N,M) becomes painfully slow on tens of millions of rows, analyzes the root causes, and presents concrete optimizations such as covering‑index delayed joins, bookmark‑based scans, and query rewrites that can cut execution time to a third of the original.
The article analyzes write latency caused by a slab lock in the monitoring agent, evaluates kernel upgrades and BIOS power‑saving settings, and explains CPU power‑state mechanisms (P‑States, C‑States, T‑States) with performance testing scripts to guide server performance tuning.
This article explains how to identify and resolve common causes of Java service slowdown—such as excessive Full GC, high CPU usage, intermittent latency, waiting threads, and deadlocks—by using tools like top, jstat, jstack, and MAT for systematic troubleshooting.
This article explains how MaFengWo built a data‑driven AB testing platform using OpenResty, MurmurHash, and a three‑tier cache to achieve low‑latency, high‑throughput traffic splitting across web, app, and micro‑service environments.
The article examines write latency problems caused by a monitoring agent's slab lock in older Linux kernels, explores kernel upgrade and agent modification solutions, and details how BIOS power‑saving settings and CPU power‑state management (P‑States, C‑States, T‑States) affect server read and compute performance.
This article explains Netty’s high‑performance asynchronous NIO architecture, its three‑layer design, I/O and threading models, serialization options, reliability, security features, traffic shaping, and graceful shutdown, showing why it’s the preferred framework for backend and distributed systems.
This article analyzes write latency caused by slab locking in older Linux kernels, evaluates kernel upgrades and BIOS power‑state settings, and explains CPU power‑management mechanisms (P‑States, C‑States, T‑States) that affect storage read/write performance.
This article explains the new descending index feature in MySQL 8.0, compares its execution plans and resource usage against traditional ascending indexes, and provides practical examples and composite index strategies to improve query performance.
This article explains why using NULL columns in MySQL can lead to extra storage, complex indexing, and query pitfalls, and provides concrete reasons and examples showing how NOT NULL constraints improve data integrity and performance.
This article reviews PHP's recent evolution—faster runtimes, a thriving ecosystem, modern language features, and improved tooling—while acknowledging lingering design quirks, to help developers decide whether PHP remains a viable choice for contemporary web development.
This article walks through Python’s string module, explaining how to import it, use the capwords function with custom implementations and performance benchmarks, and leverage the Template class for safe string substitution, including customization of delimiters and patterns.
A detailed investigation reveals that a seemingly trivial SELECT * FROM sbtest1 LIMIT 1 becomes slow due to InnoDB's MVCC visibility checks, a growing History List length, and a large number of deleted rows that must be scanned before a visible row is found.
Early Lock Release (ELR) is an optimization that moves lock release before log flushing to improve concurrency, and this article explains its principle, MySQL server‑ and InnoDB‑level implementations, potential side effects such as dirty reads and cascade rollbacks, and its measured performance impact.
This article explains the traditional copy‑based data transmission process, introduces the zero‑copy technique—including basic sendfile(), scatter/gather DMA and mmap support—shows how it reduces context switches and copies, and demonstrates its practical use in Kafka and Spark for high‑throughput workloads.
The article summarizes the latest JavaScript enhancements presented by the V8 team at Google I/O, covering massive async performance gains, new engine components like TurboFan and Orinoco, and a suite of language features such as class fields, private members, numeric separators, bigint, extended Intl APIs, top‑level await, Promise.allSettled/any, and WeakRef, illustrated with practical code examples.
This article explores practical cache usage by comparing DB‑first and cache‑first approaches, discusses transaction‑based safety, cache‑aside patterns, handling high‑availability databases, local‑cache decisions, and consistency solutions among local, distributed caches and databases.
This article explains common I/O and CPU bottlenecks in databases, compares horizontal and vertical sharding techniques, introduces practical tools, outlines migration steps, and discusses typical challenges such as non‑partition‑key queries, cross‑shard pagination, and scaling.
The article explains why HBase read operations are complex due to its LSM‑Tree storage and multi‑version design, details the step‑by‑step Scan workflow, discusses the reasons for its multi‑request architecture, compares scan performance with Parquet and Kudu, and offers recommendations for large‑scale data scanning.
This article explains MySQL function indexes (implemented via virtual columns), demonstrates five common query scenarios—date filtering, arithmetic on two fields, substring extraction, suffix matching, and JSON value extraction—shows how to create the indexes, compares execution plans and performance with regular indexes, and highlights the strict syntax requirements for optimal use.
This article explains the concept of zero‑copy, its I/O fundamentals, and how Java, Netty, RocketMQ and Kafka use mmap, sendfile and other techniques to eliminate data copies and boost backend throughput and latency.
This article compiles a comprehensive set of Linux commands, JVM utilities, and Java debugging tools—including tail, grep, awk, find, tsar, btrace, greys, JProfiler, jps, jstack, jmap, jstat, and IntelliJ plugins—to help engineers quickly diagnose, monitor, and resolve production issues while optimizing performance.
This guide walks you through essential Linux performance diagnostics—checking CPU details, boot‑time services, CPU load, free memory, and disk I/O—providing concrete commands, interpretation tips, and practical solutions to identify and resolve common slowdown causes.
The article explains common database performance bottlenecks such as I/O and CPU limits, and details horizontal and vertical sharding techniques—including database and table partitioning—along with tools, implementation steps, common issues, scaling strategies, and practical examples for improving scalability and reliability.
This article explains how MySQL 8.0 introduced WITH expressions, demonstrates their ease of use and efficiency with practical examples compared to traditional views, shows performance gains through query plan analysis, and illustrates functional use cases such as replacing temporary tables.
This roundup covers GoDaddy's open‑source Kubernetes External Secrets project, free CNCF cloud‑native courses for Chinese developers, major Kubernetes performance and security enhancements, Knative and Istio updates, containerd improvements, a shift from rich‑container ops to cloud‑native practices, and recommended open‑source and reading resources.
This article explains why Redis delivers exceptional performance by examining its pure in‑memory operations, single‑threaded design, efficient data structures such as SDS, dictionaries, skip‑lists, zip‑lists, and the encoding and rehash strategies that keep latency low even under heavy load.
The article examines Flutter's rise as a leading cross‑platform mobile framework, compares it with other solutions like Hybrid, React Native, and Qt, explores its ecosystem, and highlights key breakthroughs such as Code‑Push and Hummingbird that could redefine the mobile development landscape.
This guide outlines comprehensive MySQL naming conventions, table and column design rules, indexing best practices, SQL coding standards, and operational recommendations to improve performance, maintainability, and security while avoiding common pitfalls such as redundant indexes, unsafe data types, and excessive batch operations.
This article explores eight obscure Java language facts—from the unused goto keyword and integer caching to Unicode‑escaped comments, flexible array declarations, hidden object creation with new String, JVM instruction reordering, and a study showing most Java code adds little value—providing concise explanations and code examples for each.
This article explains the challenges of MySQL DDL on large tables, details the built‑in COPY, INPLACE, and INSTANT algorithms, compares third‑party tools like pt‑online‑schema‑change and gh‑ost, and provides practical guidance on minimizing impact, monitoring progress, and handling metadata locks.
This article examines how integrating byte‑addressable non‑volatile memory (NVM) with Redis can resolve the performance‑reliability trade‑off of AOF persistence, delivering near‑always‑mode data safety while maintaining everysec‑like throughput and dramatically reducing recovery time.
This article presents comprehensive Alibaba Cloud Redis development standards covering key and value design, lifecycle management, command usage, client integration, tooling, and efficient big‑key deletion techniques to help developers avoid common pitfalls and improve performance.
This article explains why enterprises should upgrade to Oracle 12cR2, outlines its key new features such as Multitenant, In‑Memory and Sharding, compares patch counts with earlier releases, details common bugs and work‑arounds, and provides recommended parameters and upgrade references for a smooth migration.
This article explains the original design goals of Go, outlines its key features and advantages such as fast compilation, simple syntax, powerful concurrency, and easy deployment, and compares it with languages like Java, C#, C/C++, JavaScript, Python, Scala, and Erlang.
Evaluating Dart’s AoT, AppJIT, Kernel, and JIT compilation for server‑side FaaS shows AoT yields the fastest runtime (≈6× JIT), AppJIT with aggressive optimization slightly outperforms Kernel, startup latency rivals Java, and for long‑running services JIT modes with tuning provide comparable throughput while minimizing build time.
After weeks of investigation, this post details how intermittent request timeouts in a high‑concurrency Java service were traced to frequent JVM stop‑the‑world pauses caused by GC, safepoint logging, biased lock revocation, and Log4j2’s synchronous logging, and outlines the steps taken to diagnose and resolve the issue.
This article describes how to ingest more than two billion records into MySQL by leveraging XeLabs TokuDB’s bulk‑loader, detailing configuration, table schema, performance metrics, and a comparison with InnoDB to demonstrate a three‑to‑fourfold speed improvement.
This guide explains how to improve MySQL database performance by identifying bottlenecks and applying both soft (query, indexing, table design) and hard (hardware, configuration, sharding, caching) optimizations, offering concrete commands, parameter settings, and practical examples.
This article explains the meaning of the Linux uptime/top output, defines system load average as the average number of runnable and uninterruptible processes, distinguishes it from CPU utilization, and provides guidance on interpreting load values for single‑core and multi‑core systems.
During a weekend on‑call shift a Java monitoring service repeatedly timed out due to network packet loss and a severe memory leak, leading to massive CPU usage and full GC cycles, which were diagnosed with jstat, jstack, heap dumps and MAT before the leak was eliminated.
This article explains how PHP’s upcoming JIT compiler and the PHP 8.0 release aim to improve performance, why the gains are most noticeable in CPU‑bound code, and what developers can expect from these new features.
This article critiques traditional Python multithreading tutorials and demonstrates how the built‑in map function together with multiprocessing.dummy's ThreadPool can dramatically speed up I/O‑bound and CPU‑bound tasks, offering concise code examples, performance benchmarks, and a real‑world thumbnail generation case study.
This article provides an in‑depth overview of why Redis is used, its drawbacks, the reasons behind its single‑threaded speed, data types and use‑cases, expiration policies, memory eviction strategies, consistency challenges with databases, and practical solutions for cache penetration, cache avalanche, and concurrent key competition.
This article details ByteDance's migration to Go for its backend, covering the reasons for choosing Go, the design of a five‑tuple microservice architecture, concurrency models, timeout handling, performance tuning, monitoring, and engineering practices that enabled a production system handling over 300 billion daily requests.
This article presents a comprehensive collection of Java performance‑tuning recommendations, covering proper use of singletons, static variables, object creation, final modifiers, local variables, primitive types, synchronization, collections, memory management, and code‑level tricks, each illustrated with concise code examples.
This article explains the purpose of UUIDs, common use cases, compares several Java UUID generation libraries, and presents JMH benchmark results showing that the mica implementation based on Java 9 outperforms JDK 8 ThreadLocalRandom and Hutool FastSimpleUUID by three to four times.
This article describes how Toutiao migrated its backend to Go, detailing the reasons for choosing Go, the design of a five‑tuple microservice architecture, concurrency models, timeout and performance optimizations, monitoring techniques, and engineering practices for large‑scale cloud‑native services.
The article examines Android crashes caused by the finalize() method exceeding its watchdog timeout, explains the underlying daemon implementation and typical causes such as long‑running finalizers, lock contention and low‑priority threads, and recommends avoiding finalize, reducing finalizable objects, or suppressing the watchdog exception as practical mitigations.
The article reorganizes the extensive Kubernetes 1.14 release notes by theme, detailing Windows node production readiness, GA of Local Persistent Volumes, pod priority and preemption, readiness gates, built‑in Kustomize, kubectl usability upgrades, stability fixes, and large‑scale performance optimizations.
