Skip to content
Tagged articles

performance tuning

500 articles · Page 1 of 5
Java Tech Workshop
Java Tech Workshop
Nov 19, 2026 · Databases

MySQL COUNT(*) Optimization: Debunking Myths & Real Solutions for Large Tables

This article debunks common MySQL COUNT(*) optimization myths, explains why InnoDB's MVCC architecture requires full index scans for exact counts, and presents layered strategies including estimation via information_schema, redundant counters with Redis, data archiving, partitioning, covering indexes, and offloading analytics to ClickHouse or Elasticsearch.

COUNT optimizationInnoDBMVCC
0 likes · 18 min read
MySQL COUNT(*) Optimization: Debunking Myths & Real Solutions for Large Tables
Raymond Ops
Raymond Ops
Nov 17, 2026 · Operations

Nginx High Connections: Normal Traffic or Slowloris Attack? Diagnostic Guide

This guide provides a systematic forensic process to distinguish between normal high Nginx connections and slow connection attacks (Slowloris), using Linux commands, Nginx stub_status, connection state analysis, rate comparisons, packet capture, and evidence-based decision matrices for accurate diagnosis and mitigation.

Linux troubleshootingNginxOperations
0 likes · 79 min read
Nginx High Connections: Normal Traffic or Slowloris Attack? Diagnostic Guide
Raymond Ops
Raymond Ops
Nov 13, 2026 · Operations

From 5s to 500ms: 12 Nginx Parameters for Performance Tuning

This article systematically explains 12 Nginx configuration parameters for performance tuning, advocating a methodical approach of baseline measurement, hypothesis-driven changes, canary deployment, and validation, covering worker processes, connection limits, keepalive settings, sendfile, TCP optimizations, request buffering, and gzip compression, with practical commands and monitoring strategies.

LinuxNginxOperations
0 likes · 34 min read
From 5s to 500ms: 12 Nginx Parameters for Performance Tuning
LuTiao Programming
LuTiao Programming
Nov 12, 2026 · Backend Development

SQL 300ms, API 12s: The Hidden Cost of Returning 100k Records to Frontend

A backend query interface took 12 seconds despite a 300ms SQL query because it returned 100,000 records directly to the frontend, causing massive object creation, JSON serialization, memory spikes, and GC pressure; the fix involved pagination, DTO projections, separate export endpoints, and monitoring response size.

Async ExportDTO ProjectionGC pressure
0 likes · 18 min read
SQL 300ms, API 12s: The Hidden Cost of Returning 100k Records to Frontend
Ops Community
Ops Community
Nov 6, 2026 · Artificial Intelligence

Production LLM Inference with vLLM/TGI: Deployment, Tuning & Observability Guide

This comprehensive guide covers production deployment and performance tuning of LLM inference services using vLLM and TGI, including hardware planning, Docker/Kubernetes orchestration, key parameter optimization, monitoring with Prometheus, autoscaling with KEDA, troubleshooting common failures, and security hardening.

CUDA GraphDockerFP8 quantization
0 likes · 99 min read
Production LLM Inference with vLLM/TGI: Deployment, Tuning & Observability Guide
Xiaolin Talks Programming
Xiaolin Talks Programming
Oct 31, 2026 · Backend Development

Embedding DuckDB in Spring Boot: Ad-hoc Parquet/CSV Analytics with Multi-tenant Isolation

This article details integrating DuckDB into Spring Boot for embedded OLAP analytics, covering tenant-isolated connection pools, secure view-based file access, streaming exports via COPY and cursors, SQL injection guards, and performance tuning for ad-hoc Parquet/CSV queries without a separate cluster.

CSVDuckDBEmbedded Analytics
0 likes · 48 min read
Embedding DuckDB in Spring Boot: Ad-hoc Parquet/CSV Analytics with Multi-tenant Isolation
Raymond Ops
Raymond Ops
Oct 30, 2026 · Operations

Nginx Optimization Guide: Doubling Concurrency via Configuration Tuning

This comprehensive guide details a systematic Nginx optimization process covering worker processes, connection handling, buffering, caching, compression, proxy settings, rate limiting, and monitoring, demonstrating how proper configuration tuning can triple concurrency on the same hardware with concrete examples and verification steps.

ConcurrencyNginxOperations
0 likes · 41 min read
Nginx Optimization Guide: Doubling Concurrency via Configuration Tuning
ITPUB
ITPUB
Oct 30, 2026 · Operations

Why Switching Linux Page Size from 4KB to 2MB Crashed My Production Services

The author recounts a production incident where blindly enabling 2MB huge pages for a microservice workload caused 30% memory bloat, CPU soft-interrupt spikes, and latency degradation, then explains the TLB vs. fragmentation trade-offs that make huge pages suitable only for large, contiguous memory workloads like databases.

LinuxTLBhuge pages
0 likes · 20 min read
Why Switching Linux Page Size from 4KB to 2MB Crashed My Production Services
Machine Heart
Machine Heart
Oct 26, 2026 · Artificial Intelligence

Teaching AI to Tune Ascend NPUs: Fudan & Huawei XiaoYi Achieve 95.5% Kernel Generation Success

Fudan University and Huawei's XiaoYi team propose SAGE, an AI agent system that combines knowledge cold-start, tool-enhanced diagnosis, and experience learning to generate high-performance kernels for Ascend NPUs, achieving 95.5% success rate on NPUKernelBench with up to 10.86x speedup over vendor libraries.

AI AgentAscend NPUExperience Learning
0 likes · 39 min read
Teaching AI to Tune Ascend NPUs: Fudan & Huawei XiaoYi Achieve 95.5% Kernel Generation Success
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 25, 2026 · Databases

10B Rows into MySQL: From 231 Days to 3.5 Hours — The 6-Step Bulk Insert Playbook

This article details a six-step engineering playbook to bulk-insert 10 billion rows into MySQL, reducing time from 231 days to under 3.5 hours by combining sharding, true JDBC batching with rewriteBatchedStatements, LOAD DATA INFILE, temporary parameter tuning, parallel shard loading, idempotent checkpointing, and shadow-table swapping, while explaining B+ tree capacity math and common pitfalls.

B* treeBulk InsertIdempotency
0 likes · 42 min read
10B Rows into MySQL: From 231 Days to 3.5 Hours — The 6-Step Bulk Insert Playbook
Raymond Ops
Raymond Ops
Oct 24, 2026 · Databases

Right-Sizing Database Connection Pools: From Guesswork to Capacity Budgeting

This article explains how to determine optimal database connection pool sizes by establishing a capacity budget, monitoring pool and database metrics, configuring HikariCP for PostgreSQL, and iteratively tuning based on workload characteristics rather than relying on generic formulas.

