This article examines several production incidents where using SELECT * caused dramatic performance degradation in Oracle databases, detailing shadow‑table differences, LOB handling, temporary‑table transformations, wide‑table scans, and memory‑intensive joins, and explains why the rule to avoid SELECT * is essential.
This article benchmarks Java's Fork/Join framework, Parallel Streams, and ExecutorService across IO‑bound and CPU‑bound workloads on an 8‑core machine, analyzing how thread count and pool configuration affect performance and offering practical recommendations for concurrent Java applications.
This article explains Java reflection, describing its ability to inspect and modify classes at runtime, the core reflection classes, practical use cases, performance considerations, and provides comprehensive code examples that demonstrate class, method, field, and interface introspection.
This article demonstrates how the open‑source Java diagnostic tool Arthas can be employed in various production scenarios—such as CPU spikes, class‑loading conflicts, method‑level monitoring, performance bottlenecks, and hot‑code replacement—to rapidly locate and resolve runtime problems without restarting services.
This article explores MySQL performance limits, concurrency settings, query‑time best practices, table design choices, index classifications, and a comprehensive set of SQL optimizations—including batch processing, operator rewrites, and pagination tricks—to help developers eliminate slow queries and build scalable database solutions.
This article investigates whether Java reflection impacts performance by conducting systematic benchmarks that compare direct method/field access with reflective calls, analyzing the measured overhead, identifying the costly reflection operations, and offering practical guidelines to mitigate any performance penalties.
This article introduces ClickHouse as an OLAP columnar database, compares its storage model with row‑based databases, details migration from MySQL, presents performance benchmarks showing query speeds under one second for 50 million rows, and shares practical deployment tips and pitfalls.
This article explains the InnoDB logical storage hierarchy of segments, extents, and pages, then details MySQL horizontal partitioning concepts, types (RANGE, LIST, HASH, KEY), example DDL and DML, and discusses how partitioning impacts performance for OLTP and OLAP workloads.
To accurately benchmark and reduce end-to-end latency on large live-streaming platforms, this article details practical measurement frameworks for both HTTP-FLV—using custom SEI timestamps and cloud-synced clocks—and WebRTC—leveraging RTCPeerConnection stats to dissect uplink, server, jitter, decoding, and render delays.
Although Docker has become popular for containerizing applications, this article outlines seven key drawbacks—ranging from data safety and performance to networking, statefulness, resource isolation, cloud platform incompatibility, and hardware demands—that make deploying databases in Docker containers generally unsuitable.
This article describes how the WeChat Pay team rebuilt the client‑side payment flow using a C++ cross‑platform framework, detailing the architectural redesign, performance improvements, routing mechanism, network request handling, and data‑flow safeguards that unified iOS and Android implementations while reducing code size and enhancing reliability.
This article walks through designing and implementing a lightweight front‑end monitoring platform that captures JavaScript runtime and compile‑time errors, Promise rejections, resource loading failures, and network request issues, while also recording user interactions, page navigation, and environment details using modular code and browser APIs.
Streaming ZIP decompression enables extracting files while downloading, eliminating the need to fetch the entire archive; by leveraging Local File Header metadata and supporting both traditional and AES encryption, this technique dramatically reduces latency, as demonstrated by Youku’s 0.91‑second load for 30 MB books.
This guide explains how to identify Nginx bottlenecks, apply a series of configuration and kernel tweaks—including worker processes, event model, connection limits, gzip, proxy timeouts, and sysctl settings—and then validate the improvements with Apache ab load testing to achieve up to 100 000 concurrent requests.
This comprehensive guide explains how to start, stop, and configure Apache HTTP on Windows and UNIX, covering default ports, key configuration files, version checking, security hardening, logging, virtual hosts, proxy setup, performance tuning, and common troubleshooting techniques.
This article examines a real flash‑sale incident where Redis distributed locks expired, causing overselling, analyzes the root causes such as lock safety and non‑atomic stock checks, and presents safer lock implementations, atomic stock operations, and architectural reflections to prevent future failures.
This article presents a collection of common Java coding pitfalls—such as using 'where 1=1' in MyBatis, inefficient Map iteration, improper collection checks, and suboptimal string handling—and provides concise, performance‑oriented best‑practice alternatives with code examples.
This article provides a comprehensive guide to upgrading Apache Kafka across multiple versions, detailing rolling upgrade procedures, configuration adjustments, protocol changes, new features, deprecations, and performance considerations for Kafka brokers, producers, consumers, and Kafka Streams applications.
UI testing ensures that a website’s interface functions correctly and delivers a smooth user experience, covering manual and automated approaches, cross‑browser compatibility, exploratory and scripted techniques, and performance considerations, illustrated with real‑world ticket‑booking examples and practical Selenium automation benefits.
This article explains how Suning's big‑data center leverages ClickHouse’s columnar OLAP engine and a full‑chain monitoring platform to achieve real‑time query tracing, slow‑query analysis, cluster health checks, and resource‑level alerts across diverse business scenarios.
The article introduces Offline Prerender (OPR), explains why traditional SSR and SPA first‑screen optimizations have limitations, details the OPR workflow—including scheduled Puppeteer rendering, HTML capture, data injection, diffing, CDN upload, and delayed mounting—and shares practical enhancements such as CSS tree‑shaking, async script loading, and downgrade strategies, demonstrating significant speed gains.
This article provides a detailed guide to various Java lock types—including optimistic, pessimistic, spin, reentrant, read‑write, fair, unfair, shared, exclusive, heavyweight, lightweight, biased, segment, mutex, synchronization, deadlock, lock coarsening, and lock elimination—explaining their principles, typical usages, advantages, disadvantages, and related JVM optimizations.
This article explains how to tune Java ThreadPoolExecutor parameters—including corePoolSize, maxPoolSize, keepAliveTime, and queue length—for both CPU‑bound and IO‑bound workloads, offering practical formulas, example calculations, and a step‑by‑step adjustment workflow.
This article provides a step‑by‑step troubleshooting guide for Java production incidents, covering CPU, disk, memory, GC, and network problems with practical commands, analysis techniques, and tools such as jstack, jmap, iostat, netstat, and native memory tracking.
This article benchmarks UCloud’s Kuaijie‑based UDB against a self‑built MySQL instance on UHost, detailing environment setup, sysbench testing parameters, QPS, insert/delete and update results, and evaluates performance gains of over 20% alongside a cost analysis showing UDB’s better price‑performance ratio.
This article presents practical Python performance‑boosting techniques—including avoiding global variables, minimizing attribute access, eliminating unnecessary abstractions, reducing data copies, optimizing loops, leveraging built‑in functions, and using tools like numba—each illustrated with before‑and‑after code snippets and measured speed improvements.
This article provides a detailed, step‑by‑step methodology for diagnosing and resolving common Java production problems—including CPU spikes, disk bottlenecks, memory leaks, garbage‑collection anomalies, and network timeouts—by leveraging native Linux tools and JVM utilities such as ps, top, jstack, jmap, jstat, iostat, vmstat, pidstat, and netstat.
This article explains the performance differences between IN, EXISTS, NOT IN, and NOT EXISTS in SQL queries, provides guidance on when to use each construct based on table sizes and indexes, and demonstrates the concepts with practical code examples.
The article explains why traditional OFFSET and LIMIT pagination becomes inefficient for large tables due to full‑table scans, demonstrates the performance gap with real‑world examples, and presents keyset (cursor‑based) pagination as a fast, index‑driven alternative with practical query patterns.
This article provides a comprehensive tutorial on using EF Core in .NET, covering DbContext setup for MySQL and SQL Server, thread‑safety considerations, connection‑pooling benefits, logging of generated SQL, various insertion techniques (single, cascade, bulk), querying methods, and efficient update patterns.
This guide details the end‑to‑end process for performing a 50,000‑user concurrent load test with JMeter and BlazeMeter, including script creation, local validation, sandbox execution, engine scaling, cluster testing, and Master/Slave configuration to achieve the required concurrency.
This article summarizes the key challenges and solutions when using SVGA animations in mobile live‑gift scenarios, covering import issues, frame extraction, compression, composition size, frame‑rate rules, and supported effects to help developers create smooth, lightweight animations.
This article walks through a real‑world production incident involving intermittent interface timeouts, demonstrates how tracing with SkyWalking and log analysis revealed a downstream service problem, explores GC log diagnostics, uncovers misconfigured c3p0 connection‑pool settings, and shares practical lessons for Java backend performance tuning.
The article explains how Log4j2 can cause thread blocking under heavy exceptions due to class‑loading locks, describes the JVM's reflection optimization mechanism, shows how to verify it with sample code, and outlines ways to disable or tune the optimization using system properties.
This article explains how to apply incremental thinking to ESLint code checks and webpack builds by using Git diff to detect changed files, running targeted linting and bundling, and demonstrates significant time savings in large front‑end projects.
This article explains Kafka's role as a message system, details its fundamental components such as topics, partitions, producers, consumers, and replicas, describes how Zookeeper coordinates the cluster, and explores performance optimizations like sequential writes, zero‑copy, and network design.
This guide explains what MySQL temporary tables are, how they exist only for the current connection, provides step‑by‑step SQL examples for creating, inserting, querying, and dropping a temporary table, and discusses practical scenarios such as high‑concurrency writes.
This article provides a comprehensive guide on using Prometheus for Kubernetes monitoring, covering fundamental principles, exporter selection, Grafana dashboard creation, memory and storage optimization, high‑availability designs, query performance, cardinality management, and integration with alerting and logging systems.
This article explains the internal mechanics of Java Stream’s pipeline, covering how operations are recorded as stages, how intermediate and terminal operations are composed via the Sink interface, and why the implementation achieves lazy evaluation and efficient parallel execution.
This document explains the differences between OLTP and OLAP workloads, introduces the CSTORE columnar storage engine architecture, its core technologies, performance advantages, typical use cases, benchmark results, and future development plans for MySQL 8.0.
This article explains the distinction between Linux Buffers and Cache, how they appear in the free command, their representation in /proc/meminfo, and demonstrates practical experiments using vmstat and dd to observe their behavior during read and write operations, concluding with clear usage guidelines.
An in‑depth look at bare metal servers explains how they differ from virtualized cloud instances, why they’re needed for performance‑critical or security‑sensitive workloads, their integration with cloud services, and market trends driving their growing adoption.
The article demonstrates how moving the LIMIT‑OFFSET condition into a subquery that selects only primary‑key IDs and then joining back to the main table can cut execution time from over 16 seconds to a few hundred milliseconds by avoiding massive index and data‑page scans.
This article examines the rise of ARM‑based CPUs, details AWS's Graviton 2 processor and its deployment in M6G instances, and presents extensive performance, cost, and third‑party benchmark comparisons to illustrate the emerging shift toward ARM in cloud computing.
This article explains how to replace complex Java NIO callback code with lightweight Quasar coroutines to boost throughput, simplify asynchronous programming, and reduce thread usage in high‑concurrency backend systems, while also covering integration with Netty, RPC, and handling of blocking operations.
The article explains why using NULL columns in MySQL can lead to extra storage, index complications, query errors, and performance degradation, and provides concrete examples and best‑practice recommendations to prefer NOT NULL constraints whenever possible.
An intermittent slowdown in a Java SaaS app, even during low traffic, was traced to a Log4j locking bug that blocked hundreds of threads; capturing a thread dump, analyzing it with fastthread.io, and upgrading to Log4j2 resolved the issue.
This article explains the internal workings of Java's ArrayList and LinkedList, covering their dynamic array and linked list structures, growth mechanisms, performance characteristics for random access, insertion, and deletion, and includes source code excerpts and visual diagrams to illustrate key differences.
The article describes how a news‑list page became sluggish due to large base64‑encoded images stored in the database, details the investigation using Chrome dev tools and SQL queries, and presents a step‑by‑step solution that moves images to a FastDFS file server and updates the content references.
This article explains why SQL optimization is a cost‑effective way to boost system performance, outlines fundamental principles, common pitfalls such as leading wildcards, IN/OR/NULL misuse, and provides practical tips on indexing, execution order, hints, DML batching, pagination, and table design for MySQL databases.
This article explains why Kubernetes requires an overlay network, describes Docker’s virtual bridge limitations, introduces Flannel’s architecture and its three data‑forwarding modes—UDP, VXLAN, and host‑gw—detailing their mechanisms, performance trade‑offs, and how the StarRing TCOS platform leverages these modes for different cluster sizes and network topologies.
Lokie is a high‑performance iOS AOP framework written in C++14 that replaces the slow Aspect library by using libffi‑based trampolines, offering thread‑safe method interception, detailed API usage, runtime internals, and assembly‑level trampoline implementation with significant speed improvements.
This article explains common I/O and CPU bottlenecks in databases, introduces horizontal and vertical sharding concepts, compares sharding tools, outlines practical sharding steps, discusses typical sharding issues such as non‑partition queries and expansion, and provides a concise summary and example implementation.
Brad Nicholson and Dave Cramer discuss their experiences with PostgreSQL, covering the project's community strengths and weaknesses, emerging pluggable storage, JSON path, Kubernetes deployment challenges, performance tuning, and their vision for the database’s evolution over the next decade.
This article explains why using NULL columns in MySQL can hurt performance and increase storage, debunks common myths with official documentation, and provides practical reasons and code examples for preferring NOT NULL constraints in table design.
Flutter is a Google‑backed cross‑platform framework that uses Dart and its own Skia rendering engine to deliver near‑native performance and consistent UI across mobile, web, and desktop, offering hot reload, rich widgets, and platform channels, while facing challenges such as larger app sizes, a smaller ecosystem, and limited dynamic update support compared with React Native and Hippy.
This article explains the operating‑system concepts of processes, threads, and coroutines, compares their performance with Python code examples, discusses the impact of the GIL and DMA, and provides clear guidelines for choosing the right concurrency model based on CPU‑bound, I/O‑bound, or mixed workloads.
This article compares Cloudflare and Amazon CloudFront, outlining their respective CDN architectures, setup processes, feature sets, performance characteristics, security offerings, and ideal use cases to help users choose the most suitable service for their web applications.
This article examines a real-world over‑sell incident caused by an unsafe Redis distributed lock in a high‑traffic seckill service, analyzes the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock implementations, atomic stock operations, and refactored code to prevent future overselling.
This article explains how SparkR’s performance compares to native Spark APIs, shows the slowdown caused by JVM‑R serialization, and demonstrates how enabling Apache Arrow’s vectorized execution in Spark 3.0 can accelerate SparkR operations by up to dozens of times.
This comprehensive guide covers MySQL index creation syntax, various index types—including primary, unique, full‑text, and composite—explains their advantages and drawbacks, details underlying B‑Tree and B+Tree structures, and provides practical strategies and optimization tips for effective index usage.
This article explains why ArrayList implements the RandomAccess marker interface while LinkedList does not, shows how Java's Collections.binarySearch chooses different algorithms based on this interface, and presents benchmark results that reveal the most efficient traversal method for each list type.
The article presents Sponsor, a lightweight ORM‑style wrapper for Android’s native SQLite that uses runtime annotations and dynamic proxies to generate Retrofit‑like, type‑safe CRUD APIs, automatically handling table creation, upgrades, and threading while keeping performance overhead negligible for SDK developers.
This article compares Apache Kafka and RabbitMQ, detailing their architectural differences, message handling models (pull vs push), performance characteristics, and ideal use cases, helping readers choose the appropriate messaging system for streaming, high‑throughput, or legacy protocol scenarios.
This presentation details the motivations behind rebuilding Taro, introduces the Taro Next architecture and its new capabilities, walks through practical development steps, explains underlying rendering principles for both mini‑program and H5 targets, and outlines performance optimizations and future directions.
This article details a step-by-step optimization of a Java-based Excel import process, covering migration from POI to EasyExcel, caching database lookups, using batch inserts with VALUES, and leveraging parallel streams to dramatically reduce import time for massive datasets.
Learn how to overcome Python's GIL limitations by compiling Go code into a shared .so library, invoking it from Python, and comparing performance gains, with step‑by‑step instructions, code examples, and troubleshooting tips for faster computation‑intensive tasks.
This article analyzes a severe overselling incident caused by an unsafe Redis distributed lock during a high‑traffic flash‑sale, explains the root causes, and presents safer lock and atomic stock‑decrement solutions with improved Java code examples.
This guide walks you through essential Linux networking tools—netstat, ss, sar, iftop, tcpdump, and more—explaining how to monitor connections, analyze traffic, troubleshoot TIME_WAIT and CLOSE_WAIT issues, and tune kernel parameters for handling millions of concurrent sockets.
This document outlines comprehensive MySQL database design standards and SQL writing guidelines, covering naming conventions, character sets, table and column specifications, index design, partitioning, data types, transaction handling, and prohibited statements to ensure stable, performant, and maintainable production databases.
This article analyzes a real‑world overselling incident caused by an unsafe Redis distributed lock in a high‑traffic flash‑sale service, explains the root causes, and presents safer lock implementations, atomic stock checks, and architectural improvements to prevent similar failures.
A senior architect’s over‑confident, un‑commented Java code using ConcurrentHashMap triggered a severe memory leak, revealing pitfalls in hashCode/equals implementation, non‑atomic map updates, and the trade‑offs between synchronized blocks and putIfAbsent for high‑concurrency monitoring.
This article examines seven key reasons why deploying databases in Docker containers is problematic, covering data safety, performance bottlenecks, networking complexities, statefulness, resource isolation, cloud platform constraints, and hardware requirements, while also suggesting cautious strategies for selective containerization.
This article evaluates popular Java microservice frameworks—Spring Boot, Micronaut, Quarkus, and Helidon MP—by measuring their ease of development, compilation time, startup latency, memory usage, and high‑load request handling, using identical CRUD applications deployed on Docker and GraalVM.
This article explains MySQL index structures—including B‑Tree, B+Tree, and hash indexes—their underlying principles, performance characteristics, and practical usage guidelines such as left‑most prefix, full‑text indexing, and common pitfalls, providing a comprehensive guide for database developers.
Angular, a Google‑maintained front‑end framework from version 2 onward, offers cross‑platform capabilities such as progressive web apps, native mobile and desktop applications, along with high performance through code generation, server‑side rendering, automatic code splitting, and a rich productivity ecosystem including CLI, IDE support, testing, animation and accessibility tools.
This article explains how the WebSocket API provides bidirectional, message‑oriented communication, compares its latency and overhead with XHR and SSE, discusses compression and custom protocols, and offers practical deployment and tuning guidelines for long‑lived connections.
This article provides a step‑by‑step methodology for diagnosing and resolving common online failures in Java services, covering CPU bottlenecks, disk I/O problems, memory leaks, garbage‑collection inefficiencies, and network anomalies such as timeouts, TCP queue overflows, and RST packets.
This article explains Linux's zero‑copy techniques—mmap, sendfile, and splice—detailing how they reduce data copies between user and kernel space, improve I/O efficiency, handle edge cases like SIGBUS, and leverage DMA to minimize CPU overhead in server file transfers.
The article explains that using SELECT 1 with LIMIT 1 instead of COUNT(*) to test whether rows exist can dramatically improve query performance, shows the typical COUNT(*) approach in SQL and Java, and provides a streamlined alternative with code examples and practical benefits.
This article explains the zero‑copy technique in Java, covering basic I/O concepts, buffer management, mmap + write and Sendfile methods, and how frameworks like NIO, Netty, Kafka, and RocketMQ use these mechanisms to eliminate data copies and improve performance.
Node.js’s single‑threaded model relies on an asynchronous continuation framework, and this article explains the core concepts—execution frames, continuations, link points, ready points—and how async_hooks, AsyncLocalStorage, and related APIs can be used to trace, debug, and ensure clean async task handling in backend applications.
This article reviews the most frequently asked Java collection framework interview questions, covering differences between ArrayList, LinkedList, Vector, ArrayDeque, HashSet, HashMap, Hashtable, and the distinction between Collection and Collections, while explaining underlying implementations and performance considerations.
This article explains the differences between normal and unique indexes in MySQL, examines how they affect query and update performance, details InnoDB's change‑buffer mechanism, and provides practical guidance on when to prefer ordinary indexes for better write efficiency.
This article details the redesign of the 58 APP Android home page (version 9.0), covering overall UI and data module architecture, component design inspired by fragments, handling of search bar animations, fling behavior, performance optimizations, and lessons learned from the development process.
This article explains how to achieve high‑performance bulk inserts in .NET Core applications by converting entities to CSV or DataTable formats and using MySQL's LOAD DATA and SQL Server's SqlBulkCopy, providing reusable extension methods, interface abstractions, and performance benchmarks.
This article details a real‑world test that loads 200 million rows into a MySQL TokuDB table in under six minutes, achieving roughly 570 k writes per second, and compares the results with InnoDB while providing configuration tips and bulk‑loader considerations.
This article explains the differences between Java's HashMap and TreeMap, covering their underlying implementations, performance characteristics, thread safety, and how to customize TreeMap for descending order, helping developers choose the right map for their needs.
This article explains how to load over 20 billion rows into MySQL using the XeLabs‑compiled TokuDB engine, detailing configuration tweaks, table schema, bulk‑loader commands, benchmark results that reach 574 k rows per second, and practical tips for handling auto‑increment keys.
This article walks through common Linux memory inspection commands, explains the meaning of the buff/cache field, and then dives into MySQL join types, join algorithms, buffer settings, and performance‑tuning tips, all presented as a simulated interview with promotional side notes.
This article examines why full‑table scans on massive MySQL tables are slow, explains standard LIMIT‑based pagination, and presents several optimization strategies—including sub‑queries, ID‑range filtering, and temporary tables—backed by concrete performance measurements.
This article presents a concise Big O cheat sheet that aggregates the time‑complexity notations for common data structures, sorting algorithms, graph and heap operations, and visualizes performance curves, helping readers quickly recall best‑, worst‑, and average‑case scenarios.
This article explains Redis's custom Simple Dynamic String (SDS) implementation, its dynamic expansion mechanism, and the performance benefits such as O(1) length retrieval, buffer overflow avoidance, and efficient memory allocation strategies for high‑throughput applications.
This comprehensive guide walks you through Chrome DevTools panels—including Console, Elements, Network, Sources, Performance, Lighthouse, Security, and advanced commands—detailing shortcuts, core methods, debugging techniques, performance metrics, and practical tips for front‑end developers to optimize and troubleshoot web applications.
This article introduces Google’s Protocol Buffers (ProtoBuf), explains its principles, shows how to install the compiler, provides a complete Java example for defining, compiling, and using .proto files, and compares its encoding speed and memory usage against JSON, highlighting ProtoBuf’s advantages.
This guide explains how to systematically analyze Linux performance problems—including CPU, memory, disk I/O, network, and load—using 5W2H methodology, built‑in monitoring commands, perf, flame‑graph visualizations, and a real‑world Nginx case study to pinpoint and resolve bottlenecks.
This article explains common MySQL performance problems such as missing indexes and lack of pagination, and provides practical guidance on data size limits, concurrency settings, query time targets, table design, index types, and a variety of SQL optimizations with concrete code examples.
This article explains various MySQL pagination methods—including simple LIMIT queries, sub‑query optimizations, ID‑range filtering, and temporary‑table approaches—provides detailed performance measurements on a large order_history table, and concludes with practical recommendations while also promoting a comprehensive interview‑question PDF collection.
This article analyzes the performance bottlenecks of React Native applications, explains the framework's working principles, and presents practical optimization strategies such as bundle splitting, JS bytecode, data synchronization via an information center, and native‑driven list components to improve rendering speed and responsiveness.
This article compares the three I/O multiplexing mechanisms—select, poll, and epoll—by analyzing their time complexities, limitations, trigger modes, performance characteristics, and implementation details, helping developers choose the most suitable method for different Linux networking scenarios.
