Tagged articles
Backend Performance
83 articles · Page 1 of 1
The article examines how backend performance tuning is evolving from manual, experience‑driven cycles to data‑driven observability, closed‑loop AIOps, serverless/Wasm architectures, and energy‑aware optimization, outlining concrete examples, tools, and forecasts shaping the field through 2026.
AIOpsBackend PerformanceWasm
0 likes · 8 min read

The article analyzes how replacing Kafka with a simple in‑memory Go queue reduced architectural complexity, boosted throughput from 240‑330 K to 1.8‑2.0 M messages per second, and clarified debugging, while still acknowledging scenarios where Kafka remains the better choice.
Backend PerformanceGoIn‑Memory Ring Buffer
0 likes · 8 min read

The article explains high‑concurrency scenarios and how to quantify them using QPS (queries per second) and TPS (transactions per second), highlighting their definitions, typical system capacities, and the distinction between request‑level and business‑level throughput.
Backend PerformanceQPSTPS
0 likes · 4 min read

This article explains how Kafka leverages sequential disk I/O, zero‑copy data transfer, OS page cache, and partition‑based parallelism to deliver massive throughput, detailing the underlying mechanisms, performance numbers, and a practical formula for estimating total system capacity.
Backend PerformanceKafkaPage Cache
0 likes · 5 min read

Increasing a database connection pool size often worsens performance under massive traffic because the bottleneck lies in hardware limits and management overhead, so developers must adopt async processing, read‑write splitting, caching, sharding, and proper pool tuning to sustain high concurrency.
Asynchronous ProcessingBackend Performanceconnection pool
0 likes · 4 min read

Learn how Nginx’s powerful caching mechanism can slash response times by up to tenfold, reduce backend load, and increase throughput, with detailed explanations of the caching workflow, essential configuration directives, micro‑cache tricks, and FastCGI caching examples for high‑traffic services.
Backend PerformanceCachingConfiguration
0 likes · 5 min read

This article explains what a cache avalanche is, why it occurs in distributed systems, and presents practical mitigation techniques such as multi‑level caching, staggered expirations, mutex locks, and hotspot isolation to keep backend services stable under high load.
Backend PerformanceDistributed Cachingcache avalanche
0 likes · 5 min read

This article explains what cache penetration is, why it occurs when requests bypass the cache to hit the database, and presents four effective mitigation techniques—including empty-result caching, Bloom filters, request validation, and distributed rate limiting—to safeguard backend performance.
Backend PerformanceBloom FilterCache
0 likes · 4 min read

This article compares eight popular Go web frameworks—fasthttp, Fiber, Gin, Echo, Beego, Revel, Hertz, and Kratos—by evaluating their performance, developer friendliness, and ideal application scenarios, and provides concise code examples to help you select the best fit for high‑performance backend development.
Backend PerformanceGoWeb Frameworks
0 likes · 8 min read

This article examines how asynchronous programming revitalizes PHP, detailing its core principles, emerging ecosystem, cloud‑native advantages, performance gains, improved developer experience, industry adoption, and the challenges ahead, forecasting that by 2025 async PHP will reshape modern web development.
Backend PerformanceSwooleasynchronous PHP
0 likes · 8 min read

This article explains how to identify interfaces that need pre‑emptive rate limiting, allocate resources for isolation, apply circuit‑breaking wisely, calculate thresholds based on resource capacity, and leverage Sentinel's features to ensure stable backend performance.
Backend PerformanceSentinelcircuit breaking
0 likes · 10 min read

This article presents a comprehensive guide to optimizing API performance in Spring Boot projects, covering batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction management, code refactoring, pagination, SQL tuning, and lock granularity, complete with code examples and diagrams.
API optimizationAsynchronous ProcessingBackend Performance
0 likes · 10 min read

Discover why a sluggish API hurts user retention, SEO, and costs, and learn eight practical Node.js backend optimization techniques—including mastering the event loop, avoiding blocking code, leveraging async/await, offloading heavy tasks, efficient JSON handling, caching strategies, database tuning, clustering, and continuous monitoring—to boost performance and scalability.
Async/AwaitBackend PerformanceCaching
0 likes · 8 min read

This article presents a comprehensive set of twelve backend optimization strategies—including batch processing, asynchronous execution, caching, pooling, parallelism, indexing, transaction management, and SQL tuning—to dramatically reduce API latency and improve overall system efficiency.
API optimizationBackend PerformanceCaching
0 likes · 9 min read