Connection PoolingHikariCPPostgreSQL
0 likes · 38 min read
Right-Sizing Database Connection Pools: From Guesswork to Capacity Budgeting
Deepin Linux
Deepin Linux
Oct 22, 2026 · Backend Development

Memory Optimization Deep Dive: Allocate Less, Allocate Faster, Use Efficiently

This article presents a systematic approach to memory optimization across three dimensions—reducing allocation frequency, accelerating allocation speed, and improving memory usage efficiency—with practical C++ techniques including stack allocation, object pools, size-class allocators, huge pages, data structure packing, and false sharing prevention.

C#Memory Optimizationdata structure alignment
0 likes · 23 min read
Memory Optimization Deep Dive: Allocate Less, Allocate Faster, Use Efficiently
Ops Community
Ops Community
Oct 21, 2026 · Databases

MySQL Performance Optimization: Diagnosing Gradual Query Slowdown with EXPLAIN, Composite Indexes & Online DDL Safety

This comprehensive guide walks through a complete MySQL performance optimization cycle: classifying three types of gradual slowdown, setting up slow logs and digest metrics, using EXPLAIN ANALYZE and optimizer trace to pinpoint a full-table scan on a 62M-row orders table, adding a composite index (user_id, status, created_at) via safe online DDL with three safety barriers, and establishing monitoring to prevent regression.

Composite IndexEXPLAINMySQL
0 likes · 47 min read
MySQL Performance Optimization: Diagnosing Gradual Query Slowdown with EXPLAIN, Composite Indexes & Online DDL Safety
Feidie Network
Feidie Network
Oct 19, 2026 · Backend Development

EF Core Deep Dive: Change Tracking, Query Optimization, Concurrency & Migration Strategies

This comprehensive guide explores EF Core's ChangeTracker internals, performance optimization techniques including AsNoTracking and compiled queries, optimistic concurrency with Timestamp tokens, production migration strategies using SQL scripts and bundles, and previews EF Core 10 LTS features like vector search and JSON support.

Backend DevelopmentChangeTrackerDatabase Migration
0 likes · 19 min read
EF Core Deep Dive: Change Tracking, Query Optimization, Concurrency & Migration Strategies
Code Archaeology
Code Archaeology
Oct 18, 2026 · Backend Development

Choosing a Java Garbage Collector: Which Metric Are You Optimizing For?

This guide explains Java garbage collector internals and selection criteria, covering Serial, Parallel, G1, ZGC, and Shenandoah, detailing their trade-offs between throughput, latency, and memory overhead, and provides scenario-based recommendations for microservices, low-latency systems, batch processing, and small containers, including upcoming Java 27 defaults.

Backend DevelopmentG1Garbage Collection
0 likes · 15 min read
Choosing a Java Garbage Collector: Which Metric Are You Optimizing For?
Raymond Ops
Raymond Ops
Oct 17, 2026 · Databases

MySQL Replication Lag Spikes to 10s? 3 Key Parallel Replication Optimizations

This article details a systematic approach to diagnose and resolve MySQL 8.0 replication lag by enabling WRITESET on the source, configuring LOGICAL_CLOCK with optimal worker count on the replica, and preserving commit order, complete with diagnostic queries, configuration steps, and validation metrics.

GTIDLOGICAL_CLOCKMySQL
0 likes · 31 min read
MySQL Replication Lag Spikes to 10s? 3 Key Parallel Replication Optimizations
ITPUB
ITPUB
Oct 14, 2026 · Databases

100 Essential SQL Server DBA Commands for Production Troubleshooting

A comprehensive reference of 100 practical T-SQL commands for SQL Server 2016-2022 DBAs, organized into ten categories covering instance basics, space management, session analysis, locking, performance tuning, indexes, Always On, backup/recovery, permissions, and daily health checks.

Backup RecoveryDBADMV
0 likes · 12 min read
100 Essential SQL Server DBA Commands for Production Troubleshooting
Mingyi World Elasticsearch
Mingyi World Elasticsearch
Oct 11, 2026 · Databases

Why Elasticsearch Struggles on Domestic CPUs: Write, Search & Concurrency Issues Explained

The article analyzes why Elasticsearch underperforms on Chinese ARM-based CPUs — citing weak single-core performance, complex NUMA topologies, JDK selection pitfalls, version compatibility gaps, and unfair benchmarking — and evaluates Easysearch as a supported alternative with vendor-backed compatibility across major domestic chips and OSes.

ARMChinese chipsEasysearch
0 likes · 13 min read
Why Elasticsearch Struggles on Domestic CPUs: Write, Search & Concurrency Issues Explained
ITPUB
ITPUB
Oct 6, 2026 · Databases

100 Essential Dameng DM8 DBA Commands for Daily Operations & Troubleshooting

This comprehensive guide lists 100 essential Dameng DM8 database administration commands covering instance management, user permissions, tablespace operations, performance tuning, backup/recovery, logical import/export, and high-availability monitoring for daily DBA operations and troubleshooting.

Backup RecoveryDBADM8
0 likes · 32 min read
100 Essential Dameng DM8 DBA Commands for Daily Operations & Troubleshooting
ITPUB
ITPUB
Sep 26, 2026 · Databases

100 Essential Oracle DBA Commands: Instance, SQL Tuning, RMAN & Data Guard

This comprehensive guide lists 100 essential Oracle DBA commands covering instance management, parameter configuration, session troubleshooting, lock analysis, SQL performance tuning, tablespace and user management, UNDO, temporary tablespace, RMAN backup and recovery, Data Guard, RAC, Data Pump, and OS-level diagnostics, with practical examples and usage notes.

Backup RecoveryDBAData Guard
0 likes · 30 min read
100 Essential Oracle DBA Commands: Instance, SQL Tuning, RMAN & Data Guard
MaGe Linux Operations
MaGe Linux Operations
Sep 26, 2026 · Operations

RAG System Operations: Vector Database Selection & Performance Tuning

This comprehensive guide covers end-to-end RAG system operations, from vector database selection and workload profiling to HNSW parameter tuning, filtering strategies, index freshness monitoring, embedding upgrades, capacity planning, backup validation, and troubleshooting methodologies with concrete examples and evaluation frameworks.

Backup RecoveryHNSWMilvus
0 likes · 64 min read
RAG System Operations: Vector Database Selection & Performance Tuning
liandk
liandk
Sep 22, 2026 · Backend Development

Java Memory Leak Deep Dive: 10 Hidden Scenarios, MAT Analysis & Prevention

This comprehensive guide covers 10 hidden Java memory leak scenarios, a 6-step MAT-based investigation SOP, code-level fixes for ThreadLocal and static collections, emergency mitigation tactics, and long-term prevention standards to eliminate recurring OOM crashes.

