This article demonstrates how to split large files into 5 MB chunks, compute MD5 hashes, and accelerate processing with Web Workers by dynamically allocating threads based on the browser's hardware concurrency, achieving up to ten‑fold speed improvements.
This guide compiles proven security, design, naming, schema, field, index, SQL, behavior, and process standards for databases, validated by large internet companies to help avoid low‑level faults in high‑concurrency, high‑volume environments.
This article presents Kingsoft Cloud's comprehensive practice on big data compute‑storage separation, detailing the challenges of modern data platforms, comparing HDFS with object storage, describing three separation modes, and explaining the architecture, core modules, performance optimizations, and advantages of the KS3‑HDFS solution.
iQIYI now relies on Apache Spark as its main offline engine, processing over 200 000 daily tasks for ETL, data synchronization and analytics, while recent optimizations—dynamic resource allocation, adaptive query execution, compression, rebalance, Z‑order and resource‑governance—have cut compute usage by ~27 %, storage by up to 76 % and improved query speed, completing a large‑scale migration from Hive and paving the way for Spark 3.4 and Iceberg support.
This article explains the purpose of CPU caches, describes the three cache levels and their internal structures—including direct‑mapped, set‑associative, and fully‑associative designs—and shows how cache‑aware programming can dramatically improve code performance.
This article presents a comprehensive case study of Trip.com’s train ticket service global expansion, detailing the business background, challenges such as multi‑region deployment, performance, data compliance and scalability, and the step‑by‑step architectural evolution across region selection, network, data, infrastructure, and business layers to achieve a resilient, low‑latency, and compliant worldwide service.
This article details practical optimization techniques for Apache HttpClient—including connection pooling, keep-alive, singleton client usage, proper timeout settings, and asynchronous handling—to reduce average request latency from 250 ms to about 80 ms in a ten-million-calls-per-day service.
This article explains the purpose of CPU caches, describes their hierarchical structure and internal organization—including direct‑mapped, set‑associative, and fully‑associative designs—and shows how cache‑aware programming can dramatically speed up matrix operations.
The article analyzes AI‑training traffic patterns, critiques existing flow‑based, flowlet‑based, and packet‑based ECMP load‑balancing, introduces the NSLB solution tailored for AI clusters, and presents experimental results showing up to 113% speed improvement and sub‑millisecond failover with DPFF, while also discussing direct‑topology and intelligent lossless networking techniques.
This article details Ctrip’s API gateway architecture, describing its evolution to handle 20 billion daily requests through fully asynchronous processing, streaming forwarding, single‑threaded event‑loop design, and various performance and governance optimizations, while also covering multi‑protocol compatibility, routing, and module orchestration.
The article explains how cloud‑native observability systems gather massive telemetry from infrastructure, containers, middleware and services, compares direct push and file‑based collection approaches, and details head, tail and local sampling methods to optimize data completeness and performance.
This article examines frequent MySQL performance problems such as inefficient LIMIT usage, implicit type conversion, sub‑query updates, mixed sorting, EXISTS clauses, condition push‑down, early range reduction, and intermediate result handling, and provides concrete SQL rewrites and execution‑plan analyses to dramatically improve query speed.
This comprehensive guide walks you through installing Nginx, configuring load balancing, setting up reverse proxy, enabling static resource separation, compression, caching, IP black/white lists, CORS, anti‑hotlinking, large file handling, SSL, high availability with Keepalived, and key performance optimizations.
PetPS introduces a persistent‑memory‑based parameter server that redesigns indexing with the PetHash hash table and offloads parameter aggregation to NIC Gathering, achieving up to 1.7× higher throughput and significantly lower latency for industrial‑scale embedding models in recommendation, search, and advertising workloads.
StarRocks introduces a Query Cache that stores intermediate aggregation results in memory, enabling reuse across semantically equivalent, partition‑overlapping, or append‑only queries, which can boost query performance by 3‑17× in high‑concurrency scenarios while reducing CPU and disk load.
This article details how a legacy Dubbo service built on Spring 3.2.x with many integrated components suffered a ten‑minute startup, and how using JProfile to pinpoint costly reflection checks, disabling unnecessary Spring annotations, and fixing RabbitMQ connection issues reduced the deployment time to under two minutes.
This article thoroughly examines MySQL replication, detailing binlog formats, event types, replication workflows, semi‑synchronous and parallel replication techniques, performance benchmarks, and practical implementation steps such as fake‑slave registration and connection‑pool enhancements, while illustrating each concept with concrete examples and code snippets.
Ant Group’s FaaS platform redefines serverless computing by eliminating infrastructure overhead, offering rapid function deployment, high‑throughput low‑latency scheduling, robust security isolation, and cost‑effective scaling, while detailing its architectural components, performance optimizations, and future AI‑driven enhancements.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and plain JDBC, compares direct batch insertion, per‑row insertion, and staged batch processing, and provides practical performance tips such as batch size, waiting intervals, index handling, and connection‑pool configuration.
Performance optimization, crucial for user experience, reliability, and resource efficiency, is explored through code and design techniques—from CPU and JVM considerations to caching, preloading, false sharing mitigation, inlining, async processing, and lock granularity—providing practical examples and actionable insights for Java backend developers.
The article explains why the naïve approach of reading a file into a small user‑space buffer and sending it piece‑by‑piece is inefficient, and how zero‑copy, PageCache, asynchronous I/O and direct I/O can dramatically reduce context switches, memory copies, and CPU usage for high‑throughput file transfers.
This comprehensive guide walks you through the challenges of monolithic deployments, explains core Nginx concepts, shows step‑by‑step installation, configures reverse proxy, static‑dynamic separation, compression, buffering, caching, security features, SSL, high‑availability with keepalived, and essential performance tuning for production‑grade servers.
This article explains why a naïve 32 KB‑chunk file transfer incurs excessive context switches and memory copies, and how zero‑copy, PageCache, asynchronous I/O, and direct I/O techniques dramatically reduce overhead and boost throughput for large‑scale data transfers.
The article outlines six Jetpack Compose layout‑optimization best practices—using remember to cache calculations, supplying unique keys in Lazy layouts, applying derivedStateOf to throttle recomposition, skipping unnecessary composition/layout phases, avoiding backward state writes, and enabling release‑mode R8 profiling—to dramatically reduce redundant recompositions and improve UI performance.
To overcome Spring Cloud Gateway’s memory leaks, slow O(N) routing and complex reactive code, the team built a custom, thread‑per‑core Netty gateway with in‑memory O(1) route lookup, DAG‑based filter chains and an asynchronous client, delivering four‑times higher throughput (≈45 k QPS), ~19 ms ART, no leaks, and far‑reduced latency.
This article details the architecture, core algorithms, security measures, and performance optimizations of a URL shortener platform, covering hash functions, distributed ID generation, Base62 encoding, caching, database indexing, sharding, and monitoring to achieve efficient and secure link redirection.
Since 2018 Youzan has migrated all online services to Kylin4, addressing long cube rebuilds, single‑point cache, CPU spikes, and throttling gaps by adding batch segment builds, low‑priority concurrency controls, Redis‑based query caching, parquet skew mitigation, range‑query acceleration, and class‑loader optimizations, which together doubled query‑per‑second capacity to 150, cut latency by up to 50 % and reduced CPU usage.
This article demonstrates how to generate, read, and analyze a 10 GB file of age statistics on a 4 GB RAM, 2‑core machine using Java, comparing a single‑threaded counting method with a producer‑consumer multi‑threaded approach that dramatically improves CPU utilization and reduces processing time.
This article examines traditional file transfer methods, highlights their performance drawbacks caused by excessive context switches and memory copies, and explains how zero‑copy, PageCache, asynchronous I/O, and direct I/O can dramatically improve throughput and reduce CPU usage in backend systems.
Baidu Intelligent Cloud’s GPU Container Virtualization 2.0 combines user‑mode and kernel‑mode isolation in a dual‑engine design that unifies scheduling of AI compute, rendering and encoding, supports mixed deployment and multi‑scheduler integration, and boosts GPU utilization across inference, offline tasks, autonomous‑driving simulation, and cloud‑gaming workloads.
ByteFUSE, a user‑space FUSE‑based solution for ByteNAS, delivers low‑latency, high‑throughput, POSIX‑compatible storage across AI training, database backup, and search services by replacing NFS with a cloud‑native architecture that leverages CSI, RDMA, and kernel‑module hot‑upgrade techniques.
This article examines the challenges of using Backend‑For‑Frontend (BFF) in product display scenarios, proposes a metadata‑driven GraphQL architecture that separates data fetching and presentation logic, details design patterns, performance optimizations, and the impact on development processes, and shares practical experiences from Meituan.
This comprehensive guide walks you through installing Nginx, configuring reverse proxy, setting up load balancing, enabling static‑dynamic separation, resource compression, buffering, caching, IP whitelist/blacklist, cross‑origin support, anti‑hotlinking, large file handling, SSL certificates, high‑availability with Keepalived, and performance tuning tips for production environments.
This article explains how RaftKeeper leverages the Raft consensus algorithm to create a high‑availability, high‑performance ClickHouse cluster across multiple data centers, covering project background, architecture, core features, performance optimizations, and real‑world deployment results.
To eliminate the brief latency spike that occurs when new Dubbo services start, the authors introduce a @Warmup annotation and early‑startup listeners that generate mock traffic and trigger a forced GC before publishing, cutting initial response times from seconds to tens of milliseconds and improving reliability for latency‑sensitive applications.
This article reviews the performance challenges of the logistics pricing engine, explains the limitations of the previous 1.0 optimizations, and details the design and implementation of a new 2.0 cache strategy using Tair and local caches, key‑value modeling, pre‑heating, updates, and bottleneck mitigation, achieving the required QPS.
This article explains how Ant Group tackles the performance challenges of large‑scale OLAP tables by using ADM to reduce data volume, employing Cube pre‑aggregation for reporting, and applying statistical sampling for exploratory analysis, detailing the processes, metrics, and architectural designs involved.
File transfer can be dramatically accelerated by reducing context switches and memory copies, using techniques such as zero‑copy, leveraging PageCache, and employing asynchronous or direct I/O, which together cut system calls, lower CPU usage, and improve concurrency for large‑scale data delivery.
The QQ Space team modernized their 18‑year‑old, 1.5‑million‑line mobile app by incrementally refactoring a tangled “primeval forest” architecture using the RFW‑Part and Section frameworks, layered design, and monitoring tools, cutting code size dramatically, boosting startup speed by over 50 % and improving FPS by nearly 5 %.
This article explains how the WeChat multi‑dimensional monitoring platform, which processes billions of data points daily, identified performance bottlenecks in its Druid‑based data layer and applied sub‑query splitting, Redis caching, and sub‑dimension tables to achieve over 85% cache hit rate and bring average query time down to around 100 ms.
Ximalaya improves live‑stream start‑up by measuring first‑frame latency, optimizing push (dynamic bitrate, GOP caching) and pull (RTMP/HTTP‑FLV, HttpDNS, pre‑fetch URLs, progressive component loading, pre‑render SurfaceView, low‑buffer water‑level) across detailed pipeline stages, achieving over 90 % audio and 85 % video instant‑open rates while planning H.265 adoption.
This case study examines a recurring out‑of‑memory issue in an Elasticsearch 6.8 cluster that spikes during low‑traffic night hours, analyzes GC logs and heap dumps, and details how adjusting G1 GC parameters resolved the problem and stabilized performance.
This guide outlines a five‑level learning path for MySQL, starting with installation and basic queries, progressing through proficient use, deep understanding of locks, indexes and transactions, advanced performance tuning, and finally product‑level redesign, while recommending essential books and resources.
The article explains how Baidu App reduces its iOS package size by analyzing Link Map files and applying six code‑optimization techniques—unused class and module slimming, unused method pruning with LLVM, duplicate‑code detection, utility‑method consolidation, and A/B‑test hardening—yielding up to 8 MB of savings.
This article reviews the key factors that influence PCIe link performance—including data encoding schemes, link‑layer and physical‑layer overhead, and the configuration of Maximum Payload Size (MPS) and Maximum Read Request Size (MRRS)—and explains how each impacts real‑world throughput.
This article walks through how Didi identified excessive CPU consumption by ClickHouse background move threads, diagnosed the root cause using top and pstack, and applied a lightweight code guard that reduced CPU load from 30% to under 5%, improving overall cluster performance.
Tencent Cloud’s Hybrid vCPU research, presented at KVM Forum 2023, outlines a three‑stage roadmap from homogeneous cores to mixed x86, ARM, and RISC‑V CPUs, detailing how virtualizing heterogeneous topologies, frequencies, caches, and PMU features can boost VM performance, security, live‑migration flexibility, and data‑center utilization.
This article explains how to achieve efficient pagination and multi‑condition fuzzy searches in Redis by leveraging Sorted Sets for ordered paging, Hashes with HSCAN for pattern matching, and combining both techniques with caching and expiration strategies to optimize performance.
This article details Baidu Wenku App's backend migration from a PHP‑based stack to Go, covering the motivation, technical debt, technology selection, step‑by‑step migration strategy, quality assurance practices, performance improvements, and key takeaways for large‑scale service refactoring.
This article presents the background, design, architecture, core functionalities, practical challenges, and solutions of MetrAutoAPI, a metric automation API that separates metric data from application layers, supports flexible SQL modeling, rule engine integration, and unified query services to meet evolving data demands.
This article explains how to overcome the 2 MB main‑package size limit in WeChat mini‑programs by asynchronously loading large third‑party libraries such as MQTT.js through subpackages, comparing subpackages with plugins, and providing practical Webpack and uni‑app solutions—including custom require handling, retry mechanisms, and performance gains.
Sichuan Rural Credit Union, with over 5,000 outlets and 3 billion daily transactions, migrated its core and mobile banking systems to OceanBase's native distributed database, cutting card‑issue time from 30 minutes to 5 minutes, loan processing from 3‑5 days to 1‑33 minutes, and saving more than 40% in infrastructure costs.
The article explains distributed ID concepts and business scenarios, compares nine common generation schemes, and details Vivo’s LuBan service architecture—including three built‑in ID formats, custom SPI extensions, Spring‑Boot SDK usage, performance optimizations, and large‑scale deployment metrics—offering practical guidance for building high‑throughput, globally unique ID systems.
The article analyzes the high‑CPU pressure on the outbox Redis cluster caused by feed‑stream read amplification during hot events, proposes a local‑cache solution for hot UPs, details its design, consistency mechanisms, and shows that the optimization cuts peak CPU usage by over 40% while achieving more than 55% cache hit rate.
The fifth “Long‑termism Starts from Small Things” article details how Taobao’s mobile store framework evolved from a simple Weex page to a hybrid mini‑program architecture, consolidating serial requests into a unified entry, adding a native container and WebView co‑location, which cut start‑up latency by over 50 % on low‑end devices and boosted overall performance by roughly 20 %.
This article explains why traditional log‑based performance debugging is inefficient, introduces continuous profiling with the open‑source Pyroscope tool, and provides step‑by‑step instructions for installing Pyroscope on Kubernetes, integrating it with Python, .NET, and Go microservices, and visualizing low‑overhead flame graphs to optimize code and reduce cloud costs.
This article provides a detailed overview of Apache Kafka, covering its distributed streaming architecture, storage mechanisms, replication, consumer groups, compression techniques, exactly‑once semantics, configuration tips, and performance optimizations for building reliable high‑throughput data pipelines.
This article details the end‑to‑end migration of Qunar's massive Elasticsearch logging cluster from a saturated data‑center to a new facility, covering background constraints, migration planning, manual and automated node moves, performance tuning parameters, observed challenges, and the final zero‑downtime results.
This article details iQIYI's adoption of Iceberg for its data lake, covering the OLAP architecture, reasons for a data lake, Iceberg's table format advantages over Hive, platform construction, streaming ingestion, query and performance optimizations, real‑world business deployments, and future plans.
Wukong is HelloBike’s native partial‑dynamic card engine that lets developers design once, preview instantly, and deploy cross‑platform UI and logic without full app releases, boosting development efficiency by up to 80% through Flexbox‑based layouts, lightweight JS engines, and comprehensive tooling.
This article presents a comprehensive overview of Iceberg MOR principles, Arctic‑based performance optimizations, benchmark evaluations using CH‑benchmark, and future roadmap items, highlighting how various file‑type strategies, self‑optimizing mechanisms, and task balancing improve real‑time data lake query efficiency.
iQIYI accelerated its big‑data platform by migrating the OLAP layer from Hive to Spark SQL, achieving a 67 % speedup, 50 % CPU reduction and 44 % memory savings, while automating the conversion of tens of thousands of tasks and delivering faster analytics for advertising, BI, membership and user‑growth services.
This article explains service performance concepts and presents systematic code‑level and architectural optimizations for Java back‑ends, covering class preloading, thread‑pool usage, static variables, cache‑line alignment, false sharing mitigation, branch prediction, copy‑on‑write, method inlining, reflection caching, exception handling, logging practices, lock granularity, and pooling strategies, all illustrated with concrete code examples.
Taobao’s open platform gateway has evolved into a modular, decentralized system that uses full asynchronous processing, multi‑cluster deployment, token‑based authentication, and advanced metadata caching to boost scalability, security, and performance while protecting privacy and enabling efficient large‑scale reporting.
This article introduces MyBatis streaming queries, explains the Cursor interface and its methods, provides step‑by‑step code examples for configuration and implementation, discusses practical application scenarios such as large‑scale data processing, and highlights important considerations for efficient and safe usage.
This article summarizes a technical presentation on innovative database practices, covering a preventive SQL defense framework, full‑SQL analysis for deep observation, and capacity prediction through simulated traffic testing, with detailed methods, challenges, and future plans for multi‑cloud environments.
This article explains why database sharding is needed when performance bottlenecks appear, outlines the criteria and timing for adopting sharding, and provides detailed step‑by‑step guidance on both database‑level and table‑level partitioning, including common pitfalls and solutions.
This article details iQIYI's adoption of the Iceberg data lake, covering its OLAP architecture, reasons for a lake, Iceberg table format advantages over Hive, platform construction, extensive performance optimizations, and real‑world business use cases such as ad‑flow unification, log analysis, audit, and CDC pipelines.
This guide walks developers through the essential design principles, client‑side optimizations, CDN usage, clustering, caching, database tuning, and service‑governance techniques needed to build robust high‑traffic, high‑concurrency applications.
This article describes the background, technology selection, architecture design, data flow, monitoring, logging, and trace collection mechanisms of Qunar's self‑built distributed tracing system, analyzes major performance problems such as Flume interruptions, Kafka bottlenecks, Flink back‑pressure, and presents concrete solutions including sliding‑window throttling, CGroup limits, and JavaAgent instrumentation, ultimately improving trace connectivity and system observability.
This article dives deep into Dubbo3's Triple protocol, explaining its design, identifying performance bottlenecks with tools like VisualVM and JFR, and presenting concrete code‑level optimizations—including async stream creation, lock‑contention fixes, thread‑pool tuning, and batch writes—that boost throughput by up to 45% in real‑world Alibaba workloads.
Facing a 50‑million‑row financial transaction table, the team implemented horizontal sharding with sharding‑jdbc, designed migration and pagination strategies, tackled multi‑datasource transaction issues, and outlined a phased rollout, providing practical insights for large‑scale MySQL table splitting and backend system stability.
This article investigates why a Go‑based service health‑check system experiences high latency, examines differences from Nginx checks, runs experiments on physical machines and Docker, and explores goroutine scheduling, GOMAXPROCS, and garbage‑collection tuning to reduce average response time from 40 ms to under 10 ms.
An in‑depth comparison of Java 17 and Java 8 highlights new language features such as sealed classes, pattern‑matching switch, records, enhanced garbage collectors, JIT improvements, and updated collection APIs, while providing performance insights and runnable code examples to help developers choose the right version for modern applications.
This guide explains how to use the open‑source Pyroscope continuous profiler on Kubernetes to collect, store, and visualize performance data from microservices written in Go, Python, .NET, and more, enabling developers to pinpoint bottlenecks, reduce CPU and memory usage, and lower cloud costs.
This article presents an in‑depth overview of the YouShu BI product, outlines the high‑concurrency performance challenges faced by enterprise BI, and details the multi‑layer performance architecture—including front‑end, back‑end, data engine, and data source layers—along with smart caching, MPP acceleration, materialized views, and the Data Doctor operations that together ensure low‑latency, reliable analytics for large‑scale users.
This case study details the performance bottlenecks of the iQIYI Kids feed on low‑end devices and presents a series of engineering solutions—including async card rendering, preloading strategies, image pre‑decoding, and cache optimizations—that reduced scroll hitch time to 1.4 ms, dramatically improving user experience.
This article explains how Linux memory compression techniques such as zSwap, zRAM, and the Zstandard algorithm reduce I/O pressure, extend flash lifespan, and improve overall system performance, while also covering their drawbacks and step‑by‑step activation procedures.
This article explains how JD.com’s retail shopping‑cart team tackled growing business complexity by redesigning the cart with a full asynchronous architecture, detailing the overall solution, implementation challenges such as fine‑grained retries and monitoring, and the resulting performance gains.
This article presents Blaze, a Kuaishou‑built native execution middleware for SparkSQL that leverages Apache DataFusion to achieve vectorized operator execution, detailing its architecture, implementation, performance gains, current coverage, benchmark results, production rollout, and future development plans.
This article details how WeChat's Gemini‑2.0 big‑data platform leverages Apache Pulsar, outlining cloud‑native advantages, load‑balancing refinements, cache and SSD tuning, high‑availability safeguards, and cost‑saving strategies that together enable large‑scale, real‑time, deep‑learning recommendation workloads.
This article details Waterdrop's transition from ClickHouse and TiDB to a unified StarRocks‑based OLAP platform on Alibaba Cloud EMR, covering architecture evolution, performance benchmarks, best‑practice recommendations, and future plans for large‑scale real‑time analytics.
This article explains how StarRocks’ new compute‑storage separation architecture reduces storage expenses and improves analytical performance by leveraging hot‑cold data segregation, elastic scaling, caching strategies, multi‑version storage, and optimized compaction, illustrated with real‑world log and e‑commerce workload examples.
This article describes the motivation, challenges, design, and performance optimizations of a remote state backend for Flink that leverages Bilibili's Taishan distributed KV store to achieve storage‑compute separation, lighter checkpoints, faster rescaling, and improved resource utilization in large‑scale streaming jobs.
The article explains how iOS’s lack of native GIF/WebP support leads to crashes when decoding all frames, and describes an optimized per‑frame loading component (QMAnimatedImageView) that uses CADisplayLink, NSCache, downsampling and memory‑limit tuning to dramatically reduce CPU, memory usage and jank while preserving smooth animation.
This article details a systematic performance‑boost and maintenance‑cost reduction effort for a 230,000‑line Vue3 + Vite PC web project, covering page‑load analysis, bundle visualization, code‑duplication detection, cyclomatic‑complexity measurement, and concrete optimization steps such as on‑demand imports, manual chunking, gzip and image compression, and ESLint rules, resulting in a 52% faster load time and a 3.43 MB smaller bundle.
This article explains step‑by‑step how to install, configure, and use the PhpFastCache library in PHP—including selecting cache drivers, setting and retrieving cached data, managing expiration, and employing namespaces—to improve website performance by reducing database queries.
This article summarizes Liu Donghui’s presentation at DTCC2022, detailing Baidu Intelligent Cloud’s Redis‑compatible, high‑capacity, low‑cost PegaDB, covering its design goals, architecture, KV storage engine choices, cluster scaling, replication enhancements, performance optimizations, multi‑region active‑active support, and future roadmap.
This article shares a comprehensive, step‑by‑step guide to optimizing API performance, covering batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelism, indexing, transaction management, deep pagination, SQL tuning, lock granularity, and code structure refactoring, all illustrated with Java examples.
This article explains what ClickHouse is, why a large MySQL table caused multi‑minute queries, and how migrating the data to ClickHouse using Docker, CREATE TABLE AS SELECT, and a lightweight sync tool reduced query time to under one second, while highlighting pitfalls and performance reasons.
This article analyzes the challenges of stitching multi‑modal transport routes in Ctrip's backend, identifies performance bottlenecks through monitoring, profiling and benchmarking, and presents a series of optimizations—including code refactoring, indexing, multi‑way merge, multi‑level caching, preprocessing, multithreading, lazy computation, and JVM tuning—that collectively reduce latency and resource consumption.
This article details how the Industrial and Commercial Bank of China's software development center tackled Jenkins performance bottlenecks by upgrading hardware, switching to OpenJ9 JVM, and implementing Docker‑Swarm load balancing, ultimately boosting build capacity from a few thousand to over thirty‑six thousand daily jobs.
BBC found that each extra second of load time cuts users by 10%, so they adopted server‑side rendering to boost first‑screen performance on low‑end devices, accepting higher server load and longer white‑screen time, choosing the stable Rax solution over ICE 3.0, and emphasizing selective use, streaming HTML, and careful migration guidelines.
Chrome separates browsing tasks into distinct browser, renderer, plugin, and GPU processes, parses HTML/CSS into DOM, layout, paint, and compositing trees, rasterizes tiles on a compositing thread, and uses the GPU process to display frames, enabling optimized, smooth animations such as danmaku while balancing memory usage and security.
This article details Weimob's migration to APISIX, covering background, performance requirements, benchmark results, architectural analysis, Kubernetes deployment, custom plugin extensions for authentication and rate limiting, remaining challenges, and overall conclusions about the gateway's impact.
This article demonstrates how to boost the insertion speed of over two million records by configuring Spring Boot's ThreadPoolTaskExecutor for multithreaded batch inserts, detailing the setup, code implementation, performance testing, and analysis of results.
This case study describes how the hotel business gateway at Qunar was refactored using Spring WebFlux to achieve full‑process asynchronous handling, service orchestration, and significant performance gains—including a 100% increase in single‑machine throughput, 50% reduction in response latency, and lower code complexity—while outlining the analysis, solution design, results, and future work.
This case study describes how Hangzhou Mingshitang transformed its homework photo evaluation system from a Kubernetes‑based solution to an Alibaba Cloud Function Compute serverless architecture, achieving higher elasticity, lower latency, and reduced costs while handling peak traffic of over one million daily images.
This article examines the evolution stages of a plugin framework, analyzes performance bottlenecks such as Multidex, Dex2Oat, and class loading on Android devices, and presents detailed optimization strategies—including timing adjustments, forced compilation commands, and native class‑loader hook replacements—to improve app responsiveness and reduce ANR occurrences.
This article details how Hangzhou Bank Consumer Finance modernized its big‑data platform by introducing Apache Doris 1.2, replacing the original Greenplum + CDH architecture, unifying data sources via Multi‑Catalog, achieving second‑level query latency, reducing storage and compute costs, and outlining the integration workflow with DolphinScheduler, SeaTunnel, and Spark.
