This article explains Redis's two persistence mechanisms—Append Only File (AOF) and RDB snapshots—detailing their operation, advantages, risks, write‑back strategies, rewrite process, and how to choose the appropriate method for performance and reliability requirements.
This article explains essential SQL concepts and common pitfalls—such as overusing SELECT *, choosing appropriate data types, respecting column order, handling NULL differences, leveraging database processing, using connection pools, and applying batch operations—to help developers write efficient, cost‑effective queries and advance their careers.
The article explores how a developer generated billions of if‑statements in C to decide odd or even for 32‑bit numbers, scaling the approach with Python‑generated code, custom assembly, memory‑mapped binaries, and discusses the practical limits and performance of such an extreme solution.
This article introduces a Vue 3 GridList component that supports responsive grid layouts, server‑side pagination via a request function, and virtual scrolling to render only visible items, providing performance improvements for large data sets while offering clear usage examples and full source code.
The article explains why counting rows in large MySQL tables—especially with InnoDB—can become slow, compares COUNT() performance across storage engines and query forms, and offers optimization tactics such as using metadata counts, EXPLAIN estimates, a dedicated counting table, or periodic batch processing for accurate or approximate results.
This guide walks you through checking CPU usage, system load, process resources, tracing problematic processes, reviewing system logs, and using performance tools like perf to pinpoint and resolve Linux server bottlenecks.
This article benchmarks several Rust web frameworks—including Actix, Axum, Rocket, Tide, Gotham, Nickel, Ntex, and Poem—using a simple "Hello World" test on a MacBook Pro, measuring request throughput, resource usage, and implementation difficulty across different concurrency levels.
The upcoming CPython 3.13 release will optionally include a JIT compiler built on LLVM, offering modest speed gains of 2%‑9% today and promising larger improvements in future versions through advanced optimization techniques.
This article introduces EasyExcel, a Java library that simplifies high‑performance Excel read/write operations, explains its core concepts, provides practical code examples for reading, writing, and filling Excel files, and discusses performance‑optimizing techniques and important usage considerations.
Nvidia's RTX 5880 Ada, a China‑specific GPU built on a trimmed AD102 chip, offers 14,080 CUDA cores, 48 GB ECC GDDR6 memory, and an estimated 69.3 TFLOPS performance, positioning it between the RTX 6000 Ada and RTX 5000 Ada while complying with U.S. export limits.
This guide explores ten practical Redis scenarios—including login authentication, counters, fan following, leaderboards, anti‑scraping, message queues, browser history, distributed locks, user sign‑in tracking, and website UV statistics—showcasing commands and patterns to boost performance in real‑world applications.
This article examines the evolution of Ant Design's theming—from the less‑based Antd 4.x approach to the CSS‑in‑JS design‑token system in Antd 5.x—analyzes the performance trade‑offs of CSS‑in‑JS, and presents the official antd‑style solution for high‑performance, extensible, and compatible style overrides.
Redis is an open‑source, in‑memory NoSQL database that provides ultra‑fast key‑value storage, rich data structures, persistence, clustering and extensible modules, making it the preferred distributed cache over Memcached, which lacks these features and is now rarely chosen for new projects.
This article introduces mica-http, a lightweight Fluent‑style HTTP client built on OkHttp, walks through dependency setup, synchronous and asynchronous usage, global logging, custom client and cookie management, presents performance benchmarks, and highlights its automatic resource handling for safe, high‑performance requests.
This article explains what MySQL general tablespaces are, outlines their main features and benefits, provides step‑by‑step commands for creating, managing, and assigning tables to them, and shows monitoring queries and practical usage scenarios for improved storage efficiency and performance.
This article introduces the Go WorkQueue project, detailing its motivation, overall architecture, layered design of Queue, Simple Queue, Delaying Queue, Priority Queue, and RateLimiting Queue, compares underlying data structures such as DoubleLinkedList versus slice, presents performance benchmarks, and explains memory‑fragmentation mitigation using sync.Pool.
The article explains how combining traditional monitoring with modern observability, supported by data quality practices and unified workflows, enables more reliable, scalable, and insightful application performance management in agile and cloud‑native environments.
This article presents practical Python performance‑boosting techniques, covering fundamental optimization principles, avoiding global variables and unnecessary attribute access, reducing data copying, improving loop structures, leveraging short‑circuit logic, using numba JIT compilation, and selecting appropriate built‑in data structures to achieve significant speed gains.
This article explains the PHP count() and sizeof() functions, clarifying that they are aliases with identical behavior, showing basic usage examples, discussing when to prefer one over the other, and offering performance notes, recursive counting, and object handling tips for developers.
This article explains how to configure Guava Cache with expiration and refresh policies, analyzes its thread model under high concurrency, and presents two implementation approaches for asynchronous refresh combined with multi‑level caching to achieve low latency and reduced GC overhead.
This article explains the 1 Billion Row Challenge (1BRC) for Java 21, detailing the data format, required output, how to build and run the benchmark, optimization options, submission rules, and the evaluation environment used to rank participants.
The article shows how to write high‑performance Go code by spotting bottlenecks, using go‑test benchmarks and pprof profiling, and applying optimizations such as avoiding reflection, preferring strong‑type conversions, selecting appropriate map implementations, zero‑allocation string/slice tricks, efficient loops, generics, stack allocation, data alignment, pre‑allocation, and suitable lock primitives.
This article introduces ClickHouse, an open‑source columnar OLAP database, outlines its architecture, advantages, self‑hosted and cloud deployment models, highlights recent product features such as async inserts, JSON support, Parquet acceleration, query caching, and summarizes a Q&A covering semi‑structured data, MPP, virtual columns, and future roadmap.
This article walks through a real‑world performance overhaul of Apache HttpClient—using a singleton client, connection pooling, a custom keep‑alive strategy, timeout tuning, and idle‑connection monitoring—to reduce average request time from 250 ms to about 80 ms for a high‑throughput service.
This article compares placing a try‑catch block inside versus outside a Java for‑loop, showing concrete code examples, execution results, memory‑usage measurements, and practical recommendations based on how exceptions affect loop termination and performance.
This article examines the causes of slow startup in large Spring applications, presents visual analysis techniques and a toolbox—including Arthas, JVM Sandbox, Async Profiler, and Spring Startup Analyzer—and provides concrete installation, configuration, and optimization procedures that can reduce startup time by 70‑80% while improving development efficiency and resource utilization.
To achieve fast bulk inserts in MyBatis, open a session with ExecutorType.BATCH and insert records individually (letting JDBC batch them), limit foreach‑generated statements to about 20‑50 rows, or use MyBatis dynamic‑SQL or plain JDBC batch, avoiding massive SQL parsing and CPU overload.
This article explains how MySQL indexes work, compares clustered and non‑clustered indexes, outlines their advantages and disadvantages, and provides practical design guidelines to improve query performance and maintainability.
This guide explains how to install and use Reli, a PHP‑written sampling profiler and VM state inspector, to detect bottlenecks, trace execution, locate memory issues, and generate flamegraphs for PHP processes without modifying the target program.
This article explains how to estimate capacity, choose appropriate garbage collectors, and configure JVM memory settings—including heap size, young generation, thread stack, and GC options—for a service that processes one million login requests per day on a node with 8 GB of RAM, providing step‑by‑step guidance and example command lines.
This article presents a detailed overview of Python testing tools—including requests, unittest, pytest, mocking libraries, performance measurement plugins, and data generation utilities—illustrating how to write, run, and validate API tests with code examples and best‑practice explanations.
This guide presents a comprehensive set of MySQL conventions—including engine choice, character set, naming, table and column design, indexing, and SQL usage—tailored for high‑concurrency, large‑scale internet services, explaining the rationale behind each rule to boost performance and maintainability.
This article details the background, pain points, and step‑by‑step technical solution behind refactoring a massive 670,000‑line, 46‑module ticketing application at Alibaba, highlighting architecture redesign, code simplification, performance gains, and a pragmatic rollout plan.
This article explains why using NULL columns in MySQL can lead to extra storage, index complications, query errors, and performance degradation, and provides concrete reasons and code examples showing how to replace NULL with meaningful defaults for more reliable database design.
This article explains how to monitor, interpret, and optimize Java Garbage Collection by using JDK flags, IDE configurations, and the gceasy.io visualizer, providing step‑by‑step guidance, sample logs, and performance metrics for effective JVM tuning.
This article presents four practical Python performance tricks—list reversal, variable swapping, in‑function looping, and reducing function calls—demonstrating how each can shave 10‑20% off execution time with clear code examples and timing benchmarks.
Facing heavy load times on the Feitian Service Platform’s customizable homepage, the team applied a three‑stage front‑end performance overhaul—shrinking resources, prioritizing critical paths with progressive loading, and leveraging caching via SWR and Service Workers—resulting in sub‑second page renders and a smoother user experience.
This article walks through a real‑world sales‑ranking scenario, explains why a simple SQL solution falls short at scale, and demonstrates how Redis Set and ZSet data structures provide high‑performance, real‑time ranking, including detailed command examples, performance metrics, and an in‑depth look at ZSet's internal listpack and skiplist‑dict implementations.
This article explains what Redis hot keys are, the scenarios that generate them, their risks, and provides practical monitoring methods and mitigation strategies—including cache pre‑warming, distributed caching, rate limiting, and secondary caches—to keep production systems stable.
A recent e‑commerce incident caused the home page to take 20 seconds to load due to a Redis memory overload, and the team resolved it by expanding memory, redesigning data structures, and implementing a layered caching strategy with local cache, MongoDB, and fallback mechanisms.
This article presents REDTao, Xiaohongshu's self‑built graph storage solution that unifies graph queries, reduces development duplication, and delivers low‑latency, high‑availability access to a trillion‑scale social graph through a three‑layer architecture, distributed cache, and cloud‑native deployment.
This article explains how Spring's @Transactional(readOnly = true) works internally, shows the performance and memory advantages it brings, compares service‑layer and repository‑layer usage with concrete connection‑pool tests, and provides guidance on when to apply it in JPA‑based backend applications.
This article explains a three‑step method—using top to locate the CPU‑hungry Java process, identifying the offending thread, and printing its stack with jstack—to pinpoint and resolve excessive CPU consumption in a Java application running on Linux.
This article explains how to improve PHP application performance by creating a reusable DataCache class that stores API results, demonstrates usage with a weather‑API example, shows code for reading, saving, and expiring cached data, and discusses production considerations such as concurrency, large data handling, security, and cleanup.
The guide shows how to use Next.js 13’s server‑side rendering with TypeScript and Tailwind CSS to generate fully rendered HTML for better SEO, recommending direct output of key content, native anchor tags for navigation, proper TDK, robots.txt, sitemap.xml, async components, CDN asset prefixes, optimized Tailwind utilities, and careful image handling.
This article compares Elasticsearch's ngram analyzer and the newer wildcard field for fuzzy searching, detailing configuration steps, performance trade‑offs, storage impact, and practical test results to help engineers choose the optimal approach for their use case.
This article explains how to boost PHP application performance by using caching functions, efficient array functions, selective database queries, and recursive functions, providing clear code examples for each technique.
This article explains how to implement file caching and effective memory management in PHP, providing step‑by‑step instructions and code examples for creating cache directories, generating cache filenames, checking and clearing caches, and releasing variables and objects to prevent memory leaks.
This article explains how to improve PHP web application performance by removing unnecessary whitespace and semicolons, leveraging caching, and using built‑in functions such as isset, empty, and count, with concrete code examples for each technique.
This article reviews recent decades of CPU performance improvements and semiconductor process advances, explains current CPU architectures, instruction set evolution, and how these trends influence software development practices, including parallelism, SIMD, multithreading, and power‑efficiency considerations.
The article explains Android jank, defines Google and PerfDog metrics, identifies direct and indirect causes, recommends profiling tools such as Systrace, Perfetto and APM, and details a Wesing case study where breaking tasks, lazy loading, view‑hierarchy reduction and thread off‑loading cut PerfDog jank by roughly half, concluding with a checklist for systematic detection and mitigation.
This article explains how to enable and use the OpenJDK CRaC project with SpringBoot 3.2, covering prerequisites, dependency setup, automatic and manual checkpoint creation, and demonstrates significant startup‑time reductions through detailed examples and performance results.
This article benchmarks the cost of instantiating a new ObjectMapper for each JSON conversion in a SpringBoot project, demonstrates a singleton implementation that boosts read performance by 18× and write performance by up to 300×, and shows how to add custom serializers without sacrificing speed.
Cloudflare's top architects explain why they replaced Nginx with the Rust‑based Pingora proxy, detailing architectural limits of Nginx, design decisions, performance gains, resource efficiency, and new capabilities that make Pingora faster, more efficient, and safer for massive internet traffic.
The guide outlines production‑ready Elasticsearch best practices, covering query tuning such as using shard request cache, filter context, size‑0 aggregations and composite aggregations; write strategies like auto‑generated IDs, bulk API sizing and refresh handling; optimal shard counts, explicit mappings with disabled unnecessary features, and general advice to use explicit index names and stored scripts.
This article presents a collection of seemingly humorous or "wrong" MySQL interview answers, explains why they can be insightful, and provides practical guidance on slow‑query optimization, disaster‑recovery planning, replica lag, insecure configuration, and handling massive schema changes.
This article presents thirteen practical Redis performance‑optimization rules, covering avoidance of slow commands, proper key expiration handling, data‑structure selection, persistence tuning, hardware considerations, pipeline usage, client‑side improvements, and distributed architectures such as replication, sentinel and Redis Cluster, to help developers achieve significant speed gains.
This guide explains common cache problems such as penetration, avalanche, breakdown, data inconsistency, and concurrent access, and provides practical solutions like Bloom filters, multi‑level caching, random expiration, distributed locks, and transaction mechanisms to keep systems stable and performant.
This article details how Tencent Docs implements a flexible architecture that can switch between monolithic and microservice deployments, describing the motivations, such as framework diversity, configuration conflicts, global variable management, hidden bugs, the custom 'monolith' tool with its configuration format, and the resulting performance and resource savings.
This article explains how Kafka’s design uses the operating system’s page cache and sequential disk writes to achieve fast, reliable persistence, debunking the myth that disk I/O is inherently slow and outlining practical configuration tips.
The article introduces the second version of phpy, a PHP extension that embeds a Python interpreter, explains its dual‑VM runtime architecture, shows how to use it under PHP‑FPM, presents detailed performance benchmarks, covers exception handling, IDE auto‑completion, compilation options, dynamic‑library troubleshooting, and provides numerous code examples for testing and scientific computing.
This article explains how PHP developers can improve network communication efficiency and overall application performance by using output buffering, GZIP compression, HTTP caching headers, and asynchronous curl_multi functions for concurrent requests.
This article investigates the Android 5‑6 RenderThread native crash caused by a missing EGL surface when TextureView.getBitmap is called before ThreadedRender initialization, analyzes the root cause through code inspection and runtime logs, and presents a bytecode‑instrumentation fix that dramatically reduces the crash rate.
This article details how SelectDB’s inverted‑index, Variant data type, and sampling capabilities were integrated into GuanceDB to replace Elasticsearch, achieving up to 70% storage cost reduction, 2‑4× query speed improvement, and a ten‑fold overall cost‑performance boost for log analytics and observability workloads.
This article introduces MyBatis‑Flex, a lightweight and high‑performance MyBatis enhancement framework, outlines its key features, compares it with similar tools, presents benchmark results, lists supported databases, and provides a step‑by‑step quick‑start tutorial with complete code examples for Spring Boot integration.
This article explains MySQL index types, B+Tree structures, secondary indexes, and demonstrates how enabling Index Condition Pushdown (ICP) can accelerate a query on a 6‑million‑row table by roughly ninety times, providing detailed setup, commands, and performance results.
Python automatically manages memory through garbage collection, and this article explains how the garbage collector works and presents ten practical techniques—including manual gc calls, generators, sys.getsizeof, slice copying, del statements, sys.intern, NumPy, pandas, reference counting, and __slots__—to reduce memory usage and improve performance.
This article explains the concept of AI Agents in the large‑language‑model era, details LangChain's implementation mechanics, shares practical challenges and optimizations encountered by NetEase Cloud Music, and provides step‑by‑step code examples and performance insights for building robust AI Agents.
This article explains how to improve PHP logging performance by controlling log levels, batching writes, using asynchronous processes, and implementing log rotation, providing clear code examples for each technique in real-world PHP applications.
In a recent interview with a listed game company, the author explores why microservice architectures, despite their popularity for scalable web applications, often clash with the low‑latency, state‑heavy requirements of real‑time game servers, highlighting technical and team‑size considerations.
This article compares Go and Rust across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers decide which language best fits their specific project requirements in 2024.
This article introduces six practical techniques—including profiling with timeit, memory and line profilers, using built‑in functions, f‑strings, list comprehensions, and lru_cache—as well as algorithm and data‑structure choices to help Python developers significantly boost the execution speed of their code.
The article explains PHP 8.0's end‑of‑life, presents usage statistics, highlights the risks of staying on older versions, and details the new features and improvements in PHP 8.3, urging developers to upgrade promptly for security, compatibility, and performance benefits.
A seasoned Java engineer shares his journey transitioning to Rust, highlighting Rust’s advantages for CLI tools, superior resource utilization, easier concurrency and async programming, while also acknowledging Java’s strengths in rapid feature delivery, mature ecosystem, and ease of learning, and discussing practical migration considerations.
The article investigates whether the long‑standing rule of avoiding MySQL tables larger than 20 million rows still holds on modern SSD‑backed instances by creating tables of varying sizes, measuring query latency under different InnoDB buffer pool configurations, and analyzing the impact of caching and index usage.
This article introduces ten practical Python decorators—including @timer, @memoize, @validate_input, @log_results, @suppress_errors, @validate_output, @retry, @visualize_results, @debug, and @deprecated—explaining their purpose, showing full code implementations, and demonstrating how they can improve performance, reliability, and maintainability of data‑science and general Python projects.
An in‑depth analysis shows that MySQL’s early Windows support, lower entry barrier, strong LAMP ecosystem, backing from major Chinese tech firms, and a mature tooling landscape together explain why it remains far more popular than PostgreSQL across China despite global growth trends.
This article dissects the end‑to‑end technical workflow of sending a customer‑service IM message, covering reliability, real‑time delivery, ordering, idempotency, performance bottlenecks, async handling, requestAnimationFrame, protobuf migration, and user‑experience optimizations, while sharing concrete metrics and real‑world solutions.
2023 saw rapid evolution in the front‑end ecosystem, highlighted by major events, a controversial Gemini AI demo, SkyWalking‑based performance and error monitoring, innovative text‑overflow handling, CSS techniques that boost long‑list rendering by up to seven times, and an automatic, non‑intrusive skeleton‑screen generation solution.
This guide helps Android audio developers understand and eliminate stutter, pop noise, and other glitches by examining audio formats, pipeline components, CPU scheduling, common failure cases, and offering concrete optimization steps such as proper thread priorities, reduced API blocking, and efficient frame‑count configuration.
This article explains how positioning a try‑catch block either inside or outside a Java for loop changes exception handling behavior, performance impact, and when to choose each approach based on business requirements.
This article demonstrates how to enable and use Coordinated Restore at Checkpoint (CRaC) in Spring Boot 3.2 with the Spring Petclinic example, covering required dependencies, JVM setup, automatic and manual checkpoint creation, performance measurements, and best‑practice considerations for backend developers.
Switching a Java Netty gateway from GZIP to ZSTD compression using zstd‑jni doubled GC time and introduced heap and Netty off‑heap memory leaks, which were resolved by employing the library’s direct off‑heap API with a NoFinalizer compressor, promptly releasing ByteBufs, avoiding finalize(), and adopting jemalloc to reduce fragmentation.
The Pika community announced version 3.5.2, fixing long‑standing bugs and adding features such as Redis transaction support, a cache layer for hot‑cold data separation, dynamic Codis‑Proxy configuration, and performance improvements, while also outlining the planned enhancements for the upcoming 3.5.3 release.
A detailed investigation of an Elasticsearch timeout incident reveals how an overly aggressive node_concurrent_recoveries setting caused CPU saturation, disk I/O spikes, and shard relocation overload, and outlines the steps taken to isolate the faulty node and restore cluster performance.
This article analyzes the current store system issues, outlines various refactoring types and their difficulties, presents common efficiency measures, and details testing schemes for both unchanged‑business and changed‑business refactoring cases, highlighting objectives, challenges, processes, and overall effectiveness.
This article explains how to reduce the double loading of order‑detail pages in a Huolala mini‑program by pre‑fetching API data using the preload‑js library, detailing implementation steps, caching strategies, and advanced goals such as dependency tracking and offline persistence.
The article explains why iterating a two‑dimensional array by rows runs dramatically faster than by columns, covering memory‑hierarchy basics, locality principles, cache behavior, cache‑line mechanics, and Linux perf measurements that reveal a 20‑fold speed gap caused by cache‑miss rates.
This article explains how HotSpot's C1 and C2 JIT compiler threads work, why they can consume excessive CPU, and provides practical JVM tuning options—including tiered compilation, code‑cache sizing, and compiler‑thread adjustments—to mitigate performance issues.
This article walks through a production incident where a Redis Cluster pipeline caused Dubbo threads to block and eventually deadlock, detailing the root‑cause analysis, code inspection, and verification steps using jstack, jmap, and MAT to confirm the deadlock and propose fixes.
MoonBit is a new open‑source programming language from China that delivers tiny WebAssembly binaries, high runtime speed, advanced compile‑time performance, and a modern toolchain, while sparking community debate over adding Chinese keywords to its syntax.
This article examines several drawbacks of the Spring framework—including performance overhead from reflection and proxies, complex configuration, steep learning curve, over‑reliance on the Spring ecosystem, hidden “magic” features, version compatibility challenges, and misuse of dependency injection—illustrated with Java code examples.
This article explains the recent correction in Alibaba's developer manual that replaces the ambiguous "expansion count" of HashMap with the precise "resize count", details the conditions under which HashMap triggers resize during the first put operation, and shows why storing 1024 elements in JDK 1.8 results in eight resize calls.
This article explains how a large‑scale recommendation system built with tRPC‑Go microservices was refactored into a single‑process monolith to cut network overhead, reduce CPU usage by over 60%, and retain the benefits of microservice development while minimizing code changes.
This article explains how to create, compile, and integrate a Rust‑based WebAssembly component for accelerating 3D model vertex merging in the browser, covering tool installation, code examples, data transfer techniques, performance tuning with hashing, and compatibility adjustments for both webpack and Vite.
The article explains how Cloudflare built the Rust‑based Pingora reverse proxy to overcome Nginx's architectural limits, achieve higher performance, better connection reuse, lower CPU/memory usage, and stronger safety, while supporting new features for its edge platform.
This article demonstrates how Spring Boot 3.2 leverages the OpenJDK CRaC project to dramatically cut application startup time, covering required JVM, dependencies, Zulu JDK setup, automatic and manual checkpoint creation, performance benchmarks, and restoration steps, all using the Petclinic example.
This article examines Java string concatenation performance, comparing the '+' operator and StringBuilder in both simple and loop scenarios, presenting JUnit benchmark results, bytecode analysis, and concluding that '+' is sufficient for single concatenations while StringBuilder excels in loops.
The newly released Loongson 3A6000 processor, built on the domestically designed LoongArch instruction set, delivers performance comparable to Intel's 10th‑gen i3‑10100F, features four high‑performance cores, advanced vector extensions, DDR4‑3200 memory support, and a secure trusted module, marking a major milestone for China's independent CPU development.
This article presents a comprehensive set of techniques—including lazy initialization, deferred database connections, selective auto‑configuration, logging level tuning, JVM parameter tweaks, dependency pruning, bean optimization, JIT settings, class‑path scanning reduction, and DevTools restart—to significantly shorten Spring Boot application startup time, each illustrated with clear code examples.