GCJVMJava
0 likes · 15 min read
Java Memory Leak Deep Dive: 10 Hidden Scenarios, MAT Analysis & Prevention
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 22, 2026 · Backend Development

Spring Boot Tomcat Tuning: Breaking the 4K QPS Ceiling with Thread Pool & Keep-Alive Config

This article details how default Spring Boot Tomcat settings (maxThreads=200) cap throughput at ~4K QPS despite low CPU, and demonstrates step-by-step tuning of thread pool, connection limits, and Keep-Alive parameters using Little's Law and load testing to achieve 10K+ QPS with 800 threads and proper monitoring.

Keep-AliveLittle's LawSpring Boot
0 likes · 17 min read
Spring Boot Tomcat Tuning: Breaking the 4K QPS Ceiling with Thread Pool & Keep-Alive Config
liandk
liandk
Sep 18, 2026 · Backend Development

Hidden GC Pauses Causing Random API Timeouts: JVM STW Troubleshooting Guide

This article reveals how long GC stop-the-world pauses cause random API timeouts without errors, detailing two fault scenarios, a four-step GC log analysis SOP with specific JVM flags, four root causes including young generation sizing and memory fragmentation, and optimization strategies from emergency restarts to G1/ZGC upgrades with monitoring alerts.

AlertingFull GCG1
0 likes · 15 min read
Hidden GC Pauses Causing Random API Timeouts: JVM STW Troubleshooting Guide
liandk
liandk
Sep 18, 2026 · Backend Development

Java Production Troubleshooting: Universal SOP & 10 Failure Cheat Sheet

This series finale presents a universal 6-step SOP for Java production troubleshooting, a bottom-up layered diagnosis model, a quick-reference guide for 10 common failure patterns with symptoms, root causes, and tools, plus five golden principles for incident handling.

ArthasGC AnalysisJVM
0 likes · 16 min read
Java Production Troubleshooting: Universal SOP & 10 Failure Cheat Sheet
Raymond Ops
Raymond Ops
Sep 17, 2026 · Databases

MySQL & PostgreSQL Monitoring: Critical Metrics & Alert Thresholds Explained

This comprehensive guide covers MySQL and PostgreSQL monitoring essentials, including key metrics (connections, throughput, InnoDB, replication), version-specific differences, alert thresholds, exporter deployment (mysqld_exporter, postgres_exporter), Grafana dashboards, Prometheus alerting rules, troubleshooting playbooks for common issues like connection exhaustion, replication lag, deadlocks, and disk growth, plus automation scripts for long-transaction killing and slow-query analysis.

AlertingExportersGrafana
0 likes · 74 min read
MySQL & PostgreSQL Monitoring: Critical Metrics & Alert Thresholds Explained
liandk
liandk
Sep 13, 2026 · Backend Development

Java CPU 100% Spike: Complete Production Troubleshooting & Root Cause Analysis

This article provides a comprehensive guide to troubleshooting Java CPU 100% spikes in production, covering root cause categories, a standard SOP using top, jstack, and thread analysis, a real-world infinite loop case study, GC-related CPU issues, emergency mitigation steps, and long-term prevention practices.

CPU troubleshootingGarbage CollectionJava
0 likes · 13 min read
Java CPU 100% Spike: Complete Production Troubleshooting & Root Cause Analysis
MaGe Linux Operations
MaGe Linux Operations
Sep 11, 2026 · Databases

MySQL Slow Query Mastery: From Log Analysis to Index Optimization

This comprehensive guide walks through the complete MySQL slow query troubleshooting loop: enabling slow query logs, analyzing with mysqldumpslow and pt-query-digest, using EXPLAIN to identify missing indexes or inefficient plans, designing composite indexes following leftmost prefix principles, validating in test environments, and safely deploying changes in production with rollback plans.

EXPLAINInnoDBMySQL
0 likes · 52 min read
MySQL Slow Query Mastery: From Log Analysis to Index Optimization
liandk
liandk
Sep 9, 2026 · Backend Development

Master Arthas: Zero-Downtime Java Debugging, Live Logs & Hot Code Reload

This guide demonstrates how to use Arthas, Alibaba's open-source Java diagnostic tool, to troubleshoot production issues without downtime—covering installation, core commands (dashboard, trace, watch, stack, logger, redefine), three real-world case studies, and critical production safety rules.

ArthasHot ReloadJava
0 likes · 12 min read
Master Arthas: Zero-Downtime Java Debugging, Live Logs & Hot Code Reload
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 8, 2026 · Databases

10 Essential MySQL Configuration Settings for Performance Optimization

This article outlines ten critical MySQL configuration parameters administrators should prioritize after installation, covering InnoDB buffer pool sizing, log file configuration, connection limits, flush methods, query cache disabling, binary logging, and DNS resolution skipping, with practical guidance on safe modification practices and version-specific considerations.

Database ConfigurationInnoDBMySQL
0 likes · 10 min read
10 Essential MySQL Configuration Settings for Performance Optimization
liandk
liandk
Sep 7, 2026 · Backend Development

Why Your Troubleshooting Is Slow: The 4-Step Framework Senior Java Developers Use

This article contrasts junior developers' trial-and-error debugging with senior engineers' structured four-step method — confirm symptoms, layer-by-layer isolation, evidence-based root-cause analysis, and closed-loop remediation — to cut production incident resolution from hours to minutes.

JVMJavaTroubleshooting
0 likes · 8 min read
Why Your Troubleshooting Is Slow: The 4-Step Framework Senior Java Developers Use
Architect Chen
Architect Chen
Sep 6, 2026 · Databases

2026 MySQL DBA Command Reference: 9 Essential Commands Explained

This comprehensive guide details nine essential MySQL DBA commands — SHOW DATABASES, SHOW TABLE STATUS, SHOW FULL PROCESSLIST, SHOW ENGINE INNODB STATUS, SHOW VARIABLES, SHOW STATUS, EXPLAIN, SHOW INDEX, and SHOW CREATE TABLE — with syntax examples, key output fields, and practical troubleshooting scenarios for performance tuning and database administration.

DBAEXPLAINInnoDB
0 likes · 6 min read
2026 MySQL DBA Command Reference: 9 Essential Commands Explained
MaGe Linux Operations
MaGe Linux Operations
Sep 5, 2026 · Operations

Troubleshooting High Redis Client Connections: A Step-by-Step Guide to Identification and Optimization

This comprehensive guide details a systematic approach to diagnosing and resolving high Redis client connection counts, covering connection models, configuration tuning, CLI analysis commands, application-level connection pool fixes, temporary mitigation tactics, and long-term monitoring best practices with real-world case examples.