Cloudflare built Pingora, a Rust‑based HTTP proxy that processes over a trillion daily requests, to overcome Nginx's architectural limits, achieve higher performance, lower resource usage, and add features unavailable in the legacy stack.
Backend PerformanceCloudflareHTTP Proxy
0 likes · 13 min read

This article presents a comprehensive set of practical techniques—including batch processing, asynchronous execution, caching, preprocessing, pooling, parallelization, indexing, pagination, SQL tuning, and lock granularity—to dramatically reduce API latency and improve overall backend system efficiency.
API optimizationBackend PerformanceCaching
0 likes · 12 min read

This article explains why a Golang service running on AWS EC2 failed to use the system‑level DNS cache provided by nscd, causing excessive DNS queries that triggered request timeouts, and describes the investigation and optimization steps that resolved the issue.
AWSBackend PerformanceDNS
0 likes · 6 min read

This article explains the C10K problem—how a single server can manage ten thousand simultaneous connections—and outlines four essential techniques (I/O multiplexing, asynchronous non‑blocking I/O, lightweight threading models, and network stack optimization) that enable Nginx and similar servers to achieve high concurrency efficiently.
Backend PerformanceC10KI/O multiplexing
0 likes · 4 min read

This article examines three strategies for checking username uniqueness at massive scale—direct database queries, Redis caching, and Bloom filter techniques—detailing their implementations, performance trade‑offs, memory consumption, and suitability for billions of users.
Backend PerformanceBloom FilterCaching
0 likes · 11 min read

This guide walks backend developers through a step‑by‑step approach to handle sudden 100‑fold traffic spikes, covering emergency response, traffic analysis, robust system design, scaling techniques, circuit breaking, message queuing, and stress testing to keep services resilient and performant.
Backend Performancecircuit breakingrate limiting
0 likes · 12 min read

This comprehensive guide explains the nature of high concurrency, distinguishes it from parallelism, outlines its potential consequences across application, database, and service layers, and presents a systematic set of mitigation strategies—including rate limiting, asynchronous processing, redundancy, caching, and queue‑based designs—supported by real‑world case studies and code examples.
Asynchronous ProcessingBackend PerformanceCaching
0 likes · 27 min read

This article presents a comprehensive set of backend optimization strategies—including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelism, indexing, transaction management, program refactoring, pagination, SQL tuning, and fine‑grained locking—to dramatically reduce API latency and improve system efficiency.
API optimizationBackend PerformanceCaching
0 likes · 10 min read

This article explains the hedged request pattern used by Google to combat microservice tail latency, shows how to implement it in Go with context and goroutines, discusses its impact on latency and load, and explores additional techniques such as SingleFlight and service‑class prioritization to further reduce tail delays.
Backend PerformanceGoTail Latency
0 likes · 6 min read

This article explains what constitutes high concurrency for Nginx, outlines the hardware and software factors that affect its performance, and provides concrete configuration examples such as worker_processes, worker_connections, and other tuning directives to help achieve stable high‑traffic handling.
Backend PerformanceConfiguration TuningSystem Optimization
0 likes · 4 min read

JD’s Hotkey framework provides millisecond‑level detection and cluster‑wide push of hot data, users, and interfaces, dramatically reducing backend query load, improving performance, and supporting scenarios such as local caching and rate limiting, with proven scalability demonstrated in large‑scale e‑commerce promotions.
Backend PerformanceDistributed CachingJava
0 likes · 7 min read

The article explains how TLS handshakes significantly increase request size and upstream bandwidth consumption in high‑concurrency services, demonstrates the bandwidth calculations, and proposes using plain HTTP or Keep‑Alive connections to reduce overhead and server load.
Backend PerformanceHTTPHTTPS
0 likes · 4 min read

This article explains what high concurrency is, why it matters for large‑scale systems, and presents practical techniques such as distributed caching, load balancing, database optimization, traffic shaping, and distributed architecture to dramatically improve a backend's ability to handle massive simultaneous requests.
Backend Performancedatabase optimizationdistributed cache
0 likes · 9 min read

The article explains what cache penetration is, why it can crash databases under malicious traffic, and presents practical mitigation techniques such as Bloom filters, null-value caching, data pre‑warming, and request validation to protect Redis‑backed systems.
Backend PerformanceBloom FilterNull Caching
0 likes · 6 min read

Cache warming, a technique used in high‑concurrency systems to preload frequently accessed data before traffic spikes, improves hit rates, reduces latency, prevents cache breakdowns, and eases backend load, with methods ranging from startup loading and scheduled jobs to Spring Boot listeners, Redis tools, and Caffeine loaders.
Backend PerformanceCache WarmingCaffeine
0 likes · 10 min read

