This article explains what ESBuild and SWC are, why they dramatically speed up JavaScript bundling and compilation compared to traditional tools, and provides practical guidance on integrating them into modern frontend workflows such as Vite, Webpack, and custom scripts.
This article explains how Baidu Live R&D introduced a lightweight server‑side rendering (SSR) solution that integrates into existing client‑side rendering (CSR) projects by adding a JavaScript compute function, detailing the architectural components, goals, implementation steps, development experience, risk mitigation, and future outlook.
This article explains the design of a WebAssembly‑based security sandbox using QuickJS, detailing its background, goals, technical architecture, performance benchmarks, and future roadmap for building a safer, standards‑compliant open web ecosystem.
This article explains how Umi 4 redesigns its ESLint setup to reduce rule overload, eliminate unstable dependencies, make configurations transparent, and boost linting performance by removing type‑aware checks, offering a stable, fast, and maintainable linting solution for frontend projects.
This article recounts a production incident caused by a MySQL query with a huge OFFSET, explains why large offsets lead to full‑table scans and severe latency, and presents three practical solutions—including index‑covering subqueries, start‑position redefinition, and offset throttling—along with data‑generation scripts and performance test results.
This article explains how to design Redis cache for relational list data such as user timelines or news feeds, covering fixed-length caching, consistency, resource utilization, using ZSET structures, handling additions, deletions, queries, and strategies like preloading, retry mechanisms, and asynchronous rebuilding.
The article explains Redis’s in‑memory architecture, detailing memory components, object encodings, buffer limits, fragmentation, and forked‑process overhead, and offers practical optimization tips—such as using compact encodings, controlling client buffers, disabling THP, and enabling active defragmentation—illustrated by real‑world case studies.
This article examines performance bottlenecks in a high‑traffic e‑commerce product service and proposes data‑centric optimizations—including read‑only focus, field‑level selection via bit‑masking, and Redis hash storage—to reduce payload size, lower GC pressure, and improve latency while maintaining scalability.
This article explains how JavaScript's garbage collector works, outlines typical memory‑leak scenarios, and provides practical techniques—such as reducing global variables, cleaning DOM references, and managing event listeners—to improve performance and avoid UI jank.
This article explains the concepts, creation methods, communication APIs, debugging techniques, and typical use cases of ordinary Web Workers, SharedWorkers, and ServiceWorkers, illustrating how they enable multithreaded computation, cross‑tab data sharing, and offline caching to improve web performance and user experience.
This article demonstrates how to dramatically speed up the slow pandas apply function—by up to six hundred times—using Swifter for parallel execution, vectorized pandas/numpy operations, dtype downcasting, and direct .values array manipulation, with detailed timing comparisons.
Moyu, Xianyu’s dedicated front‑end R&D framework launched in 2022, unifies template and configuration management, introduces a hybrid XTPL/JS/CSS/Schema development model, and adds a lightweight data gateway that streamlines releases, boosts first‑screen performance, and supports scalable scenarios such as product recommendations, with plans for mini‑programs and broader platform integration.
This article explains MySQL's lack of a hard row limit, the industry rule of thumb around 5 million rows, how InnoDB buffer size and hardware affect performance, and demonstrates a simple insertion test that reveals slowdown when a table grows too large.
This article examines the performance impact of instantiating a new Jackson ObjectMapper for each JSON parsing operation versus reusing a global instance, using JMH micro‑benchmarks to show that a shared ObjectMapper can be up to ten times faster.
The article analyzes a recurring one‑second pause in a Redis 4.0 master‑slave setup, identifies the periodic BGSAVE fork operation as the root cause through metrics like latest_fork_usec, and presents mitigation strategies such as memory limits, activedefrag, and migration to a lower‑RSS instance.
This article provides a detailed technical analysis of the leaked specifications for NVIDIA's Ada Lovelace GPU series, covering chip dimensions, L2 cache innovations, performance expectations, manufacturing node implications, and cost considerations while comparing them to AMD's offerings.
This article explains how excessive Linux CPU context switches affect system performance and shows step‑by‑step how to monitor and analyze them using vmstat, pidstat, and sysbench, including interpreting voluntary versus involuntary switches and interrupt statistics.
This article explains how Python list comprehensions provide a concise, memory‑efficient way to create lists, compares them with loops and map(), shows advanced features like conditional logic, nested comprehensions, set and dictionary comprehensions, and discusses when to avoid them for better readability and performance.
Facing the challenge of duplicated UI code across multiple devices, Youku’s tech team built a cross‑platform dynamic template system—including GaiaSketch, GaiaX, and GaiaStudio—that streamlines design‑to‑code workflows, reduces development effort by about 30%, and open‑sources the tools for the broader community.
The article recounts a real‑world incident where a Java message‑queue system stalled for over ten minutes because an HTTP client call lacked a timeout, walks through the step‑by‑step debugging process, shows the problematic code, and provides proper timeout configurations for different HttpClient versions to prevent such blocks.
This article explains the key Linux disk performance indicators—utilization, saturation, IOPS, throughput, and response time—and shows how to monitor them using tools such as iostat, pidstat, and iotop, including practical command examples and interpretation tips.
Meituan Search solves costly multi‑language maintenance by building a core C++ library, wrapping it with a C interface, and exposing the functions to Python via ctypes and to Java via JNI or JNA, enabling shared logic, easier packaging, and lower latency on Linux.
This article details the Snowball data team's migration from Hive3 on Tez to Spark SQL, covering the motivations, comparative performance tests, encountered compatibility issues, configuration work‑arounds, and future plans for consolidating ETL workloads on Spark.
This article explains the design and implementation of NutUI's vertical‑scroll Calendar component, covering data initialization, virtual‑list rendering, scroll and boundary handling, and extensible slots, props, and events to achieve both smooth interaction and optimal performance.
The article explains how Android UI jank and ANR stem from the Looper‑MessageQueue, and introduces MDAP’s LooperMonitor—a low‑overhead tool that records each message’s target, timing and stack, aggregates data across multiple loopers, visualizes it, and enables developers to quickly pinpoint and resolve the exact cause of stalls.
This article outlines several frequent MySQL query pitfalls—including missing table aliases in multi‑table operations, unsupported FULL JOIN syntax, unexpected REPLACE INTO side effects, auto‑increment edge cases, data‑type mismatches, nondeterministic functions, and warning‑driven query behavior—providing examples and best‑practice recommendations to prevent data loss and performance issues.
This article benchmarks three ObjectMapper usage patterns—creating a new instance per call, sharing a global singleton, and using ThreadLocal—demonstrating that a single shared ObjectMapper can achieve up to ten‑fold higher throughput in JSON parsing.
This article provides a comprehensive overview of Redis, covering its core characteristics, supported data types, common caching challenges such as consistency, avalanche, penetration and breakdown, as well as its high performance mechanisms, eviction policies, persistence options, master‑slave replication, and Sentinel high‑availability architecture.
Apache Doris (incubating) announced its 1.0 release on April 18, 2022, featuring a new vectorized execution engine, Hive external tables, Lateral View syntax, Z‑Order indexing, SeaTunnel integration, numerous performance optimizations, new bitmap functions, security enhancements, and detailed upgrade instructions for users.
This article provides a comprehensive introduction to Redis, covering its core characteristics, supported data types, caching usage patterns, typical issues such as consistency, avalanche, penetration and breakdown, performance reasons, eviction policies, persistence options, master‑slave replication, and Sentinel high‑availability mechanisms.
This article explores using IndexedDB for large‑scale client‑side data storage, covering database creation, CRUD wrappers, bulk inserts, performance testing, and multi‑tab coordination via BroadcastChannel and leader election, while providing practical code samples and optimization tips for robust offline logging.
This article analyzes the performance bottlenecks of Baidu mini‑program package installation, proposes a streaming download approach that parallelizes network I/O with signature verification and decompression, and provides detailed Java implementation using a MultiPipe pipeline to achieve a 21% reduction in download time.
This article recounts the end‑to‑end experience of planning, executing, and reviewing a database sharding project for a high‑traffic order platform, detailing pre‑implementation risk assessment, the detailed testing lifecycle, gray‑release strategies, performance validation, and post‑mortem lessons learned.
Microsoft released .NET 7 Preview 3, introducing major updates such as full native AOT compilation, improved startup times, Write‑Xor‑Execute support, enhanced code generation, new X.500 certificate handling, and default‑enabled GC optimizations across most platforms.
This article explains Redis's two expiration strategies—periodic active deletion and lazy deletion—detailing how the EXPIRE command works, the new NX/XX/GT/LT options introduced in version 7.0, the impact of unsynchronized clocks, and the underlying implementation code.
This article analyzes the full lifecycle of a MySQL connection from Java code to TCP handshake using Wireshark, measures each step’s latency, calculates the total cost per request, and demonstrates why connection pooling is essential for high‑traffic web applications.
This article explains the misconception that manually assigning null to unused objects always helps Java garbage collection, demonstrates with concrete JVM examples how stack slots and reachability analysis affect object reclamation, and shows when null‑assignment or slot reuse actually makes a difference.
The article explains why Java applications often experience high latency during the first few requests after startup, describes the role of the JVM interpreter and JIT compilation in creating hotspot code, and offers practical solutions such as JIT warm‑up techniques and traffic pre‑warming to improve performance.
Battery Historian, a Google-provided visual tool for Android bugreport analysis, lets developers generate bugreports via ADB, examine system and app statistics such as screen‑on/off, wake‑locks, and charging behavior, and diagnose common power issues like slow charging, overheating, and unexplained drain.
The Poizon mobile app team reduced iOS and Android CDN request latency by up to 100 ms through adding regional edge nodes, upgrading to TLS 1.3, enabling OCSP stapling, and migrating traffic to HTTP/2, demonstrating that targeted CDN and protocol tweaks can deliver double‑digit performance gains with modest effort.
This article demonstrates several practical techniques—including sorting before grouping, using drop_duplicates, and leveraging NumPy stacking—to extract the top N rows for each group in a pandas DataFrame, compares their performance, and provides a reusable function for custom use.
This article explains how MySQL can implement GROUP BY using either a compact index scan that reads rows sequentially or a loose index scan that jumps to the needed rows, compares their costs, and shows when each method is optimal, including a hybrid sequential‑loose scan.
This article investigates how much time a simple Java program spends establishing and closing a MySQL connection, measures the latency of each TCP and MySQL handshake step with Wireshark, and demonstrates why connection pooling is essential for high‑traffic web services.
A recent hardware failure left a physical server's disk read‑only, causing Redis to hang; this article explains the AOF mechanism, its potential pitfalls, log strategies, and practical steps to prevent and mitigate such issues in production environments.
This article explains the concept of zero‑copy I/O, how DMA offloads data movement between memory, disks and network cards, and compares practical implementations such as sendfile, mmap and Direct I/O, highlighting their benefits, limitations and typical use cases in Linux systems.
This article provides a step‑by‑step tutorial on integrating the Fair 2.0 dynamic framework into Flutter applications, covering dependency setup, widget conversion, bundle generation, runtime loading, parameter passing, navigation, plugin bridging, performance evaluation, update strategies, security checks, and practical lessons learned from its deployment in the 58 拍客 app.
This article explains how MySQL implements indexes using B+ trees in InnoDB and MyISAM, compares primary and secondary indexes, demonstrates performance gains from proper indexing on large tables, and provides practical commands for creating, viewing, and dropping indexes.
The article explains why using IN and NOT IN in SQL can lead to poor performance, incorrect results with NULLs, and index misuse, and demonstrates how EXISTS, NOT EXISTS, and JOIN provide safer and faster alternatives for database queries.
This article investigates MySQL's recommendation against UUID primary keys by creating three tables—auto‑increment, UUID, and random (snowflake) keys—running insert and query benchmarks with SpringBoot/JdbcTemplate, analyzing index structures, and discussing the performance trade‑offs and security considerations of each key strategy.
This article outlines four key React performance optimization strategies—reducing render frequency, trimming rendered nodes, minimizing computation, and designing components wisely—while providing practical code examples such as PureComponent, shouldComponentUpdate, React.memo, lazy loading, useMemo, and virtualized lists.
This article explains how using IN and NOT IN in SQL queries can lead to poor performance, index misuse, and incorrect results—especially with NULLs—and shows how EXISTS, NOT EXISTS, and JOINs provide more reliable and efficient solutions.
Under Jason Donenfeld’s leadership, Linux kernel random number generation was dramatically revamped in versions 5.17 and 5.18, replacing SHA1 with BLAKE2s and shifting from per‑NUMA to per‑CPU structures, delivering up to 131% speed gains in 5.17 and a staggering 8450% boost for getrandom() on multi‑core systems.
After encountering repeated errors and timeouts while retrieving the newly introduced 'nucleic acid code' in China, the author uses the experience to discuss why Spring Data JPA can cause performance problems in high‑concurrency systems compared to MyBatis, urging careful framework selection and deep SQL knowledge.
This article explains what performance means, why optimization remains essential even on powerful multi‑core CPUs, large memory, and SSDs, and demonstrates through simple code examples how algorithmic complexity can cause noticeable lag, urging developers to prioritize performance tuning.
This article shares a step‑by‑step troubleshooting guide for IntelliJ IDEA performance issues, covering vmoptions adjustments, disabling inspections, removing unused plugins, selecting the proper JDK version, and fixing a problematic infinite loop in Java code to reduce CPU consumption.
This article explains why SQL performance degrades as data grows, outlines a step‑by‑step optimization workflow—including slow‑query detection, EXPLAIN analysis, profiling, optimizer tracing, and corrective actions—while detailing type and extra fields, index usage, and practical scenarios such as large pagination, IN‑order‑by, range queries, and complex joins.
Redis 7.0-rc3 introduces new cluster commands, configuration ordering changes, ACL restrictions, function load adjustments, performance optimizations, enhanced CLI behavior, expanded INFO fields, module API extensions, and a comprehensive set of bug fixes, providing developers with important updates and potential migration considerations.
MDAP is a multi‑dimensional real‑time monitoring platform for mobile apps that gathers metrics, logs, and traces via lightweight SDKs, processes data through micro‑service back‑ends using Flink, Spark, and ClickHouse, applies intelligent analysis for smoothness scoring, memory‑snapshot optimization, stack de‑obfuscation, crash clustering, and URL templating, and aims to extend end‑to‑end observability and predictive issue detection.
This article explains the eight situations that trigger flow control in RocketMQ—four on the broker side and four on the consumer side—detailing their causes, relevant code paths, and practical measures such as broker scaling or consumer optimization to resolve them.
The article explains how I/O and CPU bottlenecks increase active database connections, then details various sharding techniques—including horizontal and vertical database/table partitioning, their concepts, results, scenarios, and analysis—followed by tools, implementation steps, common issues, and best‑practice recommendations.
This article explains why storing JSON strings in Redis is inefficient, compares JSON with binary‑safe formats like MessagePack, evaluates compression algorithms such as ZSTD and LZ4, and provides Python examples showing how to reduce latency and memory usage when using Redis strings.
The article analyzes a production issue where slave connections were slow due to missing skip_name_resolve, explains MySQL's reverse DNS resolution and host cache mechanisms, compares related parameters, shows how to inspect the host_cache table, and concludes that proper host cache settings can slightly improve MySQL performance.
After a year of development, the Asahi Linux project led by Hector Martin successfully runs an Alpha release of Linux on Apple M1, M1 Pro, and M1 Max Macs, detailing installation requirements, supported hardware features, known limitations, legal considerations, dual‑boot capability, and benchmarked performance gains over macOS.
This article explains how NanoID, a modern JavaScript identifier library, offers smaller size, higher security, faster generation, customizable alphabets, and broad language support compared to UUID, while also discussing its limitations and future outlook for developers choosing unique IDs.
This guide walks through systematic MySQL query optimization—from identifying slow statements via logs and EXPLAIN analysis, to profiling, tracing, and applying targeted fixes such as index tuning, query rewrites, and handling special cases like left‑most matching, implicit conversion, large pagination, and IN‑order‑by pitfalls.
This article systematically presents thirty architectural patterns—covering management, monitoring, performance, scalability, data handling, design, messaging, resilience, and security—to help engineers design, implement, and operate robust, high‑performance distributed systems.
This article outlines nine key reasons why developers favor Linux—ranging from its powerful command line and strong security to low resource usage, privacy protection, free licensing, and extensive community support—making it a reliable, developer‑friendly operating system for desktops, servers, and embedded devices.
This article explains common cache read/write strategies—including Cache Aside, Read/Write Through, and Write Back—detailing their mechanisms, advantages, drawbacks, and suitable scenarios to help developers choose the appropriate approach for different backend workloads.
This comprehensive guide explains what Nginx is, its advantages, typical use cases, request handling, high‑concurrency architecture, proxy types, directory layout, key configuration directives, virtual host setup, load‑balancing algorithms, rate‑limiting, static‑dynamic separation, gzip compression, health checks, and practical code examples for production deployments.
The guide details Go performance optimization techniques—including avoiding reflection‑based conversions, using proper capacity hints, preferring strconv over fmt, employing custom binary functions, optimizing string handling, struct layout, loop patterns, and sync.Pool reuse—backed by benchmarks that demonstrate significant speed and memory gains.
This article explores several methods for creating PHP extensions—including native C, Zephir, php-cpp, php-x, and CGO—provides sample code, describes compilation steps, and compares their execution speed using a Fibonacci benchmark with and without PHP JIT.
This article curates recent front‑end developments, covering emerging frameworks like Pinia, evolving Node.js web standards, low‑code engine open‑source releases, architectural insights, Puppeteer PDF performance tricks, and sandbox security, while also inviting developers to join the Cloud Academy front‑end team.
This article details practical Elasticsearch tuning steps—adjusting index buffers, thread pools, refresh intervals, and translog settings—to raise average write speed from 3,000 to 8,000 documents per second and maintain stability under load.
This article explains how NanoID, a compact and faster alternative to UUID, offers better security, smaller size, higher performance, and broad language support, while also discussing its limitations and future prospects for unique identifier generation in software development.
This article compares NanoID and UUID, highlighting NanoID's smaller size, higher security, faster generation speed, language support, and flexibility, while also discussing its limitations and future prospects, to help developers decide when to choose NanoID over UUID.
This article compiles essential MySQL interview topics, covering normal forms, privilege tables, ACID properties, SQL statement categories, sharding, deadlocks, isolation anomalies, view characteristics, statement lifecycle, primary key choices, CPU troubleshooting, replication, GTID, backup tools, and backup planning strategies.
Go 1.18 introduces generics, built‑in fuzzing, compiler enhancements, new ports, and up to 20% performance gains across several architectures, while also outlining experimental packages and known generic limitations for developers to consider.
This article explains how Linux zero‑copy mechanisms such as DMA, sendfile, mmap and Direct I/O reduce data copies and context switches, detailing their operation, advantages, limitations, and real‑world usage in systems like Kafka and MySQL.
This article walks through generating a 10‑million‑row MySQL table, inserting data with a fast batch script, measuring plain LIMIT pagination performance, and applying several optimization techniques—including sub‑queries, ID‑range filtering, and column selection—to dramatically reduce query time on large data sets.
This article compares NanoID and UUID, showing how NanoID’s smaller size, higher performance, stronger security, language support, and custom alphabet features make it a compelling alternative for generating unique identifiers in modern software development.
This article explains the causes of Android ANR, details the input dispatching mechanism, presents key code paths in InputDispatcher, and provides a step‑by‑step analysis workflow—including system‑level factors, stack inspection, Binder problems, and memory‑related pitfalls—to help developers diagnose and resolve most ANR cases.
This article outlines seven fundamental aspects of distributed storage—replication, storage engine, transactions, analysis, multi‑core processing, computation, and compilation—explaining their roles, challenges, and design considerations for building scalable, reliable, and high‑performance storage systems.
This article analyzes a production incident where massive OFFSET values in MySQL pagination caused severe query slowdown, demonstrates the problem with simulated data, benchmarks the impact, and presents three practical solutions—including index‑covering subqueries, remembering the last primary key, and limiting offset size—to dramatically improve performance and protect the database.
PayPal’s engineering team detailed their journey of scaling Kubernetes from a few hundred nodes to over 4,000 nodes and 200,000 pods, describing the cluster topology, workload generation, bottlenecks in the API server, controller manager, scheduler, and etcd, and the optimizations that enabled stable performance at massive scale.
Texture compression dramatically reduces memory and CPU decode costs while allowing GPUs to read data directly, making formats such as ETC1/2, ASTC, PVRTC and S3TC essential for WebGL and mobile game graphics, though developers must manage lossy quality, size constraints, and platform support.
The article describes how the Zhaunzhuan app backend team replaced a hard‑coded Map‑based routing configuration with a rule‑driven Aviator expression engine, detailing the problem analysis, engine selection, architectural redesign, code changes, a deployment incident, and the resulting improvements in flexibility, maintainability, and performance.
This article explains the concept of lazy initialization in Python, reviews the @property decorator, and provides two complete implementations—a descriptor class and a decorator function—to create lazy properties that compute a value only once and then cache it for subsequent accesses.
To reduce pod startup delays caused by slow image downloads, this article explains Kubernetes image pull policies, the impact of image size, network transfer, and caching strategies such as using smaller base images, docker‑slim, pre‑pulling via DaemonSets, and the cluster’s garbage‑collection thresholds.
This article explains how a SaaS client for enterprise customers tackled stability, security, and latency challenges on low‑end PCs by redesigning its architecture, introducing proactive resource monitoring, multi‑process isolation, and a plug‑in system to enable scalable, customizable performance improvements.
This guide explains Linux performance optimization by defining key metrics such as throughput and latency, describing how to interpret average load, and detailing step‑by‑step usage of tools like vmstat, pidstat, perf, and dstat to diagnose CPU, memory, I/O, and context‑switch bottlenecks.
Community testing of StarRocks 2.0 revealed that, across multiple benchmarks—including low‑cardinality queries, SSB workloads, and high‑concurrency scenarios—StarRocks consistently outperformed ClickHouse and Druid, delivering performance gains ranging from 2‑3× to over 7×.
This article provides a comprehensive tutorial on Vite, explaining its core principles, architecture, and practical implementation, while detailing a step‑by‑step migration from Webpack—including handling JSX, aliasing, module resolution, CSS, HMR, and performance improvements—complete with code snippets and real‑world challenges.
This article explains how a graphics‑grammar‑based chart library called ChartSpace was ported to Flutter by recording Web canvas commands in a mock canvas, replaying them on Flutter's canvas, handling touch interaction conversion, and optimizing performance, while sharing the challenges and solutions encountered.
The Go‑based GDP Streaming RPC framework extends Baidu’s internal brpc‑compatible RPC system with a high‑performance streaming transport that preserves message order, supports multiple concurrent streams per socket, offers customizable serialization and event‑driven handlers, and enables efficient large‑scale data transfers such as voice or replica synchronization, achieving comparable latency and throughput to the original C++ implementation.
This article outlines ten frequent Java concurrency pitfalls—including unsafe SimpleDateFormat usage, double‑checked locking flaws, volatile limitations, deadlocks, HashMap memory leaks, thread‑pool misuse, @Async traps, spin‑lock inefficiencies, and ThreadLocal memory leaks—providing explanations, code examples, and practical solutions for each.
This article introduces the fundamentals of 2D drawing on the web using SVG, Canvas, and WebGL, compares their strengths, demonstrates code examples for shapes and paths, explains event handling and picking methods, and provides practical performance optimization strategies for rendering and interaction.
Under Jason Donenfeld’s leadership, Linux kernel’s random number generator was overhauled in versions 5.17 and 5.18, replacing SHA1 with BLAKE2s and shifting from per‑NUMA to per‑CPU structures, delivering up to a 131% speed increase and an astonishing 8450% boost in getrandom() performance on multi‑core systems.
This article explains various cache layers—from browser and client caches to CDN, reverse‑proxy, local (disk, CPU, application) and distributed caches—detailing their mechanisms, use cases, common strategies, hit‑rate monitoring, and typical challenges such as penetration, breakdown, avalanche, and consistency.
The article demonstrates that MySQL queries using LIMIT with a large offset cause heavy random I/O by scanning many rows, and shows how rewriting the query with a sub‑query that selects only primary keys dramatically reduces execution time from seconds to milliseconds.
This article outlines a comprehensive process for diagnosing and optimizing business system performance problems, covering analysis workflows, influencing factors such as hardware, software, database and middleware, JVM tuning, code inefficiencies, and the use of monitoring and APM tools to improve system reliability.