CLIENT LISTConnection LeakConnection Pooling
0 likes · 35 min read
Troubleshooting High Redis Client Connections: A Step-by-Step Guide to Identification and Optimization
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 5, 2026 · Backend Development

Migrating Log Platform from Elasticsearch to ClickHouse: Table Design, Materialized Views & Tuning Lessons

The author details migrating a high-volume logging platform from Elasticsearch to ClickHouse, covering schema design with ReplicatedMergeTree, Spring Boot integration via JDBC and MyBatis, materialized views for pre-aggregation, and optimization techniques like skip indexes, batch inserts, and capacity planning.

ClickHouseElasticsearchKafka
0 likes · 21 min read
Migrating Log Platform from Elasticsearch to ClickHouse: Table Design, Materialized Views & Tuning Lessons
Cloud Architecture
Cloud Architecture
Sep 3, 2026 · Backend Development

TCC Is Not a Silver Bullet: Engineering Go Microservice Distributed Transactions with Performance Tuning

This article details the engineering implementation and performance optimization of TCC distributed transactions in Go microservices, using an order placement scenario with inventory locking and wallet freezing, covering data models, idempotent state machines, recovery workers, hotspot optimization, and observability.

ConcurrencyGoIdempotency
0 likes · 33 min read
TCC Is Not a Silver Bullet: Engineering Go Microservice Distributed Transactions with Performance Tuning
51CTO HarmonyOS Developer Community
51CTO HarmonyOS Developer Community
Sep 2, 2026 · Mobile Development

HarmonyOS 7.x: Build iOS-Style Rubber Band Bounce for Lists (System vs Custom Physics)

This article details two approaches to implement edge bounce effects in HarmonyOS 7.x Lists: using the built-in edgeEffect.Spring API for quick integration, and a custom physics-based animation with damping formula and spring curve tuning for deep customization, including parameter recommendations, bottom bounce implementation, performance comparison, and five common pitfalls with solutions.

HarmonyOSListPull-to-Refresh
0 likes · 18 min read
HarmonyOS 7.x: Build iOS-Style Rubber Band Bounce for Lists (System vs Custom Physics)
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 31, 2026 · Backend Development

Building a High-Performance TCP Long-Connection Gateway with Spring Boot and Netty: Protocol, Heartbeat & Cluster Broadcast

This article details integrating Netty with Spring Boot to build a scalable TCP long-connection gateway, covering binary protocol design with length-field framing, heartbeat detection using IdleStateHandler, session management with Redis and local maps, single-node and Redis Pub/Sub cluster push mechanisms, and performance tuning tips including Epoll transport and thread pool isolation.

ClusterEpollIoT
0 likes · 25 min read
Building a High-Performance TCP Long-Connection Gateway with Spring Boot and Netty: Protocol, Heartbeat & Cluster Broadcast
liandk
liandk
Aug 29, 2026 · Databases

Master MySQL Slow Query Log: Full Hands‑On Workflow to Capture, Analyze, and Fix Slow SQL

This guide explains what the MySQL slow query log records, why it is essential for production, when and how to enable it temporarily or permanently, key parameters to tune, how to simulate slow queries, interpret log fields, use mysqldumpslow for aggregation, follow a step‑by‑step optimization pipeline, and avoid common pitfalls.

MySQLdatabase optimizationmysqldumpslow
0 likes · 10 min read
Master MySQL Slow Query Log: Full Hands‑On Workflow to Capture, Analyze, and Fix Slow SQL
Java Tech Workshop
Java Tech Workshop
Aug 29, 2026 · Backend Development

When a ThreadPool Queue Is Full: How ThreadPoolExecutor Expands and Handles Rejection

The article explains the exact order in which ThreadPoolExecutor expands—core threads, queueing, non‑core threads, then rejection—illustrates the behavior with a runnable example, compares the four built‑in RejectedExecutionHandler strategies, debunks common misconceptions, and offers production‑grade configuration and monitoring best practices.

Java concurrencyThreadPoolExecutorperformance tuning
0 likes · 24 min read
When a ThreadPool Queue Is Full: How ThreadPoolExecutor Expands and Handles Rejection
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 26, 2026 · Backend Development

Million-Row Excel Import/Export: Streaming, Batching & Async Patterns for Zero-OOM Performance

This guide details a production-grade architecture for million-row Excel import/export using EasyExcel streaming reads, SXSSF streaming writes, JDBC batch inserts with rewriteBatchedStatements, async MQ processing, and resource isolation — achieving 10-100x speedups and sub-100MB memory.

Batch ProcessingEasyExcelExcel streaming
0 likes · 32 min read
Million-Row Excel Import/Export: Streaming, Batching & Async Patterns for Zero-OOM Performance
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 21, 2026 · Backend Development

Arthas in Production: Diagnosing Spring Boot CPU Spikes, Memory Leaks & Latency Spikes

This article demonstrates using Arthas to diagnose a Spring Boot service with 100% CPU, memory leaks, and latency spikes, showing step-by-step commands like dashboard, thread, heapdump, trace, and watch to pinpoint dead loops, unbounded caches, and missing SQL indexes, plus emergency hot-patching with redefine.

ArthasCPU profilingJVM troubleshooting
0 likes · 17 min read
Arthas in Production: Diagnosing Spring Boot CPU Spikes, Memory Leaks & Latency Spikes
Code Farming
Code Farming
Aug 21, 2026 · Databases

How to Cut Redis Cluster Failover to Under 10 Seconds

The article breaks down Redis‑Cluster failover into detection, election, failover, and client perception stages, explains the timing bottlenecks of each, and provides concrete server‑side and Lettuce client configurations that shrink end‑to‑end recovery to under ten seconds.

FailoverHigh AvailabilityLettuce
0 likes · 7 min read
How to Cut Redis Cluster Failover to Under 10 Seconds
Dabaoshi
Dabaoshi
Aug 18, 2026 · Backend Development

Thread Pool Mechanics and Tuning: Avoid new Thread() in Production

This article explains why creating raw threads in production is costly, breaks down the seven ThreadPoolExecutor parameters, shows the exact execution flow of a submitted task, compares queue choices and Executors factories, and provides practical tuning, rejection‑policy and graceful‑shutdown guidance.

ConcurrencyExecutorServiceJava
0 likes · 16 min read
Thread Pool Mechanics and Tuning: Avoid new Thread() in Production
Golang Shines
Golang Shines
Aug 13, 2026 · Backend Development

Cut page load from 5 s to 500 ms: 12 Nginx tuning parameters

The article explains that reducing page load from five seconds to 500 ms requires more than just tweaking a few Nginx directives, outlines a systematic workflow—baseline measurement, hypothesis, single‑parameter gray rollout, verification and rollback—and details twelve specific Nginx settings that can eliminate proven Web‑layer bottlenecks such as file‑descriptor limits, connection models, static‑file paths, compression and request buffering.