This article explains cache prewarming—its purpose, benefits, and various strategies such as startup loading, scheduled tasks, manual triggers, and cache loaders—while providing concrete Spring Boot and Redis examples, including code snippets for ApplicationReadyEvent, CommandLineRunner, InitializingBean, @PostConstruct, @Scheduled, and Caffeine cache loader.
Backend PerformanceCacheCaffeine
0 likes · 9 min read

This article documents the investigation of a JSF asynchronous call timeout that reduced interface availability, explains the async call mechanisms, analyzes the root cause in the callback thread pool, and presents short‑term and long‑term solutions to restore 100% availability.
Backend PerformanceCompletableFutureJSF
0 likes · 12 min read

Distributed tracing helps reconstruct the call chain of a request across multiple services and machines, providing insights into latency, errors, and performance; this article explains tracing concepts, OpenTracing standards, and how SkyWalking implements automatic span collection, context propagation, unique trace IDs, sampling, and its architecture and performance advantages.
Backend PerformanceOpenTracingSkyWalking
0 likes · 11 min read

A developer recounts a painful production incident caused by an un‑preheated Redis cache, explains why cache warm‑up is essential for high‑traffic services, and outlines practical techniques such as gray releases, database scanning, and ETL pipelines to safely preheat caches.
Backend PerformanceCache PreheatingETL Pipeline
0 likes · 8 min read

To eliminate the brief latency spike that occurs when new Dubbo services start, the authors introduce a @Warmup annotation and early‑startup listeners that generate mock traffic and trigger a forced GC before publishing, cutting initial response times from seconds to tens of milliseconds and improving reliability for latency‑sensitive applications.
Backend PerformanceDubboJava
0 likes · 13 min read

This article explains what caching is, outlines various cache types, analyzes common high‑traffic cache issues such as penetration, breakdown, avalanche, and hot‑key handling, and presents real‑world architectures from Weibo and Zhihu to illustrate effective cache design and operation.
Backend PerformanceCachingcache architecture
0 likes · 16 min read

This article examines common timeout problems in microservice architectures, identifies root causes such as connection and socket timeouts, and presents ten practical optimization techniques—including setting appropriate timeouts, rate limiting, cache improvements, thread‑pool tuning, GC and JIT adjustments, NIO async programming, host migration, and network checks—to enhance system stability and performance.
Backend PerformanceCachingGC tuning
0 likes · 21 min read


政采云技术Apr 25, 2023 · Backend Development
This article explains the fundamentals of cache systems, describes the evolution from no‑cache to distributed and local caches, analyzes common challenges such as consistency, hot‑key detection, and cache avalanche, and provides practical guidelines and real‑world lessons for designing effective backend caching solutions.
Backend PerformanceCachingConsistency
0 likes · 14 min read

This article summarizes practical techniques for reducing API latency, including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction size control, program structure refactoring, deep pagination handling, SQL tuning, and proper lock granularity.
API optimizationBackend PerformanceIndexing
0 likes · 9 min read

This article presents a comprehensive set of backend API optimization strategies—including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction management, code restructuring, deep pagination, SQL tuning, and lock granularity—to dramatically reduce response times and improve system efficiency.
API optimizationAsynchronous ProcessingBackend Performance
0 likes · 10 min read

This article details the systematic reduction of memory consumption for Ctrip's hotel query service by halving container memory, evaluating and tuning modern garbage collectors, diagnosing off‑heap leaks, and ultimately replacing the default ptmalloc allocator with jemalloc to achieve stable performance and lower resource costs.
Backend PerformanceContainerizationJVM
0 likes · 22 min read

This article explains how to automate Elasticsearch slow‑query inspection by extracting DSL from slow‑log files, deduplicating queries, using the Profile API for detailed execution analysis, and applying rule‑based optimizations such as avoiding term‑long and range‑keyword queries to improve backend performance.
Backend Performancedsl optimizationprofiling
0 likes · 14 min read

This article explains the concept of distributed link tracing, its importance for visualizing microservice call chains, introduces the OpenTracing standard, and details how SkyWalking implements automatic span collection, context propagation, unique trace IDs, sampling strategies, and performance advantages over other tracing tools.
Backend PerformanceDistributed TracingOpenTracing
0 likes · 12 min read

