The article reviews Doris 2.0's major enhancements—including point‑query concurrency, log‑analysis capabilities, cold‑hot data separation, lakehouse integration, and various performance and usability upgrades—explaining how these changes benefit OLAP workloads and simplify data‑engineering pipelines.
This article demonstrates how to use Alibaba's open‑source Java diagnostic tool Arthas to quickly locate and fix high CPU usage in a Java application, covering installation, attaching to a JVM, using dashboard, thread, jad, watch, and ognl commands, and interpreting the results.
This article investigates the performance difference between Java's native List.sort() method and the Stream.sorted() approach, provides simple demos, explains JIT warm‑up effects, and presents JMH benchmark results that show List.sort() consistently outperforms Stream.sorted() for typical collection sizes.
This article analyzes the challenges of browser caching in micro‑frontend projects, presents a systematic optimization plan—including resource versioning, server‑side URL proxying, nginx cache‑control configuration, and CDN integration—and demonstrates a 48.5% reduction in page‑load time with detailed implementation steps and performance data.
Learn how converting single‑threaded Python crawlers into multithreaded ones can dramatically reduce data‑fetching time, covering process vs thread concepts, practical threading code examples, performance comparisons, and a step‑by‑step guide to building a multithreaded image scraper.
This article explains the common reasons why Redis performance degrades—such as network latency, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, and memory fragmentation—and provides detailed optimization and troubleshooting steps to restore low latency.
This article reviews the evolution of mainstream CPU performance benchmarks such as SPEC and TPC, compares their methodologies and tools, discusses challenges in evaluating heterogeneous CPUs, and outlines future research directions, providing a comprehensive overview for researchers and practitioners.
This article traces the evolution of eBPF from its BPF predecessor, explains its kernel requirements, security model, probe mechanisms, performance impact, tracing capabilities, and potential event‑loss risks, and looks ahead to its expanding role in networking and system observability.
This article examines the advantages and disadvantages of placing try-catch blocks inside versus outside loops in Java, provides concrete code examples, references performance guidelines from the Alibaba Java Development Manual, and outlines scenarios to help developers choose the most appropriate approach.
This article explains how Elasticsearch pagination works with from/size, why deep paging can cause performance problems, and compares alternative techniques such as Scroll, Scroll‑Scan, Sliced Scroll, Search After, and point‑in‑time (PIT) searches for handling large result sets efficiently.
By integrating ZSTD compression into Didi’s Elasticsearch 7.6, the team cut CPU usage by about 15 %, reduced index storage roughly 30 %, boosted write throughput up to 25 %, and eliminated over 20 servers, demonstrating a faster, more storage‑efficient solution for petabyte‑scale log ingestion.
The article explains that Redis achieves exceptional performance through four main factors—its in‑memory storage, optimized data structures, a single‑threaded architecture, and non‑blocking I/O—detailing how each contributes to speed and efficiency.
This article investigates whether Java's list.sort() truly outperforms stream().sorted() by presenting simple demos, explaining the pitfalls of naive timing, and using JMH benchmarks to reveal that list.sort consistently runs faster due to lower overhead, while the performance gap remains small for typical data sizes.
This article explains the OffscreenPageLimit attribute of ViewPager2, how it controls off‑screen page loading, compares its default values with ViewPager, shows code implementations, analyzes performance trade‑offs, and provides practical recommendations for choosing an appropriate limit.
Go 1.21 has been officially released, introducing toolchain improvements such as GA‑ready profile‑guided optimization, new built‑in functions, several standard library packages, performance boosts, and experimental support for the WebAssembly System Interface (WASI).
The article explains why using the KEYS command on a large Redis dataset can block the server, introduces the SCAN command as a non‑blocking alternative with cursor‑based iteration, and provides usage examples and best‑practice tips for safely listing prefixed keys.
This article explains how Ant Design's CSS‑in‑JS implementation uses server‑side rendering and a hash‑based cache to avoid runtime style generation, dramatically improving performance for both application‑level and component‑level styling.
This article introduces a MyBatis‑based SQL analysis component that detects and prevents slow queries before they impact production by performing real‑time EXPLAIN analysis, offering optimization suggestions, and enabling dynamic SQL replacement, while detailing its design, configuration, performance testing, and practical advantages.
The article outlines practical GPU inference optimization for NetEase’s news recommendation, covering model analysis with Netron, multi‑GPU parallelism, memory‑copy reduction, batch sizing, TensorRT conversion and tuning, custom plugins, and the GRPS serving framework to achieve significant latency and utilization gains.
This article details a systematic investigation of MySQL insert slowdown caused by disk I/O anomalies, describing log analysis, blktrace data collection, RAID controller firmware bugs, and the final resolution through firmware upgrade, providing practical guidance for database performance troubleshooting.
This article explains the browser's critical rendering path, detailing how HTML is parsed into a DOM, how CSS is turned into a CSSOM, how the render tree is built, and how JavaScript and CSS can block or delay rendering, providing practical examples and performance testing results.
The article examines performance bottlenecks in Prometheus‑Grafana monitoring dashboards caused by high metric cardinality, explains the internal query processing steps, demonstrates how to analyze and reduce cardinality with PromQL and recording rules, and shows concrete command‑line examples that dramatically improve query latency.
Android ANR occurs when the UI thread is blocked, triggered by time‑outs such as KeyDispatch, Broadcast, Service or ContentProvider, often caused by long I/O, deadlocks, Binder calls or resource exhaustion; diagnosing involves examining traces.txt, thread states, CPU/memory metrics, and using tools like Looper logs, Choreographer, or Tencent Matrix to prevent future freezes.
This article explains how to correctly declare, monitor, and configure Java thread pools, recommends naming conventions, discusses CPU vs I/O workload sizing, highlights common pitfalls such as deadlocks and ThreadLocal misuse, and introduces dynamic pool‑adjustment techniques used by large tech companies.
This article details a real‑world test of loading over 20 billion records into MySQL with XeLabs TokuDB, covering the demand, configuration tweaks, table schema, bulk‑loader commands, performance metrics, comparison with InnoDB, and practical conclusions for large‑scale data ingestion.
The article examines why a Lazada front‑end team is questioning the switch from the long‑standing Alibaba Fusion component library to Ant Design, analyzing design quality, iteration speed, performance, stability, ecosystem impact, CSS‑in‑JS trends, and the overall cost of migration.
This article reviews the limitations of traditional Spark shuffle, introduces Apache Celeborn (Incubating) as a remote shuffle service, and details its design for performance, stability, and elasticity, including push shuffle, partition splitting, columnar shuffle, multi‑layer storage, congestion control, and real‑world evaluation.
This article presents practical MySQL performance tuning techniques, covering query, pagination, join, subquery, order‑by, group‑by, and count optimizations with example code, index strategies, and execution‑plan analysis to improve latency in high‑traffic systems.
This article presents sixteen practical Java coding best‑practice tips—ranging from consistent naming conventions and appropriate data structures to proper resource handling and logging—to help developers write cleaner, more efficient, and more maintainable code.
This article presents ten advanced Python techniques—including assertions, interactive debugging, profiling, comprehensions, efficient data structures, caching, NumPy vectorization, parallel processing, and appropriate storage choices—to help developers improve code quality and execution speed.
This article explains what WebAssembly is, why it is needed for high‑performance web applications, how it works internally, which languages can target it, typical use cases, and provides practical examples of loading and using WebAssembly modules in browsers and Node.js.
This article examines several Java deduplication techniques—including List.contains, HashSet, double-loop removal, and Stream.distinct—by providing sample code, measuring execution time on a 20,000‑element list, and analyzing their time complexities to guide developers toward efficient duplicate‑removal strategies.
This article explains how MySQL 8.0 updates the AUTO_INCREMENT column in INFORMATION_SCHEMA.TABLES, describes the underlying statistics caching mechanism, shows how the information_schema_stats_expiry parameter controls refresh frequency, and provides step‑by‑step tests demonstrating real‑time behavior with code examples.
This article explains how to use a timing wheel to efficiently handle RPC timeout processing, startup timeouts, and heartbeat tasks, reducing thread proliferation and CPU waste by organizing timed tasks into hierarchical time slots.
This article demonstrates how using Spring Boot's TransactionTemplate to programmatically control transactions can prevent long‑running non‑transactional operations from blocking database connections, thereby increasing system throughput compared to the traditional @Transactional annotation, with detailed code examples and performance observations.
The article introduces Sonic, ByteDance’s high‑performance Go JSON library built with Just‑In‑Time compilation and SIMD vectorization, explains its design motivations, usage patterns, API features, compatibility considerations, and showcases benchmark results that demonstrate its superiority over other popular JSON parsers.
This article introduces MyBatis‑Flex, a lightweight yet powerful MyBatis enhancement framework, outlines its key features and advantages, compares it with similar tools, presents performance benchmarks, lists supported databases, and provides a step‑by‑step quick‑start tutorial with code examples for Spring Boot integration.
The article discusses the renewed relevance of performance engineering amid the slowdown of Moore’s Law, highlighting the Chinese edition of "Systems Performance: Enterprise and the Cloud," modern observability tools like eBPF, the "golden 60‑second" analysis, and the push toward continuous performance monitoring and expert systems.
This article compares Elasticsearch and ClickHouse as log‑search solutions, detailing their architectures, Docker‑compose deployments, data‑ingestion pipelines with Vector, query syntax differences, and benchmark results that show ClickHouse generally outperforms Elasticsearch in speed and aggregation efficiency.
The article uses a vivid CPU‑as‑a‑factory metaphor to explain how instruction pipelines work, why they improve performance, how pipeline depth affects speed and power, and what structural, data, and control hazards arise when multiple instructions share hardware resources.
This article introduces the MyBatis-Flex ORM framework, highlights its lightweight, flexible, and high‑performance design, compares its features and benchmark results with MyBatis‑Plus, and provides practical code examples for queries, multi‑table joins, partial updates, data masking, multi‑datasource support, and field encryption.
This article introduces MyBatis-Flex, a lightweight high‑performance MyBatis enhancement framework, outlines its key features, compares it with MyBatis‑Plus and Fluent‑MyBatis, lists supported databases, and provides a step‑by‑step quick‑start tutorial with code examples.
This article explains the traditional I/O read/write workflow, identifies its performance bottlenecks, introduces the concept of zero‑copy, and demonstrates practical zero‑copy implementations—including DMA, sendfile, shared memory, memory‑mapped files, and Java NIO techniques such as ByteBuffer, Channel, transferTo/transferFrom, and memory‑mapped files.
This article explains how column store indexes in SQL Server store each column separately, dramatically improve query performance through batch processing and compression, outlines their physical structure, encoding methods, creation syntax, maintenance steps, and space usage considerations.
This article examines the architecture, rendering pipeline, update mechanism, and event‑picking strategy of the LeaferJS canvas library, illustrating how its lightweight node creation, selective full‑ and partial‑rendering, and optimized hit‑testing achieve high performance compared with alternatives like Konva.
This article provides a comprehensive overview of OceanBase, an open‑source distributed database, detailing its evolution, core HTAP features, multi‑tenant architecture, execution engine optimizations, advanced query optimizer, storage engine design, resource isolation mechanisms, fast import capabilities, and performance benchmarks.
This article introduces the major enhancements of Python 3.11—including structural pattern matching, improved type hints, faster execution via PEP 659, richer error messages, the new | dictionary‑merge operator, built‑in breakpoint debugging, and other standard‑library additions—illustrated with concise code examples.
This article details Baidu Zhidao’s migration from an aging, monolithic PaaS platform to a cloud‑native environment, explaining the business drivers, the selection of Pandora and Zhiyun platforms, the step‑by‑step traffic‑shifting and gateway redesign, and the measurable gains in stability, scalability, and cost after achieving 100% cloud traffic.
This article explains how positioning a try‑catch block inside or outside a Java for‑loop affects exception handling, loop termination, performance, memory usage, and provides practical guidance for choosing the appropriate placement based on business requirements.
This article presents a comprehensive set of Selenium Web testing best practices—including optimal locator selection, minimizing find operations, avoiding Thread.sleep(), reusing browser instances, creating atomic tests, parallel execution, disabling images, and leveraging headless mode—to dramatically improve test execution speed and reliability.
A detailed 2023 comparison of PostgreSQL and MySQL examines licensing, performance, features, extensibility, usability, connection models, ecosystem, and operability, helping developers decide which open‑source relational database best fits their workloads and long‑term strategy.
This article compares PostgreSQL and MySQL across licensing, performance, features, scalability, security, query optimization, replication, JSON support, CTEs, window functions, and ecosystem, using data from the 2023 Stack Overflow survey and practical experience to help developers choose the right open‑source relational database.
This article explains how to implement a scrolling barrage effect with avatar fade‑in, size transition, and periodic data replacement, while optimizing network requests, using Vue slots, CSS animation timelines, requestAnimationFrame, and low‑end device fallbacks to achieve smooth performance.
This article curates key front-end topics—including simple architecture patterns, Tencent's performance optimization tactics, CSS fundamentals from "CSS World," advanced TypeScript tricks, and the notable features of Chrome 115—while also introducing the Cloud Classroom front-end team’s mission and structure.
This article examines Python's widespread popularity, highlighting its rich ecosystem and rapid prototyping advantages while also critiquing its numerous formatting quirks, strict indentation, ambiguous special methods, verbose regex handling, limited immutable structures, community elitism, and the debate over whether the language is over‑hyped.
Fury is a JIT‑compiled, zero‑copy multi‑language serialization framework that delivers up to 170× faster performance than Java’s native serialization, supports automatic cross‑language object graph serialization for Java, Python, C++, Go and JavaScript, and offers specialized protocols for high‑throughput big‑data and AI workloads.
Tengine-Ingress, Alibaba’s cloud‑native ingress gateway built on Tengine‑Proxy, replaces the legacy Tengine gateway by delivering dynamic, loss‑less configuration updates, high‑availability gray‑release mechanisms, global consistency checks, and significant performance gains in TLS handshake latency, CPU usage, and memory consumption across large‑scale deployments.
The article explains how teams can adopt nine objective software development metrics—including lead time, cycle time, team velocity, defect rates, MTBF, MTTR, crash rate, endpoint incidents, and code‑quality measures—to continuously improve processes, assess production health, and align engineering work with business value.
React 18 introduces concurrent rendering, transitions, Suspense, and Server Components, which together reduce long tasks, lower total blocking time, and improve user interaction by allowing non‑urgent updates to run in the background, ultimately delivering smoother, more responsive web applications.
This article provides an in‑depth overview of the Caffeine local cache library for Java, covering its concepts, configuration options, loading strategies, eviction policies, asynchronous usage, statistics collection, and step‑by‑step integration with Spring Boot including annotations and practical code examples.
This article introduces common Linux command‑line tools such as top, vmstat, pidstat, iostat, sar, netstat, and tcpdump, explaining the meaning of their output fields and how to use them for diagnosing CPU, memory, disk I/O, and network performance issues on servers.
This guide explains essential Linux monitoring tools—top, vmstat, pidstat, iostat, netstat, sar, and tcpdump—detailing the metrics they expose, how to interpret CPU, memory, disk, and network statistics, and practical command examples for effective server performance troubleshooting.
A service‑wide avalanche occurred when a Redis 3.x master‑slave failover coincided with Jedis’ default 2‑second connection timeout and six retry attempts, causing up to 60‑second latencies; adjusting connectionTimeout, soTimeout to 100 ms and reducing maxAttempts to two limited latency to about one second and prevented cascade failures.
This article explores how WebAssembly can break the speed limits of JavaScript by compiling both framework and business logic into WebAssembly, describes the design of the ByteReact front‑end framework, its custom Bytets compiler that turns TypeScript into WebAssembly, and presents performance measurements showing up to three‑fold speed gains for compute‑heavy UI tasks.
The article explains why Java exception stack traces can disappear during high‑traffic events due to the JIT‑based Fast Throw optimization, describes its conditions, shows performance measurements with and without the feature, and provides practical guidance for locating and diagnosing related production issues.
MOAT is a lightweight, multi‑dimensional rate‑limiting component designed to ensure system stability amid traffic spikes, offering configurable rules, automatic blacklisting, and a closed‑loop control flow, with detailed architecture spanning access, logic, data, and logging layers, plus client‑side SDK integration.
This article summarizes the key pitfalls and recommended practices for creating, configuring, monitoring, and naming Java thread pools, including proper declaration, parameter tuning for CPU‑ and I/O‑bound workloads, avoiding OOM and deadlocks, and leveraging dynamic pool frameworks.
This article explains the most common Python file extensions—including .py, .ipynb, .pyi, .pyc, .pyd, .pyw, and .pyx—describes their purposes, shows example code for each, and demonstrates how Cython can dramatically improve performance for computation‑intensive tasks.
When interviewers ask how to insert a thousand rows with MyBatis, the answer isn’t just a simple Java for‑loop; you need to consider batch processing, disable autocommit, and understand MyBatis’s limits to choose the most reliable and performant approach.
This article curates a series of frontend engineering insights, covering request‑optimization strategies, an introduction to micro‑frontends with qiankun, building a custom animated chart as an alternative to ECharts, quick Pixi.js basics, the new JavaScript Import Maps feature, and a brief overview of the Cloud Academy frontend team.
This article explains how HuoLaLa’s stability team tackled the challenge of proving their work’s value by designing and implementing a comprehensive stability metric system from scratch, detailing the motivations, principles, step‑by‑step construction, data platform, cultural adoption, measurable results, and future plans.
This article explains how to quantify Android UI jank by calculating a jank rate, uses Jetpack's JankStats library to collect frame‑level metrics, and presents two practical methods—stack dumping and bytecode instrumentation—to pinpoint the slow functions causing stutter, complete with Kotlin code examples and performance considerations.
During a massive 618 promotion, the system’s BulkProcessor for Elasticsearch suffered deadlocks caused by competing lock acquisition between MQ consumer threads and internal scheduler threads, leading to paused message consumption; the article details the root cause, thread analysis, and two practical solutions.
This article analyses how modern frontend view frameworks such as Solid, Svelte, Qwik, React, Vue and Angular are converging on a solidified programming paradigm while competing through fine‑grained rendering, reactive data, developer tooling, compilation strategies and the push to reduce JavaScript for better first‑page performance.
The article explains how PHP 8’s Just‑In‑Time (JIT) compiler transforms hotspot code into machine code to dramatically speed up execution, demonstrates the impact with a recursive Fibonacci function, and shows how caching and static variables can further improve backend performance.
The report builds a comprehensive GPU research framework evaluating performance through micro‑architecture, process, core count and frequency, examines ecosystem dominance of CUDA, dissects NVIDIA Fermi and Hopper designs, analyzes competitive histories of Nvidia and AMD, and forecasts domestic GPU market opportunities in AI data centers, autonomous vehicles, and gaming.
This article surveys a wide range of Python optimization tools—including NumPy, SciPy, Pandas, JIT compilers like PyPy and Pyston, GPU libraries, Cython, Numba, and interfacing utilities—explaining how they can accelerate code execution, reduce memory usage, and improve overall performance for single‑ and multi‑processor environments.
This roundup covers Chrome’s new Document Picture‑in‑Picture API, WhatsApp’s shift away from Electron, a deep‑dive into IndexedDB versus other web storage options, a real‑world performance analysis case, Vue’s dynamic image handling with require, and the latest ES7‑ES12 language features.
This article walks through a real‑world front‑end performance overhaul, explaining how Lighthouse metrics revealed major bottlenecks, detailing practical optimizations such as code splitting, lazy loading, image format changes, and CSP setup, and showing how monitoring tools keep the site fast over time.
This article introduces BeetlSQL's recent updates—including Oracle12Style support and a version upgrade—provides the Maven dependency configuration, lists the wide range of databases it works with, and presents detailed benchmark comparisons against other ORM frameworks.
Facing explosive growth and increasingly complex distributed services, Huya designed and deployed a custom APM platform that unifies metric, trace, and log collection, provides zero‑cost integration, supports real‑time root‑cause analysis, and offers open APIs for cross‑team empowerment.
This article analyzes MySQL's recommendation against UUIDs and non‑sequential keys by benchmarking three tables—auto‑increment, UUID, and random snowflake IDs—using a Spring Boot JdbcTemplate test, revealing that sequential primary keys provide superior insert performance and lower index fragmentation.
This article provides a comprehensive comparison of Bazel and Gradle build systems, examining their design philosophies, concurrency, incremental compilation, configuration phases, performance benchmarks, and ecosystem support, particularly in the context of large‑scale Android monorepo projects, to help developers choose the appropriate tool.
WebAssembly is moving beyond browsers into server‑side workloads, offering a portable binary format, promising performance, and new security considerations, while integrating with containers and Kubernetes through WASI, making it a compelling technology for modern backend development.
This article describes Qunar's systematic client crash governance framework, covering background challenges, APM‑based fast problem discovery, multi‑level alerting, common‑issue remediation, code‑level fixes for URL and Bundle size crashes, detection tools, code checks, automated testing, and the measurable improvements achieved in Android and iOS stability.
This article explains the Unix pipe operator, demonstrates its convenient usage with practical examples, and then presents a detailed performance benchmark of four different shell methods for calculating string length, showing why excessive piping can significantly reduce script efficiency.
JupyterLab 4.0 introduces a flexible multi‑document interface, customizable layouts, an integrated file browser, modular extensibility, built‑in terminal, significant performance improvements, a separate real‑time collaboration package, and a PyPI‑based extension manager, while noting that AI‑assisted coding tools may now outpace it.
This article examines batch processing in microservice environments, defining its role versus data warehouses, exploring optimal placement across architectural layers, discussing access methods, and providing criteria such as complexity, consistency, security, performance, reliability, and scalability to guide the selection of an appropriate batch processing architecture.
This article evaluates the impact of three microservice communication styles—REST, gRPC, and asynchronous messaging via RabbitMQ—on functional and non‑functional software quality attributes, presenting experimental results from a Kubernetes‑based order‑processing scenario that show gRPC delivering the best performance across varying loads.
Certain MySQL queries, such as those using functions, leading wildcards in LIKE, OR operators, inequality comparisons, or NULL checks, prevent the database engine from utilizing indexes, leading to slower performance, and should be rewritten for optimal query efficiency.
This article explains MySQL master‑slave architecture, why it’s used, the replication process, consistency challenges, causes of replication lag, and practical strategies—including binlog formats, mixed mode, monitoring, caching, and failover setups—to optimize performance and ensure high availability.
This article walks through diagnosing V8FatalErrorCallback OOM crashes in an Electron‑based PC Taobao Live client, explores stack analysis, disables compilation cache, adjusts V8 heap limits, compiles a custom Electron without pointer compression, and uses Chrome DevTools Memory and Performance tools along with runtime monitoring to locate and fix the underlying memory leak.
This article examines why MySQL LIMIT pagination becomes slower with deeper offsets on a 500,000‑row table, demonstrates the performance impact with concrete queries, and presents three optimization strategies—including using ordered primary keys, subqueries, and join‑based approaches—to reduce scan range and improve query speed.
Google’s internal survey of over a thousand Rust developers shows that, despite concerns about ownership and borrowing, most find Rust no harder to learn than other languages, quickly become productive, appreciate its safety and performance, yet cite slow compilation as the top challenge.
The article details how the author traced V8FatalErrorCallback out‑of‑memory crashes in an Electron‑based Taobao Live client to an ever‑growing compilation cache and pointer‑compression limits, rebuilt Electron with those disabled, identified a JavaScript memory leak caused by unfiltered error logging, and implemented runtime heap monitoring to prevent future OOM failures.
This article details a step‑by‑step optimization of a high‑volume Excel import workflow in Java, covering the migration from raw POI to EasyPOI and EasyExcel, caching database lookups, using MySQL batch inserts, and leveraging parallel streams to reduce import time from minutes to under two minutes.
This article explains how to benchmark Redis latency, identify common reasons for slowdowns such as high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, swap usage, and CPU binding, and provides detailed configuration and operational steps to monitor and resolve each issue.
This article explores the core front‑end technologies behind JD’s Race Ranking H5 page, covering animation implementations, style configuration, skin switching, poster generation, debugging tools, API protection, and deployment workflows, offering practical insights and code examples for developers building sophisticated mobile web applications.
This article presents a collection of lesser‑known Python tricks—including string normalization, iterator slicing, keyword‑only functions, custom context managers, memory‑saving __slots__, CPU/memory limits, import control with __all__, and simplified ordering with total_ordering—to help developers write cleaner and more efficient code.
Tencent has donated its high‑performance OpenKona JDK compiler to the Open Atom Open‑Source Foundation, offering up to 15% better performance than standard OpenJDK and supporting domestic CPUs and operating systems, making it a significant contribution to the Java ecosystem.