LinuxNginxmonitoring
0 likes · 26 min read
Cut page load from 5 s to 500 ms: 12 Nginx tuning parameters
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 13, 2026 · Backend Development

Spring Boot + Flowable 7.x: Enterprise-Grade Integration Guide with Production Pitfalls

A comprehensive practical guide to integrating Flowable 7.x with Spring Boot for enterprise workflow systems, covering core concepts, database initialization strategies, process versioning, dynamic form decoupling, multi-instance approval patterns, listener injection, historical data archiving, performance tuning, cluster deployment, multi-tenancy, and production-grade transaction and deadlock handling.

BPMNFlowableProduction Best Practices
0 likes · 18 min read
Spring Boot + Flowable 7.x: Enterprise-Grade Integration Guide with Production Pitfalls

MySQL Large Table Optimization: 5 Strategies for 100M+ Row Queries

This article presents a five-step practical guide for optimizing MySQL queries on tables exceeding 100 million rows, covering index optimization, SQL rewriting, cursor-based pagination, table structure improvements including partitioning, and architectural upgrades like read-write separation and sharding, with concrete code examples and performance comparisons.

MySQLPartitioningindex optimization
0 likes · 12 min read
MySQL Large Table Optimization: 5 Strategies for 100M+ Row Queries
Mike Chen Rui
Mike Chen Rui
Aug 6, 2026 · Operations

Hands‑on Nginx High‑Concurrency Tuning: Boost Performance Up to 10×

This article walks through practical Nginx high‑concurrency tuning steps—including worker_processes, worker_connections, Linux file‑descriptor limits, and sendfile zero‑copy settings—to dramatically increase throughput and handle tens of thousands of simultaneous connections.

Nginxhigh concurrencylinux limits
0 likes · 3 min read
Hands‑on Nginx High‑Concurrency Tuning: Boost Performance Up to 10×
CodeOnCode
CodeOnCode
Aug 6, 2026 · Backend Development

Why Mixed GC Doesn’t Empty the Old Generation in G1

Mixed GC in G1 only reclaims a portion of the Old generation that fits within the pause‑time budget, so seeing the Old region size stay high after a mixed pause does not mean G1 has failed, but rather reflects collection cost, survival rates, and budgeting constraints.

G1 GCGarbage CollectionJVM
0 likes · 16 min read
Why Mixed GC Doesn’t Empty the Old Generation in G1
Engineer Tang's Implementation Study Notes
Engineer Tang's Implementation Study Notes
Aug 6, 2026 · Backend Development

Connection Pool Exhausted? It's Likely Leaked Connections, Not Database Limits

This guide diagnoses database connection pool exhaustion by distinguishing connection leaks from genuine high concurrency, demonstrating log analysis for HikariCP and Druid, verifying leaks via SHOW PROCESSLIST and pool metrics, fixing code with try-with-resources, tuning key HikariCP parameters, and enabling leak detection to pinpoint exact leak locations.

Backend DevelopmentConnection LeakConnection Pool
0 likes · 10 min read
Connection Pool Exhausted? It's Likely Leaked Connections, Not Database Limits
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 6, 2026 · Backend Development

Spring Boot + Quartz: Production-Grade Scheduling with Dynamic Control, Cluster HA & Misfire Handling

This guide details building a production-grade Spring Boot Quartz scheduler covering JDBC persistence, cluster coordination via database locks, misfire policies, dynamic job management, execution logging via JobListener, idempotency patterns, monitoring metrics, and troubleshooting common pitfalls like transaction boundaries and clock drift.

ClusterIdempotencyQuartz
0 likes · 20 min read
Spring Boot + Quartz: Production-Grade Scheduling with Dynamic Control, Cluster HA & Misfire Handling
Ops Community
Ops Community
Aug 5, 2026 · Operations

Linux Kernel Sysctl Tuning Checklist – Proven Steps to Improve Performance

This article debunks the myth that simply copying a sysctl.conf yields a 30% boost, and presents a rigorous engineering loop—baseline measurement, hypothesis formulation, gray‑scale changes, observation of side effects, and rollback—along with detailed scripts, metrics, and per‑parameter guidance for memory, network, file handles, and more.

LinuxOperationskernel parameters
0 likes · 37 min read
Linux Kernel Sysctl Tuning Checklist – Proven Steps to Improve Performance
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 5, 2026 · Backend Development

Spring Boot + Caffeine: Multi-Level Cache Architecture, Consistency & Load Tests

This article details integrating Caffeine with Spring Boot 3.x for a three-tier L1/L2/DB cache architecture, covering Window TinyLFU internals, refreshAfterWrite vs expireAfterWrite, manual vs annotation-driven integration, read/write paths, message-driven invalidation with version stamps, load test results showing 48k QPS at 2ms P99, and production tuning for memory, GC, and hot-key protection.

CachingCaffeineConsistency
0 likes · 20 min read
Spring Boot + Caffeine: Multi-Level Cache Architecture, Consistency & Load Tests
MaGe Linux Operations
MaGe Linux Operations
Aug 4, 2026 · Databases

Why 70% of System Outages Stem from SQL Performance: A MySQL Index Optimization Guide

The article walks through a systematic MySQL 8.0 index‑optimization workflow—starting with diagnosing slow queries and lock waits, validating execution plans with EXPLAIN ANALYZE, safely adding or dropping indexes using online DDL, handling pagination patterns, and verifying improvements via comprehensive metrics before and after.

EXPLAIN ANALYZEMySQLindex optimization
0 likes · 12 min read
Why 70% of System Outages Stem from SQL Performance: A MySQL Index Optimization Guide
Raymond Ops
Raymond Ops
Aug 3, 2026 · Databases

How to Diagnose MySQL Slow Queries Without Relying on Blind Indexing

This guide walks through a systematic approach to uncovering and fixing MySQL slow queries, covering slow‑query‑log configuration, log analysis with mysqldumpslow and pt‑query‑digest, EXPLAIN‑based execution‑plan inspection, index design principles, SQL rewrites, configuration tuning, and ongoing monitoring to prevent performance regressions.

Database ConfigurationEXPLAINMySQL
0 likes · 27 min read
How to Diagnose MySQL Slow Queries Without Relying on Blind Indexing
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 2, 2026 · Backend Development

Spring Boot + Spring Session: Distributed Session Management & Multi-Client Sync in Practice

This article provides a production-ready guide to replacing traditional HttpSession with Spring Session backed by Redis, covering multi-client session unification, performance tuning, security hardening, high-availability patterns, and practical Spring Boot 3.x configuration with code examples.