JD-hotkey is a high‑performance backend framework that detects billions of hot keys daily, captures crawlers and hot items, and pushes them to service memory within milliseconds, dramatically reducing data‑layer load and boosting application performance.
Backend PerformanceHot Data DetectionJava
0 likes · 6 min read

This article explains the key performance metrics of backend systems—including QPS, TPS, response time, concurrency, and throughput—provides their definitions, relationships, practical calculation examples, and guidance on optimal thread counts for achieving balanced performance.
Backend PerformanceQPSResponse Time
0 likes · 7 min read

This article explains the three critical cache failure scenarios—cache penetration, cache avalanche, and cache breakdown—detailing their causes, real‑world impacts on high‑concurrency systems, and practical mitigation techniques using Redis and general backend strategies.
Backend PerformanceRediscache avalanche
0 likes · 11 min read

This article outlines practical strategies for handling high‑QPS backend services, including avoiding relational databases, employing multi‑level caching, leveraging multithreading, implementing degradation and circuit‑breaker mechanisms, optimizing I/O, using cautious retries, handling edge cases, and logging efficiently.
Backend PerformanceCachingCircuit Breaker
0 likes · 10 min read

This article outlines practical techniques for handling ultra‑high‑traffic backend services—including abandoning relational databases, employing multi‑level caching, leveraging multithreading, applying degradation and circuit‑breaker patterns, optimizing I/O, using cautious retries, guarding boundary cases, and implementing efficient logging—to maintain sub‑300 ms response times at 200k+ QPS.
Backend PerformanceCachingCircuit Breaker
0 likes · 10 min read

This article outlines practical techniques for optimizing high‑concurrency online services handling over 200 k QPS, covering the avoidance of relational databases, multi‑level caching, multithreading, circuit‑breaker and degradation strategies, I/O reduction, cautious retry policies, boundary checks, and efficient logging.
Backend PerformanceCachingCircuit Breaker
0 likes · 10 min read

This article outlines practical techniques for handling ultra‑high‑traffic online services—such as avoiding relational databases, employing multi‑level caches, leveraging multithreading, applying degradation and circuit‑breaker patterns, optimizing I/O, using retries wisely, handling edge cases, and logging efficiently—to keep response times under 300 ms.
Backend PerformanceCircuit BreakerIO optimization
0 likes · 9 min read

The article examines the repeated failures of the Xi'an health‑code platform, explaining that the root cause lies in serving all static assets (JS, CSS, images) from a single un‑CDN endpoint, which under peak load of 33 000 requests overwhelms the network bandwidth, leading to a crash.
Backend PerformanceCDNNetwork Bandwidth
0 likes · 5 min read

This article analyzes a real‑world cloud office system failure caused by cache avalanche, explains the concepts of cache avalanche, penetration, and breakdown, and presents practical solutions such as clustering, rate limiting, random expiration, pre‑warming, Bloom filters, and distributed locking to ensure system stability under heavy load.
Backend PerformanceCachingcache avalanche
0 likes · 13 min read

This article explains how caching can accelerate read/write performance and reduce backend load, analyzes its benefits and costs, discusses update strategies, granularity control, and solutions for common problems such as cache penetration, empty‑hole, avalanche, and hot‑key reconstruction, providing practical guidelines for robust backend design.
Backend PerformanceRediscache invalidation
0 likes · 14 min read

Explore comprehensive caching concepts—including client, server, and CDN caches—along with hit rate metrics, eviction methods, popular strategies like FIFO, LRU, LFU, and design patterns such as Cache‑Aside, Read/Write‑Through, and Write‑Behind, plus essential testing considerations for robust application performance.
Backend PerformanceCache EvictionCache Hit Rate
0 likes · 8 min read

This article explains the evolution and core concepts of caching in backend services, covering service‑cache interaction, hit rate, consistency challenges, granularity choices, cache penetration risks, and strategies to prevent cache avalanche through high availability and traffic control.
Backend PerformanceCachingcache avalanche
0 likes · 9 min read

This article explains the differences between in‑process caching and external cache services like Redis, outlines when each approach is appropriate, and provides practical strategies for maintaining data consistency and performance in modern microservice architectures.
Backend Performancemicroservicesprocess cache
0 likes · 9 min read

This article explains how Nginx achieves high performance through its modular design, event‑driven architecture, multi‑stage asynchronous request handling, master‑worker process model, and efficient memory‑pool implementation, contrasting it with traditional web servers and illustrating each concept with diagrams.
Backend PerformanceProcess Modelevent-driven architecture
0 likes · 9 min read

