Learn how to boost Node.js application performance using the popular lru-cache package, covering the LRU algorithm fundamentals, basic installation and usage, advanced features like peek, fetchMethod, and custom disposal, plus an in‑depth look at its internal Map and doubly‑linked list implementation.
This article explains the concept of API gateways, compares popular solutions such as Kong, Zuul, Spring Cloud Gateway and Tyk, details Kong's architecture, features, performance benchmarks, deployment scenarios, monitoring setup, and the practical problems encountered with their resolutions.
The MoonWebTeam Frontend Tech Monthly curates the latest front‑end frameworks, performance optimization case studies, AI innovations, domain‑driven design insights, and practical best‑practice techniques, offering developers a comprehensive snapshot of cutting‑edge web development trends.
This article investigates the mysterious "prevent gc" comment in RocketMQ source code, explains how Thread.sleep(0) interacts with JVM safepoints and counted loops, and demonstrates practical fixes by changing loop indices or inserting explicit safepoint calls.
At PyCon 2024, experts demonstrated how static typing, Cython compilation, static‑linked C extensions, and sub‑interpreter architectures can dramatically accelerate Python code, reduce runtime overhead, and mitigate GIL limitations, offering practical pathways for faster, more scalable Python applications.
This article walks through a series of practical performance‑boosting techniques for Vue‑based web applications, covering Webpack bundle analysis, Gzip compression, WebP image conversion, HTTP/2 configuration, Nginx tweaks, and OSS/CDN integration, with concrete code snippets and step‑by‑step guidance.
This article compares Google’s Protocol Buffers and the Swagger/OpenAPI framework, detailing their features, data formats, use cases, flexibility, development workflows, and why Google created protobuf, helping developers choose the right tool for high‑performance data serialization or comprehensive API documentation.
The article analyzes Nvidia’s historic advantage, the massive performance and energy efficiency gains from Pascal to Blackwell GPUs, the economics of training large language models like GPT‑4, and the detailed roadmap of upcoming GPU, memory, and interconnect technologies shaping the future of data‑center AI.
This article explains common scenarios that cause MySQL or Java processes to consume 900% CPU, walks through step‑by‑step diagnosis using Linux tools, and provides concrete optimization techniques such as indexing, caching, thread analysis, and code adjustments to bring CPU usage back to normal levels.
This article examines the performance differences between using the '+' operator and StringBuilder for string concatenation in Java, presenting JUnit benchmark tests for simple concatenations and looped concatenations, analyzing compiled bytecode, and concluding that '+' is suitable for simple cases while StringBuilder excels in loops.
This article compiles seven hands‑on Linux performance optimization experiences, covering key performance factors, rapid troubleshooting steps for CPU, memory, disk and network issues, load‑average analysis, top‑process identification, memory‑stat discrepancies, swap usage scenarios, and detailed TCP kernel tuning recommendations.
The author benchmarked Go's standard HTTP library against PHP frameworks Workerman, Webman, and Swoole (including coroutine mode) on a 4‑core Ubuntu 20.04 Aliyun instance using ApacheBench with and without keep‑alive, revealing that Workerman and Webman often outperform Go in raw request‑per‑second throughput.
This guide introduces Memray, a powerful Python memory analysis tool, explains how to install it, run command‑line profiling, integrate it into code with the Tracker API, interpret detailed reports, and apply advanced filtering and merging techniques while noting its runtime overhead.
This article explains Hugging Face's KV cache quantization technique, detailing how it reduces memory usage for long‑context LLM generation, the underlying quantization methods, implementation steps in 🤗 Transformers, benchmark results versus fp16, and the trade‑offs between speed, memory, and accuracy.
This article presents twelve practical guidelines for Java logging, covering interface‑layer usage, avoiding separator lines, preventing logging‑induced exceptions, leveraging Fastjson features, preserving exception stacks, limiting message length, merging stack traces, skipping costly placeholders, avoiding console output, discarding redundant utilities, and adhering to Alibaba's logging specification.
Traditional LAMP stacks, relying on php‑fpm and nginx, suffer from synchronous blocking and high CPU usage, limiting throughput for IO‑intensive microservice workloads, while benchmarks show that upgrading to PHP 7 and using a modern, asynchronous PHP framework like Webman can dramatically improve QPS and reduce latency.
The article examines Peter Zaitsev’s critique of Oracle’s stewardship of MySQL, debunks long‑standing myths, evaluates recent MySQL Heatwave features and performance gaps, and compares MySQL’s trajectory with PostgreSQL and other open‑source databases.
This guide compiles practical Nginx performance‑tuning directives, FastCGI settings, Linux kernel parameter adjustments, security hardening tips, and monitoring configurations, providing concrete examples and command‑line snippets to help sysadmins and developers optimize high‑concurrency web services.
This article analyzes MySQL's recommendation to avoid UUID or non‑sequential random primary keys by benchmarking insert performance across three tables—auto_increment, UUID, and random key—explaining the underlying index structures, observed speed differences, and the trade‑offs of each approach.
This article examines four common WeChat red packet distribution algorithms—simple random, double‑mean, line‑segment division, and array_rand optimization—explaining their principles, PHP implementations, performance characteristics, and how to verify randomness, providing code samples and comparative analysis for developers.
This article explains how to design a MySQL table for product sales statistics, initialize massive test data, and compare several query strategies—including loop queries, OR‑concatenated dynamic SQL, mixed filtering, and the SQL‑92 row‑comparison technique—to efficiently retrieve sales figures for multiple business units and their products without violating development constraints.
This guide introduces Uber’s open‑source Zap library for Go, explains its performance‑focused features, shows how to install and configure it, and provides step‑by‑step code examples for basic logging, sugared logging, level control, file output, and log rotation.
This article analyzes the performance bottlenecks of an H5 map built with the AMap JS‑SDK, explains the causes of frame drops on low‑end devices, and presents a step‑by‑step refactor using data‑fetching tweaks, DistrictCluster aggregation, and conditional rendering to achieve smoother interactions.
Microsoft’s Windows now runs on Qualcomm’s ARM processors through a combination of native kernel adaptations, driver and library recompilation, and an x86‑to‑ARM emulation layer, balancing performance gains from direct ARM execution with compatibility‑driven overhead, while outlining ongoing optimization efforts and future prospects.
The article explains how Fast‑Retry, an asynchronous multi‑task retry framework, dramatically outperforms synchronous retry libraries like Spring‑Retry and Guava‑Retry when handling massive workloads, and provides step‑by‑step code examples, performance benchmarks, and integration tips for Java developers.
This whitepaper examines the industry trend of moving data‑intensive analytics workloads to cloud‑native platforms, analyzes the unique cost model of cloud storage, and presents case‑study findings from Uber's Presto production environment to guide efficient I/O design and cost‑effective performance optimization.
The article explores how Nordic programmers like Linus Torvalds, Andreas Kling, and Ville Turjanmaa have built full operating systems—from Linux to SerenityOS and the assembly‑only MenuetOS—highlighting their motivations, technical achievements, performance gains, and the cultural environment that fuels such ambitious open‑source projects.
Tencent News upgraded its recommendation architecture by consolidating data platforms, redesigning index and feature services, adopting DDD and Lambda/Kappa patterns, and adding robust debugging and stability measures, which boosted availability to 99.99%, cut CPU, memory and cost by over 60%, and accelerated development and experiment cycles.
This article explains Java virtual threads, compares them with traditional OS threads, shows how to enable them in SpringBoot 3, and presents performance benchmarks demonstrating up to 200‑fold speed improvements for I/O‑bound workloads.
This article compares Java's standard ThreadLocal with Netty's FastThreadLocal, explains their internal mechanisms, shows practical code examples, runs a JMH microbenchmark, and discusses performance, memory management, and usage scenarios to help developers choose the right thread‑local storage solution.
This article introduces several MySQL performance‑diagnostic utilities—including mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—explains how to download and run them, interprets their reports, and also contains promotional material for unrelated AI services.
The article defines large database transactions, explains their performance and replication risks, offers practical guidelines to avoid them, demonstrates a MySQL example that creates and repeatedly inserts data to illustrate growing execution time, and discusses challenges and solutions for handling massive tables in high‑traffic environments.
An in‑depth postmortem of a costly MySQL data‑migration failure caused by using INSERT INTO SELECT without proper indexing, detailing the OOM issue, full‑table scans, lock contention, and best practices to safely employ the statement.
FrankenPHP, a Go‑based PHP application server built on Caddy, claims to double web request performance and halve developer/DevOps workload, offering container‑ready deployment, automatic HTTPS, native PHP extensions, in‑memory mode, structured logging, Prometheus metrics, and experimental HTTP/3 support.
This article outlines seven typical cache problems—including cache penetration, breakdown, avalanche, large keys, hot keys, hit‑rate issues, and data inconsistency—and provides practical solutions such as parameter validation, Bloom filters, null‑value caching, locking, auto‑renewal, random expiration, high‑availability setups, compression, and cache warming to improve system reliability and performance.
This article explains the concept of the Virtual DOM, its performance benefits in front‑end development, and presents several open‑source implementations such as Million.js, Snabbdom, virtual‑dom, blockdom, Maquette, and additional lightweight libraries, each with brief descriptions and GitHub links.
This article dissects Pulsar’s storage layer by examining the Bookie component, detailing its architecture, the sequential write‑ahead log, ledger management, journal handling, caching mechanisms, and the complete read/write call chains with concrete code examples and performance considerations.
This article investigates two real‑world performance incidents—one caused by excessive disk I/O from a misconfigured Filebeat and another by kernel memory‑fragmentation bugs triggered by a trace feature—detailing observations, Linux diagnostic commands, analysis, and practical remediation steps.
GraalVM Native Image now supports Native Memory Tracking (NMT), allowing developers to monitor off‑heap memory allocations, compare Java and native execution, integrate with JFR, and assess performance impact through detailed reports and experimental events.
This article explains how to use a custom CommonContext with conditional logging and lambda‑based delayed evaluation to quickly trace issues in high‑concurrency Java back‑end systems without degrading performance, and demonstrates the performance improvements through before‑and‑after measurements.
This article documents the author's practical migration from JDK 8 to JDK 11, covering motivations such as performance, compatibility, and industry trends, detailed upgrade steps, GC tuning, resolved issues, and showcases significant performance gains and new Java 11 language features with code examples.
This article explains database sharding concepts, reasons for using it, various sharding strategies, and demonstrates implementation with ShardingSphere, including configuration and Java code examples, while also offering additional resources for advanced architecture and interview preparation.
This article compares the Go web frameworks Echo and Gin, detailing their main features, performance, API design, middleware and routing capabilities, community support, and provides side‑by‑side code examples to help developers choose the most suitable framework for their projects.
Zero‑copy is an optimization technique that eliminates unnecessary memory copies between kernel and user space by leveraging DMA, memory‑mapping and specialized system calls, thereby reducing CPU load, latency and improving throughput for high‑performance networking, storage and multimedia workloads.
This article introduces Python decorators tailored for mathematical functions, presenting four practical examples—a timing decorator, a simple automatic differentiation decorator, a result‑caching decorator, and a random‑noise decorator—each accompanied by complete code snippets and explanations.
This article explains the essential conditions, metrics, and scenario classifications for building high‑concurrency systems, then details common solutions such as database read/write separation, local and distributed caching, cache‑eviction policies, handling master‑slave lag, preventing cache penetration and avalanche, and applying CQRS to achieve scalable, high‑performance back‑end services.
This article examines the main algorithms behind WeChat's red‑packet distribution—plain random, double‑mean, and segment‑split (including an optimized version), explains their PHP implementations, validates array_rand's randomness, and compares their performance and fairness through code examples and timing tests.
This article explains how Go's garbage collector manages adjusted, old, and new stacks, detailing the stack adjustment process, expansion and contraction steps, and practical techniques—including debugging tools, stack printing, memory profiling, and stress testing—to verify correct behavior.
The article explains why using IN and NOT IN in SQL queries can lead to poor performance, index bypass, unexpected results with NULL values, and subtle bugs, and it recommends safer alternatives such as EXISTS, NOT EXISTS, and JOIN constructs.
This article presents a systematic benchmark comparing ClickHouse local (single‑node) tables and distributed tables across three data volumes—≈60 billion, 5 billion and 50 million rows—using a variety of aggregation and filter queries, and reveals that distributed tables dominate at large scale while the gap narrows as the dataset shrinks.
This guide details how to fine‑tune Linux kernel parameters—covering sysctl configuration, network stack adjustments, local port range, shared memory limits, swap behavior, and disk scheduler choices—to dramatically improve server performance and stability.
This article demonstrates how to refactor a complex, production‑level SQL query used in a routing system by formatting, decomposing into layers, merging temporary tables, pushing predicates, optimizing joins, and validating performance, ultimately reducing nesting from four levels to one and cutting execution time from 4.75 s to 0.6 s.
This article explains common scenarios of implicit type and charset conversions in MySQL, demonstrates how they cause index loss and performance degradation through detailed examples and EXPLAIN output, and provides practical guidelines to prevent such conversions in production environments.
This article explores the proper usage of Java's Optional class, debunks common misconceptions, examines its internal implementation, compares methods like map, orElse, orElseGet, and provides practical code examples to help developers avoid null‑pointer pitfalls and write cleaner backend code.
This comprehensive guide explains how to use essential Linux monitoring commands—top, free, vmstat, iostat, mpstat, sar, netstat, uptime, ps, watch, strace, and lsof—detailing their purpose, key parameters, interactive shortcuts, and how to interpret their output for effective system performance analysis.
A MySQL‑driven data‑migration using INSERT INTO SELECT caused full‑table scans, lock contention and lost payment records, leading to a $10,000 loss and the engineer’s dismissal; the post‑mortem explains the root cause and how proper indexing can prevent it.
This article explains common Redis performance pitfalls—including per‑command network latency, expensive commands like SUNION and KEYS, mass key expiration spikes, and big‑key deletions—and provides practical techniques such as MSET batching, randomizing expirations, and using UNLINK to keep your backend fast.
This guide explains how to replace slow synchronous HTTP calls with Guzzle's asynchronous requests in PHP, showing code examples, performance measurements, and practical tips for installing and using promises to achieve faster concurrent API calls.
This article explains what monkey patching is in Python, demonstrates how to replace the standard json module with the faster ujson module using a simple runtime patch, and shows performance measurements before and after the patch to illustrate the speed improvement.
This article presents a comprehensive collection of MySQL performance guidelines, covering query writing, index usage, join strategies, data types, batch operations, and execution plan analysis to help developers write faster and more reliable SQL statements.
The article explains that software performance is measured in milliseconds to nanoseconds, describes core hardware components—CPU, caches, and DRAM—shows how cache hierarchy speeds differ, defines a clock cycle as the basic time unit, and provides typical latency figures for operations ranging from a single CPU cycle to a full system reboot.
The study benchmarks Kotlin, JavaScript, Dart, C++ and Swift across iOS, Android and HarmonyOS using 237 protobuf files, finding Kotlin’s performance and binary size rival native Swift, JavaScript slower with higher memory, while C++/Rust excel but need more effort, leading to a recommendation of Kotlin Multiplatform with a three‑repo structure for optimal reuse and maintainability.
This article documents a month‑long effort to replace Fastjson with Gson in Java projects, analyzing security vulnerabilities, comparing performance and features of Fastjson, Jackson and Gson, and providing detailed migration steps, code examples, and solutions to common issues such as date handling, SpringBoot integration, Swagger compatibility and numeric type conversion.
The article analyzes a real‑world MySQL data‑migration failure caused by an INSERT INTO SELECT operation that triggered full‑table scans and row‑level lock contention, leading to massive data loss and highlighting the need for proper indexing and cautious use of this command.
This article explains various server‑side caching strategies—including full‑page static caching, fragment caching, data and query caching, time‑based and content‑change invalidation, as well as memory caches like Memcached and Redis, Apache modules, APC, and opcode caches—providing PHP code examples for each method.
In 2023, leading cloud giants like Google and Amazon publicly questioned the value of microservices, presenting new “Microservices 2.0” principles and monolithic alternatives that promise dramatically lower latency, cost, and operational complexity while reshaping backend architecture debates.
A developer used MySQL’s INSERT INTO SELECT to migrate millions of rows, causing full‑table scans, OOM errors and lost payment records, leading to a costly incident; the post analyzes the root causes, explains transaction locking behavior, and offers practical indexing and testing safeguards.
This article explains how to quickly locate the MySQL statements that cause sudden CPU spikes by inspecting per‑thread usage with top, correlating threads to SQL via performance_schema, and using a Python script to list and optionally kill the offending queries.
This article describes Zhihu's hybrid cloud architecture—including offline, online, and GPU data centers—its self‑built UnionStore cache, the performance and latency challenges faced during large‑scale AI model training, and the subsequent evaluation and migration to Alluxio community and enterprise editions to achieve higher throughput, stability, and lower operational overhead.
The article reviews Amazon MemoryDB, a Redis‑based in‑memory database that uses a distributed transaction log to achieve strong consistency and durable persistence for high‑throughput, latency‑sensitive workloads, and compares its architecture and performance with open‑source Redis.
This article details the investigation of sporadic interface timeouts in the Sirius real‑time pricing service, revealing a weekly pattern linked to RAID controller consistency checks that cause IO spikes, logback queue blockage, and ultimately Dubbo client‑side timeouts, and proposes mitigation steps and general performance‑troubleshooting guidelines.
This article examines PHP’s evolution over the past two decades, outlines its present strengths such as performance gains in PHP 7 and community vitality, and explores emerging trends—including modern language features, cloud‑native integration, serverless adoption, and performance optimization—that will shape its future role in backend web development.
A MySQL data‑migration task using INSERT INTO SELECT triggered a full‑table scan, leading to lock contention, payment‑record loss, and ultimately the developer's dismissal, highlighting the dangers of unindexed bulk operations and the need for proper indexing and testing.
This article compares common API communication styles—including SOAP, RESTful, GraphQL, gRPC, WebSocket, and Webhook—explains their strengths and trade‑offs, shows how gRPC operates, outlines when to use short polling versus webhooks, and provides practical tips for boosting API performance and security.
This article systematically examines seven typical cache problems—penetration, breakdown, avalanche, data inconsistency, big‑key, hot‑key, and low hit rate—explaining their root causes, illustrating concrete scenarios with diagrams and code, and presenting step‑by‑step mitigation techniques such as parameter validation, Bloom filters, locking, auto‑renewal, random expirations, high‑availability setups, and cache warm‑up.
This article explains the principles of Redis Pipeline, compares Lettuce and Redisson client implementations in Spring Boot, presents performance tests showing dramatic speed gains over single commands, discusses practical usage scenarios, common pitfalls, and provides detailed source code examples for both clients.
In today's digital era, Laravel queues enable backend applications to offload time‑consuming tasks, improve performance, enhance scalability, and deliver a smooth, responsive user experience, making them an essential tool for modern web development.
This article explains how integrating Go with assembly language can overcome Go's performance and low‑level control limits for system and driver development, covering basic concepts, integration methods, multi‑CPU architecture support, practical code examples, and the resulting performance and portability benefits.
This article explains the rules of platform coupons, demonstrates a concrete example, and details three generations of algorithms—from a Cartesian‑product approach to Map‑based and array‑index methods—highlighting their implementations, performance trade‑offs, and a comparative benchmark.
A real‑world MySQL case study shows how using INSERT INTO SELECT for large‑scale data migration without proper indexing caused full‑table scans, lock contention, and data loss, highlighting the need for careful query planning and performance testing.
This article explains how MySQL table‑level locks and metadata locks (MDL) can block both reads and writes, describes the two lock implementations, their types, the interaction with LOCK TABLES and FLUSH TABLES, and provides practical queries for diagnosing lock‑related blocking issues.
The article investigates why altering a MySQL VARCHAR column from a length that fits within 255 bytes to one that exceeds this limit (e.g., VARCHAR(63) to VARCHAR(64) in utf8mb4) triggers a costly copy operation, analyzes the storage mechanics, reproduces the issue, and provides practical recommendations to avoid performance penalties.
This article explains how the hierarchical security model in Microsoft Dataverse extends existing security mechanisms by introducing manager and position hierarchies, details their configuration, access rules, performance tips, and how to include or exclude records of disabled users.
This article explores why Redis delivers ultra‑high performance by examining its in‑memory design, single‑threaded event loop, efficient data structures such as hash tables, SDS strings, ziplist, quicklist, and skiplist, as well as its encoding strategies and I/O multiplexing model.
This article compiles detailed technical Q&A about NVIDIA's Quantum‑2 InfiniBand platform, covering compatibility of CX7 NDR ports, cabling options, switch connections, UFM deployment, PCIe bandwidth limits, and performance considerations for high‑performance computing clusters.
This article explores Go's experimental arena library, detailing its design principles, core features such as fast allocation and memory reuse, suitable use cases like object pools and game development, provides a practical code example, and discusses performance benefits and limitations for high‑concurrency applications.
This article explores Java String internals across JDK versions, explaining its memory representation, immutability, substring behavior, and how techniques like StringBuilder, intern(), and shared objects can dramatically reduce memory usage from gigabytes to megabytes in high‑scale applications.
This guide introduces essential Linux monitoring commands such as top, htop, vmstat, iostat, sar, netstat, iftop, tcpdump, and Glances, explains their usage with example code, and shows how to analyze logs and create custom scripts for comprehensive system performance tracking.
This article explains the behavioral and performance differences of positioning a try‑catch block either outside or inside a Java for‑loop, illustrating each case with code examples, execution results, memory analysis, and practical recommendations for handling exceptions during batch processing.
The article explains the limitations of Spring's BeanUtils.copyProperties—such as type mismatches, null overwriting, and reflection overhead—and demonstrates how MapStruct provides a faster, compile‑time generated alternative for copying properties between Java objects, with usage examples and Maven setup.
This article explains why read‑heavy internet services use MySQL master‑slave replication for read/write separation, describes the asynchronous replication process, discusses latency side‑effects, and offers practical strategies such as data redundancy, caching, and direct master queries to mitigate delays.
This guide walks you through installing the wrk load‑testing tool on Unix‑like systems, explains its core command‑line options, shows how to interpret benchmark results, and demonstrates advanced customization using Lua scripts for POST requests, dynamic parameters, authentication, and HTTP pipelining.
This article presents a systematic benchmark comparing Go's new generic types with the traditional interface{} approach, measuring execution time and memory allocation on identical hardware to determine whether generics provide a measurable performance advantage.
This guide covers practical MySQL performance improvements, detailing SQL-level optimizations such as limit pagination, proper LIKE usage, UNION ALL, EXISTS vs IN, TRUNCATE, batch inserts, early filtering, function placement, data type minimization, CHAR/VARCHAR choices, indexing strategies, force index, as well as server parameter tuning for buffer pool and redo log settings.
This comprehensive guide explores Rust’s signed and unsigned integer types, detailing their ranges, appropriate use cases, performance considerations, and provides practical code examples for type selection, conversions, arithmetic, and bitwise operations to help developers write efficient, safe Rust code.
This article explains where MySQL stores auto‑increment values, why gaps appear after failed inserts, duplicate‑key errors, rollbacks or batch inserts, and how different innodb_autoinc_lock_mode settings and MySQL 8.0 improvements can mitigate the issue.
This article explains Go's unsafe package, covering its core concepts—Pointer, Sizeof, and Offsetof—provides practical code examples, outlines suitable scenarios such as system calls and performance tuning, and highlights the associated risks and best‑practice precautions.
This article presents practical Go performance tips, covering memory‑allocation strategies, slice and map pre‑allocation, stack management, GC reduction, goroutine‑pool usage, avoiding blocking syscalls, and efficient string handling to minimize latency and resource consumption.
React 16 feels smoother than React 15 because its new Fiber architecture breaks state updates into small, priority‑aware units that the Scheduler runs asynchronously, allowing high‑priority user input to render first while lower‑priority work is paused and resumed, eliminating the lag seen in full‑tree re‑renders of React 15.
Fast‑Retry is a high‑performance, multi‑task asynchronous retry framework for Java that outperforms traditional synchronous retry libraries like Spring‑Retry and Guava‑Retry, offering flexible APIs, annotation support, and easy integration for massive retry workloads.