High AvailabilityMulti-clientRedis
0 likes · 19 min read
Spring Boot + Spring Session: Distributed Session Management & Multi-Client Sync in Practice
MaGe Linux Operations
MaGe Linux Operations
Aug 1, 2026 · Databases

MySQL Replication Lag Soars to 10 seconds? Three Parallel‑Replication Tricks to Fix It

When MySQL replication latency jumps from milliseconds to 10 seconds, blindly raising replica_parallel_workers won’t help; the article walks through diagnosing the delay, then applies three concrete parallel‑replication optimizations—enabling WRITESET on the source, configuring LOGICAL_CLOCK with appropriate applier workers, and optionally preserving commit order—while showing the required SQL commands, monitoring queries, and rollback steps.

GTIDLOGICAL_CLOCKMySQL
0 likes · 21 min read
MySQL Replication Lag Soars to 10 seconds? Three Parallel‑Replication Tricks to Fix It
Dabaoshi
Dabaoshi
Jul 31, 2026 · Backend Development

JVM GC Tuning and Live Production Troubleshooting

This article guides backend engineers through practical JVM garbage‑collection tuning and on‑line incident diagnosis, covering measurement‑first principles, JDK 8 vs 17 log changes, key JVM flags, essential tooling, and step‑by‑step real‑world cases for CPU spikes, memory leaks, and deadlocks.

ArthasGCJFR
0 likes · 20 min read
JVM GC Tuning and Live Production Troubleshooting
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 31, 2026 · Backend Development

Spring Boot gRPC Integration: Contract-First Microservices with HTTP/2 Performance Gains

This article details production-ready gRPC integration with Spring Boot 3.x, covering contract-first Protobuf design, Maven code generation, timeout and retry strategies with Resilience4j, mTLS and JWT interceptors, JVM/Netty tuning for 40k+ QPS, Spring Cloud service discovery integration, and cross-language Java-Go benchmarking results showing 2x throughput over REST.

HTTP/2ProtobufResilience4j
0 likes · 21 min read
Spring Boot gRPC Integration: Contract-First Microservices with HTTP/2 Performance Gains
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Jul 30, 2026 · Databases

Running MySQL in Docker: Avoiding Data Loss, Performance Drops & HA Gaps

This article analyzes the risks of running MySQL in Docker—data loss, I/O performance degradation, networking overhead, and HA gaps—and provides production-ready solutions including Docker Compose configs, custom my.cnf, backup scripts, Kubernetes StatefulSet examples, and a troubleshooting matrix for interview preparation.

Backup StrategyContainerizationDocker
0 likes · 28 min read
Running MySQL in Docker: Avoiding Data Loss, Performance Drops & HA Gaps
MaGe Linux Operations
MaGe Linux Operations
Jul 30, 2026 · Operations

Cut Page Load from 5 s to 500 ms: 12 Essential Nginx Performance Tweaks

The article explains how to reduce overall page latency from five seconds to half a second by systematically measuring, hypothesizing, and tuning twelve Nginx directives—such as worker processes, file‑descriptor limits, keep‑alive settings, and gzip—while backing up configurations, performing gray‑scale rollouts, and validating results with curl and log analysis.

LinuxNginxconfiguration
0 likes · 25 min read
Cut Page Load from 5 s to 500 ms: 12 Essential Nginx Performance Tweaks
Java Architect Handbook
Java Architect Handbook
Jul 27, 2026 · Backend Development

Druid Crashed in Production? Essential Optimizations for Spring Boot

The article explains why Druid connection pools can fail in production and provides a step‑by‑step guide to extreme optimization, covering environment setup, core pool parameter tuning, monitoring with StatFilter and web UI, security hardening, leak detection, dynamic adjustments, and common pitfalls.

Advanced OptimizationConnection PoolDruid
0 likes · 15 min read
Druid Crashed in Production? Essential Optimizations for Spring Boot
Dabaoshi
Dabaoshi
Jul 22, 2026 · Databases

Why InnoDB Needs a Buffer Pool and How It Works

The article explains why InnoDB must cache disk pages in a Buffer Pool, details the pool's internal structure, eviction policies, dirty‑page flushing mechanisms, multi‑instance and chunk sizing for large workloads, and how to monitor its health with SHOW ENGINE INNODB STATUS.

Buffer PoolChunkInnoDB
0 likes · 13 min read
Why InnoDB Needs a Buffer Pool and How It Works
Programmer1970
Programmer1970
Jul 21, 2026 · Backend Development

How to Cut RocketMQ Consumer Latency from 10 s to 500 ms with Five Overlooked Settings

During a traffic peak the order service saw 30‑second consumer latency and a backlog of over 20 000 messages; by adjusting five RocketMQ consumer parameters—pullBatchSize, consumeThreadMin/Max, adjustThreadPoolNumsThreshold, pullTimeoutMillis, socketTimeoutMillis, and consumeMessageBatchMaxSize—the team reduced end‑to‑end latency to 500 ms, raised TPS to over 2500, and cleared the backlog.

RocketMQconfigurationconsumer latency
0 likes · 9 min read
How to Cut RocketMQ Consumer Latency from 10 s to 500 ms with Five Overlooked Settings
Cloud Architecture
Cloud Architecture
Jul 20, 2026 · Databases

Designing MySQL for Millions of QPS: From Single Server to Distributed Architecture

The article walks through a real‑world order system that spikes to 300,000 QPS, explaining why the original single‑node MySQL design fails, and detailing a step‑by‑step evolution—index tuning, transaction fixes, read‑write splitting, vertical and horizontal sharding, plus data‑pipeline integration—to achieve stable low latency at massive scale.

MySQLdatabase scalinghigh QPS
0 likes · 20 min read
Designing MySQL for Millions of QPS: From Single Server to Distributed Architecture
Tinker Programmer
Tinker Programmer
Jul 18, 2026 · Backend Development

From CMS to ZGC: How Java GC Pauses Dropped Below 1 ms

The article chronicles Java’s garbage‑collector evolution—from the deprecated CMS to G1’s pitfalls and the low‑latency ZGC and Shenandoah—explaining why CMS was removed, how G1 can degrade, and how ZGC/Shenandoah achieve sub‑millisecond pauses, plus new JDK 25/26 features and practical tuning steps.

G1Garbage CollectionJDK25
0 likes · 18 min read
From CMS to ZGC: How Java GC Pauses Dropped Below 1 ms
Raymond Ops
Raymond Ops
Jul 16, 2026 · Operations

Nginx Configuration Optimization: Mastering Worker Processes for Performance Tuning

