This article explains why MyBatis-Plus saveBatch does not perform true batch inserts, shows how to enable JDBC rewriteBatchedStatements, creates a custom SQL injector with InsertBatchSomeColumn, implements batch splitting in a service layer, and presents benchmark results that demonstrate a several‑second speedup for inserting tens of thousands of rows.
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.
The article investigates IntelliJ IDEA's suggestion to replace StringBuilder with the '+' operator, showing that for simple concatenations the compiled code is identical and performance comparable, while in loops '+' becomes inefficient and StringBuilder remains preferable.
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 dissects Java's HashMap by first explaining the collection framework's design goals—generality, scalability, performance, interoperability, readability, and thread safety—then walks through the core source code of HashMap (hash, put, resize, get, remove, treeify, etc.), illustrates LRU cache implementation, and finally offers practical usage tips, performance considerations, and version‑specific changes up to JDK 9.
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.
This article explains CDN fundamentals, its DNS‑based routing and caching mechanisms, how back‑origin works, when CDN accelerates content delivery, the costs involved, and scenarios where using a CDN may not bring performance benefits.
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 compares Java 8 Streams with traditional for‑loops through concrete code examples, benchmark results, parallel‑stream speedups, and discusses scenarios where Streams excel or fall short, helping developers decide when to prefer Streams over loops.
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.
This article evaluates the startup speed, memory consumption, and request‑handling performance of a simple Spring Boot "Hello World" service when run on the traditional JVM compared with a GraalVM‑compiled native binary, using a MacBook M1 and Bombardier for load testing.
The article details a step‑by‑step investigation and optimization of a Java backend service that initially delivered only 50 requests per second under load, covering profiling, slow‑SQL fixes, thread‑pool tuning, JVM memory adjustments, and Spring bean creation overhead to approach the target 500 req/s.
This article examines Baidu Search's content storage team's HTAP table storage system, detailing the challenges of supporting massive OLAP workloads on an OLTP‑oriented backend, the architectural split into Neptune and Saturn, storage‑engine optimizations such as row partitioning and dynamic columns, and a SQL‑like KQL framework for compute and scheduling.
This article presents advanced Next.js techniques—including dynamic imports, CDN asset publishing, server‑side caching, Incremental Static Regeneration, and custom server integration for WebSockets—to help developers build faster, more scalable, and performance‑optimized web applications.
The article explains CPU overclocking, covering its feasibility, required high‑quality motherboard, memory and cooling, the relationship between external frequency, multiplier and core speed, and the potential hazards such as increased heat, system instability, reduced component lifespan, and voltage considerations.
This article provides a comprehensive overview of Redis, covering its architecture, key features, data types, caching use cases, common pitfalls such as consistency, avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence options, replication, and Sentinel high‑availability mechanisms.
This article experimentally compares the performance of JOIN and IN approaches for retrieving order and user data in MySQL, showing that JOIN is faster on small datasets while IN may become costly with large data volumes, and discusses code implementations and practical conclusions.
This article explains how Apache Paimon simplifies CDC data lake ingestion with one‑click, low‑cost, low‑latency pipelines, details its architecture and tag‑based Hive compatibility, provides best‑practice configurations, and presents benchmark results showing Paimon outperforming Hive and Hudi in both write and query performance.
A ToB system that seemed able to handle 500 requests per second stalled at 50 req/s due to hidden lock contention in prototype‑scoped Spring beans, slow SQL updates, excessive logging, and thread‑pool misconfiguration, prompting a step‑by‑step performance investigation and multiple optimizations.
This article evaluates the execution time and bytecode differences of simple and looped string concatenation in Java, comparing the '+' operator with explicit StringBuilder usage, and concludes that '+' is fine for single concatenations while StringBuilder dramatically outperforms '+' in iterative scenarios.
To import one billion 1 KB log records into MySQL efficiently, the article examines data size constraints, B‑tree index limits, batch insertion strategies, storage engine choices, file‑reading techniques, task coordination with Redis, Redisson semaphores, and distributed lock handling to ensure ordered, reliable, high‑throughput loading.
PHP 8.3 introduces a JIT compiler, enhanced array and string handling, OPcache improvements, and Match expressions, delivering significant performance gains and offering optimization strategies while highlighting common pitfalls to ensure efficient, maintainable backend development.
GaiaDB, Baidu’s cloud‑native database, combines compute‑storage separation with a fused, log‑service architecture to boost performance, simplify consistency, and deliver multi‑level high availability across zones and regions, while supporting new features such as parallel query, HTAP replicas, and serverless scaling.
An empirical study compares Java string concatenation using the '+' operator versus StringBuilder, showing that for simple concatenations '+' is equally efficient and more concise, while in loops '+' incurs significant overhead, making StringBuilder the preferred choice for iterative concatenation.
A developer shares insights from a game company interview, explaining why microservice architectures often clash with the low‑latency, state‑heavy requirements of real‑time multiplayer games and when they might still be appropriate.
This article compares MySQL and MongoDB, outlining their core concepts, shared features such as open‑source licensing and indexing, and key differences in data model, scalability, performance, flexibility, and security, while summarizing pros and cons and recommending suitable application scenarios for each database.
This article examines how YouTube achieved massive scalability using a simple tech stack, a "flywheel" process, strategic outsourcing, caching layers, and three core pillars—statelessness, replication, and partitioning—while keeping the engineering team lean and adaptable.
This article walks through the limitations of Java's Future, introduces CompletableFuture's richer asynchronous API, and demonstrates step‑by‑step how to refactor a shop‑detail page using parallel tasks, custom thread pools, and composition patterns to cut response time from seconds to under two.
The team traced read‑request timeouts to a single overloaded Elasticsearch node where an excessively high node_concurrent_recoveries setting caused many simultaneous shard recoveries and disk‑watermark‑driven relocations, and resolved the issue by lowering concurrent recoveries, enabling adaptive replica selection, and adjusting allocation settings.
The article examines whether Docker incurs performance penalties compared to native services, arguing that the decision to adopt containers and micro‑services must weigh business complexity, company stage, team size, infrastructure readiness, and operational costs rather than relying on generic hype.
This article outlines five comprehensive techniques—including database indexing, caching, code refactoring, load balancing, and horizontal scaling—to dramatically improve API response times and reliability, illustrated with practical Java code examples and a real‑world case study.
The article explains how bundling many business‑logic steps into a single large transaction harms API performance, outlines the resulting concurrency, locking, undo‑log, and DB‑pressure issues, and then presents practical techniques—programmatic transactions, batch processing, transaction splitting, and asynchronous parallelism—to optimize and speed up backend services.
An in‑depth, timeline‑driven investigation of a production Redis memory leak revealed that the custom 3.2.8 build’s getKeysInSlot function failed to free a temporary key‑array after traversing the radix‑tree, causing hundreds of megabytes of leaked SDS strings, which was fixed by adding a single free call and highlighted the need for functional code reviews and early leak detection.
RAID combines multiple physical disks into virtual drives, offering various levels—RAID 0, 1, 1ADM, 5, 6, 10, 10ADM, 1E, 50, and 60—each balancing performance, fault tolerance, and capacity, with detailed processing flows, storage calculations, and best‑practice recommendations for optimal deployment.
This article explains why Redis may become slower, covering benchmark testing, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, memory fragmentation, and lazy‑free mechanisms, and provides practical optimization steps.
