This article explains why Web Components are gaining traction, outlines their technical and performance advantages over frameworks like React, and highlights the business and security benefits of adopting native, framework‑agnostic components for modern web development.
This article explains the Cube mini‑program rendering stack, its modular architecture, thread model, advanced Flow Layout and Inline Text support, CSS stylesheet capabilities, QuickJS integration, multi‑mode packaging and performance benchmarks, showing how it achieves fast startup, low memory usage and near‑native experience on low‑end devices.
This article explains the concept of FLOPS, its measurement units, common benchmarks such as Linpack and MLPerf, why traditional HPC benchmarks may not suit AI workloads, and provides a comprehensive overview of hardware performance figures from GFLOPS to PFLOPS across various modern processors and supercomputers.
tinylog2 is an open-source, lightweight Java logging framework that supports JVM languages, offers a static Logger API, SLF4J adaptation, multiple output options, configurable properties or YAML/JSON, high performance benchmarks, and a small footprint, making it a secure alternative to log4j2.
This article introduces Caffeine Cache as a high‑performance local cache for Java, explains its W‑TinyLFU algorithm advantages over Guava, details various eviction and loading strategies, and provides step‑by‑step Spring Boot integration with Maven dependencies, configuration properties, bean definitions, and annotation‑driven usage examples.
From architecture tweaks like distributed caching and read‑write separation to hardware upgrades, DB instance tuning, and concrete SQL refactoring, this guide walks through four optimization layers, illustrates each with diagrams and a full‑scale MySQL case study, and shows how performance can improve up to twentyfold.
The article explains how Redis, originally a single‑threaded in‑memory cache, introduces Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking during large key deletions, describes the underlying event‑driven architecture, shows relevant source code, and discusses the benefits and constraints of these mechanisms.
This article explains the differences between memory leaks and memory overflows, outlines common causes and classifications of leaks, describes why leaks can lead to overflows, and provides practical steps to detect and fix both issues in long‑running applications.
A practical MySQL InnoDB test shows that count(1) and count(*) have almost identical performance, explains the underlying index usage, and clarifies why MyISAM can count rows faster due to its storage design.
This article details how Taote engineers tackled severe frame‑rate and stutter issues in a complex e‑commerce Flutter app by applying ten practical performance optimizations—ranging from reducing setState calls to leveraging RepaintBoundary—resulting in measurable FPS gains and a noticeably smoother user experience on low‑end devices.
The article details how China Construction Bank's fintech arm designed, deployed, and operated a cloud‑native, three‑layer MPP data warehouse spanning 16,000 servers, covering architectural choices, performance gains, operational automation, and high‑availability strategies for ultra‑large scale workloads.
An in‑depth walkthrough of React’s Fiber architecture reveals how time‑slicing and a linked‑list Fiber tree replace the stack‑based reconciler of React 15, delivering smoother UI updates, priority‑based task scheduling, and interruptible rendering, complete with code examples, performance comparisons, and the underlying event‑loop mechanics.
This article explains graph computing fundamentals, illustrates its use in fraud detection, search ranking, and brain modeling, highlights Ant Group's record‑breaking performance and standards efforts, and outlines future challenges such as standardization, higher performance, and integration with AI.
Canvas performance hinges on the number and size of drawn shapes, so optimizing by reducing draw‑calls, using layered or clipped rendering, and offloading heavy drawing to OffscreenCanvas or Web Workers can preserve frame rates and keep the UI responsive.
The article analyzes the Xi’an “Yima Tong” health‑code system outage, detailing the symptoms, root‑cause factors such as rate‑limiting gaps, server overload, architectural coupling, and ISP differences, and then offers short‑term, long‑term, design, high‑availability, and testing recommendations to prevent future crashes.
The Quite OK Image Format (QOI) is an open‑source, lossless image format that promises PNG‑like file sizes with 20‑50× faster encoding and 3‑4× faster decoding, has a tiny C implementation, and has quickly attracted thousands of stars and community interest on GitHub.
The report presents a comprehensive performance benchmark of RedisJSON (RediSearch) against MongoDB and ElasticSearch, showing RedisJSON’s superior write, read, and mixed‑workload throughput and latency across isolated and hybrid scenarios, with detailed test methodology and analysis.
The article explains Go’s scheduler (M, P, G), demonstrates goroutine, channel, and select usage, covers sync primitives, atomic ops, context cancellation, singleflight, common pitfalls, debugging tools, and a channel‑driven chatroom case study, offering best‑practice guidance for efficient concurrent programming.
Facing build times of up to 35 minutes for Android release packages, Youku’s engineering team applied data‑driven metrics, software and hardware optimizations—including Atlas removal, Gradle and AGP upgrades, DX tuning, redundant task cleanup, and pipeline redesign—cutting debug builds by minutes and release builds by tens of seconds.
This article outlines a comprehensive process for analyzing, diagnosing, and optimizing performance issues in production business systems, covering hardware, OS, database, middleware, JVM settings, code inefficiencies, and the role of monitoring tools like APM to pinpoint bottlenecks.
This article explains how to replace synchronous price‑lookup APIs with Java 8's CompletableFuture, compares synchronous and asynchronous performance, introduces the most useful CompletableFuture creation and composition methods, shows practical code examples, and discusses when to prefer it over traditional Future or thread‑pool approaches.
This article provides an in‑depth overview of Linux I/O mechanisms, covering the memory hierarchy pyramid, kernel‑level caching layers, the Linux I/O stack, page‑cache synchronization strategies, file‑operation atomicity, locking, and practical disk performance testing techniques.
The report presents extensive YCSB‑based performance benchmarks showing that RedisJSON (with RediSearch) outperforms MongoDB and ElasticSearch by large margins in isolated writes, isolated reads, mixed workloads, and latency across a variety of operation mixes on identical AWS hardware.
This article explains the design goals, exactly‑once semantics, Java transaction API, coordinator and log architecture, and practical performance trade‑offs of Apache Kafka's transactional messaging, helping developers build reliable stream‑processing applications.
The article explains how Redis read/write separation works, compares star and chain replication architectures, and highlights the benefits of transparent compatibility, high availability, and improved performance for read‑heavy, write‑light workloads.
This article explains how ThreadLocalRandom in JDK7 improves multithreaded random number generation, compares it with Random and Math.random(), analyzes the underlying linear congruential algorithm, and provides practical code examples for high‑performance Java applications.
This article explains why traditional Excel export methods cause memory overflow, introduces Alibaba's EasyExcel library that keeps memory usage in kilobytes, and provides step‑by‑step Maven setup, POJO definitions, and code examples for exporting small, medium, and massive data sets in a Spring Boot environment.
Optimizing HTML5 canvas performance involves reducing draw calls, using layered and clipped rendering, performing quick bounding‑box checks, and offloading heavy drawing to OffscreenCanvas with Web Workers, enabling smooth animation even when thousands of shapes are rendered.
This article presents a detailed performance benchmark of RedisJSON (RediSearch) against MongoDB and ElasticSearch, showing RedisJSON’s superior throughput and latency across isolated writes, reads, and mixed workloads, supported by YCSB test results and extensive latency analysis.
Traditional Linux I/O relies on read() and write() system calls that involve multiple CPU and DMA copies and context switches, while modern optimizations such as zero‑copy, multiplexing, and page cache techniques reduce copying overhead, and understanding buffered, mmap, and direct I/O reveals their impact on performance.
This article outlines a comprehensive approach to diagnosing and optimizing performance problems in production business systems, covering common causes such as concurrency spikes, data growth, and environment changes, and detailing hardware, middleware, database, JVM, code-level analyses, monitoring tools, and APM strategies.
During high‑traffic events like Double‑11, Linux systems often see load averages surge, affecting response times and command execution; this article explains what load averages represent, how the kernel computes them using exponential weighted moving averages, and outlines common causes and systematic methods for root‑cause analysis.
Using LIMIT with a large offset in MySQL can cause severe performance degradation due to excessive random I/O, but by rewriting the query to first fetch primary keys in a subquery and then joining, execution time can drop from seconds to milliseconds, as demonstrated with real data.
This article examines seven typical scenarios where MySQL indexes unexpectedly fail—such as OR conditions, leading wildcards in LIKE, missing quotes, functions on indexed columns, NULL checks, arithmetic operations, and composite index ordering—providing SQL examples, execution plans, and practical tips to avoid costly full‑table scans.
This article explores the evolution of BPF from its origins as a packet‑filtering mechanism to the modern eBPF engine, detailing its architecture, security and performance benefits, core features such as hooks, maps and helper functions, and real‑world cloud‑native use cases like Cilium, Falco and kubectl‑trace.
The article explains Linux’s traditional system‑call I/O path, detailing how read() and write() trigger multiple CPU and DMA copies and context switches, describes read and write workflows, explores network and disk I/O, examines the Linux I/O stack, page cache, buffering strategies, zero‑copy, mmap and Direct I/O, and discusses performance trade‑offs.
This article explains the fundamentals of web animation, compares animation techniques such as CSS, SVG, and Canvas, demonstrates how to create frame‑based Canvas animations with JavaScript and Konva, shows how to integrate them into React (including react‑konva), and provides performance‑optimisation strategies for smoother rendering.
This article explains why SQL queries can become slow, outlines MySQL's internal architecture, demonstrates how to use the EXPLAIN statement to view execution plans, and interprets key fields such as type, key, and Extra to help developers identify and optimize performance bottlenecks.
This article details the open‑source release of Alibaba’s iLogtail, explains the observability challenges it solves, traces its evolution through the Feitian 5K, Alibaba Group, and cloud‑native stages, highlights its high‑performance, stability, and multi‑tenant features, and outlines the community‑driven open‑source goals alongside a brief Impala overview.
This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with delegate‑based syntax, dramatically improves code readability, reduces boilerplate, and achieves up to 20% faster compilation while providing detailed implementation steps, performance results, and practical guidelines.
This article explains how to build a non‑intrusive debugging and diagnostic platform for Node.js, covering process and thread inspection using the V8 Inspector API, dynamic control via an SDK, multi‑process and multi‑thread handling with Agent processes, and practical usage steps.
This article reveals the technical design of Youku's high‑performance danmaku rendering engine, covering its background, industry landscape, GPU‑based rendering pipeline, multi‑layer architecture, performance‑boosting techniques, real‑world benchmarks, and the innovative effects it enables.
This article summarizes Sam Gross’s nogil project—a Python 3.9 fork that removes the GIL—detailing its design changes, early benchmarks, integration challenges, and the community’s discussion on feasibility, performance, and the roadmap toward a GIL‑free CPython.
This article explains why MySQL queries become slow, how index design and lock contention affect performance, and when to complement MySQL with Elasticsearch for full‑text search or HBase for write‑intensive workloads, providing practical optimization strategies and architectural guidance.
The article chronicles Taobao’s architectural evolution from a LAMP stack to an Oracle‑IBM mainframe setup, then to a Java‑centric distributed system, and finally to a cloud‑native solution on Alibaba Cloud, highlighting key design decisions, scalability challenges, and migration best practices across storage, services, OLTP and OLAP workloads.
This article outlines ten practical habits for developers, from relying on official documentation and thorough testing to effective logging, Git mastery, prioritizing functionality, handling ambiguous requirements, proactive problem‑solving, scheduling buffers, hands‑on learning, and improving English for better access to technical resources.
This article compares Google Chrome and the open‑source Chromium browser, covering UI nuances, open‑source versus proprietary code, feature gaps such as sign‑in and media codecs, installation quirks across platforms, privacy implications, benchmark performance, and guidance on which browser best fits different user priorities.
This article presents practical techniques for optimizing image resources in e‑commerce front‑end projects, covering lazy loading of ordinary images, progressive and skeleton loading for high‑fidelity assets, and server‑side splitting of long graphics using Node.js, with detailed code examples and performance considerations.
This article introduces relationship graph visualization, compares common front‑end chart libraries such as ECharts, D3, and G6, explains why D3 and G6 were chosen for a real‑world case, and discusses performance‑related optimizations and layout improvements for large‑scale graph data.
This article details the evolution from a Node.js‑based WebSocket gateway to a Go‑implemented, gRPC‑driven architecture, describing the redesign of connection handling, TLS off‑loading, socket ID generation, session management, custom Kafka headers, code‑level optimizations, and extensive performance testing that validates the new gateway’s scalability and resource efficiency.
This article describes the architectural evolution from Gateway 1.0 to Gateway 2.0 for a high‑traffic document collaboration platform, detailing the redesign of the WebSocket layer, resource‑usage optimizations, heartbeat mechanisms, custom Kafka headers, message serialization, load‑testing results, and the operational lessons learned to support millions of concurrent connections.
This article walks through a practical approach to safely split a 50 million‑row MySQL history table, add missing indexes, and migrate data in batches using backup, table‑copy, and incremental INSERT operations while avoiding long locks and performance degradation.
This article explains why asynchronous execution is needed in Spring Boot, demonstrates how to enable @Async, shows step‑by‑step code for configuration, method annotation, and controller usage, and details how to create and manage custom thread pools for optimal performance and fault tolerance.
The Xianyu team’s talk outlines Flutter performance challenges—complex list‑item logic, a 16.6 ms frame budget, DynamicX template overhead, and scroll‑curve‑induced offset jumps—and presents best‑practice solutions such as PowerScrollView caching, partial refresh, frame‑splitting, DynamicX caching, isolate offloading, layer merging, plus custom benchmarking, DevTools extensions, and FlutterBlockCanary for measurement, urging developers to prioritize perceived smoothness, monitor raster costs, and leverage multi‑threading and community updates.
This article details the evolution from a Node.js Socket.IO gateway to a Go‑based, gRPC‑enabled WebSocket gateway that supports millions of concurrent connections, covering architecture redesign, TLS handling, socket ID generation, session management, heartbeat optimization, custom Kafka headers, code‑level refinements, and extensive performance testing results.
The article presents a detailed performance comparison of three HTTP client implementations—Java FunTester, Go's net/http, and the high‑performance fasthttp library—across multiple thread counts and artificial latency settings, reporting CPU usage, memory consumption, and QPS to determine the most efficient choice.
The article explains how shifting complex filtering, validation, and join operations from the database to the application layer reduces scarce database resource usage, improves scalability, and enables more flexible resource allocation for modern web applications.
This article explains how the JavaScript with statement creates a new lexical scope that can unintentionally create global variables, cause data leakage, and dramatically degrade performance, while also covering LHS/RHS lookup, execution contexts, variable/activation objects, and scope chain mechanics.
The article investigates a DBCP 1.4 connection‑pool bug that allows the pool to exceed its configured limits, explains how removeAbandoned and socketTimeout interact to produce excess MySQL connections, reproduces the issue with a multithreaded test, and proposes configuration changes to avoid it.
PHP 8.1.0 introduces enums, read‑only properties, first‑class callable syntax, new initializers, intersection types, never return type, final class constants, explicit octal literals, fibers, string‑keyed array unpacking, and numerous performance optimizations, providing developers with richer language features and faster execution.
This article explains why indexes are vital for MySQL performance, how to decide when to add ordinary, composite, prefix, or unique indexes, the pitfalls of using non‑sequential primary keys, and advanced optimizations such as change buffer, index condition pushdown, and MRR to reduce I/O.
This article introduces Java 8's Stream API, explains its intermediate and terminal operations, highlights its functional characteristics, compares its performance with traditional iterator loops through benchmark tests, and offers practical recommendations for using streams and parallel streams in backend development.
The article details the design, architecture, core features, scheduling logic, and performance gains of Vipshop’s self‑built Hera data service, which unifies data‑warehouse access, supports multiple engines, adapts SQL execution, and dramatically improves SLA for both B‑to‑B and B‑to‑C workloads.
This article examines seven typical scenarios where MySQL indexes fail—such as OR conditions, leading wildcards, missing quotes, functions, NULL checks, arithmetic on indexed columns, and composite index order—explaining why they happen and offering practical solutions to maintain query performance.
This article compares PyInstaller and Nuitka for converting Python projects into standalone executables, highlighting Nuitka's dramatically smaller file size, faster build times, and better performance while also providing step‑by‑step installation and usage instructions.
This article provides a systematic, step‑by‑step methodology for diagnosing Redis latency spikes, covering baseline performance testing, slow‑log analysis, high‑complexity commands, big‑key handling, expiration patterns, memory limits, fork overhead, huge‑page settings, AOF configurations, CPU binding, swap usage, memory fragmentation, network saturation, and practical monitoring tips.
This article details the end‑to‑end preparation, execution, reporting, and retrospective of a large‑scale production‑environment load test for the Double 11 shopping festival, covering data preparation, QPS target calculation, multi‑scenario testing, issue analysis, and continuous improvement practices.
This article provides an in‑depth overview of Glide 4.11, covering its basic usage, the four‑step request lifecycle, six‑step image loading flow, caching mechanisms, initialization, configuration options, and common interview‑style questions for Android developers.
This article explains how MySQL InnoDB partition tables can dramatically boost query speed, simplify routine operations, enable parallel writes, and provide efficient data exchange and cleanup compared to non‑partitioned tables, illustrated with concrete SQL examples and performance metrics.
This article explains the difference between memory leaks and overflow, whether young GC triggers stop‑the‑world pauses, distinguishes major GC from full GC, and describes Java's direct memory usage, providing clear insights into Java memory management and performance considerations.
This article examines the origins of Java's infinite loop constructs, compares the frequency of for(;;) and while(true) in the JDK source, and shows through compiled bytecode that both forms are semantically identical and have no inherent performance advantage.
This article presents fifteen practical SQL optimization techniques—including avoiding SELECT *, using UNION ALL, leveraging IN/EXISTS, batching inserts, applying LIMIT, controlling IN list size, incremental queries, efficient pagination, preferring JOINs, limiting join tables, managing indexes, choosing proper column types, improving GROUP BY, and using EXPLAIN—to help developers dramatically improve query speed and resource usage.
This article outlines ten essential Redis best‑practice tips, covering why to avoid the KEYS * command, using SCAN, interpreting INFO stats, leveraging hashes, setting key expirations, choosing eviction policies, handling errors, scaling with clusters, CPU considerations, and ensuring high availability with Sentinel.
This article provides an in‑depth overview of Apache Log4j2, comparing it with Logback and Log4j 1, highlighting its superior asynchronous performance, zero‑GC operation, flexible configuration formats, rich appender ecosystem, and practical code examples for Maven integration, XML setup, and advanced logging techniques.
A Kubernetes‑deployed business app sees its QPS drop from over 100k with a NodePort service to about 50k when exposed via Ingress, but adjusting Nginx keep‑alive parameters in the ingress‑controller can restore and even exceed the original performance while also enabling high availability.
This article presents fifteen practical SQL optimization tips—including avoiding SELECT *, preferring UNION ALL, leveraging small‑table‑driven queries, batching inserts, applying LIMIT, handling large IN lists, incremental fetching, efficient pagination, join strategies, index management, field‑type choices, and using EXPLAIN—to dramatically improve MySQL query speed and resource usage.
This article explains the concept, principles, and practical steps of iOS symbolication, covering crash log processing, address translation, ASLR handling, function‑start and nlist tables, DWARF debugging information, and essential Xcode command‑line tools for accurate source‑level debugging.
This article analyzes why Flutter apps suffer from high memory usage, identifies BuildContext and State as primary leak sources, and proposes a comprehensive, automated detection tool inspired by Android LeakCanary that accurately and efficiently finds memory leaks in production Flutter applications.
Git 2.34 introduces a sparse index for large monorepo repositories, multi‑package reachability bitmaps, the default "ort" merge strategy, OpenSSH‑based tag signing, interactive autocorrect prompts, performance improvements for fetch and push, and various submodule enhancements.
This article introduces Loguru, a third‑party Python logging library, explains why it simplifies logging compared to the standard logging module, outlines its key features such as out‑of‑the‑box setup, async safety, lazy evaluation, and file rotation, and provides practical code examples for quick integration into scripts, libraries, and frameworks.
Rust, a fast and memory‑efficient language adopted by major tech firms, is increasingly replacing JavaScript in web tooling such as bundlers, compilers, and linters, with projects like SWC, Deno, and WebAssembly demonstrating its performance, safety, and growing ecosystem for the future of JavaScript infrastructure.
This article presents practical Python performance tips, covering fundamental optimization principles, avoiding global variables and attribute lookups, reducing unnecessary abstractions, eliminating data copies, leveraging short‑circuit logic, loop improvements, JIT compilation with numba, and choosing efficient built‑in data structures, all illustrated with measurable code examples.
In a large‑scale Redis cluster, expanding nodes caused unexpected CPU spikes and higher latency for MGET operations, prompting a deep investigation that traced the issue to the CLUSTER SLOTS command and its handling of MOVED errors, followed by a code‑level optimization that reduced CPU usage by over 90% and cut command latency dramatically.
This article explains Kafka’s core architecture—including topics, partitions, replication, consumer groups, controller coordination with Zookeeper, and performance tricks like sequential writes and zero‑copy—to show how it achieves high‑throughput, fault‑tolerant messaging for large‑scale systems.
This article explains why iOS memory leaks become critical as apps grow, introduces five representative leak models, details a production‑ready object‑graph scanning solution with custom data structures and a non‑recursive DFS algorithm, and evaluates its performance impact and mitigation strategies.
This article dissects the Android cold‑start sequence of the Alipay app, detailing each stage from the initial input event through process forking, activity initialization, splash screen rendering, and final frame display, while providing timing data and optimization insights.
This article explains React 18’s new concurrent rendering features, focusing on the startTransition API, its problem‑solving benefits, practical demos comparing React 17 and 18, and a deep dive into the underlying source code and scheduling mechanisms that enable prioritized updates.
This article walks through developing a simple Go WebSocket server that echoes the current time, shows a minimal client, compares startup speed with Java, and provides full source code and test logs for practical performance testing.
This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with concise delegated properties, explains its design and implementation details, demonstrates significant compilation‑time reductions of up to 20% and cleaner code, and provides a step‑by‑step guide for developers interested in building similar compiler extensions.
The article details Tencent Cloud's TDSQL‑C cloud‑native database, explaining traditional database bottlenecks, its four standout features—PB‑level storage, second‑level scaling, rapid snapshot backup, and serverless pay‑as‑you‑go—and the deep kernel optimizations that enable these capabilities while outlining future performance and cross‑region goals.
This article presents fifteen practical SQL optimization tips—including avoiding SELECT *, using UNION ALL, driving large tables with small ones, batch operations, LIMIT usage, index control, proper data types, and efficient GROUP BY—to help developers improve query speed, reduce resource consumption, and avoid common performance pitfalls.
Bisheng JDK is Huawei's customized OpenJDK distribution offering high‑performance, production‑ready Java runtime optimized for ARM, compatible with Java SE 8, supporting Linux/AArch64, and featuring JFR and a fast serializer with specific JVM options.
This article examines cloud computing’s core principle of using interchangeable machines, compares parallel‑first and single‑storage‑first database architectures, outlines the advantages such as scalability, cost efficiency, and integration, and discusses the weaknesses including maturity gaps, latency, and vendor lock‑in.
The article investigates why the Feishu app sometimes fails to respond to swipe gestures after a hot start, tracing the issue to the app entering a D (uninterruptible) state during memory compression, and demonstrates how adjusting CPU priority for compression threads can reduce the problem's occurrence.
This guide compares simple Date‑based timing, System.currentTimeMillis(), and Spring's StopWatch utility, showing how to accurately measure and analyze execution durations of individual code blocks in Java applications.
This article examines how cloud computing principles shape database system design, compares parallel‑first and single‑system‑first architectures, outlines the strengths and weaknesses of cloud databases, and offers guidance for selecting the right cloud‑based data platform.
This article provides a thorough overview of Redis, covering its core data structures and common commands, persistence options, memory management and eviction policies, pipelining, transactions, Lua scripting, performance optimization techniques, replication with Sentinel, cluster sharding, and a comparison of popular Java clients.
This article walks through the complete Linux kernel path for sending a network packet, covering the send() system call, TCP processing, IP routing, queueing, driver interaction, DMA mapping, and the role of hard and soft interrupts, while answering common performance questions.
In this article we detail a two‑week sprint that identified and eliminated multiple Java backend performance bottlenecks, optimized CPU usage with jtop, re‑engineered Hystrix circuit‑breaker settings, reduced logging overhead, and fixed Spring data‑binding issues, ultimately doubling QPS and stabilizing service recovery.
PowerImage combines FFI and external‑texture techniques to deliver native‑like Flutter image handling, offering direct ui.Image loading, unified caching, simulator support, custom channels and comprehensive error capture, with texture‑based rendering preferred for typical use and FFI reserved for legacy simulators or direct pixel access, while providing performance gains and upcoming animated‑image support.