This guide explains Nginx's multi‑process architecture, shows how to bind worker processes to CPU cores, tune worker connections, configure upstream load‑balancing, enable proxy buffering, keepalive, gzip/Brotli compression, SSL/TLS settings, and provides testing and troubleshooting scripts for high‑performance deployments.

GZIPNginxSSL
0 likes · 35 min read
Nginx Configuration Optimization: Mastering Worker Processes for Performance Tuning
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 15, 2026 · Backend Development

HikariCP Deep Tuning: Leak Detection, Parameter Optimization & Slow SQL Defense in Spring Boot

A production incident where core API latency spiked from 50ms to 30s+ due to connection leaks and exhausted MySQL max_connections is dissected, revealing how default HikariCP settings become time bombs under load and how to build a defense system with leak detection, parameter tuning, slow SQL interception, and kill mechanisms.

Connection PoolHikariCPMySQL
0 likes · 18 min read
HikariCP Deep Tuning: Leak Detection, Parameter Optimization & Slow SQL Defense in Spring Boot
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 14, 2026 · Backend Development

ORM Performance Tuning in Spring Boot: Fixing N+1 Queries, Dynamic SQL Optimization & Fetch Strategies

This guide covers root-cause analysis of N+1 queries in JPA and MyBatis, APM-based detection methods, fetch strategy optimization using EntityGraph and JOIN FETCH, MyBatis resultMap refactoring, lazy-loading boundaries, second-level cache trade-offs, keyset pagination, and production-grade SQL interceptors with code review checklists.

Fetch StrategyJPAMyBatis
0 likes · 21 min read
ORM Performance Tuning in Spring Boot: Fixing N+1 Queries, Dynamic SQL Optimization & Fetch Strategies
Coder Trainee
Coder Trainee
Jul 13, 2026 · Fundamentals

Top 10 Must‑Ask JVM Interview Questions

This article presents ten essential JVM interview questions, covering the Java 8 memory model, object allocation flow, common GC algorithms and collectors, class‑loading mechanics, OOM and CPU‑spike troubleshooting, tuning parameters, and the differences among strong, soft, weak and phantom references.

Class LoadingGarbage CollectionJVM
0 likes · 12 min read
Top 10 Must‑Ask JVM Interview Questions
Raymond Ops
Raymond Ops
Jul 13, 2026 · Operations

Systematic Root‑Cause Analysis for NFS Mount Failures

This guide presents a systematic, layer‑by‑layer methodology for diagnosing and resolving NFS share mount failures, covering version differences, architecture layers, key daemons, RPC mechanisms, common error messages, detailed server and client checks, firewall and SELinux considerations, performance tuning, high‑availability setups, and monitoring.

KerberosLinuxNFS
0 likes · 50 min read
Systematic Root‑Cause Analysis for NFS Mount Failures

How CPU Affinity Boosts Low‑Latency in High‑Frequency Trading

The article explains why the Linux scheduler’s thread migration hurts deterministic low‑latency trading, outlines three reasons to bind threads to specific cores, demonstrates how to use taskset and Rust’s core_affinity crate for binding, and shows how to verify the binding with htop and command‑line tools.

CPU affinityLinux schedulingRust
0 likes · 13 min read
How CPU Affinity Boosts Low‑Latency in High‑Frequency Trading
Ops Community
Ops Community
Jul 11, 2026 · Operations

Boost Nginx Performance: Scaling from Thousands to Ten‑Thousands RPS

The article presents a reproducible Nginx performance‑tuning workflow that starts with defining a baseline and acceptance criteria, measures CPU, file‑descriptor, upstream and disk limits, then incrementally adjusts worker settings, systemd limits, keepalive, buffering and compression, while using gray‑scale deployment and safe rollback.

BufferingGZIPLinux
0 likes · 18 min read
Boost Nginx Performance: Scaling from Thousands to Ten‑Thousands RPS
MaGe Linux Operations
MaGe Linux Operations
Jul 8, 2026 · Operations

How I Optimized Nginx to Double My Site’s Concurrency

The article walks through a systematic Nginx performance tuning process that starts with baseline load testing, identifies bottlenecks in worker processes, connection limits, I/O and buffering, and applies targeted configuration changes—such as auto workers, keep‑alive tuning, gzip, and proxy buffers—resulting in a three‑fold increase in concurrent request handling.

ConcurrencyLinuxNginx
0 likes · 31 min read
How I Optimized Nginx to Double My Site’s Concurrency
CodeOnCode
CodeOnCode
Jul 6, 2026 · Backend Development

Big‑Sale Load Test: Why You Shouldn't Rush to Tune JVM Parameters

During a major sales promotion, a sudden P99 latency jump can tempt teams to tweak JVM settings, but this article shows how to build a three‑layer evidence chain—GC logs, JFR, business and container metrics—to confirm whether the JVM is truly at fault before making any parameter changes.

Big SaleGCJFR
0 likes · 16 min read
Big‑Sale Load Test: Why You Shouldn't Rush to Tune JVM Parameters
Coder Trainee
Coder Trainee
Jun 29, 2026 · Backend Development

Java Performance Tuning in Practice (Part 6): End-to-End Case Study from Full GC to 200 ms Response

The article walks through a real e‑commerce order service where afternoon spikes caused response times to jump to 2‑3 seconds, Full GC to run every few minutes, and Metaspace to hit 99.9%, then demonstrates step‑by‑step analysis using monitoring, GC logs, jstat, jmap, and heap dumps, fixes a custom class‑loader leak, adjusts JVM flags, and achieves sub‑200 ms latency with no Full GC.

Classloader LeakGCJVM
0 likes · 8 min read
Java Performance Tuning in Practice (Part 6): End-to-End Case Study from Full GC to 200 ms Response
Cloud Architecture
Cloud Architecture
Jun 29, 2026 · Databases

Deep Guide to MySQL Index Failure: From Core Mechanics to High‑Concurrency Production Practices

This comprehensive guide explains why seemingly indexed MySQL queries can still cause severe latency spikes in high‑traffic systems, explores the underlying InnoDB structures and optimizer cost model, enumerates twelve common failure patterns with concrete SQL examples, and provides a production‑grade methodology for diagnosing, engineering, and automating index governance.

InnoDBMySQLhigh concurrency
0 likes · 39 min read
Deep Guide to MySQL Index Failure: From Core Mechanics to High‑Concurrency Production Practices
Coder Trainee
Coder Trainee
Jun 28, 2026 · Fundamentals

Java Performance Tuning Part 5: Hands‑On GC Optimization from G1 to ZGC

This article walks through Java GC tuning by defining low‑latency and high‑throughput goals, comparing major collectors, presenting G1 and ZGC configuration examples, and demonstrating a real‑world payment system case where pause times were reduced from 150‑200 ms to under 50 ms.

