The article explains MySQL 8.0.18's new hash join capability, shows how to enable and view it with EXPLAIN FORMAT=TREE, provides sample SQL and table definitions, compares its performance against block nested‑loop joins under various conditions, and discusses configuration limits and tuning tips.
This article details JD Finance's Android mobile app startup speed optimization project, covering background, launch type analysis, measurement tools, and a series of practical improvements such as theme switching, application code reduction, thread management, network tweaks, and activity refinements that together cut launch time by up to 45%.
This guide explains the drawbacks of Maven, the advantages of Gradle, how to install Gradle via binaries or package managers, use the Gradle wrapper, manage dependencies with concise scopes, configure mirrors and proxies, and leverage Gradle's speed, flexibility, and simplicity for Java projects.
This article demonstrates five different techniques for eliminating duplicate integers from a Java List—including nested loops, contains checks, HashSet, TreeSet, and Java 8 streams—provides complete source code for each method, and compares their execution times under different random data ranges.
Facing slow page loads on weak mobile networks, Alibaba’s Feizhu marketing team adopted a Serverless Faas SSR solution combined with async rendering, reducing first‑screen time to under one second, improving offline capabilities, and addressing challenges like image flicker, titlebar support, and scaling performance.
This article explains how the Linux top command provides real‑time server monitoring, details its common options, interprets each line of its output—including CPU, memory, and process information—and shows useful interactive commands and a practical example for tracking a specific process.
This article explains why using the KEYS command on massive Redis datasets can cause service blockage, analyzes the underlying O(n) traversal cost, and demonstrates how the incremental SCAN command with cursor, MATCH, and COUNT options provides a non‑blocking alternative for efficiently iterating keys.
The article examines the challenges of exposing numerous backend microservices to clients and proposes using an API gateway to centralize traffic, handle authentication, rate limiting, protocol conversion, service discovery, performance optimization, and operational concerns, while also discussing the shift toward decentralized service‑mesh solutions.
This article provides a comprehensive overview of Google’s V8 JavaScript engine, covering its architecture, compilation process, bytecode, hidden classes, inline caches, garbage collection, and debugging tools such as d8, with practical code examples and performance optimization tips for developers.
This guide consolidates practical Elasticsearch tuning techniques—from configuration file settings and system‑level adjustments to usage‑level optimizations—covering memory locking, discovery, fault detection, queue sizing, JVM heap, file descriptors, translog handling, bulk indexing, shard management, and best practices to achieve a stable, high‑performance cluster.
This article explains Google’s Core Web Vitals initiative, detailing the key performance metrics—Largest Contentful Paint, First Input Delay, and Cumulative Layout Shift—along with tools, APIs, and a JavaScript library to help developers measure and improve user experience.
This guide outlines core VR design principles—including performance optimization, comfort, learnability, camera handling, UI placement, interaction feedback, motion safety, and environment setup—to help creators build immersive, user‑friendly virtual experiences while avoiding common pitfalls that cause discomfort or confusion.
Xianyu IM’s data‑sync was re‑engineered by extracting a dedicated sync layer that uses domain‑based versioning, push‑pull hybrid buffering, and priority queues, decoupling business logic, eliminating redundant pushes, and achieving a 31% latency reduction and 35% traffic savings while enabling dynamic priority adjustments.
This article presents faster PHP alternatives for removing duplicate array values, selecting random elements, testing alphanumeric strings, and replacing substrings, providing benchmark results that show significant speed improvements and discussing trade‑offs and additional coding tips for better script performance.
The team built a low‑intrusion Gradle plugin that detects changed source and resource files, performs precise dependency analysis, leverages aapt2 for incremental resource compilation, and injects updated Dex and assets into the running app, cutting full Android builds from 418 seconds to 13 seconds and boosting daily developer productivity on large projects such as QQ Music.
The article outlines practical backend performance optimization methods such as SQL tuning, eliminating duplicate calls, on‑demand queries, parallel execution, caching, asynchronous processing, JVM parameter tweaks, and horizontal scaling, providing code examples and actionable advice for developers.
This article examines the defining traits of large‑scale web systems and walks through the step‑by‑step evolution of their architecture—from single‑server LAMP setups to multi‑layer, distributed, and automated designs—highlighting performance, availability, scalability, and security considerations.
This article explains the functional and performance differences among MySQL's count(1), count(*), and count(column) functions, illustrates how NULL handling varies, and provides a concrete example demonstrating their results and execution efficiency under different table schemas.
This article provides a detailed comparison of the three major frontend frameworks—React, Angular, and Vue—covering their design principles, strengths, weaknesses, performance benchmarks, popularity, learning curves, and suitability for different project requirements.
Although Docker has become popular for deploying applications, this article outlines seven critical drawbacks—data safety, performance, networking, statefulness, resource isolation, cloud platform incompatibility, and environment requirements—that make containerizing databases generally unsuitable, while also suggesting scenarios where lightweight or distributed databases may still benefit from containerization.
This article explains a practical fixed‑QPS load‑testing model for HTTP requests, provides reusable Java code for creating test tasks, and details two bug fixes—one for thread‑pool shutdown handling in asynchronous compensation threads and another for inaccurate request‑counting that caused over‑compensation.
This article details JD.com's transition from a custom ad‑reporting system to Apache Doris, describing the background, challenges with the legacy platform, selection criteria, implementation of data import, pre‑aggregation, on‑site computation, and the resulting performance and operational benefits during regular operation and major sales events.
This article explains why Redis uses a custom SDS string structure instead of native C strings, describes the SDS layout, expansion rules, redisObject metadata, and the three string encodings (int, embstr, raw) that optimize performance and memory usage.
The article explains how to improve Elasticsearch query speed on billions of records by leveraging filesystem cache, reducing indexed fields, using data pre‑heating, separating hot and cold indices, designing efficient document models, and applying pagination techniques such as scroll API and search_after.
This article explains the storage hierarchy from CPU registers and caches to RAM, SSD, and HDD, quantifies their speed differences (L1 cache vs. memory, SSD, HDD) and cost ratios, and provides Linux commands to inspect cache sizes, helping readers understand why each level exists and how they interact.
This article explains how React can serve as a complete state‑management solution by using hooks, lifting state, component composition, the Context API, and optional libraries, while also covering performance tips, server‑cached versus UI state, and when to adopt external tools.
This article investigates why using Log4j2's ConsoleAppender can block business threads, analyzes thread stack traces and performance bottlenecks, and demonstrates how switching to AsyncLogger with Disruptor dramatically improves logging throughput and eliminates service deadlocks.
This guide explains seven critical Linux operating‑system settings—memory overcommit, swappiness, Transparent Huge Pages, OOM killer, NTP synchronization, ulimit, and TCP backlog—that together ensure Redis runs reliably and at peak speed.
This article explains why MySQL indexes dramatically improve query speed, outlines common reasons for slow SQL, shows how to use EXPLAIN to analyze execution plans, and provides step‑by‑step optimization examples with code and visual illustrations.
This article explains how to improve the performance of rarely‑changed web pages such as user agreements by storing their rendered HTML in Redis as a full‑page cache, describing the design of helper functions, the RedisFPC class implementation, usage examples, testing results, and practical recommendations.
This article explains how Tencent's self‑developed KonaJDK underpins cloud Java services, enhances micro‑service monitoring, adds national cryptography support, optimizes large‑heap tools like jmap, and delivers performance gains for big‑data workloads, while contributing key features back to the OpenJDK community.
This article demonstrates how to build a basic Tornado server, measures its performance under blocking operations, and then progressively applies multithreading, thread‑pool executors, and finally asyncio to achieve dramatically higher QPS and lower response times.
Large‑scale front‑end projects suffer from oversized bundles, unnecessary listeners, deep cloning, and mutable state, causing latency and crashes; the article explains how to diagnose these problems with Chrome DevTools and Webpack tools and resolves them through bundle splitting, tree‑shaking, memoisation, immutable patterns, and caching.
This article details ZTO Express's journey of adopting Apache Kylin for OLAP, comparing it with Presto, describing platform architecture, performance gains, integration with scheduling and monitoring systems, and the practical optimizations and future plans that enabled sub‑second query responses on massive daily data volumes.
This article examines a production incident where Dubbo services became congested, explains the underlying communication process with detailed code analysis, identifies key protocol and service parameters affecting performance, conducts experiments on connection count and TCP buffers, and offers practical recommendations to optimize Dubbo throughput.
This article examines reliable and trustworthy execution of dynamic JavaScript in Node.js, compares isolation techniques such as new Function, the vm module, and worker threads, evaluates their performance and security trade‑offs, and explores advanced container and WebAssembly sandboxing options.
The article details how Xianyu improved long‑list scrolling smoothness on both native Android and Flutter by building a cross‑platform frame‑jank detection tool, applying async view‑caching and unbinding in Android, and using repaint boundaries, clipping tweaks, time‑slicing and custom scroll physics in Flutter, achieving up to 57 FPS and halving big‑jank counts on low‑end devices.
This article explains the zero‑copy data transfer technique, compares it with traditional read/write approaches, shows Java NIO code examples, and discusses its use in high‑performance systems such as Kafka and Spark, highlighting the reductions in context switches and memory copies.
This article explains how to optimize a SpringBoot application by modifying the application.properties configuration file and tuning JVM parameters, providing practical code examples, IDE and script methods, and detailed explanations of each JVM option for better performance.
This article examines the motivation, architecture, rendering principles, code adaptations, performance testing, and practical challenges of converting Flutter mobile code to Flutter for Web, presenting a case study from JD.com and offering recommendations for future cross‑platform development.
This article systematically details Didi's migration of over 30 Elasticsearch clusters, 3,500 nodes and 8 PB of data from version 2.3.3 to 6.6.1, covering background, problem analysis, multi‑version architecture redesign, capacity planning, tiered storage, FastIndex, query replay, upgrade pitfalls, and the resulting cost reduction and performance improvements.
Database auditing records user actions to detect illegal operations, with approaches ranging from application‑layer and transport‑layer monitoring to kernel‑level and plugin solutions; TXSQL’s MySQL‑compatible audit plugin offers both synchronous and asynchronous modes, delivering flexible rule configuration and only 3‑6 % performance overhead, making it a low‑impact, feature‑rich choice for compliance and forensics.
This article explains how Redis introduced Lua scripting to combine multiple commands atomically, covers Lua basics, data types, control structures, script execution with EVAL/EVALSHA, script management commands, and practical tips for writing efficient, safe Redis Lua scripts.
This article explains the various MySQL index implementations—including B‑Tree, B+Tree, hash, clustered, non‑clustered, and covering indexes—illustrates their internal structures with diagrams, provides SQL examples, and offers practical guidelines for selecting and using indexes efficiently.
To eliminate Xianyu’s Weex pages’ long white-screen delays, the team identified large bundles, slow first-screen data requests, and heavy UI as root causes and applied offline bundle caching, data prefetching, progressive and on-demand rendering, and bundle slimming, cutting first-screen load to under two seconds on low-end phones and achieving near-instant display on higher-end devices.
This article provides an in‑depth tutorial on Glide 4.11, covering its basic usage, the four‑step decode task startup, six‑step image loading flow, caching mechanisms, initialization process, and extensive configuration options for Android developers.
A detailed investigation of a slow Elasticsearch cluster revealed that massive Stop‑The‑World (STW) safepoint pauses caused by a buggy ARM‑based JDK version were the root cause, and switching to a proper Kona JDK eliminated the frequent ForceSafepoint interruptions and restored performance.
This article revisits memory allocation and reclamation concepts by examining Java's Netty memory pool implementation, its theoretical basis in jemalloc, and practical design choices such as arena allocation, thread‑local caches, pool chunks, sub‑pages, and multi‑threaded performance considerations.
This article analyzes common questions about Netty‑based push services, presents a real‑world IoT case study, and provides detailed design guidelines—including kernel tuning, connection handling, heartbeat configuration, buffer management, memory pooling, logging pitfalls, TCP and JVM tuning—to help engineers build stable, scalable, and high‑performance million‑connection push systems.
This article examines the YYCache iOS library, covering its multi‑level architecture, LRU implementation, thread‑safe APIs, eviction policies, lock choices, disk‑storage strategies, Swift integration, performance benchmarks, and practical takeaways for building high‑performance mobile caches.
ClickHouse is a PB‑scale, open‑source columnar OLAP database that uses a ZooKeeper‑coordinated sharded cluster, columnar storage, vectorized execution, advanced compression, data‑skipping indexes, and materialized views to deliver high‑performance interactive analytics, yet it requires manual shard management, lacks a mature MPP optimizer, and handles real‑time single‑row writes poorly.
This guide details a systematic approach to diagnosing Java service failures by sequentially checking CPU, disk, memory, and network issues, using tools like ps, top, jstack, jstat, iostat, jmap, and netstat to pinpoint root causes and apply appropriate fixes.
This article explains why MySQL's default InnoDB storage engine uses B+ trees instead of B trees or hash indexes, covering storage engine basics, query performance, I/O considerations, and the structural advantages that make B+ trees ideal for OLTP workloads.
This article benchmarks Java's ArrayList and LinkedList by measuring insertion and lookup times at the head, tail, and middle of a list with 100,000 elements, then explains the underlying source‑code mechanisms that cause the observed performance differences.
This article examines MySQL pagination on a multi‑million‑row table, compares plain LIMIT queries with subquery, ID‑range, and temporary‑table techniques, provides SQL examples and performance measurements, and offers recommendations for fast, scalable paging.
The article outlines five common performance problems affecting Salesforce SaaS deployments—location latency, bandwidth competition from multimedia traffic, low‑quality bandwidth, ineffective caching, and heavy plugin usage—and provides practical mitigation strategies for IT teams to ensure reliable user experiences.
This article presents a series of Java Stream API performance experiments—comparing serial and parallel streams on primitive, object, and reduction tasks—showing that while serial streams are slower than traditional loops for simple operations, parallel streams can significantly outperform both in multi‑core environments.
This article provides a comprehensive overview of Redis interview topics, covering persistence mechanisms, cache avalanche and penetration problems, hot and cold data concepts, differences from Memcached, single‑thread performance, data structures, expiration policies, clustering solutions, distributed locks, transactions, and practical troubleshooting tips.
The article details a real‑world investigation of a Java HTTP service that experienced a sudden QPS increase and response‑time spikes, tracing the issue through database queries, local method latency, CPU load, frequent ParNew GCs, and large response payloads, and presents concrete remediation steps.
An in‑depth guide explains Guava’s Stopwatch utility, showing how to create, start, stop, and reset timers, customize the time source via Ticker, compare it with raw System.nanoTime or System.currentTimeMillis, and highlights its advantages for accurate performance measurement in Java and Android projects.
These Java performance optimization guidelines cover best practices such as appropriate use of singletons, minimizing static variables, reducing object creation, leveraging final modifiers, preferring local variables, efficient handling of collections, avoiding costly operations like synchronized blocks and split, and proper resource management to improve application efficiency.
This article compiles a comprehensive list of frequent Vue development challenges when building WeChat mini‑programs—covering routing parameters, cross‑origin requests, Axios encapsulation, UI library on‑demand loading, scoped CSS overrides, timer cleanup, responsive rem handling, Swiper integration, source‑map suppression, gzip compression, bundle analysis, lazy loading, keep‑alive caching, v‑model customization, mixins, and deployment considerations.
This article details Youzan’s testing team’s evolving API automation strategy, covering architectural context, dual‑approach request simulation, regression efficiency enhancements, blind‑spot elimination through online validation and traffic recording‑replay, and practical lessons for large‑scale product delivery.
This article investigates whether Java reflection impacts performance by running systematic benchmarks that compare direct method calls, reflective method calls, direct field access, and reflective field access across varying iteration counts, presenting detailed results, analysis of the slow paths, and practical guidelines to mitigate any overhead.
The article examines the difficulties of reusing SQL Server stored procedures to obtain simple boolean checks, illustrates a concrete example of counting jobs with temporary tables, discusses maintenance pitfalls, and concludes that business logic is often better implemented outside stored procedures.
This article explains the design and implementation of a Java‑based fixed QPS load‑testing framework, covering its multithreaded base class, concurrent executor, compensation thread, performance metrics collection, and provides source code links for practical use and further development.
The article explains how Kafka implements a hierarchical time‑wheel—a ring of bucket sets with a map for O(1) insertion, removal and expiration—to replace costly per‑tick scans, enabling efficient management of millions of delayed tasks across multiple timeout layers.
A concise collection of Linux command‑line snippets helps you query Oracle client IPs, kill specific processes, count connections, summarize traffic, find large files, measure copy time, and monitor CPU and memory usage, all useful for DB and system administrators.
This comprehensive guide explains what Redis is, its data structures and features, demonstrates how to use Redis as a cache in Spring Boot applications, discusses cache eviction policies, persistence mechanisms, replication, Sentinel high‑availability, and performance characteristics while also covering common interview questions such as cache snowball, penetration and breakdown.
This article explains the internal structure and algorithms of Java’s HashMap, covering its array‑based storage, collision handling with linked lists and red‑black trees, key methods like put, get, resize, and thread‑safety considerations, complete with code examples and diagrams.
This article presents a systematic benchmark of Java reflection versus direct method and field access, analyzes the measured latency across varying call counts, identifies the costly operations within reflection (such as getMethod, getDeclaredField, invoke, and set), and offers practical guidelines to mitigate reflection‑induced performance overhead.
This comprehensive guide explains what software architecture is, distinguishes systems, subsystems, modules, components, and frameworks, outlines architecture layers and classifications, describes strategic versus tactical design, tracks the evolution from monoliths to micro‑services, and highlights how to evaluate and avoid common architectural pitfalls.
This article systematically compares Redis and Memcached across thread models, supported data structures, eviction strategies, pipelining, transactions, persistence, high‑availability mechanisms, and clustering, helping developers choose the most suitable in‑memory database for their specific workload requirements.
This article presents a comprehensive guide to MySQL performance tuning, covering the use of EXPLAIN, proper handling of IN clauses, selective column queries, limit usage, index best practices, avoiding costly operations, pagination techniques, full‑text search, join optimization, and advanced directives such as FORCE INDEX and STRAIGHT_JOIN.
This article explains how JD Cloud’s JCHDB, built on ClickHouse, achieves millisecond‑level queries on billions of rows through columnar storage, distributed multi‑master architecture, SIMD vector engine, sparse indexing, and specialized table engines, and outlines the ideal use cases and deployment details.
Understanding Linux load average and CPU utilization, this guide explains process states, how load is calculated, the difference between load and CPU usage, common bottlenecks, and practical troubleshooting steps using tools like top, vmstat, pidstat, iostat, and perf to pinpoint performance issues.
This article presents a detailed comparison between Swift and Objective‑C, covering language popularity, community activity, real‑world app adoption, performance benchmarks, Swift's advantages and disadvantages, ABI and module stability, Apple’s strategic support, binary size effects, and deep compiler optimizations such as SIL, inlining, generic specialization, and dispatch mechanisms.
This article analyzes common database performance bottlenecks such as I/O and CPU limits, explains horizontal and vertical sharding techniques, reviews available sharding tools, discusses the challenges of distributed transactions, cross‑node joins, pagination, and global primary‑key generation, and offers practical mitigation strategies.
This article examines the challenges of running Spark on Kubernetes, introduces the Remote Shuffle Service architecture to overcome shuffle bottlenecks, details EMR on ACK integration, showcases performance gains with Terasort benchmarks, and outlines future cloud‑native big‑data strategies such as mixed‑cluster and serverless deployments.
This article presents a comprehensive Q&A guide for developers covering MySQL index structures, transaction principles, table schema design, storage engine choices, and various practical issues such as char vs varchar, binlog formats, large pagination, and stored procedures.
This article provides a systematic, step‑by‑step guide for diagnosing and resolving Java runtime problems—including CPU spikes, memory leaks, disk I/O bottlenecks, network timeouts, and GC inefficiencies—by using native Linux tools and JVM utilities such as top, ps, jstack, jmap, jstat, iostat, vmstat, pidstat, netstat, ss, and tcpdump.
This article examines why naïve LIMIT‑OFFSET pagination on a multi‑million‑row MySQL table becomes increasingly slow, presents several optimization techniques—including simple LIMIT usage, sub‑query id lookup, ID‑range queries, and temporary‑table tricks—along with concrete benchmark results to guide developers toward faster data paging.
This article introduces Redis's advanced bitmap capabilities, detailing the SETBIT, GETBIT, BITCOUNT, and BITOP commands, their syntax, underlying SDS data structure, performance characteristics, storage calculations, and practical use cases such as user sign‑in tracking and online status monitoring.
This article explains why restoring MySQL backups can fail due to missing SUPER privileges, describes the DEFINER and SQL SECURITY concepts, and details how the mysqldump source code was altered for MySQL 5.7 to strip DEFINER clauses, show backup progress, and improve performance testing.
Unity has launched the public beta of version 2020.2, introducing significant performance boosts, C# 8 support, enhanced editor workflows, and numerous rendering and optimization upgrades, while also outlining future plans for Unity 2021 and the upcoming 2020 LTS release.
The article explains how Redis caching boosts high‑concurrency applications by outlining common use cases such as counters, session storage, rate limiting, leaderboards and distributed locks, then details best‑practice guidelines, typical pitfalls like TTL overwrites and cache stampedes, and essential monitoring techniques for performance and reliability.
By tracking the discrepancy between the number of EngineLayer objects actually rendered each frame and the total EngineLayer instances retained in native memory, developers can detect and pinpoint Flutter memory leaks caused by lingering Dart references, using SceneBuilder monitoring and WeakPersistentHandle inspection.
A high‑traffic Java backend service suddenly suffered seconds‑long response times, prompting a systematic investigation that traced the issue from unexpected QPS spikes through database checks, local call delays, CPU load, and frequent ParNew GC, ultimately revealing oversized responses and memory pressure as the root cause.
This article explains why Redis latency can suddenly increase—covering high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides practical diagnostic steps and mitigation techniques.
The article introduces Facebook's HipHop VM (HHVM) as a PHP JIT compiler, highlights the performance gains and memory savings, details the release of version 4.75 with its supported versions, and outlines new highlights and upcoming deprecations such as the removal of is_array().
Database read/write separation, alongside sharding and master‑slave architectures, mitigates high‑concurrency bottlenecks by distributing reads to replicas and writes to a primary, offering scalability and performance benefits while introducing challenges such as replication lag, routing complexity, and resource utilization trade‑offs.
This article reviews Java WebSocket options—including the Java EE specification, SockJS, Socket.IO, and reactive stream implementations—detailing their advantages, drawbacks, and performance characteristics, and provides benchmark data to help developers choose the most suitable solution for their backend communication needs.
This article explains why a high‑performance Redis instance can suddenly experience high latency, covering complex commands, large keys, expiration bursts, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation, and provides practical troubleshooting and mitigation steps.
This article demonstrates how to create a test database, export data with mysqldump, and then replay a large SQL dump into a busy MySQL instance while throttling the import speed with the pv tool to keep CPU usage low and avoid disrupting ongoing business operations.
This article examines several production incidents where using SELECT * caused dramatic performance degradation in Oracle databases, detailing shadow‑table differences, LOB handling, temporary‑table transformations, wide‑table scans, and memory‑intensive joins, and explains why the rule to avoid SELECT * is essential.
This article benchmarks Java's Fork/Join framework, Parallel Streams, and ExecutorService across IO‑bound and CPU‑bound workloads on an 8‑core machine, analyzing how thread count and pool configuration affect performance and offering practical recommendations for concurrent Java applications.
This article explains Java reflection, describing its ability to inspect and modify classes at runtime, the core reflection classes, practical use cases, performance considerations, and provides comprehensive code examples that demonstrate class, method, field, and interface introspection.
This article demonstrates how the open‑source Java diagnostic tool Arthas can be employed in various production scenarios—such as CPU spikes, class‑loading conflicts, method‑level monitoring, performance bottlenecks, and hot‑code replacement—to rapidly locate and resolve runtime problems without restarting services.
This article explores MySQL performance limits, concurrency settings, query‑time best practices, table design choices, index classifications, and a comprehensive set of SQL optimizations—including batch processing, operator rewrites, and pagination tricks—to help developers eliminate slow queries and build scalable database solutions.
This article investigates whether Java reflection impacts performance by conducting systematic benchmarks that compare direct method/field access with reflective calls, analyzing the measured overhead, identifying the costly reflection operations, and offering practical guidelines to mitigate any performance penalties.