This article details a large‑scale C10K performance test of Dubbo, analyzes why service calls time out under thousands of concurrent consumers, identifies heartbeat‑induced Netty thread saturation and TCP full‑connection‑queue overflow as root causes, and presents concrete optimizations that dramatically improve latency and stability.
Backend PerformanceC10KDubbo
0 likes · 13 min read

This article explains the concepts of user space and kernel space, shows how traditional file‑to‑socket transfers involve multiple data copies with read/write system calls, and demonstrates how the Linux sendfile system call implements zero‑copy to reduce copies and system calls for high‑performance servers.
Backend PerformanceLinuxsendfile
0 likes · 6 min read

This article explains how large‑scale internet applications can use various caching patterns—such as Cache‑Aside, Read‑Through, Write‑Through, and Write‑Behind—to alleviate database pressure, maintain data consistency, and avoid pitfalls like cache penetration, avalanche, and thundering under extreme traffic loads.
Backend PerformanceCachingcache patterns
0 likes · 9 min read

This article explains how large‑scale internet applications can use various caching patterns—Cache‑Aside, Read‑Through, Write‑Through, Write‑Behind—and mitigation techniques for consistency, stampede, penetration, jitter, and avalanche to keep databases from becoming performance bottlenecks under massive traffic spikes.
Backend PerformanceCache ConsistencyCaching
0 likes · 9 min read

This article explains how large‑scale internet applications can use various caching patterns—such as Cache‑Aside, Read‑Through, Write‑Through, and Write‑Behind—to reduce database load, avoid consistency problems, and mitigate high‑concurrency issues like cache avalanche and penetration.
Backend PerformanceCachingcache patterns
0 likes · 9 min read

This guide walks developers through a step‑by‑step progression of performance‑boosting techniques—including zero‑copy I/O, epoll, thread pools, lock‑free programming, IPC, RPC, database indexing, caching, Bloom filters, full‑text search, and load balancing—to help build faster, more scalable backend services.
Backend PerformanceConcurrencyI/O optimization
0 likes · 22 min read

The article explains how long‑running database transactions can exhaust connection pools, block threads, and cause widespread service failures, then offers practical strategies—including keeping transactions short, removing RPC calls, enhancing monitoring, and reviewing code—to detect and prevent these high‑risk issues.
Backend PerformanceDatabase Connection PoolSpring
0 likes · 7 min read

The article explains that high concurrency in distributed systems is measured by QPS, but its essence lies in effectively utilizing CPU resources, discusses control‑variable analysis of the HTTP request flow, compares PHP‑Swoole and Java‑Netty implementations, and shows how coroutine‑based designs can dramatically boost throughput when I/O blocking is present.
Backend PerformanceCPU utilizationNetty
0 likes · 15 min read

This article outlines core principles for building high‑concurrency back‑end systems—doing less and doing it cleverly—then demonstrates their application in a real‑world flash‑sale (秒杀) scenario that handled 60,000 queries per second through careful feature selection, data reduction, caching strategies, queue control, and asynchronous processing.
Backend PerformanceCachingflash sale
0 likes · 18 min read

This article explains why hotspot keys occur in large‑scale services, outlines the performance risks they create, and presents multiple mitigation strategies—including server‑side caching, Memcache/Redis, local caches, read/write separation, and proactive hotspot detection—to keep systems stable under heavy load.
Backend PerformanceCachingRead-Write Separation
0 likes · 8 min read

This article explains the causes of hot key problems in high‑traffic scenarios, outlines their potential impact on system performance, and presents multiple mitigation strategies—including server‑side caching, Memcache/Redis, local caches, read‑write separation, and proactive hot‑data detection—while comparing their advantages and trade‑offs.
Backend PerformanceHot KeyRead-Write Separation
0 likes · 7 min read

This article shares practical insights on handling high‑concurrency traffic, explaining what constitutes large traffic, common mitigation strategies such as caching, downgrade, and focusing on rate‑limiting techniques—including counters, sliding windows, leaky‑bucket and token‑bucket algorithms—and demonstrates using Guava’s RateLimiter for Java applications.
Backend PerformanceGuavahigh concurrency
0 likes · 6 min read

This article explains why distributed caching is essential for high‑concurrency systems, outlines typical use cases, compares Memcached and Redis across features and performance, and discusses common problems such as cache avalanche, penetration, warm‑up, update strategies, and degradation.
Backend PerformanceMemcachedRedis
0 likes · 8 min read


