This article presents a comprehensive guide to Java code optimization, covering goals such as reducing code size and improving runtime efficiency, and detailing 30 practical techniques ranging from using final modifiers and reusing objects to efficient loop constructs, proper resource handling, and optimal collection usage.
The article presents 360’s challenges with heterogeneous, high‑volume data sources, explains the design of a unified federated SQL engine called QuickSQL that leverages Apache Calcite, Spark, Flink and other back‑ends, and evaluates its performance and future development directions.
This article provides a comprehensive overview of Kafka, covering its core features, use‑case scenarios, partition and replica design, file storage structure, consumer‑group coordination, delivery guarantees, performance optimizations, and the role of Zookeeper in managing the cluster.
This article explains how Java 8 Parallel Stream uses the common ForkJoinPool, why it may not improve performance for large proxy‑IP validation tasks, and demonstrates a custom ForkJoinPool solution that dramatically reduces execution time.
IntelliJ IDEA 2019.2, released on July 24, 2019, brings JDK 13 support, smarter code suggestions, duplicate detection, structured search, folder‑specific settings, enhanced cursor movement, tab shortcuts, large‑file handling, performance boosts, refined debugging, tighter Git integration, and a revamped plugin center, all aimed at improving developer productivity.
This article introduces Facebook's Hermes JavaScript engine, details its integration into React Native Android projects, explains its bytecode precompilation and JIT‑free design, presents performance benchmarks versus JavaScriptCore and V8, and discusses current limitations and future considerations.
The article compares MySQL 8.0 and MySQL 5.7 memory usage on a 1 GB VM, showing that MySQL 8.0 consumes significantly more resident and swap memory despite similar lightweight workloads, and provides the test configuration and observations for developers.
This article provides a comprehensive, step‑by‑step explanation of how Linux load averages are calculated, how to dissect them with scripts like load2process, and how to use kernel modules and monitoring techniques for precise performance analysis and troubleshooting.
This article explains the principle, implementation, configuration, and practical performance impact of Linux Kernel Samepage Merging (KSM), showing how it reduces memory usage in containerized game services while outlining integration costs, risks, and monitoring guidelines.
The article explains why Google created Swift for TensorFlow, highlights Swift's strong backing, built‑in automatic differentiation, high performance comparable to C, seamless interoperability with Python, C and C++, low‑level hardware access, and its future role within the MLIR compiler ecosystem for deep learning.
This introductory article explains how JavaScript functions are created and executed—detailing heap allocation, name hoisting, stack frames, parameter binding, scope‑chain lookup and closures—while offering practical tips for reducing lookups, avoiding recursion overflow, and laying the foundation for a series on robust, functional, and pattern‑driven function design.
This article explains why Kafka achieves remarkable speed by relying on Linux page cache, detailing the differences between page and buffer caches, Kafka's zero‑copy I/O path, relevant kernel parameters, and tuning recommendations for optimal backend performance.
To achieve low‑latency, high‑throughput data access in systems like Gaode’s navigation service, the article advises evaluating CPU and I/O bottlenecks, choosing between local (HashMap/ConcurrentHashMap or Caffeine) and distributed caches (Redis preferred), applying appropriate eviction, TTL, and consistency patterns, and mitigating cache penetration, breakdown, and avalanche risks.
The article details Redis 6’s new multithreaded I/O feature—motivated by network‑I/O bottlenecks, implemented with lock‑free pending‑read queues that offload reads, writes, and protocol parsing to worker threads while keeping command execution single‑threaded—and demonstrates through a simple benchmark that using four I/O threads roughly doubles GET/SET throughput compared with Redis 5.
This article explains how the Matrix team created a low‑overhead iOS/macOS energy‑consumption monitor that captures high‑CPU thread stacks, builds aggregated power‑consume stacks, and helps pinpoint heating scenarios such as image uploads, VoIP calls, and game usage.
Alibaba’s Xianyu team replaced costly JNI‑style Java calls with the AliMesh sidecar service‑mesh, decoupling heterogeneous Dart services from Java back‑ends, simplifying code, and achieving modest overhead—under 20 % CPU rise and roughly 1 ms extra latency—while delivering stable, maintainable production performance.
A sysbench benchmark comparing MySQL 5.7.25 and MySQL 8.0.15 shows that latin1 charset favors 5.7, while utf8mb4 dramatically improves 8.0 performance, and that collations such as utf8mb4_unicode_ci can further affect query speed.
This article analyzes the technical distinctions between SLC and MLC NAND flash—covering bit density, cost, device and system performance, endurance, error rates, and enterprise‑grade variants—to explain why SLC remains the preferred choice for demanding industrial environments.
This article presents a real‑device performance comparison of Json, Protocol Buffers and FlatBuffers across Android, Flutter and H5 channels, explains their internal structures, shows serialization/deserialization code, and provides practical guidance on choosing the right format for mobile data transmission.
This article describes how a single‑machine prototype was built in Go to simulate a WeChat red‑envelope service capable of handling up to 6 × 10⁴ QPS, supporting one million concurrent connections, and processing 10 billion shake‑red‑envelope requests through careful load‑balancing, monitoring, and performance analysis.
This article provides a comprehensive technical overview of NVMe over TCP, covering its specification status, required host components, namespace limits, latency impact, OS support, performance considerations with DPDK, TCP congestion control, R2T handling, upgrade procedures, open‑source implementations, comparisons with iSCSI, NVMe/FC, and NVMe/RDMA, as well as practical guidance for data‑center deployments.
This article explains the two‑layer architecture of NewLife.Redis, demonstrates basic and advanced usage with code examples, shares stress‑test results achieving hundreds of thousands of operations per second, and provides practical tips and FAQs for high‑performance Redis deployments.
The article explains why the Java compiler generates synthetic access$xxx methods for inner‑class field access, describes their negative impact on dex size, multidex, APK size and performance, and details a practical ASM‑based approach to safely eliminate them while handling related Dalvik bugs.
This Flutter FAQ explains the framework's high‑performance capabilities, rapid hot‑reload development cycle, differences between hot‑reload and hot‑restart, supported platforms—including mobile, web, and desktop—and how developers can extend widgets, access native services, and embed Flutter into existing apps.
Gaode Map transformed its app architecture by fusing Android and iOS through C++ sinking, dynamic UI floating, and dual‑end alignment, introducing component‑based containers and a unified R&D middle‑platform, which turned a pseudo‑bus into a real bus, cutting build time, crash rate, and release cycles while enabling true parallel development and paving the way for a future feature‑team model.
This article explains how a mobile news‑feed application reduces first‑paint latency from 820 ms to 260 ms by pre‑fetching static templates and news data, inlining resources, and using a localized detail‑page strategy that works offline and mitigates WebView cross‑origin issues.
This article enumerates ten frequent Go programming errors—from unknown enum handling and benchmark mis‑optimizations to pointer misuse, slice initialization, context pitfalls, and error‑handling practices—explaining why they occur, showing reproducible code examples, and offering concrete fixes to write more reliable Go code.
A sudden surge of requests triggers e.printStackTrace() to flood the JVM's non‑heap string pool, exhausting memory, blocking threads, and causing the entire Java web service to become unresponsive, highlighting the dangers of careless exception logging.
The article examines the risks of using the dangerous FLUSHDB command in Redis, explores common alternatives like SCAN, async deletion, and expiration, and proposes a secondary‑index solution using sets and sorted sets to efficiently invalidate only the affected cache entries without blocking the service.
The article lists DOM properties and methods—such as element measurements, scrolling APIs, focus calls, getComputedStyle, and various window and document attributes—that cause browsers to synchronously recalculate styles and layout, explains why they are performance bottlenecks, and offers practical mitigation techniques.
This article walks through a systematic investigation of a web page that takes 2‑2.4 seconds to load, covering HAProxy configuration checks, network latency tests, TCP three‑handshake and packet‑capture analysis, and finally pinpointing MySQL connection handling as the root cause.
The article explains how using the KEYS command on millions of Redis keys blocks the single‑threaded server, causing outages, and demonstrates how the incremental SCAN command with cursor, MATCH, and COUNT options provides a safe, non‑blocking way to iterate large keyspaces.
This article explains the purpose and classification of database locks, demonstrates how to manually apply and inspect table and row locks in MySQL, analyzes lock‑related status variables, and offers practical optimization strategies to improve concurrency and performance.
The article explains two approaches for flexible performance testing on a head‑only Linux server—one using configuration files to assemble requests and another using Groovy scripts—detailing code implementations, command‑line execution, and deployment steps.
The article examines autonomous vehicle hardware, covering aesthetic design, sensor placement for full 360° vision, weather impacts on perception, performance versus power consumption, cooling solutions, and environmental robustness such as vibration, temperature, humidity, salt corrosion, and electromagnetic interference, while highlighting modular sensor modules and innovative concepts like Zoox's direction‑free chassis.
This tutorial explains why Java applications often exceed their -Xmx limits, enumerates the main sources of native memory consumption in the JVM, and shows how to monitor and analyze these allocations using Native Memory Tracking (NMT) commands and flags.
This article explains how the Linux kernel manages memory reclamation, the role of kswapd, the distinction between file and anonymous pages, the impact of swap and the swappiness parameter, and provides practical guidance for tuning swap usage in production systems.
The article illustrates the basic principle of bubble sort through a series of comic‑style images, explains how repeated element comparisons and swaps gradually produce an ascending sequence, discusses performance implications of excessive swaps, and provides a complete Java implementation of selection sort for comparison.
The article explains how MySQL metadata locks, especially SHARED_UPGRADABLE and SHARED_READ_ONLY locks acquired during ALTER TABLE on tables with foreign keys, can cause long wait times under concurrent write transactions, and shows how adjusting the max_write_lock_count variable resolves the issue.
This report details the background, personnel effort, migration process, performance gains, operational experience, and lessons learned from moving a high‑traffic automotive content platform from Windows‑only .NET Framework to cross‑platform .NET Core and Docker, highlighting seamless upgrade, elasticity, and tooling improvements.
This article walks Java developers through diagnosing and fixing common problems such as deadlocks and CPU usage spikes, explaining the underlying concepts, showing practical code examples, and demonstrating how to use tools like jps, jstack, JConsole, JVisualVM, and Arthas to pinpoint and prevent performance bottlenecks.
This article examines the limitations of Prometheus's original V2 time‑series storage, proposes a block‑oriented V3 architecture that tackles series churn, write amplification, and indexing inefficiencies, and validates the new design with extensive benchmarks showing dramatic reductions in memory, CPU, and disk usage.
This article explores cache fundamentals, common pitfalls like penetration and avalanche, naming conventions, warm‑up techniques, and provides step‑by‑step guidance for setting up Redis master‑slave, testing containers, and optimizing configurations for high‑performance backend systems.
Alibaba’s Dragonwell JDK 8.0.0‑GA, now GA‑ready for production, syncs the latest OpenJDK 8u212‑b04 updates, adds security patches, fixes critical Alibaba‑specific bugs, and introduces proprietary features such as JWarmUp, JFR enhancements, and the upcoming ElasticHeap, with detailed installation steps and performance results.
Microsoft’s Build conference introduced Windows Terminal and WSL 2, and this guide walks you through installing WSL 2 on Windows 10 (Build 18917+), enabling required features, setting the default version, and even compiling the WSL 2 kernel, highlighting performance gains like 20× faster tar extraction.
This article presents a practical guide for Oracle DBAs to quickly diagnose and resolve application‑related database issues by checking OS load, analyzing wait events, querying session and object details, capturing diagnostic dumps, and using scripted commands to kill sessions or restart the database.
This article presents a comprehensive benchmark of Java 8 Stream API on large‑scale data, comparing serial and parallel stream operations with traditional external iteration across primitive, object, and reduction workloads, and draws practical recommendations on when to use streams for optimal performance.
This article analyzes the shortcomings of Nginx's native Smooth Weighted Round‑Robin (SWRR) algorithm in large‑scale application gateway scenarios, presents a real‑world case where weight adjustments cause traffic spikes, and introduces the VNSWRR algorithm that achieves O(1) selection time, smoother weight handling, and up to 60% higher QPS performance.
This guide presents 24 practical methods—including timing measurements, faster data structures, loop optimizations, vectorization, and parallel processing—to dramatically accelerate Python code, each illustrated with clear before‑and‑after performance screenshots.
Elasticsearch performance at billions‑scale can be dramatically improved by leveraging the OS filesystem cache, limiting indexed fields, separating hot and cold data, pre‑warming caches, and using scroll or search_after for pagination, while avoiding costly joins and ensuring the dataset fits in memory.
The article explains what cache avalanche and cache penetration are in Redis, why they can crash databases, and provides practical strategies—including random expiration, high‑availability setups, local caches, rate limiting, Bloom filters, and empty‑object caching—to mitigate these issues and maintain cache‑database consistency.
This article explains how React.memo, its second‑argument comparator, and the related hooks useCallback and useMemo can be used to avoid unnecessary re‑renders, handle function props correctly, and dramatically improve rendering performance in complex functional components.
This article enumerates the most frequent Java OutOfMemoryError scenarios—including heap space exhaustion, GC overhead limits, oversized array allocations, PermGen/Metaspace depletion, thread creation failures, and native method errors—detailing their causes and practical JVM flag or code fixes to resolve them.
This article presents a detailed case study of how the Qingju Bike mini‑program, serving hundreds of millions of daily users, adopted the Chameleon cross‑platform framework to achieve high performance, stability, multi‑entry support, and maintainable code across multiple mini‑program ecosystems such as WeChat, Alipay, and Baidu.
This article details a real‑world performance test of loading over two billion rows from a big‑data platform into MySQL using XeLabs TokuDB, covering requirements, TokuDB features, table schema, bulk‑load commands, results, and practical recommendations for high‑throughput data ingestion.
This article explains how Youku processed billions of daily logs, migrated from Hadoop to Alibaba Cloud MaxCompute in 2017, and achieved lower compute and storage costs, faster data delivery, and greater operational flexibility through a robust big‑data platform tailored to its complex business needs.
This article explains why monitoring is essential for Node.js applications, outlines the most important performance metrics such as CPU usage, memory usage, garbage collection, event‑loop latency, clustering, and request/response latency, and introduces several ready‑to‑use open‑source monitoring tools.
Android activity startup latency stems from three phases—Pause, Launch, and Render—so optimizing only onCreate often leaves perceived delays; developers can measure each phase via system logs or AOP hooks (Instrumentation, Looper‑Printer, or ActivityThread handler) to pinpoint and reduce bottlenecks.
A friend needed to import over 2 billion records from a big‑data platform into MySQL for next‑day reporting, so we evaluated InnoDB versus XeLabs TokuDB, configured TokuDB parameters, created test tables, used LOAD DATA, measured write speed, file size, and discovered TokuDB can achieve about 570 k rows per second, roughly three to four times faster than InnoDB, especially when avoiding auto‑increment columns.
This article explains how leveraging HBase's SnapshotScanMR feature to create a custom hbase2hiveBySnapshot task dramatically reduces region server pressure, halves ETL execution time, and improves cluster stability for large‑scale data back‑fill operations.
This article debunks the myth that COUNT(1) is faster than COUNT(*), explains how MySQL engines handle these functions, compares their performance with COUNT(column), and offers practical tips for avoiding costly full‑table counts.
This article introduces MXFlutter, a JavaScript‑based dynamic framework that enables full‑runtime UI updates for Flutter apps on iOS, explains its architecture, code implementation, performance advantages over Dart VM, and discusses rendering optimizations, memory management, threading, and developer ergonomics.
This article explains the fundamentals of Serverless architecture, its pros and cons, and provides a detailed, practical walkthrough for migrating a lightweight web application to Tencent Cloud's Serverless Cloud Function platform, covering architecture redesign, data storage, performance tuning, debugging, deployment, logging, and monitoring.
This article examines how integrating Non‑volatile Memory (NVM) with Redis can replace traditional RDB/AOF persistence, offering a hybrid design that improves durability, reduces recovery time, and maintains high write performance, while discussing implementation details, performance benchmarks, and future optimization challenges.
This article describes how Ctrip's hotel query home page evolved through three architectural versions—1.0, 2.0, and 3.0—detailing the motivations, design choices, performance considerations, and the final unified module‑based structure that leverages VLayout for improved scalability and maintainability.
Gatling‑Dubbo 2.0 is a Gatling‑based load‑testing plugin that replaces generic Dubbo invocations with real API calls, offering richer scenario orchestration, traffic models, native throttling, lower resource use, and higher concurrency, while providing Action, Check, and DSL components illustrated through a complete mixed‑scenario simulation.
Printing a Java exception stack trace with e.printStackTrace() can exhaust the non‑heap string pool, causing request threads to block and the entire web application to appear dead‑locked, especially under heavy load.
This article analyzes why MySQL LIMIT pagination becomes increasingly slow with larger offsets, presents six optimization techniques—including using primary keys, covering indexes, prepared statements, subqueries, and composite indexes—and provides experimental results that demonstrate dramatic performance improvements.
This article details the WeChat client team's evolution from early C99‑based cross‑platform components to a mini‑program‑centric architecture, examines performance challenges on Android, and describes how integrating native rendering, the LV‑CPP C++ layer, and Flutter dramatically improved UI consistency, efficiency, and maintainability across iOS and Android.
This article details Tencent's online‑education mini‑program ecosystem, covering business matrix, native framework selection, engineering practices, audio/video integration, automated release pipelines, performance optimization through sub‑packages, and a comparison of WeChat and QQ mini‑program platforms.
The article explores how bitwise operations can dramatically speed up counting the number of set bits in a 32‑bit integer, presenting a naive O(n) solution and four successive optimizations that reduce runtime from about two seconds to under a tenth of a second, while sharing practical low‑level coding tricks.
The article outlines 19 practical MySQL optimization methods—from using EXPLAIN and limiting IN clause size to proper pagination, index usage, and JOIN strategies—providing clear explanations and example SQL snippets to help developers improve query performance and reduce resource consumption.
This article analyzes MongoDB sort operation memory limits, explains why queries may exceed the 32 MB in‑memory sort threshold, demonstrates how to inspect and adjust server parameters, create appropriate compound indexes, and use allowDiskUse in aggregation pipelines to avoid sort‑related errors.
This article examines Druid 1.1.5 connection‑pool settings—maxWait, connectionProperties, keepAlive, maxActive—illustrates real‑world cases of misconfiguration, provides recommended values, and shares a step‑by‑step investigation of a DB slow‑query incident to help engineers prevent performance and stability issues.
This article explains why MySQL queries can become slow—covering occasional delays from dirty‑page flushing or lock contention and persistent slowness caused by missing, unused, or mis‑chosen indexes—while offering practical tips such as checking process lists, correcting index usage, and refreshing statistics.
The article investigates why a DELETE without a WHERE clause on a 500k‑row MySQL table takes over ten hours to replay on a slave, analyzes row‑mode binlog replay mechanisms, compares different slave_rows_search_algorithms, presents test results, and offers practical recommendations for improving replication performance.
This article recounts the evolution of the Class Optimization Master Android project—from a dual‑end, no‑design prototype to an MVP‑based implementation and finally a modularized architecture—highlighting pain points, solutions, and practical steps for improving code boundaries, build times, and reusable modules.
This article examines Xianyu's adoption of Flutter, detailing its benefits for small and Android‑focused teams, the technical hurdles of integrating Flutter into existing apps, memory‑optimized engine sharing, video rendering improvements, the evolution of the Fish Redux framework, and the automation pipeline that drives efficient, data‑backed development.
The article analyzes a slowdown issue in the 58 Cloud Platform caused by an overloaded API Server and uneven Etcd load, explains the root causes—including load‑balancing failure and missing namespace segmentation—and presents concrete remediation steps such as DNS round‑robin, namespace partitioning, Etcd client upgrade, and cache‑enabled queries.
This article explains MySQL's Instant Add Column feature, describing the traditional costly column‑addition process, the instant method’s internal mechanics, how data is read and written before and after the change, and the practical constraints that limit its usage.
This article examines why MySQL LIMIT pagination becomes slower as the offset grows, presents six practical methods—including direct LIMIT, primary‑key indexing, ordered index scans, prepared statements, sub‑queries, and joins—provides benchmark results on large tables, and distills actionable guidelines for designing covering and composite indexes to achieve fast, stable pagination.
In a Docker‑based test environment, a Dubbo‑called RPC timed out due to a MySQL deadlock caused by missing indexes, and the issue was resolved by monitoring with Druid, remote JMC inspection, killing blocking threads, and adding proper indexes to the locked table.
This article explains why JavaScript developers often avoid bitwise operators, highlights the specific scenarios where they provide performance and code‑size benefits—such as fast integer conversion with x|0, using ~ for -1 checks, creating bit fields, and leveraging them in databases and BigInt.
This article explains the browser rendering pipeline—from network communication and HTML/CSS parsing to DOM and render tree construction—highlighting common misconceptions, performance bottlenecks, and practical optimization strategies such as DNS reduction, TCP reuse, HTTP/2 features, efficient CSS selectors, and JavaScript loading techniques.
This resource compiles a complete series of articles on distributed system theory covering consistency, consensus, high availability, scalability, performance, testing, and operations, offering both quick overviews for newcomers and in‑depth readings for practitioners seeking to master modern distributed architectures.
The article explains how using the KEYS command on large Redis datasets can block the single‑threaded server and cause outages, and demonstrates how the incremental SCAN command safely retrieves keys without impacting performance, including syntax, options, and practical examples.
This article explains the principles, advantages, and drawbacks of various RAID configurations—including RAID 0, 1, 10/01, 3, 5, 6, 50, and 60—illustrated with diagrams, to help you choose the right storage solution for speed and data protection.
This article introduces SG, a lightweight PHP syntax‑sugar extension that simplifies access to superglobal variables, outlines its features, configuration, usage examples, performance testing, and provides the GitHub project link for developers seeking more efficient and readable backend code.
This article explains how to handle 20,000+ concurrent SQL requests by moving from a simple single‑instance setup to multi‑instance sharding and finally to read‑write separation, detailing the architectural decisions, routing algorithms, and practical limits for high‑traffic e‑commerce systems.
SG is a PHP syntax‑sugar extension that introduces a new way to retrieve and manipulate superglobal variables, offering simplified, zero‑copy access, customizable preprocessing, and configurable global lookup depth, while maintaining performance and compatibility across major PHP versions.
This guide walks you through practical Linux performance troubleshooting steps, covering how to inspect CPU details, list boot‑time services, monitor CPU load, check free memory, and analyze disk I/O, with concrete commands and solutions to improve system speed.
This article explores MySQL performance when storing and querying billions of financial transaction records, detailing table creation, massive data generation, the impact of indexes on query and insert speed, pagination limits, and a practical time‑based sharding approach for bank‑level cash‑flow logs.
MySQL 8.0's histogram feature provides column value distribution statistics that help the optimizer choose better execution plans, and the article demonstrates how to create, view, and leverage histograms to significantly reduce query costs for range predicates.
The case study shows how Qingju Bike’s high‑traffic bike‑sharing mini‑program was built with the Chameleon cross‑platform framework, delivering consistent UI across WeChat, Alipay and other entry points, meeting strict performance and security demands while cutting development time by half and simplifying maintenance.
This article presents a comprehensive collection of Java backend performance best practices, covering singleton usage, static variables, object creation, final modifiers, local variables, primitive vs wrapper types, synchronization, resource cleanup, efficient data structures, and many other optimization techniques to help developers write faster, more memory‑efficient code.
The article explores TiDB’s evolution philosophy, detailing its core beliefs, early user stories, and the three‑step "Make it work, make it right, make it fast" approach, while covering technical choices such as cloud‑first design, hardware‑agnosticism, formal verification, massive testing, performance tuning, and cost‑effective scaling.
This article explains the MySQL 5.6 slave_rows_search_algorithms parameter, reproduces the HASH_SCAN bug that causes "Can't find record" errors during row‑based replication, analyzes why it occurs, and provides practical solutions such as adjusting keys, changing the algorithm setting, or upgrading MySQL.
This guide introduces a collection of practical Linux operations tools—including Nethogs, IOZone, IOTop, IPtraf, IFTop, HTop, NMON, MultiTail, Fail2ban, Tmux, Agedu, NMap and Httperf—providing concise installation commands, basic usage examples, and key options to help system administrators monitor performance, security and resources efficiently.
Discover the most common MyBatis pitfalls—from # vs $ usage, handling nulls, resultMap quirks, and dynamic SQL issues—to master safe query practices, optimize performance, and avoid runtime errors, while comparing its strengths and weaknesses against Hibernate for effective Java backend development.
This article examines the pause behavior of various OpenJDK garbage collectors by running a memory‑allocation benchmark, presenting detailed GC logs for G1, Parallel, CMS, Shenandoah, and Epsilon, and drawing conclusions on how to choose the appropriate collector for a given workload.
