This article explains the differences between Java's ArrayList and LinkedList, detailing their internal implementations, performance characteristics for adding, inserting, deleting, and iterating elements, and provides code examples and benchmark results to guide when to choose each collection.
This article explains how Java's HashMap stores key‑value pairs, details the hash calculation, index mapping, collision handling via linked lists, the role of load factor, resizing mechanics, and provides annotated source code for core methods such as put, get, and internal Entry class.
This article analyzes the limitations of native Twemproxy, describes how Nginx's master‑worker multi‑process model and related Linux kernel features were integrated to create a high‑performance, highly available cache proxy, and presents extensive online and benchmark results showing significant latency and QPS improvements.
The article explains how modern servers with multiple CPUs and memory modules connect via legacy Front Side Bus and modern NUMA architectures, demonstrates Linux commands to inspect memory topology, and presents benchmark results showing latency differences between intra‑node and inter‑node memory accesses.
The article outlines how integrating CheckStyle, Lint, and FindBugs with a custom Gradle plugin, applying full‑scan optimizations to collect only necessary source and class files and implementing incremental scans that target only files changed in a PR, cuts Android CI static‑analysis time by over 50 %, dropping full scans from nine to five minutes and enabling sub‑minute incremental checks.
The article presents a bytecode‑generation technique that creates dynamic wrapper classes to invoke arbitrary Java methods with near‑native speed, avoiding reflection’s overhead, and details the CallerWrap base, generator, and thread‑safe cache implementation that together enable high‑performance middleware calls.
This article explains how Amap (Gaode) handles billions of daily requests with sub‑millisecond latency by redesigning its gateway layer, adopting full‑asynchronous pipeline architecture, leveraging reactive frameworks like Vert.x and WebFlux, aggregating APIs, and implementing a unit‑based routing solution that paves the way for distributed sidecar and service‑mesh deployments.
To handle the massive memory and CPU demands of modern front‑end map annotations, the article explains JavaScript’s stack‑heap model, object hash‑table storage, and the trade‑offs of plain arrays, TypedArray, DataView, and SharedArrayBuffer, showing that contiguous memory structures and Web‑Worker off‑loading dramatically improve performance and reduce allocations.
This article explains how V8’s compiler, garbage collector, and a bug‑inspired optimization improve async/await performance across Node.js versions, detailing benchmark results, code behavior differences, and the engine’s internal steps for handling await.
This article explains how to optimize Spring Boot applications by adjusting configuration properties and JVM parameters, provides essential Tomcat settings, demonstrates practical tuning steps with and without IDE support, and details the meaning of common JVM flags for improved performance.
This article explains how Linux reports CPU usage with tools like top, the meaning of the fields in /proc/stat, how utilization percentages are calculated, the concepts of run queues, load average, context switching, multi‑core scheduling, and how to use perf and taskset for deeper performance analysis.
This article provides a comprehensive overview of the HTTP/2 protocol, explaining its binary framing, multiplexing, header compression, request prioritization, and server push features, and offers step‑by‑step guidance for upgrading Nginx to support HTTP/2 along with detection methods.
Vue 3 introduces substantial performance gains, a smaller bundle size, tree‑shakable global APIs, a proxy‑based reactivity system, and experimental time‑slicing features, all of which make modern, mobile‑first web development faster and more efficient.
This article provides a comprehensive guide to caching technologies, covering HTTP caching, CDN caching, load‑balancer caching, in‑process caching, and distributed caching, while explaining strategies, algorithms, and common pitfalls such as cache avalanche, penetration, and breakdown.
This article explains various Flutter image loading techniques—including AssetImage, NetworkImage, FileImage, MemoryImage, CachedNetworkImage, and FadeInImage—provides detailed source code analysis of the Image widget and its underlying classes, and discusses performance considerations and potential optimization strategies.
This weekly community newsletter highlights the open‑source launch of the TXLE distributed transaction framework, DBLE user meetups, deep dives into MySQL slow‑query analysis and EXPLAIN ANALYZE, recent DBLE feature developments, bug fixes, community Q&A, and a preview of next week's technical plans.
This article presents fifteen practical Java backend coding guidelines—including avoiding "where 1=1" in MyBatis, iterating Map entrySet, using Collection.isEmpty, pre‑sizing collections, employing StringBuilder, preferring Set for contains checks, initializing static members correctly, removing dead code, shielding utility constructors, eliminating redundant catches, using String.valueOf, avoiding BigDecimal(double), returning empty collections, calling equals on constants, securing enum fields, and escaping regex in split—each illustrated with bad and good code examples to improve readability, safety, and efficiency.
A detailed DBA interview walks through the diagnosis of excessive Oracle RAC GC wait events, revealing that cross‑instance queries, network latency, NIC bonding mode, and unbalanced IRQ handling together caused the slowdown, and shows step‑by‑step fixes that finally eliminated the problem.
The article explains how MySQL 8.0 introduced the instant algorithm for adding columns, compares it with older copy and inplace‑rebuild methods, shows usage examples, performance test results, and outlines the restrictions and version differences of this fast DDL operation.
This article explains the seven Java garbage collectors available up to JDK 1.8, compares their strengths and weaknesses, and shows how to select and tune the appropriate collector—Serial, Parallel, CMS, or G1—based on application characteristics and deployment environments.
The weekly roundup presents concise, actionable articles on font fundamentals, building an AST for arithmetic expressions, cyclomatic complexity metrics, the evolution from HTTP/2 to HTTP/3, native image lazy‑loading, and an overview of CSS Level‑4 selectors, all aimed at front‑end engineers.
The article explains why creating and destroying threads directly is inefficient and risky for high‑traffic services, then introduces thread pools as a solution, detailing four common pool types with code examples, their advantages, limitations, and overall impact on system performance.
qrpc is a lightweight, high‑performance RPC framework that adopts gRPC's streaming and bidirectional concepts without HTTP/2, offering a smaller binary, lower memory usage, up to three‑fold throughput gains, and flexible modes such as blocking, non‑blocking, streaming, push, and bidirectional calls, all demonstrated with Go code examples and real‑world use cases.
This article details the redesign of Tokio's Rust async scheduler, describing its new task system, queue algorithms, task‑stealing strategy, reduced synchronization, memory‑allocation optimizations, Loom‑based concurrency testing, and the resulting ten‑fold performance gains in benchmarks and real‑world workloads.
This article examines C's unmatched hardware efficiency, its safety trade‑offs, the rise of higher‑level languages focused on developer productivity, and why C remains essential for embedded, real‑time, and AI systems despite shifting popularity trends.
This article explains the Serverless architecture, its advantages for front‑end developers, showcases Tencent Education’s Serverless design, discusses its use in educational services, and highlights current challenges such as cold‑start latency and state management, while offering insights from industry experts.
This article analyzes the MySQL slow query log in Percona 5.7, explaining how timestamps, execution time, lock time, and various log fields are derived from the source code, and clarifies the meaning of each output component for accurate performance debugging.
This article enumerates typical Java coding mistakes—such as using "where 1=1" in MyBatis, iterating Map inefficiently, neglecting Collection.isEmpty, omitting collection size hints, concatenating strings in loops, overusing List.contains, misusing static initializers, keeping redundant code, and more—while providing concise, performance‑oriented corrections with clear examples.
This article recounts Dropbox’s multi‑year effort to adopt static type checking with mypy across millions of Python lines, detailing why type checking is essential for large projects, the performance challenges encountered, and the engineering solutions—including incremental checks, a daemon, and a custom compiler—that enabled successful migration.
This article presents sixteen practical Java coding guidelines—ranging from avoiding "where 1=1" in MyBatis to using static blocks for collection initialization, preferring Set over List for contains checks, and returning empty collections instead of null—to help developers write more efficient, readable, and safe backend code.
This article dissects Netty's custom FastThreadLocal and FastThreadLocalThread implementations, showing how they replace JDK ThreadLocal with constant‑time indexed access, padding to avoid false sharing, and customizable initialization and cleanup to boost backend concurrency performance.
This article explains the MySQL Clone plugin introduced in version 8.0.17, describes its underlying mechanism, installation and execution steps, outlines usage constraints and scenarios, and presents a detailed performance comparison with LVM snapshots and Xtrabackup under various workloads.
This article explains why Redis is chosen for projects—highlighting its performance and concurrency benefits, detailing its data types, expiration and eviction policies, and offering solutions to common issues such as cache consistency, avalanche, penetration, and key‑competition.
A recent offline performance test of a Dubbo service revealed that enabling Logback’s default packageData option caused massive AladdinClassLoader lock contention, dramatically increasing response times, and the issue was fixed by upgrading Logback to a version where packageData is disabled by default.
This article compiles and translates the latest Chrome DevTools enhancements from versions 74 to 78, detailing new UI highlights, debugging shortcuts, performance metrics, service‑worker insights, and other practical tools that front‑end developers can immediately apply to improve their workflow.
This article analyzes why iOS apps experience long cold‑start times, explains the pre‑main and main launch phases, shows how to measure each stage using DYLD statistics and timestamp code, and provides concrete optimization strategies to reduce startup latency.
This article benchmarks Java 8 Stream against traditional for‑loops and parallel streams across three experiments—primitive array traversal, string list processing, and complex object reduction—using JUnitPerf to measure execution time and analyze when Stream offers real performance benefits.
This article explains why large numbers of active Python objects can cause memory problems and presents several techniques—including using dicts, class __slots__, namedtuple, recordclass, Cython, and NumPy—to shrink object size and dramatically lower memory consumption.
This article explores the pervasive role of caching in modern systems—from browser and HTTP caches to CDN, load‑balancer, in‑process, and distributed caches—detailing their mechanisms, algorithms, common pitfalls like cache avalanche, penetration and breakdown, and practical mitigation techniques for robust backend performance.
This article explains the differences between Java's HashMap and TreeMap, covering their underlying implementations, performance characteristics, ordering behavior, and how to use a custom comparator to achieve descending order, helping developers choose the appropriate map based on ordering and efficiency needs.
This article explains the concept of skeleton screens, demonstrates how to use the CSS :empty selector, and provides a step‑by‑step Vue implementation—including route‑aware class switching—to reduce white‑screen time on slow networks.
PostgreSQL 12 brings major enhancements—including up to 40% faster queries on large datasets, improved indexing, partitioning, JSON path queries, generated columns, pluggable table access methods, stronger authentication, and built‑in JIT compilation—while also adding better localization, multi‑constraint authorization, and convenient maintenance commands.
This article explores the maximum number of threads a Java Virtual Machine can support, examining factors such as CPU, operating system, JVM version, and memory, and presents real‑world experiments, code examples, and theoretical calculations to help developers understand and manage thread limits effectively.
Flutter Web re‑implements the dart:ui library using HTML, CSS, and Canvas, allowing Dart‑written Flutter apps to run in browsers without plugins; it follows a layered rendering approach, supports image, text, shape, and gesture handling, but currently suffers from large bundle sizes, incomplete feature support, and performance challenges in technical preview.
This article explains why Java’s String.hashCode method multiplies by 31, covering the mathematical derivation, prime‑number benefits, JVM optimization tricks, and experimental results that compare 31 with other multipliers on a large word list.
This article provides a comprehensive technical overview of MinIO, an open‑source, S3‑compatible object storage system, covering its design philosophy, data organization, distributed architecture, erasure‑coding, lock management, lambda notifications, backup strategies, performance optimizations, and a comparative analysis with Ceph, highlighting its suitability for AI, big‑data, and cloud‑native deployments.
This article examines the evolution from backend template engines to SPA, highlights SPA's SEO and first‑paint drawbacks, and presents a detailed Vue server‑side rendering implementation with optimization techniques, degradation strategies, and performance results showing over 300% faster first‑screen rendering.
This article explains what Linux load average measures, how to read the 1‑, 5‑, and 15‑minute values, what they indicate on single‑core and multi‑core systems, and which thresholds should raise alerts for system performance monitoring.
This article explains Go's garbage collection mechanism, describing its Mark‑Sweep model, the three collection phases, latency implications, and practical tips for reducing pause times through memory‑pressure reduction and runtime debugging tools.
This article provides a comprehensive MySQL replication FAQ covering cross‑OS and hardware compatibility, master‑slave connection behavior, monitoring lag, forcing master pause, bidirectional replication considerations, performance improvements, high‑availability setups, and how to exclude GRANT/REVOKE statements from replication.
This article demonstrates how to use MySQL Shell's util.import_table and util.import_json functions to import CSV and JSON data efficiently, compares their performance with the traditional mysqlimport tool, explains required options such as file path, schema, table, dialect, threading, and shows example sessions in both JavaScript and Python modes.
This article explains how multithreaded inserts into a MySQL table can be faster than single‑threaded inserts by reducing connection and parsing overhead, and it details techniques such as prepared statements, multi‑value inserts, and batch transaction commits to boost performance.
V8 Lite, introduced by the V8 team in late 2018, implements a series of memory‑saving techniques—such as lazy feedback allocation, delayed source positions, and bytecode flushing—that together can reduce heap usage by roughly 22% in memory‑constrained scenarios while maintaining acceptable execution performance.
An intriguing experiment shows that replacing a harmless "y += 0" with "y += 0.1f" makes a tight C++ loop run seven times faster, revealing how denormalized floating‑point numbers trigger costly CPU paths and how understanding IEEE‑754 representation can restore performance.
This article details Alibaba's experience deploying Kubernetes at massive scale, describing the performance bottlenecks encountered in etcd, API server, controller, and scheduler components, and presenting the concrete engineering improvements—such as storage sharding, lease‑based heartbeats, load‑balancing, watch bookmarks, and hot‑standby controllers—that enabled stable operation of clusters with tens of thousands of nodes.
This article explains MySQL thread fundamentals, distinguishes PID, LWP ID and Thread TID, shows a small C program to observe these IDs, demonstrates how to map MySQL threads to LWP IDs using system tools and SQL, and provides a step‑by‑step guide to set up a GDB‑based debugging environment on Linux.
By replacing the naïve DSL‑to‑Widget mapping with custom Widget, Element, and RenderObject classes that respect match_parent and match_content semantics and leverage RelayoutBoundary optimizations, the team reduced layout complexity from O(N²) to O(N), boosting long‑list frame rates from about 28 fps to roughly 50 fps while outlining further refinements.
This article explains how java.util.concurrent.atomic.LongAdder provides a more efficient counting mechanism than AtomicLong under high contention, discusses its trade‑offs in space and precision, presents JMH benchmark results, and walks through the internal implementation details such as cells, CAS loops, and hash‑based distribution.
This article explains the three-stage execution process of JavaScript in V8, compares interpreter and compiler approaches, describes how the JIT combines their strengths, and provides practical tips for writing JavaScript that maximizes performance by leveraging V8’s optimization mechanisms.
This guide walks you through essential Linux server monitoring tools—top, vmstat, pidstat, iostat, netstat, sar, and tcpdump—explaining each metric, how to interpret CPU, memory, disk, and network statistics, and offering practical tips for troubleshooting performance bottlenecks.
This article explores why Java faces challenges in the cloud‑native era, demonstrates how multi‑stage Docker builds, OpenJ9 shared class cache, and Micronaut‑GraalVM native compilation can dramatically reduce image size and cut startup time by up to 50 % while also lowering memory consumption.
Although both browsers receive identical data, Chrome and Firefox display sorted results differently due to their distinct underlying sorting algorithms—Firefox uses merge sort while Chrome employs a hybrid of insertion and quick sort—this article explains the issue, demonstrates implementations, and compares performance and optimization techniques.
This article recaps a hardcore Node.js underground salon where experts explored runtime optimization, V8 engine enhancements, Alinode monitoring, fork(2) performance tricks, and core startup processes, highlighting practical insights for Serverless, IoT, and high‑performance backend development.
This article documents a multi‑stage investigation of intermittent GitLab Runner build timeouts and hangs, describing the background, VM configuration, successive diagnostic steps using strace, iotop, perf, and storage‑driver adjustments, and concludes with performance test results and lessons learned.
This article details Meituan's end‑to‑end development of a merchant‑side mobile video feature, covering background needs, architecture design, technology selection, implementation of playback, recording, composition, cutting, processing pipelines, encountered pitfalls, monitoring strategies, and future optimization directions.
This article chronicles the architectural evolution of a web‑based mini‑program engine, detailing the challenges of sandboxing Vue, restricting unsafe tags, handling performance and native capability limits, and ultimately adopting a dual‑thread model to achieve security and control while preserving developer experience.
This article examines how design‑focused techniques such as preloading, non‑blocking scrolling, and efficient DOM recycling can dramatically improve the perceived responsiveness of infinite‑scroll lists, drawing on the Google RAIL model and user‑experience research.
This article examines Alibaba's practical use of Flutter, covering application adoption, infrastructure setup, SDK maturity, hybrid stack routing, iOS packaging scripts, monitoring, performance tuning, upgrade strategies, and a brief look at Flutter for Web, providing actionable insights for mobile developers.
This guide walks through diagnosing a Java portal's high CPU usage by checking system load, identifying the offending thread, analyzing JVM stack traces, pinpointing a slow MySQL query, and resolving the issue with data cleanup and index creation, reducing CPU load from 800% to 40%.
This article compiles essential Redis interview questions covering its advantages over Memcached, performance pitfalls, data structures, persistence options, clustering, scaling strategies, and practical usage patterns such as distributed locks and asynchronous queues, providing concise answers and best‑practice recommendations for each topic.
System.currentTimeMillis() appears fast but under heavy concurrent calls it becomes dramatically slower due to kernel‑mode time‑of‑day queries, and this article explains the root cause, shows benchmark results, and offers a cached‑timestamp solution to restore performance.
This guide shares practical experience and step‑by‑step solutions for migrating C/C++ and other language projects from x86 servers to ARM64 TaiShan platforms, covering compilation differences, code adjustments, compiler options, and performance tuning to achieve stable and efficient execution.
This article explains the fundamentals of CPUs, covering their core functions, internal components, operation stages, key performance metrics such as clock speed, multiplier and external frequency, as well as modern technologies like Turbo Boost, multi‑core, hyper‑threading, and the evolution of CISC and RISC architectures.
This article explains the structure and behavior of System.out.println in Java, covering the System class, the out field, println method, output redirection, performance implications, comparison with logging frameworks, static import shortcuts, and the related System.err and System.in streams.
This article explains the differences between structured, semi‑structured and unstructured data, walks through the evolution stages of relational database architectures, evaluates their advantages and drawbacks, and then compares major NoSQL families—KV, search, column‑oriented and document stores—to help engineers decide the right storage engine for their workloads.
This article analyzes Java 8 Stream API versus traditional iterator approaches across mapping, filtering, sorting, reduction, string concatenation and mixed operations, presenting benchmark results on various data sizes and offering practical recommendations for when to use streams, parallel streams, or iterators.
This article presents nineteen practical MySQL optimization methods—including using EXPLAIN, limiting IN clause size, specifying columns in SELECT, proper use of LIMIT, avoiding costly ORDER BY RAND(), choosing between IN and EXISTS, leveraging full‑text indexes, and applying join and index best practices—to improve query performance and reduce resource consumption.
This article provides a comprehensive overview of the JVM runtime memory areas, explains how the JVM determines garbage objects, reviews major GC algorithms and collectors—including the latest ZGC—and offers practical code examples and command‑line instructions for reproducing various OutOfMemoryError scenarios.
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.
