This comprehensive guide explains what Elasticsearch does, its underlying Lucene technology, core concepts such as clusters, shards, replicas, mapping, indexing and storage mechanisms, and provides practical performance‑tuning advice for building and operating a robust distributed search engine.
This article explains how moving image preprocessing and post‑processing to GPU with the open‑source CV‑CUDA library dramatically reduces system complexity, eliminates CPU‑GPU bottlenecks, and delivers up to thirty‑fold performance gains for computer‑vision workloads across training and inference stages.
Meituan Visual's engineering team tackled the common low‑GPU‑utilization bottleneck in online inference services by splitting model structures and adopting micro‑service deployment, raising GPU usage from 40% to 100% and more than tripling QPS, and then generalized the approach for other GPU‑based services.
DeWu’s container SRE team combines software‑engineered reliability with routine operations, using defined on‑call roles, SLO/SLA targets, progressive change management, capacity forecasting, four‑metric monitoring, MTTR/MTTF tracking, kernel‑parameter tuning, and namespace‑protected security policies to swiftly resolve incidents such as Redis latency spikes.
Facing massive log volume in JD.com’s shopping cart service, we reduced disk consumption, CPU load, and improved request latency by applying Log4j2 log level filtering, asynchronous logging with AsyncLogger, and TTL‑based thread‑local context propagation, while providing detailed metrics, configuration steps, and best‑practice recommendations.
This article explores practical techniques for optimizing online services handling over 200,000 QPS, covering why relational databases fall short, multi‑level caching, multithreading, circuit breaking, I/O reduction, controlled retries, edge‑case handling, and efficient logging to maintain sub‑300 ms response times.
This article explains common MySQL database performance optimization techniques, underlying storage architecture, index construction and usage guidelines, and presents several real‑world cases from an internet hospital project, helping developers understand optimization strategies, avoid hidden pitfalls, and improve query efficiency.
This article introduces WebAssembly’s efficient, safe, open standards and LLVM‑based compilation pipeline, then guides Rust developers through installing tools, writing and binding simple functions, optimizing performance and bundle size, and explores tooling, runtimes, real‑world use cases, current limitations, and future extensions such as WASI, SIMD, and threads.
This article provides a comprehensive overview of Flutter, covering why to learn it, the architecture layers, widget fundamentals with code examples, Dart language basics, GetX state management, common development pitfalls and solutions, as well as performance optimization techniques for building efficient cross‑platform mobile applications.
This article details Ctrip's experience migrating MySQL workloads to the distributed OceanBase database, covering the design of an assessment tool, a one‑click migration workflow, comprehensive monitoring dashboards, automated fault‑diagnosis pipelines, encountered compatibility issues, and future roadmap for the platform.
The article chronicles Caiyun Weather’s evolution of geographic lookup—from a naïve nearest‑adcode algorithm to a high‑precision H3‑based system—detailing the evaluation of Geohash, S2, and H3, performance benchmarks, memory trade‑offs, and the final R‑Tree‑augmented point‑in‑polygon solution.
This article details Meituan's search‑engine optimization for its food‑delivery platform, describing the performance bottlenecks of Elasticsearch's inverted‑list query and merge phases, the design of a run‑length‑encoding (RLE) index, custom hash‑map term look‑ups, sparse RoaringBitmap structures, integration steps, and the resulting 84% latency reduction.
Facing a four‑hour coupon‑calculation bottleneck at eLong, I explored Storm’s stream‑processing model, identified the data‑extraction stage as the weak link, refactored the hotel‑pull service, leveraged RocketMQ for threading, and ultimately reduced full‑batch processing time to just over an hour.
To support Southeast Asian live-streaming, we designed a custom danmaku system capable of handling up to a million concurrent users per room, tackling bandwidth pressure, weak-network latency, and reliability by employing HTTP compression, response simplification, short-polling, local caching, and lock-free ring buffers.
This extensive tutorial walks through installing Nginx from source, setting up environment, configuring reverse proxy load balancing, static resource handling, compression, buffering, caching, IP black‑white lists, anti‑hotlinking, large file transfer, SSL certificates, high availability with Keepalived, and advanced performance tuning techniques.
Baidu’s Baige AI heterogeneous computing platform delivers an end‑to‑end, low‑cost AI IaaS for autonomous driving, covering data cloud, tiered storage, RapidFS caching, AIAK‑Inference and AIAK‑Training acceleration, GPU container virtualization, and remote GPU pooling, achieving up to 5× faster data access, 391% training speedup, 90% inference latency reduction, and 60% simulation cost cut.
This article curates the ten most-read technical posts from NetEase Yanxuan in 2022, covering DDD adoption, reverse transaction systems, availability metrics, documentation practices, inventory locking, performance optimization, stability governance, H5 containerization, 2B architecture, and the evolution of the Yanxuan app’s engineering architecture.
The article analyzes the growing demands on network I/O, explains Linux’s kernel bottlenecks, and shows how user‑space frameworks like DPDK and UIO can achieve multi‑hundred‑million packets per second through techniques such as huge pages, SIMD, zero‑copy, and careful CPU cache management.
The article walks through a real‑world case of locating the K closest national weather stations to a Beijing site, explains why naive full‑scan using Vincenty's formula is slow, and details a tile‑based indexing solution that cuts query time to 900‑3000 ns and reduces CPU usage by about 10 percent.
Facing memory leaks and high CPU load in a Canvas‑based avatar editor, the team switched to WebGL, leveraging GPU parallelism, off‑screen framebuffers, and blending techniques to dramatically reduce memory consumption and CPU usage while adding features like image layering and color blending.
This article explores the challenges of end‑to‑end tracing on mobile apps, explains why issues are hard to reproduce, and presents a four‑step solution using a unified OpenTelemetry standard, automated data linking, performance optimizations, and machine‑learning‑driven root‑cause analysis.
Ant Group and Hong Kong University of Science and Technology’s award‑winning paper, “Complexity‑guided Container Replacement Synthesis,” presented at OOPSLA 2022, introduces a static‑analysis‑driven method that automatically replaces inefficient Java containers, achieving an average 8.1% runtime improvement across real‑world projects.
The article presents an in‑depth overview of Tencent's self‑developed Unified Scheduling Platform, detailing its system architecture, design challenges, performance optimizations, resource‑fair scheduling mechanisms, operational metrics, future roadmap, and a Q&A session that together illustrate how the platform enables massive offline data processing at scale.
This article details Meituan's use of Kafka as a unified data cache and distribution layer, outlines the challenges of massive scale and latency, and presents comprehensive optimizations across application, system, and cluster management layers, including disk balancing, migration acceleration, fetcher isolation, and full‑link monitoring.
stl4go provides a generic Go 1.18 container library that implements an optimized skip‑list‑based ordered map, using adaptive levels, efficient random‑level generation, type‑specific paths, and cache‑friendly node structures to achieve near‑C++ performance, surpassing existing Go generic collections.
This article presents the background, requirements, architecture, key modules, and practical impact of OPPO's non‑intrusive big‑data diagnostic platform—named Compass—designed to quickly locate issues, provide optimization suggestions, and achieve cost‑saving and efficiency gains for large‑scale Spark and Hadoop workloads.
This article explains how ICBU measures and improves global front‑end performance using Core Web Vitals and FCP, outlines the rationale behind metric selection, details threshold logic for LCP, CLS and FID, describes multi‑channel data collection and aggregation, and showcases dashboards that help developers identify and resolve performance issues.
This article systematically examines the major performance bottlenecks in AI model training, explains the underlying hardware and software causes, and presents a comprehensive set of acceleration strategies—including data‑loading optimizations, compute‑side enhancements, communication tricks, and the AIAK‑Training suite—backed by real‑world case studies and quantitative results.
This article details the private‑deployment architecture of Volcano Engine A/B Testing (DataTester), outlines three major challenges—version management, performance optimization, and stability—and explains the branch‑logic, release pipeline, model‑optimization, and pre‑aggregation solutions implemented to enable reliable, low‑resource SaaS‑like operation in on‑premise clusters.
This article details Volcano Engine DataTester's private deployment architecture, the version‑management, performance, and stability challenges encountered, and the business‑oriented solutions—including branch strategies, pipeline automation, ClickHouse model optimizations, and multi‑level caching—that enable reliable, efficient A/B testing in on‑premise environments.
The article reflects on developing mobile 3D games, advising developers to choose between lightweight libraries like Three.js and full‑featured engines such as Babylon.js, weigh web, native, or hybrid deployment, adopt appropriate technical trade‑offs, and build a well‑structured 3D team with clear roles to balance performance and visual quality.
This article explains how technical professionals transitioning to management can apply quantitative analysis and systematic measurement to optimize both software system performance—illustrated by an image‑processing pipeline case study—and organizational workflows, highlighting DevOps bottlenecks, resource utilization, and the importance of holistic process improvement.
This article consolidates three performance‑optimization posts, detailing six universal time‑space trade‑off techniques—indexing, caching, compression, prefetching, peak‑valley smoothing, and batch processing—plus four advanced parallelism strategies, illustrated with real‑world analogies and practical guidelines for developers.
This article examines the evolving demands of network I/O, analyzes Linux and x86 bottlenecks, explains DPDK's user‑space bypass architecture, and presents practical optimization techniques—including huge pages, SIMD, cache prefetching, and compile‑time tricks—to achieve multi‑gigabit packet processing rates.
By replacing the default JavaScriptCore engine with Hermes for Hippy’s UI rendering in QQ Browser, the team cut module load time by 70‑80 %, lowered first‑frame latency and crash rate, kept memory usage comparable, and leveraged Hermes’s bytecode support and React‑Native ecosystem to dramatically improve startup performance.
This article explains how to batch multiple cluster endpoint requests in Go by using a token‑based queue and concurrent workers, dramatically reducing load on the registration center while requiring minimal changes to existing code.
This article systematically analyzes the main performance bottlenecks in AI model training, explains why acceleration is essential, and presents current hardware‑ and software‑based solutions—including data‑loading optimizations, operator fusion, mixed‑precision and Tensor Core usage, as well as distributed communication strategies—followed by real‑world case studies of Baidu's AIAK‑Training suite that demonstrate significant speed‑ups.
This article explains the architecture of Weibo's popular recommendation system, the role of the weidl online learning platform, and how DeepRec’s performance optimizations—such as oneDNN operator acceleration, cost‑aware scheduling, and adaptive memory allocation—significantly improve training speed, inference latency, and overall service throughput.
This article recounts a year‑long, hands‑on experience of deploying and continuously optimizing Apache SkyWalking for full‑link monitoring in a large micro‑service environment, covering the motivations, architecture choices, pre‑research, POC integration, and a series of performance‑tuning steps that reduced segment storage from billions to millisecond‑level query latency.
This article describes the background, technical selection, architecture, deployment, performance tuning, and operational practices of a Milvus‑driven vector retrieval platform, including cloud‑native deployment, index choices, capacity planning, and real‑world application cases that improve recall latency and resource efficiency.
This article introduces a two-level cache framework designed to address issues with Spring-Cache, providing enhanced caching strategies and improved performance in Java-based backend systems.
This article shares Ctrip's practical experience in microservice governance, detailing the background, common pitfalls such as excessive service granularity and cyclic dependencies, and presenting concrete goals, principles, and strategies that led to significant improvements in stability, performance, and development efficiency.
By eliminating unnecessary reverse‑geocode calls, aggregating nearby coordinates with GeoHash, and employing a multi‑layer LRU‑K cache with time‑ and access‑count eviction, the Hellobike map team cut daily requests from 200‑300 million to 20‑30 million while adding fallback and monitoring mechanisms.
This article explains React's internal update loop, the render and commit phases, default bailout optimizations, and how developers can accelerate rendering using techniques such as state lifting, content lifting, React.memo, useMemo, and useCallback while avoiding over‑optimization.
Bilibili's cloud‑based Android build system leverages high‑performance remote servers, Dockerized build images, Git diff synchronization, and distributed compilation of heavy tasks like DexBuild to dramatically accelerate builds for its massive monorepo, providing parallelism and VIP priority while incurring a learning curve and added maintenance costs.
Tencent Cloud’s OCR team cut average response time from 1.8 seconds to under one second and boosted throughput by over 50 % by redesigning the model with self‑attention, accelerating inference with a Tensor‑Network accelerator, shrinking RPC payloads, enabling asynchronous logging, and optimizing multi‑region GPU memory utilization.
The article details vivo's development of a high‑accuracy, high‑performance streaming speech‑recognition inference engine built on the wenet framework, its optimization techniques such as dynamic batching and memory pooling, collaborative acceleration with KunlunChip's high‑performance inference library, and extensive performance benchmarks demonstrating multi‑batch GPU and XPU gains.
The team created Layout2Code, an APT‑based generator that translates XML layouts into Kotlin code at build time—handling merge and include tags and supporting custom Views—cutting homepage layout inflation by over 200 ms, boosting performance metrics while requiring far less maintenance than traditional X2C solutions.
This article describes how Qunar’s travel app team built a unified performance measurement platform and applied a series of frontend‑focused optimizations—including JSBundle pre‑loading, slimming, splitting, rendering‑stage improvements, and service‑request prefetching—to consistently reduce the Time‑to‑Interactive metric by double‑digit percentages across core booking pages.
This article examines the selection of ClickHouse as the OLAP engine for a self‑service analytics platform, describes the platform’s architecture, details memory and performance tuning techniques, discusses large‑scale join handling, and outlines current challenges and future development directions for ClickHouse.
In early 2021 senior engineer Liu Lei led a complete redesign of Bilibili’s PC homepage, adopting Vue 3 with a custom SSR/CSR hybrid, responsive grid layouts via CSS grid and flex, theme variables, monorepo tooling, and extensive performance tweaks—boosting the page’s score dramatically while preserving hackability and supporting both narrow and ultra‑wide screens.
The article proposes a full‑stack H5 containerization framework for mobile apps that boosts user experience and development efficiency by pre‑heating WebViews, using offline packages and parallel data loading to cut load times, adding comprehensive performance monitoring, a modular native‑plugin system, and a configuration‑driven shell‑container factory that frees frontend teams from mobile‑team dependence.
This article explains how Alibaba Cloud EMR StarRocks extends data lake analytics to support Hive, Iceberg, and Hudi, detailing its architecture, Iceberg integration, performance gains over Trino, IO merging, lazy materialization, intelligent caching, and elastic compute capabilities for faster, unified, and cost‑effective queries.
This article explains the concept of Redis data skew, its causes and impacts, explores data volume and access skew classifications, presents mitigation strategies, and provides a comprehensive source‑code walkthrough of JD's open‑source hotkey framework—including client, worker, and dashboard components—for detecting and handling hot keys in distributed cache clusters.
This article details Meituan's large‑scale Kafka deployment—over 15,000 machines and petabyte‑level daily traffic—its operational challenges such as slow nodes, load imbalance, and resource contention, and the comprehensive read/write latency, system‑level, and cluster‑management optimizations implemented to improve performance and reliability.
The article surveys GPU rendering pipelines and hardware architectures for desktop and mobile, explains classic stages, compares Immediate Mode, Tile‑Based and Tile‑Based Deferred rendering, details PowerVR, Mali and Adreno components, and offers optimization advice on draw calls, depth pre‑passes, shader efficiency, and render ordering.
This curated guide explores key front-end topics—including unified browser storage APIs, comprehensive engineering configuration practices, deep dives into exception handling and performance optimization, essential packet-capture techniques, impactful micro-copy design, and a personal four-year front-end development journey—providing practical insights for modern web developers.
This article describes the architecture, key features, dynamic deployment, performance optimizations, and real‑world results of a high‑throughput online inference platform that serves deep‑learning models for JD.com’s risk‑control decision engine, achieving near‑hundred‑fold latency improvements.
An accidental discovery by a GitHub engineer revealed that moving a single '&' operator in a Go program eliminated unnecessary copies, reduced heap allocations via escape analysis, and improved execution speed by 42%, highlighting common pitfalls in Go’s regex engine, malloc, and garbage collection.
This article introduces front‑end lazy‑loading strategies—including route lazy loading, three image lazy‑loading methods (native, scroll‑event, and IntersectionObserver), and module lazy loading—explaining their principles, showing complete React/Vue code examples, and demonstrating how they reduce initial load time and improve user experience.
UCloud’s US3 object storage metadata service, originally built on a chained MongoDB architecture, faced scalability, performance, and cost challenges, prompting a redesign that introduces a high‑compatibility DB‑Gateway, a distributed KV store (UKV) with custom RocksDB, delivering faster reads, zero list‑service latency, 80% cost reduction, and simpler operations.
This article explains how to build a reliable e‑commerce inventory system by handling concurrent stock deductions, designing inventory and flow tables, using optimistic locking and transactions, and scaling the solution with read‑write splitting and Redis caching to meet high‑QPS demands.
Meituan's food‑delivery search team identified heavy CPU and latency hotspots in Elasticsearch's posting‑list query and merge phases, then redesigned the inverted index using Run‑Length Encoding, hash‑based term lookup, index sorting and a custom SparseRoaringDocIdSet, ultimately reducing TP99 search latency by 84% and cutting CPU usage dramatically.
This article reviews a decade of Google TPU development, highlighting ten technical and architectural lessons, the hardware's impact on the AI industry, performance and energy‑efficiency improvements, and strategies for reducing machine‑learning carbon footprints.
Uber processes over 500,000 daily Presto queries across 20 clusters handling more than 50 PB of data, and by deploying Alluxio Local Cache on NVMe disks they raised cache‑hit rates from roughly 65% to over 90% while addressing real‑time partition updates, node churn, and cache‑size constraints.
This article explains the value, underlying HTTP redirect mechanism, and detailed design approaches—including hash‑based and distributed‑ID generation, base‑62 encoding, database storage, caching, indexing, sharding, and rate‑limiting—to build a scalable short‑link service.
This guide details practical performance‑optimization techniques for Cocos‑based WeChat mini‑games, covering scene and prefab optimizations, asset compression, code size reduction, garbage‑collection handling, mask usage, plugin assistance, code‑level improvements, and a suite of testing tools to measure and verify the gains.
This article explains how the automotive app team tackled severe scrolling lag on low‑end Android devices by replacing the default FlatList with a reusable RecyclerListView implementation, detailing rendering principles, layout calculations, height estimation techniques, and the resulting performance gains.
This article explains user path analysis as a method to visualize and optimize user flow, describes its productization in the Hunyi analytics platform, details the underlying computation logic, presents a complex StarRocks SQL solution, discusses performance challenges, and suggests future improvements and recruitment opportunities.
This article explains why Vue SSR performance suffers, introduces cache concepts and eviction policies, and walks through a complete, O(1) LRU cache built with JavaScript using a hash map, doubly‑linked list and arrays, complete with code and visual examples.
The article examines Turbopack's claimed performance advantages over Vite, critiques marketing-driven comparisons in open-source tools, and emphasizes the need for transparent, peer-reviewed evaluations in frontend development.
Bilibili’s FlinkSQL team has enhanced the Flink engine—now based on 1.11 with back‑ported 1.15 features—by adding Delay‑Join, table‑valued functions, projection‑push‑down, UDF and object reuse, automatic mini‑batch/two‑phase aggregation, key‑group skew fixes, connector slot‑groups, real‑time projection with Hudi, and RocksDB state‑performance tweaks, while planning remote state backends and deeper stream‑batch integration.
Modern C++ performance suffers when seemingly harmless abstractions—such as virtual functions, hidden copies, non‑trivial destructors, overused std::shared_ptr, type‑erasing wrappers, std::variant/optional, and std::async—prevent inlining and efficient memory use, while patterns like std::move on returns, hidden destructors in tail recursion, and branchy loops thwart NRVO, tail‑call, and auto‑vectorization optimizations.
This article analyzes the original template‑variable replacement logic used in Alipay's card package, identifies costly String.replace operations, and presents five iterative optimizations—including removal of indexOf/substring, caching with Guava, and replacing String.replace with StringBuilder—that together achieve more than a ten‑fold speedup while discussing trade‑offs in readability and resource consumption.
This article provides a comprehensive overview of Elasticsearch, covering its underlying Lucene architecture, data types, cluster components, shard allocation, indexing mechanisms, storage strategies, and performance tuning tips for building scalable, near‑real‑time search solutions.
This article explains the design and implementation of a reusable feeds component that supports multiple layout modes, renders different data types, and uses virtual scrolling to keep DOM size low and maintain smooth performance during infinite scrolling.
This article introduces the Lingjie page‑level micro‑frontend solution, explains the concept and types of micro‑frontends, describes its design principles and iframe‑based architecture, outlines core features, and provides step‑by‑step guidance for integrating and optimizing applications with Lingjie.
This article provides a comprehensive introduction to Elasticsearch, covering the distinction between structured and unstructured data, Lucene’s inverted index, ES core concepts such as clusters, nodes, shards and replicas, mapping, basic usage, storage mechanisms, and practical performance‑tuning tips for large‑scale search deployments.
This article presents a comprehensive guide to Unity rendering pipelines, key terminology, and practical performance‑optimization techniques—including AR, texture, memory, heat, and package‑size improvements—applied to the VI Sales Crown product, with detailed tools, methods, and measurable results.
This article describes how Meituan’s data platform tackles the growing challenges of a 15,000‑plus‑node Kafka deployment by detailing current bottlenecks, latency‑reduction techniques across application and system layers, large‑scale cluster management strategies, and future directions for robustness and cloud‑native migration.
This article examines the comprehensive challenges AI applications face from storage to compute, traces the evolution of AI training infrastructure, analyzes key bottlenecks such as compute acceleration, resource scheduling, massive data handling and data flow, and presents Baidu Cloud's storage acceleration solutions—including parallel file systems, caching, and the Fluid scheduler—to dramatically improve AI training performance.
The article explains what data skew is in distributed computing, analyzes its logical and data‑level causes, and presents preventive and remedial techniques such as data partitioning, logical replacement, two‑stage aggregation, increasing parallelism, and data cleaning to improve processing efficiency.
This article explains how mobile games assign default graphics quality levels to various devices using configuration tables, code‑based matching, and a hybrid approach, detailing iOS and Android specifics, server switches, testing practices, and the trade‑offs of each method.
This article provides a comprehensive introduction to Elasticsearch, covering data types, Lucene fundamentals, cluster architecture, node roles, shard and replica mechanisms, mapping, basic usage, installation steps, health monitoring, indexing workflow, storage strategies, refresh and translog handling, segment merging, and practical performance tuning tips.
The paper describes a green‑computing‑focused system for Alibaba Mama’s display ad engine that dynamically reallocates CPU cores among services by offline analysis of response‑time, concurrency and RPM data, enabling up to 3 % revenue gains while reducing operational cost.
This article curates essential thoughts and summaries on frontend architecture, SAP system design, ToB customization, JavaScript framework evolution, micro‑interaction design, information loading UX, and micro‑frontend performance analysis, highlighting how clear, flexible, and scalable structures drive rapid, stable product growth.
This article explains the background, challenges, and design principles of horizontal scaling for TDSQL, detailing its architecture, scaling process, shard‑key selection, high availability, distributed transactions, performance optimization, practical case studies, and a Q&A section.
This article explains the motivations, challenges, and design principles of horizontal scaling for databases, using TDSQL as a case study to illustrate architecture, scaling procedures, shard key selection, high‑availability mechanisms, distributed transactions, and performance optimization techniques.
This article provides a step‑by‑step guide on compiling, deploying, and testing the Hardcoder server on Android, covering pre‑integration checks, property configuration, socket communication, JNI performance APIs, protobuf integration, build scripts, init scripts, and SELinux policies.
The paper proposes a full quantization pipeline for YOLOv6 that combines a re‑parameterization optimizer, partial PTQ, channel‑wise distillation, graph‑scale merging, and GPU‑offloaded preprocessing, enabling an INT8 model to retain ~42 % mAP while delivering over 200 % throughput increase and 40 % QPS gain versus FP16.
An in‑depth case study of Alipay’s card‑coupon template engine reveals that replacing costly String.replace calls with a custom StringBuilder implementation, combined with caching strategies, can boost rendering performance by more than tenfold, while also reducing memory overhead and improving scalability.
This article provides a comprehensive technical overview of DPDK, covering its architecture, core libraries, platform modules, polling and CPU‑affinity techniques, huge‑page memory management, NUMA considerations, OS tuning steps, and integration with OVS for high‑performance packet processing.
This guide explains how Fluid, a Kubernetes‑native data orchestration engine, can be deployed on Alibaba Serverless Kubernetes (ASK) to cache and pre‑warm large datasets from OSS, enabling elastic bandwidth, reducing latency, and cutting costs for data‑intensive serverless applications.
This article explains why locating a record in a B‑Tree index is crucial for MySQL InnoDB operations, describes scan intervals, index page structures, and details the step‑by‑step binary and sequential search process used to find the first matching record, including performance optimizations.
Bilibili’s Log Service 2.0 replaces its Elastic‑Stack pipeline with an OpenTelemetry‑driven architecture that writes logs via high‑performance Go/Java SDKs to ClickHouse, delivering ten‑fold write throughput, two‑fold query speed, one‑third storage cost, a custom query gateway, visualization UI, and advanced alerting.
Redis achieves exceptional speed by operating as an in‑memory database, leveraging compact data structures like SDS, linked lists, hash tables, skip lists and ziplists, running a single‑threaded event loop with I/O multiplexing, and employing optimizations such as lazy‑free, progressive rehashing, and multithreaded network I/O.
This article details the performance tuning of Vivo's Java-based push recommendation service, covering background challenges, measurement metrics, hotspot code and JVM GC optimizations, custom split utilities, map key improvements, off‑heap caching, and the resulting throughput and latency gains.
The Vivo Push recommendation service was dramatically accelerated by replacing regex‑based String.split with a custom utility, converting massive String‑key maps to long keys, and moving large caches off‑heap, which together cut latency by about 32%, boosted throughput roughly 45% and nearly doubled overall performance.
This article presents a comprehensive, high‑precision, stable, and full‑link event tracking solution for iOS, Android, and H5 clients, detailing the shortcomings of traditional point‑tracking, the design of objects and a virtual tree (VTree), AOP‑based click handling, exposure tracking via VTree diffs, performance optimizations, refer‑based link tracing, and integration with H5/RN, all validated in the NetEase Cloud Music ecosystem.
The article presents a transparent data‑encryption framework for database security that uses an AOP‑based driver interceptor to rewrite SQL, encrypt/decrypt sensitive fields, manage performance with locks and caching, support configurable algorithms via SPI/YAML, and guide a three‑phase migration with minimal code intrusion.
