This article explains how the Taro multi‑platform framework reduced its H5 bundle from over 450 KB to about 96 KB by applying dead code elimination, configuring sideEffects, converting core packages to ES modules, and using a custom Babel plugin to transform default imports into named imports.
Alibaba’s newly open‑sourced coobjc framework brings coroutine‑based async/await, generators, and actor model support to Objective‑C and Swift on iOS, offering cleaner code, better performance, and reduced threading issues compared to traditional block‑based GCD approaches, with detailed design, implementation, and benchmark insights.
This article examines a real MySQL deadlock case caused by concurrent UPDATE‑then‑INSERT logic, explains the underlying InnoDB lock phases, analyzes the deadlock log step by step, and proposes a safer single‑statement solution using INSERT ON DUPLICATE KEY.
This article presents a comprehensive guide to improving SOFARPC performance, covering custom BOLT protocol design, Netty transport optimizations, serialization choices, batch decoding, and client‑proxy benchmarking, with practical code demos and configuration recommendations for Java RPC services.
This article explains the concept of lazy loading in front‑end development, covering placement of placeholder elements, scroll event listening, viewport detection methods, detailed JavaScript implementations, and advanced optimizations such as throttling, vertical‑only checks, and extending lazy loading to other resource types.
This article explains the evolution of JVM garbage collectors from Serial to G1, details the different collector types, describes G1's memory model and collection phases, and outlines scenarios where G1 provides low‑latency, high‑throughput garbage collection for large Java applications.
This comprehensive guide explains the main factors that slow down MySQL queries—including inefficient SQL, concurrency limits, CPU and disk I/O bottlenecks, network issues, large tables, and transaction overhead—while offering concrete configuration tweaks, storage‑engine choices, indexing strategies, and sharding techniques to dramatically improve performance.
This article reviews seven common Python string‑concatenation techniques—including +, commas, direct literals, %, format(), join(), f‑strings, and *—and explains when each method is most suitable for small or large string assemblies.
This article explains why and when to shard databases, compares sharding methods such as key‑based, range‑based, and dictionary approaches, and outlines the performance gains, availability improvements, and new challenges like increased complexity, ID handling, cross‑shard queries, and distributed transactions.
This article highlights the most reliable, simple Linux performance utilities, introduces Brendan Gregg's updated talk and slides from LinuxCon NA 2014 that now cover testing and optimization, and presents concise visual summaries of monitoring, testing, and optimization tools for various subsystems.
This article explains MySQL’s storage engines, compares B‑Tree and B+Tree indexes, details their structures and search processes, and outlines key principles for designing efficient indexes to avoid slow queries in relational databases.
This article classifies various cache types—client, browser, CDN, NGINX, application, and unified caches—and presents real‑world case studies on hotspot key handling and a three‑layer category center design, highlighting strategies, challenges, and performance results.
This article gathers subtle yet frequent anti‑patterns that new Python developers encounter—misusing range, avoiding list comprehensions, overlooking set/dict look‑ups, variable‑scope surprises, and PEP8 style rules—and offers clear, practical alternatives to write cleaner, faster, and more maintainable code.
The article recounts a pre‑promotion MySQL replication incident at JD.com, explains the master‑slave architecture and thread roles, identifies slow‑SQL and missing indexes as root causes of replication lag, and proposes practical measures to reduce latency and improve system stability.
Database sharding, a horizontal partitioning technique that splits a table’s rows across multiple nodes, enables scalable performance and fault isolation for high‑traffic applications, but introduces complexity, potential data imbalance, and recovery challenges, so it should be adopted only after simpler optimizations are exhausted.
This article details the comprehensive front‑end performance improvements applied to the JD PLUS membership project, covering the migration to the Gaea4.0 webpack‑based scaffold, PWA offline caching, Babel 7 polyfill on‑demand loading, request and image optimizations, skeleton screens, and build‑time caching techniques to accelerate first‑screen rendering on mobile H5.
This article provides a comprehensive overview of the HTTP protocol, covering its relationship with DNS/TCP/IP, request/response structure, methods, design principles, persistent connections, cookies, compression, caching, status codes, and the enhancements introduced in HTTP/2.
This article summarizes essential JVM tuning flags—including AutoBoxCacheMax, AlwaysPreTouch, CMSInitiatingOccupancyFraction, MaxTenuringThreshold, ExplicitGCInvokesConcurrent, and memory settings—explaining their effects on object caching, memory allocation, garbage‑collection behavior, and overall Java application performance.
This article analyzes whether the entire Chinese population could be added to a single WeChat group, examining user statistics, message volume, required bandwidth, CPU processing limits, Moore's law projections, supercomputer alternatives, hardware costs, storage demands, and practical challenges, concluding that it is theoretically possible but practically infeasible.
This article examines how different Java string concatenation techniques impact performance, demonstrates compile‑time optimizations and bytecode generation, and provides practical recommendations—such as using StringBuilder—to avoid costly object creation inside loops.
This article compiles 52 practical SQL performance optimization strategies—including indexing best practices, query rewriting, use of temporary tables, storage engine selection, data type choices, backup procedures, and diagnostic tools—to help developers write faster, more efficient database queries.
This article explains Java string concatenation methods—including the + operator, concat, StringBuilder, StringBuffer, and StringUtils.join—covers their underlying implementations, compares their performance, and provides practical recommendations for efficient and thread‑safe usage.
This article details a two‑month exploration of the Weex framework, covering its architecture, project scaffolding, build commands, demo implementation, environment configuration, caching strategies, native bridging, and a concise comparison with React Native and Flutter to demonstrate its suitability for cross‑platform front‑end development.
This article explains how to monitor Nginx in high‑traffic e‑commerce scenarios, covering essential metrics, latency, error and traffic monitoring, saturation analysis, and visualizing data with ELK and Grafana, plus real‑world case studies and practical configuration tips.
TDH 5.2.3 introduces a series of stability and performance upgrades—including transaction and compaction optimizations, enhanced error handling, SQL length protection, improved Oracle‑compatible UDFs, default resource pool support, Guardian caching, TxSQL monitoring, and workflow and OLAP engine fixes—aimed at delivering a more reliable big‑data platform.
The project re‑engineers Twemproxy by adopting Nginx’s master‑worker multi‑process model, adding non‑blocking accept locks, reuseport load balancing, CPU affinity and crash isolation, which transforms the single‑threaded proxy into a scalable, low‑latency, high‑QPS solution suitable for public‑cloud high‑concurrency workloads.
This article explains the browser's critical rendering path, detailing how HTML, CSS, and JavaScript are transformed into pixels through DOM construction, CSSOM creation, render tree generation, layout, and painting, and discusses how JavaScript can block and delay these stages.
This article presents the integration of Alluxio as an in‑memory caching layer for QueryEngine's Spark SQL engine, detailing Alluxio's architecture, key features, deployment practice, performance testing methodology, results, and lessons learned for large‑scale ad‑hoc query acceleration.
The article investigates why one of two identical Alibaba Cloud servers experiences frequent Full GC pauses, analyzes heap and GC logs, compares 3‑, 6‑, and 12‑hour metrics, and proposes JVM heap‑size and flag adjustments to eliminate the issue.
This article explores the origins, challenges, and ongoing research surrounding Python's Global Interpreter Lock (GIL), explaining why it limits multithreaded performance, how it has evolved, and what alternatives developers can consider for true parallel execution.
By integrating OVS‑DPDK with VF‑based flow separation, stateless forwarding, and dual redundant processes, Didi Cloud’s engineering team achieved millisecond‑level hot upgrades—approximately 80 ms per VM—while maintaining high‑performance packet forwarding, scalability across hundreds of VMs, and rapid fault recovery.
This article explains how OpenResty, built on Nginx and Lua, powers JD Logistics' high‑throughput, extensible gateway by leveraging non‑blocking I/O, plugin architecture, multi‑level caching, dynamic load balancing, and custom JSON handling to achieve stable, scalable performance.
This tutorial explains what Java memory leaks are, how they occur through static fields, unclosed resources, improper equals/hashCode, inner classes, finalizers, String interning, and ThreadLocal usage, and provides practical detection methods, profiling tools, and concrete prevention strategies to keep applications performant.
This article examines the evolution from legacy SCSI and SAS storage protocols to NVMe and NVMe over Fabrics, explaining the performance bottlenecks of traditional storage, the technical advantages of NVMe, deployment options, vendor implementations, and future trends shaping data‑center storage architectures.
The article explores the fundamental problems of UI engineering—consistency, responsiveness, latency, navigation, caching, accessibility, internationalisation, transport, resilience, abstraction, and prioritisation—encouraging developers to solve them by building small, library‑free prototypes to deepen their understanding of trade‑offs.
When a data platform server spikes to 98% CPU despite low traffic, this guide walks you through using Linux tools and Java thread analysis to locate the offending process, identify the problematic code, and apply a targeted fix that drops CPU load dramatically.
This article presents 19 practical MySQL optimization tips, ranging from using EXPLAIN and proper indexing to rewriting IN/EXISTS queries, avoiding costly ORDER BY RAND(), improving pagination, leveraging full‑text indexes, and applying join and execution‑plan strategies for faster, more efficient database performance.
The article explains why InnoDB semaphore waits exceeding 600 seconds trigger server crashes, details the lock structures and functions involved, shows how buffer pool pressure and metadata statistics cause contention, and introduces a small DBA utility that parses MySQL error logs to reveal the relationships between threads, locks, and transactions.
This article analytically breaks down HBase's write pipeline, quantifies disk and network overheads for massive random writes, derives formulas for resource consumption under realistic assumptions, and offers concrete tuning recommendations to optimize throughput and reduce cost.
This article details CTrip’s experience of containerizing a 200 TB+ Redis deployment with millions of queries per second, covering the motivations, architecture, Kubernetes strategies, performance testing, operational challenges, and the practical solutions they devised to achieve high scalability and resource efficiency.
This article explores how JVM memory is allocated, why objects created in methods are not reclaimed instantly, and demonstrates through experiments how Eden space, YGC, and GC behavior affect object lifetimes and overall heap utilization.
This article explains the five Redis data types—String, List, Hash, Set, and Zset—their characteristics, typical use cases, and how to combine them effectively, illustrated with a real‑world hot‑top cache design for a high‑traffic group‑buying system.
HTM is a pure‑JavaScript library that implements a JSX‑like syntax without a compiler, offering sub‑kilobyte bundle sizes, seamless integration with React/Preact, ergonomic syntax enhancements, and a new Babel plugin that dramatically improves performance and flexibility for frontend developers.
This article explains the technical reasons why front‑end monitoring systems commonly use 1×1 transparent GIF images for data reporting, covering cross‑origin constraints, non‑blocking behavior, and the minimal file size advantage over PNG and BMP formats.
The Gatling‑Dubbo plugin extends Gatling’s high‑performance, event‑driven load‑testing framework with a Dubbo protocol layer, providing protocol, action, and JsonPath‑based check components plus a HTTP‑like DSL, enabling asynchronous generic calls, response validation, throttling, and full example simulations for distributed Dubbo service testing.
This article explains why SQL auditing is essential, outlines its core principles, dimensions, scoring model, and workflow, and provides practical guidance on building a self‑service, visualized, and automated audit solution that improves database reliability and developer productivity.
The article uses a restaurant scenario to explain the differences between centralized, cluster, and distributed system deployments, illustrating how performance, security, scalability, and availability map to user requirements and why scaling from a single server to clusters and distributed architectures is essential as demand grows.
This article explains how to select the right index for mixed‑type queries, quantitatively compare query performance with and without LIMIT, and safely handle long‑running DELETE statements by using InnoDB status and proper kill techniques.
This report details the background, objectives, environment, test plan, distributed JMeter setup, server monitoring, results, and analysis of a load‑testing effort aimed at identifying performance bottlenecks and validating reliability of a front‑end Node.js quality‑inspection service under increasing concurrent traffic.
This article investigates why objects allocated in a Java method are not immediately reclaimed after the method exits, demonstrating through experiments how JVM heap regions, especially the Eden space, influence garbage collection timing, and provides practical steps to control memory and CPU usage by deliberately allocating small and large objects.
This article examines the role of message‑queue middleware in high‑concurrency IM systems, compares popular open‑source options such as ActiveMQ, RabbitMQ, Kafka, RocketMQ and ZeroMQ, and provides a detailed multi‑dimensional framework—including functionality, performance, reliability, operational management, and ecosystem factors—to help engineers select the most suitable queue for their specific business needs.
This article outlines MongoDB's key features, describes a real‑world outage caused by misconfigured connection limits, details the root‑cause analysis and temporary remediation, and presents a comprehensive set of configuration, sharding, and hardware optimizations that dramatically improved the system's reliability and throughput.
The Binary AST proposal introduces a three‑layer binary encoding for JavaScript abstract syntax trees, aiming to reduce parsing time by up to 90 % and improve web application startup performance, with early prototypes showing promising results and growing community interest.
This article compiles 20 common Java interview questions asked by investment banks, covering topics such as multithreaded HashMap usage, hashCode/equals contracts, String substring memory issues, singleton patterns, design patterns, deadlock avoidance, and performance considerations, each accompanied by concise answers and code examples.
This technical article details how the IMWeb team transformed the high‑traffic Penguin Tutoring course detail page—built with React—by applying static resource caching, CGI pre‑loading, server‑side rendering, Redis and PWA offline caching, ultimately cutting first‑screen render time from seconds to sub‑second levels and delivering a native‑like user experience.
This article describes how NetEase Games built a Presto‑based interactive ad‑hoc query platform backed by Alluxio caching to achieve sub‑10‑second query latency, outlines the architectural design, performance comparisons with other Hadoop‑based solutions, encountered issues, and future improvement plans.
This article explains why traditional HashSet approaches run out of memory on huge integer collections, introduces Bloom Filter theory, walks through a custom Java implementation and performance tests, compares it with Google Guava's built‑in version, and analyzes the underlying source code to show how Bloom Filters achieve low‑memory, high‑speed existence queries with a controllable false‑positive rate.
This article presents a detailed “weapon list” of mobile testing tools, covering common application patterns, debugging utilities, UI automation frameworks, unit‑test libraries, network capture solutions, weak‑network simulators, specialized testing tools, code‑coverage options, cloud testing platforms, continuous‑integration systems, and monitoring SDKs, helping engineers quickly locate the appropriate tool for each testing scenario.
This article walks through the NewLife.Redis library’s two‑layer architecture, demonstrates basic and advanced usage with C# examples, shows pressure‑testing results, and shares practical tips such as GetAll/SetAll, pipelines, and serialization tricks for high‑throughput big‑data scenarios.
This guide shares actionable strategies for Java backend interview preparation, covering essential Java fundamentals, framework mastery, distributed system concepts, database optimization, Linux troubleshooting, and how to showcase real project experience to stand out from other candidates.
This article explains various cache types—including client, browser, CDN, NGINX, application, and unified Redis caches—and presents two real‑world case studies on handling hotspot keys and designing a three‑tier category‑center cache, highlighting performance gains, consistency challenges, and best‑practice solutions for high‑traffic backend systems.
This article presents eight practical strategies—including upgrading Node.js, leveraging fast-json-stringify, optimizing promises, tuning V8 GC, using streams correctly, and employing node‑clinic tools—to dramatically improve the performance and scalability of Node.js applications.
This article examines how Eureka, the Spring Cloud service registry, stores its registry in an in‑memory ConcurrentHashMap, uses a 30‑second pull and heartbeat interval, and employs a multi‑level cache to comfortably handle millions of daily requests in large‑scale microservice deployments.
This guide compiles essential MySQL optimization techniques—including index cardinality, common index pitfalls, effective use of EXPLAIN, handling character sets, online schema changes, and practical slow‑query analysis commands—providing developers with actionable tips to improve query performance and avoid common pitfalls.
An incident where a PHP engineer ran a Redis KEYS * command caused a massive lock, CPU spike, and a cascading database crash, prompting a review of Redis safety rules, command restrictions, and best‑practice alternatives like SCAN to prevent future outages.
This article explains the evolution of storage networking, the performance bottlenecks of legacy SCSI‑based protocols, and how NVMe and NVMe over Fabrics leverage PCIe, RDMA, and high‑speed fabrics to deliver massive parallelism, lower latency, and a new paradigm for data‑center storage architectures.
This article details a real‑world investigation of unexpected Redis slowlog latencies after container migration, tracing the issue through slowlog mechanics, contradictory monitoring data, gettimeofday inaccuracies, NTP drift, and ultimately a kernel bug affecting Skylake‑X CPUs, and offers concrete recommendations for reliable time measurement.
This comprehensive guide explains how to diagnose Linux performance issues using a structured 5W2H approach, introduces essential monitoring tools for CPU, memory, disk I/O, and network, and demonstrates practical flame‑graph techniques—including on‑CPU, off‑CPU, memory, and differential analyses—to quickly locate and resolve bottlenecks.
This guide details how to optimize Nginx for high‑traffic sites by configuring worker processes, CPU affinity, file descriptor limits, event handling, fastcgi, gzip compression, expires caching, anti‑leech rules, and kernel parameters, providing concrete code snippets and practical recommendations.
This article shares WeChat's engineering experience in detecting and preventing various Android memory leaks—including Activity, Bitmap, native, and thread leaks—by building custom tools, refining monitoring pipelines, and applying fallback protection to keep the app stable at scale.
A production Java service suffered a thread‑pool alarm due to an unbounded LinkedBlockingQueue and a non‑thread‑safe HashSet, leading to massive memory usage, a circular linked‑list loop in HashMap, and severe CPU load, which was resolved by switching to ConcurrentHashMap and tuning the pool.
Over ten years Alibaba's database team transformed from commercial Oracle‑based systems to open‑source AliSQL and finally to the self‑developed X‑DB, introducing distributed middleware, cloud resources, full‑link testing, intelligent optimization and storage‑compute separation to support the massive Double 11 traffic peaks.
This article translates David Cheney's 2014 Gocon talk, detailing five Go language features—efficient value handling, inlining, escape analysis, goroutine scheduling, and dynamic stack management—that together explain Go's performance advantages, memory usage, and concurrency model.
This article explains how JavaScript’s single‑threaded nature can cause UI jank, introduces Web Workers as a standard HTML5 solution for off‑loading heavy computations, details their API, limitations, practical use cases, and presents superWorker—a lightweight wrapper that simplifies worker creation and management.
This guide compiles the typical technical and HR questions asked in Ant Financial's Java interview process, covering topics such as project introductions, thread pools, data structures, JVM memory, database pagination, distributed consistency, load balancing, and personal strengths and career plans.
This article explains the JVM's built‑in lock optimization strategies—including biased, lightweight, heavyweight, spin, and adaptive spin locks—their allocation and inflation processes, advantages, drawbacks, and when each should be used to improve concurrent Java program performance.
This article details a step‑by‑step investigation of frequent full GC events and high CPU usage in a Java backend service, covering memory analysis with SGM, heap dumps, identification of large Base64 image strings, static encryption utilities, and remediation actions such as heap size increase and custom encryption handling.
This report evaluates how enabling SSL encryption in MySQL affects transaction‑per‑second performance, compares the OpenSSL and yaSSL libraries across SSL connection and transparent encryption test groups, and analyzes the underlying CPU, I/O, and lock bottlenecks that cause the observed performance differences.
The article explains why traditional image‑based log reporting can interfere with critical front‑end tasks, introduces the Beacon API as an asynchronous, low‑priority solution, and provides practical code examples and usage guidelines to ensure reliable data delivery without impacting user experience.
In this talk, Tencent Cloud senior engineer Zou Peng outlines cloud‑native best practices for Redis 4.0 clusters, detailing a smart‑proxy architecture with gossip‑based management, lazy‑scan big‑key handling, automatic fail‑over, the high‑performance CKV engine, and practical guidance on scaling, sharding, monitoring, and cost‑effective high‑availability deployment.
This article presents ten classic MySQL error scenarios—from connection limits and replication conflicts to permission issues and timeout settings—explaining their causes, illustrating them with screenshots, and offering concrete configuration tweaks and procedural steps to resolve each problem efficiently.
NVMe SSD performance can be unpredictable, so this article opens the SSD "black box" to examine hardware, firmware, and workload factors—such as NAND type, multi‑queue design, garbage collection, and I/O patterns—and offers software‑level strategies to maximize flash efficiency in modern data‑center storage systems.
This article shares a detailed, experience‑driven guide on Elasticsearch tuning, covering data model fundamentals, storage cost reductions, cluster stability tricks, performance‑boosting settings, and custom kernel improvements, all illustrated with real‑world diagrams and Q&A insights.
Swift performance hinges on allocation choices, ARC overhead, and method dispatch, so using stack‑allocated structs instead of heap‑allocated classes, applying final or private to force static dispatch, leveraging protocol‑oriented containers, specializing generics, and enabling whole‑module optimization together yield faster, more efficient iOS code.
This article explains the JVM memory architecture—including heap, method area, stack, native stack, and program counter—details how each region is organized, and provides common JVM command‑line options and typical configuration examples for optimizing Java applications.
The article introduces SGM, a comprehensive service governance and monitoring solution that addresses scaling, dependency complexity, and operational challenges by providing automated topology, real‑time tracing, capacity planning, root‑cause analysis, and extensive monitoring features such as performance metrics, JVM stats, call‑chain visualization, business dashboards, and intelligent alerting.
This article provides a comprehensive introduction to Redis, covering its core concepts, advantages, data structures, persistence mechanisms, eviction policies, clustering, common usage scenarios, and typical interview questions for developers working with this high‑performance in‑memory key‑value store.
This article explains how JavaScript reference equality for objects and functions affects React's shallow prop and state comparison, shows common pitfalls that cause needless re‑renders, and provides practical techniques—such as defining functions outside components and caching event listeners—to dramatically improve rendering performance.
This article explains how Lighthouse can measure JavaScript execution time, reveal unused code through coverage, and offers practical steps—such as sending only needed scripts, minifying, and removing dead code—to reduce JavaScript overhead and improve user experience on web pages.
This guide walks you through compiling Nginx from source, stripping unnecessary modules, applying GCC optimization flags, fine‑tuning Nginx configuration, adjusting Linux kernel parameters, and designing a scalable architecture to achieve maximum web‑server performance and stability.
This article explores the fundamentals and practical details of server‑side caching in distributed web systems, covering local vs. distributed caches, Redis instance planning, key‑value modeling, persistence, eviction policies, and CRUD operations with performance‑focused recommendations.
This multi‑part article explains Chrome’s low‑level architecture—from CPU/GPU fundamentals and its multi‑process model to the step‑by‑step navigation flow, the rendering pipeline, and how the compositor processes input events—providing developers with a deep understanding of browser performance and best‑practice optimizations.
This article explains MySQL's index structures, how indexes accelerate queries but slow down writes, the differences between B‑tree and hash indexes, clustered versus non‑clustered indexes, the left‑most prefix rule, and provides a comprehensive overview of MySQL locking mechanisms and best practices.
KafkaBridge is a lightweight, multi‑language SDK that wraps Kafka read/write operations, offering a minimal, reliable API for C/C++, PHP, Python and Go, with php‑fpm long‑connection optimizations, and includes compilation, usage, and performance testing details.
This newsletter curates the month’s top front‑end articles on React rendering, performance optimization, Electron internals, event loop mechanics, Unicode quirks, plus the latest front‑end news, version releases, and upcoming technical conferences, providing developers with concise insights and resources.
This article explains how Mozilla optimized the Firefox engine to dramatically speed up function calls between JavaScript and WebAssembly by reducing bookkeeping, eliminating trampolines, merging activations, applying monomorphic call optimizations, and improving built‑in function handling, resulting in call performance that now exceeds native JavaScript‑to‑JavaScript calls.
This article details Meitu's engineering of a Redis/Memcached proxy platform, describing why twemproxy was chosen, the limitations of its upstream version, the multi‑process redesign with live configuration reload, added latency metrics, reuse‑port handling, Redis master‑slave support, performance testing, and remaining challenges.
This article compiles essential Linux commands and a suite of Java diagnostic utilities—including tail, grep, awk, find, tsar, btrace, Greys, JProfiler, and others—providing concise examples and code snippets to help engineers troubleshoot and monitor production systems efficiently.
This article explains how large data volumes and differing environments can degrade MySQL query performance, demonstrates using EXPLAIN to analyze index usage and row scans, and offers practical steps such as adding filters, pagination, and code adjustments to improve speed.
Explore core Python backend techniques—from efficient file reading with generators and iterator nuances, through memory management and the Global Interpreter Lock, to practical Django deployment, Nginx proxying, Tornado async I/O, essential Linux commands, and fundamental data structures and sorting methods.
