By refactoring Xianyu’s key features with RxJava 2.0, the team replaced blocking logging, HTTP, RPC, and cache operations with asynchronous streams, cutting response time by half, boosting CPU utilization to 97%, raising throughput about 30%, and demonstrating a unified, core‑size thread‑pool model.
This article provides a comprehensive overview of caching in large distributed systems, covering CDN, reverse‑proxy, local and distributed caches, popular implementations such as Ehcache, Guava, Memcached and Redis, common pitfalls like consistency and avalanche, and practical solutions with real‑world case studies.
Flutter, Google’s open‑source cross‑platform UI framework built on Dart and Skia, provides native‑level performance through a layered widget‑rendering architecture, supports rapid development via hot‑reload (with known limits), offers extensive plugins, can be integrated into Android apps as an AAR, and delivers comparable frame‑rate performance to native code with a modest APK size increase.
This article examines the evolution, motivations, and trade‑offs of mobile dynamic solutions—including Hybrid WebView, React Native, Weex, Flutter, and mini‑program architectures—while discussing performance, platform constraints, and future directions such as PWA and JSCore‑centric designs.
This article presents a comprehensive guide to HBase performance optimization, covering I/O throttling, compaction and flush settings, multi‑WAL strategies, SSD usage, version‑specific pitfalls, key monitoring metrics, log analysis, and practical troubleshooting techniques for production clusters.
This article explains how to select an appropriate Team Foundation Server (TFS) deployment topology and design a data storage strategy, covering single, dual, and cluster deployments, hardware recommendations by team size, high‑availability options, performance testing results, and best practices for managing TFS databases.
This article dispels seven widespread HTTPS misconceptions—from caching and certificate costs to speed and IP requirements—explaining how browsers handle secure caching, affordable SSL options, wildcard certificates, migration steps, performance impacts, and why HTTPS is essential beyond login pages.
The article details how Redis’s incremental rehashing can double memory usage and trigger massive key eviction and scan inconsistencies in large‑scale clusters, explains the underlying dictionary structures, demonstrates the cursor bug when tables shrink, and presents a memory‑guard and scan‑cursor patch that resolves both problems.
This article outlines seven frequent misuse patterns in Redis development—such as improper use of collection types, missing expirations, oversized values, inefficient batch operations, unnecessary requests, poor key naming, and unsafe commands—provides real‑world case analyses, and offers practical recommendations to improve Redis health and performance.
The article details iQIYI’s systematic approach to Android app startup optimization—analyzing cold‑start processes, measuring latency with SysTrace and adb, applying process‑aware initialization, async work off the UI thread, layout simplifications, delayed services, and automated tracing—to achieve up to 40 % launch‑time reduction and establish continuous monitoring.
EasyReact is an iOS reactive programming framework that replaces closure‑based data flow with object‑graph nodes, offering visual EZRNode debugging, automatic memory management, and cross‑platform potential while delivering up to 725 % faster performance than ReactiveCocoa, simplifying learning, debugging, and future Swift‑based extensions.
This article explains Flutter’s cross‑platform engine architecture, detailing its four Task Runners, the Dart isolate model, platform‑specific implementations, custom thread configurations, and common pitfalls, helping developers understand and optimise performance for mobile apps.
This article compiles a thorough collection of Java interview questions covering fundamentals, deep technical concepts, frameworks, system architecture, distributed systems, practical problem‑solving, soft skills, and the standards expected of a Java architect, while also providing guidance on further learning resources.
This article outlines common geographic, device, browser, and Salesforce org configuration problems that cause slow page loads in Lightning Experience and provides practical mitigation steps such as network latency testing, browser benchmarking, disabling unnecessary plugins, and optimizing Visualforce and Lightning page designs.
The article explains how a repeating iOS animation caused a hidden memory leak by retaining its view controller through a strong CABasicAnimation delegate and a performSelector‑afterDelay timer, and shows how replacing the delegate‑based animation with a CAKeyframeAnimation/CAAnimationGroup and using weak references or cancelling pending selectors eliminates the retain cycle.
The Meituan Android team built an automated, non‑intrusive page‑speed plugin that injects SDK calls at compile time via a Gradle Transform, measures cold‑start, first render, network request and second render for Activities and Fragments—including ViewPager lazy loading—fetches real‑time config from a server and reports metrics to their monitoring platform.
This guide explains Bash logical operators, file‑test flags, comparison symbols, and conditional expressions, showing how to choose the right tests, use test, [] and [[]] syntax, and improve script performance with practical examples.
This article explains how database indexes are implemented using B+ trees, describing their structure, advantages such as shallow depth and ordered leaf nodes, and how they reduce disk I/O, illustrating calculations of node capacity and emphasizing the importance of index size for performance.
This guide reviews eight common Python string concatenation techniques—including the plus operator, commas, direct literals, percent formatting, format(), f-strings, join(), and the multiplication operator—highlighting their syntax, use cases, performance considerations, and recommendations for small versus large string assemblies.
This article introduces Nginx Unit, walks through its installation on CentOS 6.9, shows how to configure a simple PHP application using JSON, and presents a performance comparison with tengine + php‑fpm, demonstrating significantly higher QPS and lower request latency for Unit.
This article evaluates the server‑side performance of three popular message middleware platforms—Kafka, RabbitMQ, and RocketMQ—by measuring throughput and latency when sending small 124‑byte messages, revealing that Kafka leads, followed by RocketMQ and then RabbitMQ.
Learn seven practical Python optimization techniques—from using local variables and reducing function calls to leveraging generators and pre-compiling code—that can noticeably improve execution speed, lower memory usage, and make your scripts more efficient.
The article examines Kotlin’s hidden runtime overheads—such as companion‑object constants, default synchronized lazy delegates, boxing‑prone array types, and temporary progression objects in loops—and describes how the author built a custom Android Lint plugin (KLint) that parses Kotlin files, defines detectors, integrates with Gradle and IDE, and enforces performance‑aware coding standards through CI checks.
Quora’s founders explain why they rejected PHP and other languages in favor of Python, highlighting its ecosystem, readability, performance‑boosting tools like Tornado and PyPy, and the strategic decision to write critical code in C++ while relying on comprehensive testing for type safety.
This article details how Qunar's ATPCO international fare system was analyzed and optimized through performance profiling, application of Little's Law and Amdahl's Law, code refactoring, cache replacement, pruning of search space, and concurrency improvements such as ForkJoinPool to dramatically reduce response times and CPU pressure.
This article recounts a step‑by‑step migration of a 2010‑era Nginx‑based multi‑site environment and two MySQL databases to a cloud server, highlighting security risks, performance bottlenecks, backup commands, failed restore attempts, and practical lessons learned.
Xianyu became the first Chinese app to adopt Flutter after its 2018 preview, choosing it for performance and a single codebase, and used it to solve hybrid integration, page‑stack, video and component issues while overcoming Armv7, font, ICU and memory challenges, achieving comparable or better performance, modest APK growth, and a stable production page, though dynamic updates remain limited, prompting continued collaboration with Google.
The article demystifies high‑concurrency myths by explaining that network cards merely forward packets, while the true challenges lie in OS‑level I/O handling, CPU‑IO imbalance, and selecting the right I/O models and concurrency patterns to fully utilize hardware resources.
From legacy JSP‑based MVC to semi‑separated Ajax‑driven pages and finally fully separated front‑end architectures using Node.js, this article examines each stage’s structure, advantages, and drawbacks, arguing that small‑to‑mid‑size companies must weigh resource constraints, performance, and maintenance before fully embracing front‑end separation.
The article examines a Java URL‑validation regex that caused near‑100% CPU usage, explains how Java's NFA engine and backtracking lead to catastrophic performance, and shows how to rewrite the pattern with possessive quantifiers and proper character classes to eliminate the issue.
This article analyzes why a seemingly simple Java regular expression for URL validation caused near‑100% CPU usage, explains NFA backtracking, demonstrates the problem with concrete examples, and provides practical fixes and tools to avoid catastrophic regex performance pitfalls.
This article explains why React Fiber was introduced, describes its core concepts such as the fiber tree, work‑in‑progress tree, double buffering, priority scheduling, and lifecycle changes, and summarizes the new capabilities it brings to improve UI performance and responsiveness.
During a production incident a Java service’s URL‑validation regex caused near‑100 % CPU due to catastrophic backtracking from a greedy domain pattern, which was fixed by adding missing characters to the final class and converting the domain part to a possessive or atomic quantifier, preventing exponential matching.
An in‑depth comparison of MySQL 8 and PostgreSQL 10 examines feature parity, storage architecture, indexing, memory usage, replication, update overhead, and garbage collection, highlighting how recent improvements narrow the gap and offering guidance on choosing the right database for specific workloads.
This article details how the Qidian reading page was optimized by advancing the scroll trigger, continuously preloading upcoming chapters, and applying a throttled scroll handler, resulting in sub‑second load times, minimal loading indicators, and a smoother user experience.
This guide introduces essential Linux I/O monitoring tools—including iostat, iotop, sar, dstat, nmon, Zabbix, and Cacti—explaining their installation, key commands, and how to interpret their output for effective system performance analysis.
This article presents a comprehensive overview of Oracle partitioning, covering basic concepts, the evolution of partition features across versions, practical best‑practice scenarios, and the latest enhancements in Oracle 12c, 12.2, and 18c that improve performance, manageability, and availability.
The article examines front‑end architecture by highlighting its primary focus on user experience, performance, reliability, tooling choices, and engineering difficulties such as monitoring and caching, arguing that front‑end architects must balance these factors just like their back‑end counterparts.
The article summarizes the GIAC Shenzhen conference, highlighting front‑end, mobile, and backend optimization techniques, large‑scale architecture designs, cloud‑native solutions, big‑data testing strategies, and quality assurance practices shared by top Chinese internet firms.
DiDi PS is a custom RDMA‑based parameter server that uses a ring topology and optimized ibverbs communication to dramatically accelerate distributed deep‑learning training, consistently outperforming OpenMPI, NCCL2, TensorFlow’s built‑in RDMA, and Horovod while providing more stable and scalable synchronization for massive data workloads.
This article introduces Weex as a simple, high‑performance cross‑platform solution that leverages Vue and W3C standards to build native mobile apps, explains its architecture, page structure, components, layout, lifecycle, and shares practical experiences and best practices for integrating Weex in mobile office applications.
This article from the Xianyu tech team explains Flutter’s architecture, covering the creation and management of the widget, element, and render object trees, the three‑stage rendering pipeline (build, layout, paint), performance‑optimizing techniques, state lifecycle, data flow, and practical tips for building efficient cross‑platform mobile applications.
An in‑depth comparison of Hadoop and Spark examines their architectures, performance, cost, security, and machine‑learning capabilities, helping readers decide which open‑source distributed processing platform best matches their batch, streaming, and analytical workloads.
This article explains how 58.com’s in‑house C++ search kernel ESearch was architected to provide second‑level real‑time indexing, high‑concurrency low‑latency querying, flexible ranking models, and efficient storage structures for billions of daily queries across massive classified data.
This article provides a comprehensive review of Redis, covering why it’s used, its performance advantages, single‑threaded speed, data types and use cases, expiration policies, memory eviction strategies, consistency challenges, and practical solutions for cache penetration, avalanche, and concurrent key competition.
An Alibaba tech support engineer investigates a server whose CPU appeared fully utilized, discovers the misleading 'ni' metric, reproduces the issue with high‑nice loops, uncovers hidden mining processes via ld.so.preload, and explains how to detect and mitigate such stealthy CPU hogs.
The article explains JD’s Woodpecker monitoring system, detailing its architecture, functional and performance checks, use of headless Chrome and Puppeteer, scheduling and alert modules, and how it efficiently detects and resolves thousands of daily e‑commerce activity issues.
This article analyses the performance challenges of high‑concurrency Java applications, explains how misuse of atomic operations and blocking degrade throughput, introduces an asynchronous monitor concept and a concrete AsyncMutex implementation, and presents experimental results showing its scalability advantages over traditional ReentrantLock‑based locking.
After moving a Git server to a new data center, CPU sys time surged due to thousands of sshd processes contending on XFS read‑write locks while repeatedly reading a massive /var/log/btmp file caused by PAM postlogin, and the analysis shows how perf, strace and log rotation can resolve the issue.
This article outlines Alibaba Cloud Redis development guidelines, covering key naming conventions, value design, command usage, client configuration, lifecycle management, and recommended tools, providing practical recommendations to avoid common pitfalls, improve performance, and ensure reliable operation of Redis in production environments.
This article explains why traditional H5 pages perform poorly compared to native apps, introduces Progressive Web Apps (PWA) as a solution, details how service workers enable offline caching, presents real‑world performance comparisons, and reviews common cache strategies such as cache‑first, network‑first, stale‑while‑revalidate, cache‑only, and network‑only.
This article explores Flutter's memory management, detailing the Dart runtime's generational GC, comparing Image widget memory usage across Android versions, and evaluating the impact of reusing or not reusing FlutterView on Java and native memory consumption, with practical test results and optimization tips.
This article explains how Redis uses a dual‑hashtable structure and a progressive rehash process to handle hash collisions, detailing the rehash conditions, migration steps, and performance implications for in‑memory key‑value storage.
The article recounts a four‑year investigation that uncovered and repaired a subtle race‑condition bug in Python's Global Interpreter Lock, detailing the bug's origin, the implemented fixes, performance testing, and the decision to make the GIL creation unconditional in Python 3.7.
The article examines Kerberos KDC performance issues on Meituan‑Dianping’s data platform, showing that PREAUTH halves throughput while RAID10 has little effect, and that a single‑CPU core limits QPS; deploying 40 processes and disabling PREAUTH raises throughput over tenfold, and a lock‑free shared‑memory monitoring module with the kstat tool provides real‑time metrics for troubleshooting.
The article investigates a high‑traffic Java backend issue caused by synchronized reflection calls, analyzes thread‑blocking stack traces, demonstrates the problematic code, and presents a compile‑time PropertyDescriptor optimization that eliminates runtime locking, resulting in significant latency improvements and a deeper understanding of JVM lock mechanisms.
This article explains how ServiceComb builds on Vert.x to support both reactive and synchronous communication modes, details the thread models for single and multiple connections, presents performance improvements through CAS queues and multi‑connection setups, and outlines flexible thread‑pool strategies for microservice providers and consumers.
Meituan‑Dianping built a custom C++11 real‑time advertising index featuring a hierarchical model, lock‑free three‑layer architecture, specialized memory allocators, and forward/inverted indexes to achieve millisecond updates, high throughput, and scalability for search ads, with plans for Java integration and SQL support.
This article compiles and translates key information about HikariCP, detailing why Spring Boot 2 adopts it as the default JDBC pool, comparing its performance and stability against BoneCP, C3P0, Tomcat and Druid, and providing practical configuration steps for quick integration.
The article examines Flutter’s memory architecture, compares its Image widget’s graphics‑memory usage to Android ImageView’s Java and native heap behavior across OS versions, and evaluates FlutterView integration strategies—showing reuse saves native memory and offering a pre‑render trick to reduce first‑frame latency.
This article reviews mainstream Java database connection pools—including C3P0, DBCP, Tomcat JDBC, BoneCP, Druid, and HikariCP—compares their features and performance, explores an even faster Scala async pool, discusses future middleware trends, and examines Sharding-JDBC's evolution toward a Database Mesh architecture.
This article explains the sophisticated pagination system used by Stack Overflow, covering offset‑based queries, a custom Tag Engine, database joins, in‑memory sorting, and caching techniques that together deliver rapid page navigation even over billions of records.
This article recounts the four‑month redesign of JD.com’s homepage, detailing the migration from jQuery + SeaJS to the Nerv framework, the introduction of the Athena engineering platform, performance and experience optimizations such as code splitting, lazy loading, IE8 compatibility, and the monitoring and automation practices that ensure stability and scalability.
Facing a 20‑million‑row master table and millions of rows in up to ten child tables, the article examines the inefficiencies of repeated IN‑clause queries and presents three alternative strategies—including a single‑SQL join, a UNION ALL view, and the use of global temporary tables—detailing their trade‑offs and experimental results.
This article explains fundamental performance concepts—defining response time and throughput, using axiomatic methods, analyzing bottlenecks with sequence diagrams and profiling, applying Amdahl’s Law, and guiding capacity planning to build reliable, high‑performance applications.
Meitu’s Android DNS SDK combines LocalDNS and HTTP DNS in a hybrid strategy, transparently replaces the system resolver via reflection and native hooks, and dynamically switches to HTTP DNS on anomalies, cutting lookup latency by about 100 ms, boosting cache hit rates and overall request success while preventing DNS hijacking.
This article presents a comprehensive 2018 frontend performance checklist that guides teams from establishing a performance culture and selecting metrics to optimizing build processes, static assets, HTTP/2, security, and monitoring, while offering quick‑win actions for immediate impact.
This article introduces Alibaba’s X‑Engine storage engine, the foundation of the next‑generation distributed database X‑DB, and explains how FPGA‑accelerated compaction and asynchronous scheduling dramatically improve write‑intensive OLTP performance, reduce CPU contention, and achieve up to 50 % throughput gains while maintaining fault tolerance.
This article explains how to improve front‑end performance by separating business code from libraries, using on‑demand async loading, configuring CommonsChunkPlugin, externalizing large dependencies, and applying HTTP/2 optimizations, all demonstrated with a real Vue/Vuetify project.
Multithreading allows concurrent processing by dividing tasks among multiple threads, improving throughput and scalability when used appropriately, as illustrated through examples such as web servers, file processing, database operations, background jobs, and UI responsiveness, while highlighting the importance of choosing the right number of threads.
This article introduces a curated set of practical Linux operations tools—including Nethogs, IOZone, IOTop, IPtraf, IFTop, Fail2ban, Tmux, NMON, MultiTail, NMap, and Httperf—detailing their purpose, installation steps, key command‑line options, and usage examples to help system administrators monitor bandwidth, disk I/O, processes, logs, and security on Linux servers.
This article compiles essential MySQL interview topics, covering ACID transaction properties, isolation levels and their issues, storage engine differences, index types, query execution order, lock mechanisms, temporary tables, normalization, read‑write splitting, performance tuning, and recovery logs, providing concise explanations and examples for each concept.
This article reviews Java 10’s major enhancements—including local‑variable type inference, time‑based release cadence, new garbage‑collector interfaces, parallel G1 GC, heap‑allocation on alternative memory devices, repository consolidation, default root certificates, experimental Graal JIT, ThreadLocal handshakes, and removal of the javah tool—highlighting their impact for developers.
The article investigates why massive Redis deployments experience network packet loss despite using 10 Gbps NICs, explains how Linux kernel counters such as net.if.in.dropped are derived from /proc/net/dev, walks through the driver‑to‑kernel processing path, and proposes CPU‑affinity, interrupt‑affinity and NUMA‑aware tuning to eliminate the drops.
This article walks through a gray‑scale, controlled upgrade of Hive from version 0.13 to 2.1, covering metadata schema analysis, syntax compatibility, new Hive‑2.1 features, UDF adjustments, performance tweaks, and a step‑by‑step procedure to ensure stability and zero service interruption.
This article explains Redis's dictionary structure, the conditions that trigger rehashing, the step‑by‑step incremental rehash process, and provides the core C implementation code, illustrating how Redis maintains high performance while resizing its hash tables.
This guide compiles the most frequent Ethereum synchronization problems—such as blocks lagging by dozens, the sync process stalling at 99%, zero block height or balance readings, and abnormal logs—and provides step‑by‑step commands, hardware tips, cache settings, and log‑analysis techniques to diagnose and resolve them.
This article explains how to correctly configure JedisPool and its underlying GenericObjectPoolConfig, provides Maven dependency details, demonstrates pool initialization and usage patterns, and offers practical recommendations for maxTotal, maxIdle, minIdle, idle monitoring, and warm‑up to ensure stable and efficient Redis operations in Java applications.
This article explains how to use MySQL's EXPLAIN to verify index usage and outlines ten common situations—such as using !=, OR, functions, or low‑cardinality columns—that can cause indexes to become ineffective, helping developers and interviewees avoid performance pitfalls.
This article translates hardware latency into human‑scale time, revealing how disks, networks, memory and other components appear painfully slow from a CPU’s viewpoint and why performance optimization is a complex, system‑wide challenge.
This article provides a comprehensive guide to Rax 0.5's long‑list components, explaining when to use each list tag, how to enable scrolling, optimize performance with RecyclerView, handle refresh, appear, and onScroll events, and organize complex page layouts with sticky headers, nested scrolling, and gesture management.
This article explores practical JavaScript and DOM optimization techniques—avoiding eval, using local variables, minimizing reflows, and leveraging efficient string handling—to dramatically improve web application performance.
This article introduces WebAssembly, explains its performance advantages over JavaScript, details the setup of development tools like Emscripten, CMake, and WABT on macOS, and provides step‑by‑step examples for compiling C/C++ code to .wasm, loading modules in JavaScript, and using advanced features.
This article explores WebAssembly’s origins, technical architecture, current browser support, limitations such as lack of OOP, garbage collection, and multithreading, and discusses its security concerns and roadmap, ultimately questioning whether it will ever supplant JavaScript in the web ecosystem.
This article explains the evolution of Java application servers, the inner workings of servlet containers, and provides a detailed walkthrough of Tomcat’s components, request handling flow, and key performance‑tuning considerations for modern backend development.
The article analyzes why Go's ioutil.ReadAll becomes a performance bottleneck in IO‑intensive workloads after CPU microcode patches, explains the underlying buffer reallocations, and presents a multi‑level memory‑pool design that reduces allocations and achieves roughly a 19‑fold speedup.
This article translates hardware latencies—from CPU cache and memory to disk and network—into human‑scale time equivalents, using vivid analogies and benchmark data to illustrate why storage and networking appear extremely slow from the processor's viewpoint.
This article explains the origin of Android's 64K method limit, how it varies across OS versions, and evaluates several approaches—including Google Multidex, asynchronous child‑process loading, plugin architectures, and lazy loading—to help developers choose the most suitable solution for their app.
This article outlines the most frequent SQL performance mistakes—such as misusing UPDATE, over‑selecting columns, unnecessary double queries, and improper use of GUIDs—and provides concrete, actionable techniques like CASE expressions, temporary tables, batch operations, and table‑valued functions to dramatically improve query speed and concurrency.
This article explores recent Python performance improvements, benchmarks a new microframework called Japronto that can process over a million HTTP requests per second using techniques like HTTP pipelining, C extensions, and careful memory management, and outlines its features and future directions.
The article explores the collaborative relationship between Chrome teams and the web development community, outlining high‑level goals for accessibility, performance, security, privacy, overall platform openness, and calls for transparent cooperation, best‑practice guides, and shared tools to build a faster, more reliable web for everyone.
Pluto is an iOS layout engine that uses JSON/JS files to describe UI elements, dramatically improving development efficiency while maintaining smooth performance and low memory usage for complex feed styles.
This article explains MySQL's row‑level, table‑level, and page‑level locks, maps them to storage engines, details MyISAM and InnoDB lock types, describes the four internal lock queues, and provides practical optimization and monitoring techniques to improve concurrency and performance.
This article recounts a 2017 internal high‑performance competition where a C server handling a 40 million‑row user‑info dataset was progressively optimized through data compression, custom hash tables, memory layout redesign, and a thread‑pool model, ultimately achieving a four‑fold throughput increase.
This article discusses the rapid evolution of Node.js versions, the practical difficulties of converting legacy code from yield to await, and why developers should consider upgrading to newer releases like Node 8 to leverage V8's performance improvements.
This article systematically explains how browsers use multiple processes and threads, how the rendering pipeline works, why JavaScript runs on a single thread, and how the event loop, macrotasks, microtasks, timers, and Web Workers interact to affect performance and stability.
This article details UCloud's comprehensive optimizations for KVM live migration—including host selection, zero‑data handling, network switch improvements, auto‑converge tuning, compression, fast‑migration paths, cross‑machine type migration, and local hot‑upgrade—demonstrating how each stage reduces downtime, data transfer, and resource consumption while maintaining VM availability.
This article explains how to anticipate and monitor Elasticsearch issues such as node unavailability, OOM errors, and long garbage‑collection pauses by tracking key performance metrics across query, indexing, memory, and system levels, helping prevent service disruptions.
This article explains the evolution of JavaScript performance, introduces WebAssembly concepts and browser support, provides step‑by‑step installation of Emscripten, WABT, and related tools on macOS, demonstrates WebAssembly APIs such as validate, Module, compile, Instance, Memory and Table, and shows practical examples of compiling and invoking C/C++ and Rust code from JavaScript.
The article thoroughly examines MyBatis’s first‑level (session) and second‑level (namespace) caches, detailing their configurations, internal workflows, source‑code implementations, experimental behaviors, common pitfalls such as stale or dirty data, and advises disabling built‑in caching in favor of dedicated solutions for production.