G1GCJVM
0 likes · 8 min read
Java Performance Tuning Part 5: Hands‑On GC Optimization from G1 to ZGC
Coder Trainee
Coder Trainee
Jun 27, 2026 · Backend Development

Mastering Java Thread‑Pool Tuning: Practical Performance Tips

This article explains why Java thread pools need tuning, walks through the seven core ThreadPoolExecutor parameters, provides formula‑based sizing, offers configuration templates for different workloads, shows monitoring and dynamic adjustment techniques, and highlights common pitfalls with concrete code examples.

ConcurrencyJavaSpring
0 likes · 8 min read
Mastering Java Thread‑Pool Tuning: Practical Performance Tips
Coder Trainee
Coder Trainee
Jun 26, 2026 · Backend Development

Java Performance Tuning: Practical Guide to Detecting and Fixing Memory Leaks

This article explains how to differentiate memory leaks from out‑of‑memory errors, identifies classic GC‑based leak signals, introduces a toolchain (jstat, jmap, MAT, Arthas, JProfiler), walks through a step‑by‑step investigation workflow, lists common leak patterns, presents a real‑world ThreadLocal leak case, and offers preventive measures such as monitoring, regular heap dumps, code review, and stress testing.

ArthasGCJava
0 likes · 9 min read
Java Performance Tuning: Practical Guide to Detecting and Fixing Memory Leaks
Xiaolin Talks Programming
Xiaolin Talks Programming
Jun 26, 2026 · Backend Development

Multi-Tenant SaaS in Production: Spring Boot Dynamic Data Source & Row-Level Isolation

This article shares production-hardened patterns for multi-tenant SaaS using Spring Boot, covering isolation mode selection, ThreadLocal-based context propagation, MyBatis-Plus SQL interception for automatic tenant_id injection, Feign and async thread propagation, HikariCP tuning, composite indexing, cursor pagination, and real-world pitfalls like interceptor ordering, transaction-bound data source switching, and ThreadLocal leakage.

FeignMulti-tenancyMyBatis Plus
0 likes · 19 min read
Multi-Tenant SaaS in Production: Spring Boot Dynamic Data Source & Row-Level Isolation
Coder Trainee
Coder Trainee
Jun 25, 2026 · Backend Development

Java Performance Tuning Part 1: Understanding the JVM Memory Model from a GC Log

This article launches a Java performance tuning series, explaining why GC logs are the starting point, reviewing the JVM memory model, showing how to enable and read GC logs, dissecting minor and full GC entries, comparing common GC algorithms, and introducing visualization tools to help pinpoint memory issues.

GCGarbage CollectionJVM
0 likes · 10 min read
Java Performance Tuning Part 1: Understanding the JVM Memory Model from a GC Log
Shepherd Advanced Notes
Shepherd Advanced Notes
Jun 24, 2026 · Backend Development

Boosting Throughput 10×: Architecture Evolution and Tuning for High‑Concurrency Batch Processing

The article details how a sluggish batch‑processing system handling millions of records was redesigned with XXL‑JOB sharding, Redis‑based dynamic task distribution, cursor pagination, and selective transaction scopes, achieving nearly ten‑fold throughput improvement while addressing resource contention, load‑balancing, and reliable result reconciliation.

Batch ProcessingJavaMySQL
0 likes · 19 min read
Boosting Throughput 10×: Architecture Evolution and Tuning for High‑Concurrency Batch Processing
Xiaolin Talks Programming
Xiaolin Talks Programming
Jun 23, 2026 · Cloud Native

Solving Java Cold Starts: Spring Boot 3 + GraalVM Native Image in Production

This article details compiling Spring Boot 3 applications to GraalVM native images, covering static analysis constraints, RuntimeHints configuration, build pipeline setup, performance benchmarks showing 0.14s startup and 115MB RSS, monitoring without JFR, and production pitfalls like HTTPS and Netty, with a phased rollout strategy for cloud-native deployments.

AOT CompilationCloud NativeGraalVM
0 likes · 14 min read
Solving Java Cold Starts: Spring Boot 3 + GraalVM Native Image in Production
Cloud Architecture
Cloud Architecture
Jun 22, 2026 · Databases

Opening the Hood of PostgreSQL WAL: From Transaction Logs to Production‑Grade HA, Replication, and Performance Tuning

This article dissects PostgreSQL's Write‑Ahead Logging (WAL), explaining how it underpins transaction durability, replication, CDC, point‑in‑time recovery, and commit latency, and provides a step‑by‑step guide to architecture design, parameter tuning, troubleshooting, containerization, backup strategies, and operational checklists for production‑grade deployments.

CDCHigh AvailabilityPostgreSQL
0 likes · 37 min read
Opening the Hood of PostgreSQL WAL: From Transaction Logs to Production‑Grade HA, Replication, and Performance Tuning
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 22, 2026 · Operations

How to Tune Nginx Kernel Parameters for Up to 10× Performance Boost

The article walks through a step‑by‑step Nginx performance tuning guide, covering worker_processes and worker_connections settings, Linux file‑descriptor limits, sysctl tweaks such as net.core.somaxconn and tcp_max_syn_backlog, explicit listen backlog, and zero‑copy sendfile with tcp_nopush/tcp_nodelay to dramatically increase throughput and lower CPU usage.

Zero-Copyhigh concurrencykernel parameters
0 likes · 4 min read
How to Tune Nginx Kernel Parameters for Up to 10× Performance Boost
Raymond Ops
Raymond Ops
Jun 15, 2026 · Databases

How to Deploy VictoriaMetrics for High‑Performance Prometheus Remote Storage

This article walks through the challenges of scaling Prometheus storage, compares Thanos, Cortex, and VictoriaMetrics, and provides a complete step‑by‑step guide—including hardware requirements, configuration, deployment, tuning, multi‑tenant setup, and troubleshooting—to replace Prometheus local TSDB with VictoriaMetrics for long‑term, high‑performance monitoring.

PrometheusVictoriaMetricsdeployment
0 likes · 43 min read
How to Deploy VictoriaMetrics for High‑Performance Prometheus Remote Storage
MaGe Linux Operations
MaGe Linux Operations
Jun 14, 2026 · Operations

Linux Disk Partitioning, Mounting & Read/Write Issue Troubleshooting Guide

This article provides a comprehensive, step‑by‑step guide to Linux disk fundamentals, partitioning tools, mounting options, filesystem choices, LVM management, performance tuning, common error diagnostics, and five real‑world troubleshooting cases, enabling sysadmins to confidently manage and resolve disk‑related problems.

Disk ManagementFilesystemIO monitoring
0 likes · 49 min read
Linux Disk Partitioning, Mounting & Read/Write Issue Troubleshooting Guide