JD TechJul 26, 2018 · Backend Development
This article explains the motivation behind cache design, compares CPU and application‑level caches, discusses multi‑level and distributed caching, outlines synchronization methods, eviction policies, and answers frequent cache‑related questions to help reduce database load and improve system performance.
Backend PerformanceCache EvictionCaching
0 likes · 13 min read

This article discusses practical approaches to handling massive traffic spikes—defining high‑traffic scenarios, common mitigation methods such as caching, degradation, and various rate‑limiting algorithms (counter, sliding window, leaky bucket, token bucket), including Guava's RateLimiter and brief notes on distributed implementations.
Backend PerformanceGuavaJava
0 likes · 6 min read

This article discusses the definition of high traffic, common mitigation methods such as caching, degradation, and especially various rate‑limiting algorithms—including counters, sliding windows, leaky bucket, and token bucket—and demonstrates using Guava's RateLimiter for practical throttling.
Backend PerformanceGuavahigh concurrency
0 likes · 7 min read

This article explains how Alibaba’s lightweight web server Tengine leverages Intel QuickAssist Technology to offload SSL operations via an async ssl_async module, detailing its architecture, integration with OpenSSL, performance gains across various cipher suites, and the resulting multi‑fold increase in HTTPS throughput.
Backend PerformanceHTTPS accelerationIntel QAT
0 likes · 8 min read

This article explains how tuning the PHP‑FPM max_requests setting and modifying its source code can eliminate periodic CPU_IDLE and MEM_USED fluctuations in high‑traffic web services, resulting in smoother resource utilization and more reliable performance.
Backend PerformanceCPU optimizationMemory usage
0 likes · 6 min read


ITPUBMay 18, 2017 · Backend Development
This article explains common problems of distributed caching such as cache breakdown, cache expiration, and hot‑key bottlenecks, and provides practical mitigation techniques including default null values, staggered expiration times, distributed locking, client‑side caching, and key sharding to maintain high‑concurrency performance.
Backend PerformanceHot Keycache breakdown
0 likes · 5 min read

The article explains the design, implementation, and operational benefits of a middleware component that dynamically adjusts log levels in Java services, helping large‑scale delivery platforms balance comprehensive debugging information with system performance and avoid catastrophic failures during peak traffic.
Backend PerformanceJavaSLF4J
0 likes · 13 min read

NGINX 1.9.1 introduces the SO_REUSEPORT socket option, allowing multiple workers to share the same IP and port, reducing lock contention and improving throughput, with detailed configuration steps and benchmark data demonstrating up to three‑fold request rate gains.
Backend PerformanceSO_REUSEPORTaccept_mutex
0 likes · 7 min read

This article explains why a tiny fraction of slow requests can dominate overall service latency, explores their causes—especially slow nodes on the query path—and shows how proper tracing and analysis can improve response times and cut infrastructure costs.
Backend PerformanceResource OptimizationTail Latency
0 likes · 11 min read


21CTOFeb 4, 2016 · Backend Development
This article explains how a rate‑limiting system can identify hot‑spot resources by using time‑window statistics, a concurrent LRU hash map, and cluster‑wide aggregation to efficiently track and evict low‑frequency keys while maintaining high throughput.
Backend Performanceconcurrent data structuresdistributed systems
0 likes · 9 min read

This article compares PHP and Node.js server‑side architectures, explaining CGI, FastCGI, Node.js child_process and cluster modules, PHP‑FPM limitations, and how ReactPHP brings event‑driven, asynchronous, non‑blocking I/O to PHP for higher web performance.
Backend PerformanceNode.jsPHP
0 likes · 14 min read

Varnish is a high‑performance open‑source reverse proxy and HTTP cache that stores data in memory for faster retrieval, using a master process to manage child workers that handle requests, allocate, serve, and evict cached objects based on LRU policies.
Backend PerformanceHTTP cachingMemory Cache
0 likes · 4 min read

Caching dramatically improves website performance by storing data in memory for faster responses and reducing database load, with Memcached and Redis as popular solutions; proper routing algorithms like consistent hashing are essential to scale clusters without causing cache misses or service disruption.
Backend PerformanceCachingConsistent Hashing
0 likes · 2 min read

The article summarizes Zhao Haiping’s 2015 QCon talk on how asynchronous processing, profiling, and dependency‑tree scheduling can dramatically improve performance and scalability of distributed backend systems, drawing lessons from Facebook’s migration to async PHP and Alibaba’s ongoing optimization efforts.
Backend PerformanceConcurrencyFuture
0 likes · 12 min read
