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.
This article examines the challenges faced by Volcano Engine's DataLeap in computational governance, outlines automated solutions such as real‑time rule engines and monitoring, and presents concrete performance and cost benefits achieved through resource optimization across large‑scale Spark and Hadoop workloads.
The article defines testability as the precondition for conducting testing at each software lifecycle stage, explains its manifestations during requirements, design, development, and release phases, and illustrates the concept with a performance‑impact example from an e‑commerce order‑detail scenario.
This article explains the principles and practical designs of high‑performance database clusters, covering read/write separation, master‑slave replication lag, distribution mechanisms, sharding (both vertical and horizontal), business‑level partitioning, and the role of NoSQL technologies such as key‑value stores, document databases, columnar databases, and full‑text search engines.
Through a series of local experiments on MySQL tables with varying data volumes, this article analyzes the performance trade‑offs between JOIN queries and IN‑list queries, detailing execution plans, PHP benchmarking, and the impact of large IN lists on query speed and reliability.
This article explains the principle of deadlocks, the four necessary conditions, how they manifest in SQL Server resources, methods for investigating deadlocks with system procedures and Profiler, and practical techniques—including isolation level changes, lock timeouts, and bound sessions—to avoid and resolve them.
This article explains how caching improves website performance by reducing server load and response time, and provides PHP code examples for file‑based, database‑based, and memory‑based caches, guiding developers on selecting the appropriate cache type for their needs.
This article investigates the performance difference between Java's List.sort() and Stream.sorted(), providing simple demos, JMH benchmark results, and analysis of underlying overheads to explain why the native list sorting is generally faster than sorting via streams.
This article presents ten essential best‑practice guidelines for using Java’s Stream API—covering primitive streams, avoiding nested streams, cautious parallelism, lazy evaluation, side‑effect avoidance, immutability, filter‑before‑map, method references, distinct, and sorted—to help developers write more efficient, readable, and reliable functional code.
By instrumenting Java services with JaCoCo’s agent and analyzing runtime coverage data, teams can identify unused (“zombie”) code, safely remove or deactivate it, and consequently reduce maintenance costs, shorten delivery cycles, and improve overall system performance and developer productivity.
This article explains the concept of coroutines as lightweight user‑level threads, compares them with traditional threads, details various implementation mechanisms in C/C++ (including libco and NtyCo), and demonstrates how they improve I/O‑bound server performance through examples and code snippets.
This article explains how to implement cross‑platform caching in PHP using both file‑based storage and Redis, providing complete code examples and detailing the functions involved to ensure compatibility, performance, and proper cache expiration handling.
A real‑world MySQL case study shows how using INSERT INTO SELECT for large data migrations can trigger full‑table scans, lock contention, and massive data loss, emphasizing the need for proper indexing and careful testing before deployment.
This article explains why iterating a Java HashMap with keySet() results in two traversals, detailing the internal iterator creation, the role of KeyIterator and HashIterator classes, and how the do‑while loop in HashIterator’s constructor locates the first entry, with code examples and bytecode analysis.
Python 3.12 introduces enhanced error messages, expanded f‑string capabilities, inline collection optimizations, new buffer protocol support, refined type‑annotation syntax, additional language tweaks, and performance‑focused garbage‑collector changes, providing developers with clearer diagnostics and more expressive, efficient code constructs.
This article explains why caching is essential for web applications, introduces PHP caching options such as APC, Memcache, and Redis, and provides step‑by‑step installation and code examples showing how to implement APC caching to boost speed and protect site security.
This article explains the internal representations of Go strings and byte slices, why converting between them incurs memory allocation and performance overhead, and provides safe and unsafe conversion techniques along with guidance on when to prefer each type.
The article investigates frequent OutOfMemoryError incidents in a distributed Java service, explains heap and metaspace causes, analyzes MyBatis source that retains large SQL strings in memory, reproduces the issue with heavy IN clauses and limited heap, and offers practical mitigation advice.
This article explains what Redis hotkeys are, the performance and replication problems they cause, various techniques for detecting them—including client statistics, MONITOR, the HOTKEYS command, and TCP packet capture—and practical mitigation approaches such as sharding, multi‑level caching, and monitoring optimization.
This article compares Spring Boot and Quarkus across startup time, memory usage, CPU consumption, and response latency, presents benchmark results from JMeter and VisualVM tests, and provides practical guidance for migrating Java developers from Spring to the cloud‑native Quarkus framework.
The 2023 China Linux Storage, Memory Management and File System Workshop, held on October 26‑27 and organized by OPPO, gathered leading Linux kernel developers from firms such as SUSE, Intel, AMD, Huawei and academic institutions to present keynotes and talks on memory reclamation, scalability, storage, BPF, container images, and future kernel innovations, fostering collaborative advancement of Chinese kernel development.
A real‑world case study shows how using INSERT INTO SELECT without proper indexing caused full‑table scans, lock contention, and data loss, ultimately leading to a costly incident and a colleague's dismissal.
Cloudflare abandoned Nginx for its home‑grown Rust‑based proxy Pingora, detailing architectural limits of Nginx, design choices, multithreaded scheduling, connection‑reuse improvements, and how these changes deliver faster, more efficient, and safer traffic handling at massive scale.
This article examines the causes of Java OutOfMemoryError in a distributed backend service, analyzes MyBatis-related memory leaks, demonstrates a reproducible scenario with large SQL concatenations and multithreading, and offers practical mitigation strategies to prevent heap and metaspace overflow.
The article analyzes why a Java API endpoint took eight seconds, demonstrates through benchmarks that List.sort() outperforms Stream.sorted(), shows how sorting on computed columns and using BigDecimal can drastically slow execution, and presents three practical optimizations that reduce the response time to under a second.
This article explains what MySQL master‑slave replication lag is, walks through the replication workflow, identifies the main technical reasons for delay such as single‑threaded replay and lock contention, and provides concrete configuration and architectural solutions to reduce or eliminate the lag.
This article curates recent frontend breakthroughs—including Electron memory tuning, printer integration, efficient file streaming, Chrome 117's SHA‑1 deprecation, native JavaScript array grouping, and continuous user‑experience improvement—offering practical insights for modern web developers.
This article explains the full spectrum of Java locking mechanisms—including pessimistic, optimistic, distributed, reentrant, spin, read/write, fair vs. non‑fair, JVM lock states, and optimization techniques—detailing their principles, use‑cases, SQL/Redis examples, and performance trade‑offs.
The incident showed that Redis hashes encoded as ziplist incur O(N) HEXISTS latency, causing high CPU on hot keys, while hashtable‑encoded hashes remain O(1); adjusting hash‑max‑ziplist settings or redesigning hot‑key patterns can convert to faster, though more memory‑hungry, hashtable encoding.
This article provides a comprehensive guide to front‑end monitoring, covering performance metrics, exception alerts, daily inspections, instrumentation methods, data collection, log storage, and practical code examples for building a robust monitoring system that improves stability, user experience, and business insight.
This article explains how to implement low‑level thread pools and coroutine mechanisms in PHP, providing detailed code examples that demonstrate creating a ThreadPool class, managing worker threads, and using generator‑based coroutines to achieve high‑performance, concurrent execution.
This article explains various PHP caching techniques—including file‑system, memory (Memcache and Redis), and framework (Laravel) caches—providing code examples and configuration steps to reduce database load, speed up page rendering, and enhance overall user experience.
This article investigates whether WebAssembly truly outperforms JavaScript by compiling Rust to wasm and comparing execution times of Fibonacci and convex‑hull algorithms, revealing that data copying and serialization overhead can make wasm slower in realistic front‑end scenarios.
The Didi Android delivery merchant app suffered periodic crashes on Huawei devices because a null‑checked fopen in libpush.so caused an unchecked fwrite, leaking file handles until the per‑process limit was reached, and the issue was resolved by adding proper null checks, closing handles, and instituting systematic FD‑leak monitoring and code‑review safeguards.
This article explains the circumstances under which MySQL creates internal temporary tables, illustrating the behavior with UNION, UNION ALL, GROUP BY, various hints, and additional query patterns, and provides practical examples and execution plans to help developers understand and optimise their queries.
This article examines the benefits and drawbacks of implementing caching in PHP backend development, illustrating how caching can boost page load speed, reduce database load, and improve performance, while also discussing cache expiration, data consistency, and memory usage, accompanied by practical code examples.
This article explains the core principles of virtual scrolling and provides complete React implementations for three types of virtual lists—fixed‑height, variable‑height, and dynamic‑height—using react-window, including detailed code snippets, performance considerations, and optimization suggestions.
This article provides a detailed overview of the latest 2023 trends, tools, libraries, architectural patterns, and best practices for developing modern Android applications, covering everything from Kotlin and Jetpack Compose to Clean Architecture, modularization, performance optimization, and Google Play features.
This article explains how to tune MySQL's InnoDB settings—including buffer pool size, log file configuration, I/O threads, flush behavior, and timeout values—by providing detailed explanations and exact configuration snippets to improve performance and resource usage.
Improving web page load speed is crucial for user experience, and PHP developers can employ methods such as caching, script and stylesheet compression, database query optimization, reducing HTTP requests, using CDNs, output compression, cache plugins, asynchronous loading, and image optimization to significantly enhance performance.
This article explains how Redis implements geospatial indexing with GEOADD and GEORADIUS commands, walks through their source‑code implementations, describes the underlying geohash calculations and nine‑cell grid search strategy, and derives the O(N + log M) time complexity for nearby‑people queries.
The article reports on Zhengcai Cloud's successful migration to Dubbo3.1.8, detailing the motivations, scale of the system, upgrade process, and the resulting performance and stability improvements for its massive procurement platform.
The article examines the scalability limitations of the Linux kernel TCP/IP stack, comparing its packet‑processing and connection‑setup performance with user‑space stacks such as mTCP and F‑Stack, explains how hash‑table locking and spin‑lock contention cause poor CPS scaling, and argues why user‑space implementations often achieve higher throughput despite their own trade‑offs.
This article explains the purpose, recommended settings, and tuning tips for MyISAM‑related MySQL variables such as key_buffer_size, read_buffer_size, read_rnd_buffer_size, bulk_insert_buffer_size, myisam_sort_buffer_size, myisam_max_sort_file_size, myisam_repair_threads, and myisam_recover, helping DBAs optimize indexing and query performance.
This article analyzes the constraints of loading one billion 1 KB log records from distributed storage into MySQL, evaluates single‑table limits, proposes batch‑insert, sharding, storage‑engine, file‑reading, and distributed‑task coordination techniques to achieve high‑speed, ordered, and reliable data ingestion.
A scheduled task system that frequently accesses MySQL and cache crashes at night due to a SIGSEGV in the HotSpot JVM caused by JIT compilation of hotspot code, and the article explains the JVM internals, JIT behavior, and provides configuration and driver downgrade solutions to prevent the failure.
tRPC is a highly extensible, plugin‑driven backend RPC framework designed to unify disparate service stacks, support cloud‑native components, and provide cross‑language, multi‑protocol, and streaming capabilities while delivering strong performance and easy integration for large‑scale enterprises.
This article introduces Numba, explains its parallel, distributed, and GPU acceleration capabilities, and provides detailed Pandas benchmark examples that show how Numba’s JIT compilation dramatically speeds up data‑frame operations compared with default and Cython engines.
This article explains the technical reasons why a MySQL single table should not exceed about 20 million rows, covering limits from auto‑increment primary keys, data‑page structures, B+‑tree storage calculations, and practical partitioning recommendations for large‑scale applications.
This article provides a comprehensive introduction to the Java Virtual Machine, covering its architecture, core principles, services such as garbage collection and security, and real‑world applications ranging from enterprise systems and Android apps to big‑data frameworks and game servers.
The article details Gaode’s journey of building a high‑performance Go ecosystem that scaled from zero to tens of millions of QPS, comparing Go with Java and Erlang, outlining cloud‑native serverless architecture, and sharing real‑world refactoring and optimization case studies such as a million‑QPS rendering gateway and a Go‑based sharding middleware.
This article outlines over ten practical techniques for optimizing Java for‑loops, including caching list size, using reverse iteration, employing iterators, leveraging enhanced for‑each loops, minimizing method calls, and handling exceptions efficiently, helping developers write cleaner and more performant code.
To boost the performance and user experience of WeChat Mini Programs, this guide demonstrates PHP techniques including asynchronous API calls, Redis-based data caching, and image optimization with the GD library, providing practical code examples for faster page loads and smoother interactions.
This article explains the startup process and lifecycle of WeChat mini programs, defines key performance measurement indicators such as launch time, first render time, and first screen load time, and provides detailed optimization techniques to address long startup, page load, and UI lag issues.
This article explains what constitutes a Redis BigKey, why oversized keys degrade performance through data skew, network blocking, slow queries and CPU pressure, and provides practical detection methods, open‑source tooling, and mitigation techniques such as lazy‑free deletion, incremental scans, and key sharding.
WebAssembly (Wasm) is a fast, binary bytecode format that lets browsers execute near‑native code written in languages like C, C++ or Rust, offering superior performance for CPU‑intensive tasks such as games and data processing, and can be integrated into front‑end projects via fetch, instantiateStreaming, and toolchains like Emscripten or wasm‑pack.
The article explains how Cloudflare built Pingora, a Rust‑based, cloud‑native reverse proxy that surpasses NGINX in performance, efficiency, and safety by redesigning the worker model, improving connection reuse, and leveraging multithreading and Tokio, while also offering greater extensibility for future services.
This article explains why Redis, despite being described as single‑threaded, achieves extremely high performance by using a single thread for network I/O and command execution, avoiding multithreading overhead, and leveraging efficient in‑memory data structures together with an event‑driven multiplexing I/O model.
This article explains why and how to use Spring's asynchronous tasks, demonstrates enabling @Async, shows the default SimpleAsyncTaskExecutor behavior, and guides you through customizing a thread pool to improve application throughput and responsiveness.
The article details a step‑by‑step investigation of a Java Spring backend that initially achieved only 50 req/s under load, identifies bottlenecks such as slow SQL, excessive logging, thread‑pool misconfiguration and costly Spring bean creation, and demonstrates how targeted optimizations roughly doubled throughput while reducing response times.
This article presents ten practical tips for using the Java Stream API effectively, covering primitive streams for performance, avoiding nested streams, careful use of parallel streams, lazy evaluation, side‑effect avoidance, immutability, proper ordering of filter and map, method references, distinct, and sorted operations, each illustrated with concise code examples.
The article details a week‑long investigation of a sandbox environment where Spring Boot APIs became unresponsive due to Redis connection pool blocking, describing the use of system tools, JVM thread analysis, and code inspection to identify mis‑configured pool settings and recommending proper connection handling with Spring's RedisTemplate.
This article explains how to build three kinds of virtual scrolling lists—fixed‑height, variable‑height, and dynamic‑height—using React‑Window, covering core principles, detailed implementation code, performance considerations, and practical tips for handling irregular item sizes.
This article explains Redis' client‑server request model, introduces the pipeline technique, compares normal and pipelined requests, and provides Spring Boot code examples that demonstrate a three‑fold speed improvement when writing 100,000 keys.
This article explains Java 21 virtual threads, their lightweight nature, cost advantages over platform threads, practical code examples, performance experiments, and how they enable high‑throughput backend applications with minimal code changes.
The G1 Garbage Collector, introduced in Java 7 update 4, replaces CMS by using a region‑based design that minimizes pause times and improves throughput, and a detailed video with diagrams and code examples is provided to deepen understanding of its operation.
To overcome storage, compute, and I/O bottlenecks in Bilibili’s risk‑control engine, the team combined pre‑fetching with Redis caching, batch retrieval, asynchronous writes via Railgun, aggressive log compression, and a multi‑level cache plus Bloom filter, cutting latency to sub‑100 ms, reducing Redis QPS by over 90 % and storage by ~38 %, while supporting million‑level query throughput.
This article examines how a metrics‑driven development approach, combined with observability tools like Prometheus, helped a large online used‑car marketplace improve system insight, accelerate business processes, and deliver measurable performance and efficiency gains across both customer‑facing and dealer‑facing operations.
This article explains how Cloudflare built Pingora, a Rust‑based HTTP proxy that outperforms NGINX in scalability, connection reuse, and security, detailing the architectural limits of NGINX, design decisions behind Pingora, and the measurable performance and efficiency gains achieved in production.
This article explores how to capture and process screenshots of web pages directly in the browser, discussing canvas drawImage basics, pixel extraction, the trade‑offs of using html2canvas versus dom‑to‑image, performance and bundle size considerations, and alternative plugin‑based approaches.
This article presents ten practical Java Stream API best‑practice tips—including using primitive streams, avoiding nested streams, cautious parallelism, lazy evaluation, side‑effect prevention, immutability, proper ordering of filter/map, method references, distinct and sorted usage—to help developers write more efficient, readable, and safe stream code.
This article walks you through the evolution of web rendering modes—from early static pages to modern CSR, SSR, SSG, ISR, and edge‑rendering techniques—explaining their design ideas, pros and cons, and how to pick the best fit for different performance, cost, and development scenarios.
Cloudflare’s new Rust‑based Pingora proxy outperforms Nginx by improving connection reuse, cutting CPU and memory usage, and enhancing security, offering a faster, more efficient, and feature‑rich solution for handling trillions of HTTP requests across its global network.
This guide introduces VTable, an open‑source high‑performance table component built on VRender, covering installation via npm or CDN, basic usage, table types, cell rendering options, interaction features, theming, and performance characteristics for modern web applications.
The investigation revealed that the Go http.Client was not reusing connections because response bodies were closed before being fully read, causing the underlying connections to be marked dead; fully reading the bodies restored pooling, eliminated DNS‑resolution timeouts and dramatically lowered query‑per‑second spikes.
This article investigates why a SpringBoot service takes 6‑7 minutes to start, identifies the bean‑scanning and bean‑initialization phases as the main performance culprits, and presents concrete JavaConfig and starter‑based solutions to reduce startup time to around 40 seconds while handling cache auto‑configuration pitfalls.
