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.
This article explains how ByteHouse, a heavily optimized fork of ClickHouse, introduces a multi‑stage execution model, advanced exchange mechanisms, and runtime filters to overcome the limitations of the original two‑stage query flow, delivering significant performance gains for complex joins, aggregations, and large‑scale analytics workloads.
The Xiaohongshu mini‑app runtime uses a dual‑thread container separating a Render UI layer and a Service logic layer, linked by a serialized Bridge, with unified iOS/Android containers, Webpack‑based build outputs, priority‑queued messaging, pre‑loading, and AOP performance monitoring to provide fast, scalable, merchant‑focused mini‑apps.
By analyzing the Alipay card‑package template substitution logic, the author identified costly String.replace calls and iteratively applied five optimization versions—removing indexOf/substring, adding caching, and finally substituting StringBuilder for String.replace—achieving over tenfold performance gains and reduced resource consumption.
ByteDance’s Cloud Shuffle Service (CSS) replaces the traditional Pull‑Based Sort Shuffle in Spark, FlinkBatch and MapReduce with a Push‑Based remote shuffle that improves stability, performance and elasticity, supports compute‑storage separation, and delivers significant speedups in large‑scale TPC‑DS benchmarks.
This article presents seven practical Spring Boot performance optimization methods—including asynchronous execution, increasing embedded Tomcat connection limits, component scanning, switching to Undertow, using BufferedWriter, DeferredResult, and AsyncHandlerInterceptor—each illustrated with code samples and explanations for improving Java backend applications.
This article details how the Litmus code‑quality platform was integrated into a CI pipeline, the performance bottlenecks encountered with Jenkins and Sonar, the systematic optimizations applied—including server redesign, script refactoring, parallel testing, and JVM tuning—and the resulting dramatic reduction in task duration and increase in throughput.
This article summarizes the challenges and optimization techniques for building a high‑performance long‑connection service with Netty, covering non‑blocking I/O, Linux kernel tuning, client‑side testing, VM‑based scaling, data‑structure tweaks, CPU and GC bottlenecks, and the final results of achieving hundreds of thousands of connections and tens of thousands of QPS on a single server.
Faced with ClickHouse query times ballooning to over an hour for massive game‑event data, the team replaced the DB‑pull model with a stream‑processing pipeline that evaluates trigger rules in real time, cuts batch queries by 60 %, and brings reporting latency down to minutes.
This article explains how Baidu's performance team tackled the slowdown of mobile internet growth by defining low‑end devices, building observability, creating high‑efficiency tooling, redesigning key components such as KV storage and locks, and introducing a smart scheduling framework that together reduced Android cold‑start TTI by over 50% and iOS cold‑start TTI by more than 40%, while establishing a continuous anti‑degradation pipeline.
This article details Alipay's evolution from basic thread pools to a sophisticated, multi‑layered scheduling framework that balances UI responsiveness, task prioritization, and resource control across Android devices, while outlining the technical challenges and future directions of fine‑grained scheduling.
This article explains the implementation principles of cnpm rapid mode, demonstrates how server‑side dependency‑tree generation, high‑speed downloading, tar‑based disk I/O, and a FUSE‑backed overlay filesystem together achieve up to ten‑fold faster npm installations and seamless CI/CD integration.
This article explains the dual‑thread architecture of WeChat Mini Programs, covering the separation of view and logic layers, component systems, native component rendering, data communication, runtime mechanisms, and a series of performance‑optimisation techniques for developers.
This article theoretically outlines seven major Java performance optimization strategies—including reuse, computation, result set, resource conflict, algorithm, high‑efficiency implementation, and JVM tuning—explaining their principles, typical techniques, and how they collectively improve resource utilization and application speed.
Numba is a Python just‑in‑time compiler that transforms functions into fast native machine code, enabling near C‑level performance without rewriting code; by adding simple decorators like @jit or @njit, you can accelerate loops, NumPy operations, and even leverage parallel or GPU execution.
This article provides a comprehensive, code‑rich guide on using TiDB DM v2.0.7 to perform full and incremental migration of terabyte‑scale MySQL data to DBLE, covering environment setup, TiDB DM installation, DBLE configuration, data generation, task execution, verification, and important operational considerations.
A curated roundup of technical deep‑dives covering Byte's frontend monitoring SDK architecture, the evolving landscape of Cloud IDEs, practical Webpack performance tricks, React Fiber internals, open‑platform front‑end design, visual log‑tracing solutions, engineering culture, the Bud framework, and clear explanations of TCP/UDP and iterators versus generators.
Shopee’s video platform combines live‑stream and on‑demand transcoding, link‑mic, multi‑party mixing, and backend editing services with a proprietary high‑definition low‑bitrate pipeline that leverages GPU and CPU encoders, AI‑enhanced pre‑processing, hierarchical B‑frames, and SIMD‑optimized sharpening to deliver high‑quality video on low‑end devices while cutting compute costs, and the company is actively recruiting engineers for further development.
This article outlines the testing plan for a data download refactoring project involving over 400 metrics, describes automated CSV comparison scripts, evaluates single‑process, multithreaded, and multiprocess approaches with shared memory, and provides practical recommendations for improving verification efficiency and performance.
This article explains the motivation behind object pooling in Java, walks through the core classes of Commons Pool 2 with a Jedis example, details key configuration parameters, presents JMH benchmark results that show a five‑fold throughput gain, and analyzes HikariCP’s design tricks and common interview questions about pool tuning.
This article introduces federated learning, traces its evolution, compares horizontal and vertical federated learning, analyzes the unique computational traits of vertical FL, and presents practical performance‑optimization techniques such as offline computation, sparse‑data handling, communication compression, and homomorphic encryption integration.
The article examines the difficulties encountered when implementing a Backend‑For‑Frontend (BFF) layer in the JD Finance app, introduces a visual service‑orchestration platform that replaces hard‑coded solutions with drag‑and‑drop workflows, details its core functions, architecture, and performance benefits, and demonstrates how it dramatically improves delivery speed, service governance, and debugging efficiency.
This article analyzes Baidu Intelligent Cloud's data‑lake acceleration strategy, covering the evolution of big‑data architectures, the advantages and challenges of compute‑storage separation, the native hierarchical namespace and RapidFS cache solutions, performance test results, and recommended deployment patterns.
This article details how the Zuoyebang front‑end team rebuilt their PC student live‑class client using Electron, introducing a modular, config‑driven architecture, improved logging, BVManager and player modules, and performance and stability optimizations that reduced CPU/memory usage and crash rates while simplifying maintenance.
The article explains how to query sales statistics for multiple business units and their associated products in MySQL, compares several implementation strategies such as looping, OR‑concatenation, mixed filtering, and finally adopts the SQL‑92 row‑by‑row comparison technique to achieve a single‑query solution that respects indexing and corporate coding standards.
The guide details selecting Electron for cross‑platform desktop apps, then outlines a TypeScript‑Vue‑Vite stack with pnpm‑Turbo, explains build and packaging strategies, performance tweaks, update mechanisms, automated testing, crash handling, and layered security measures including native Rust modules and source‑code protection.
The article explains how Uber replaced CPU quota enforcement with cpusets (CPU pinning) for stateful workloads, reducing P99 latency, improving performance consistency, and saving about 11% of cores across the cluster by eliminating throttling.
This article details Bilibili's evolution from a Hadoop‑based offline platform to a Spark‑driven architecture, covering the Hive‑to‑Spark migration, automated SQL conversion, result validation, stability enhancements, performance tuning, meta‑store federation, and future directions for large‑scale data processing.
This article presents a comprehensive overview of NetEase's log collection and transmission platform, detailing its evolution from 2011 to the current Datastream‑NG architecture, the system's design goals, core component optimizations, operational monitoring, and future plans for intelligent scaling and diagnostics.
This article details the design of an AI interview robot for 58.com, covering its backend architecture, dialogue engine, resource‑management strategies, performance‑testing methodology, and the optimizations that boosted concurrent interview capacity by twenty times while improving user experience.
37 Mobile Games, a leading mobile game publisher, migrated its user‑profile analytics from a Hadoop‑Hudi‑Kafka‑Hive‑Flink stack to StarRocks, achieving sub‑second query latency on billion‑row tables, simplifying operations, reducing storage costs, and enabling real‑time data sync, as detailed in this technical case study.
This article presents a comprehensive overview of Alibaba Cloud Elasticsearch for log analytics, detailing cluster characteristics, common pain points, five key optimization techniques—including cold/hot resource sharing and indexing service—followed by engine kernel improvements, performance benchmarks, and a step‑by‑step product demonstration.
This article provides a comprehensive introduction to Elasticsearch, covering data types, Lucene fundamentals, cluster architecture, node roles, shard and replica mechanisms, mapping, installation, health monitoring, indexing principles, storage strategies, refresh and translog handling, segment merging, performance tuning, and JVM optimization for large‑scale search applications.
The article reviews the development of NetEase Leihuo's game recommendation system, covering the shift from offline batch recommendation to real‑time feature engineering and online inference, detailing architecture design, practical experiences, performance optimizations, and future directions such as real‑time training.
This article walks through using Apache Spark for large‑scale GBDT training, covering the challenges of massive data, Spark deployment, PySpark code examples, differences from Pandas, feature engineering, mmlspark installation, early‑stopping tricks, performance bottlenecks, and a systematic evaluation of alternative frameworks.
This article explains Redis's memory model, covering memory statistics, internal structures such as redisObject, SDS, and various object types, their encoding schemes, memory allocation, fragmentation, and provides practical examples for estimating memory usage, optimizing consumption, and monitoring fragmentation in high‑performance applications.
Zhihu's data‑empowerment team designed a low‑cost, high‑response real‑time data architecture on Apache Doris that powers business analytics, algorithm features, and user profiling, dramatically improving timeliness, reducing targeting costs, and boosting key performance metrics across multiple services.
The article explains how Tubes employs a reactive data system to handle multi‑screen rendering, compares loop‑based and reactive approaches, details classic and hash‑table implementations, and demonstrates significant performance gains, offering valuable insights for frontend developers seeking efficient rendering architectures.
This article explains the fundamentals of structured and unstructured data, introduces Lucene's inverted index, describes Elasticsearch's distributed cluster architecture, node roles, sharding and replication mechanisms, indexing workflow with refresh and translog, storage segment model, and provides practical performance‑tuning recommendations.
This article explains the concept of CPU cache false sharing, how it degrades performance on multi‑core systems, and provides practical techniques—including cache‑line alignment macros and padding strategies—to prevent it and improve multithreaded application efficiency.
This article details the architecture, service design, performance optimizations, sorting mechanisms, and stability strategies of Baidu's comment middle‑platform, illustrating how it evolved to support billions of daily requests with high availability, low latency, and scalable distributed services.
This article explains how to generate a 10 GB file of age data, read it efficiently on a machine with limited memory, and use both single‑threaded and multithreaded Java techniques—including a producer‑consumer model and divide‑and‑conquer—to identify the age that appears most frequently, while analyzing performance, memory usage, and CPU utilization.
This article presents a layered approach to Go performance optimization, covering reasonable code practices, deliberate algorithmic and structural improvements, risky low‑level tweaks, and practical profiling techniques such as pprof, flame graphs, and trace, while providing concrete examples and actionable guidance.
The Qunhe Technology data team replaced their legacy Hadoop and Presto clusters with a StarRocks MPP database, achieving up to three times faster queries, supporting billion‑row tables and sub‑second latency for both real‑time and analytical workloads on a daily 1TB data influx.
The article presents Tubes, Alibaba’s high‑performance terminal renderer, and argues that a hash‑table‑based reactive data system—tracking dependencies, triggering updates only for changed inputs, and making Tubes idempotent—eliminates manual loop control, reduces developer burden, and delivers up to 1,350× read speed‑up and hundreds of milliseconds faster first‑screen rendering on low‑end devices.
To support the rapidly growing DeWu App, the team created Rainbow Bridge—a ShardingSphere‑based middleware that unifies horizontal sharding, read‑write separation, shadow‑DB routing, rate limiting, and active‑active traffic correction, while adding a graphical console, stability enhancements, fine‑grained observability, hybrid JDBC/Proxy switching, and ongoing open‑source contributions.
This article explains how to build a scalable long‑connection server using Netty, discusses the underlying bottlenecks such as Linux kernel limits, CPU and GC issues, and provides practical code examples and tuning techniques to achieve hundreds of thousands of connections and high QPS.
The article details Guangguang’s shift from a rule‑based, Hive‑driven recommendation pipeline to an algorithmic service that leverages Elasticsearch and Redis for multi‑source recall, coarse and fine model ranking, exposure filtering, cold‑start handling, latency optimizations, reliability monitoring, and future vector‑based enhancements.
The 2022 Kunpeng Developer Summit showcased Huawei Cloud EulerOS, an openEuler‑based cloud‑native operating system, highlighting its high‑performance, security‑focused features, mixed‑deployment solutions, and real‑world case studies such as smart property management and a micro‑service banking core, illustrating the platform’s role in advancing intelligent computing.
This article explains the fundamental differences between JavaScript throttle and debounce techniques using an intuitive real-world analogy, provides clear code implementations, compares their execution behaviors, and demonstrates practical usage scenarios with the Lodash library for optimizing frontend event handling.
The 2021‑2022 DX updates introduce the RecyclerLayout container, a native‑based list component with configurable styles, pull‑to‑refresh and pagination that can be altered via XML without native releases, and an JSON‑driven event chain protocol enabling sequential or asynchronous actions, visual IDE debugging, full‑link tracing, and real‑time monitoring, collectively delivering over 30% faster release cycles and 15% quicker server responses across multiple Taobao and Alibaba apps.
DX (DinamicX) is Alibaba’s native dynamic development platform that evolved from simple homepage widgets into a full‑stack framework offering out‑of‑the‑box components, a VS‑code‑compatible IDE, ProCode and LowCode workflows, optimized rendering pipelines, event‑chain logic, and future‑focused standardization for high‑performance, content‑rich mobile apps.
This article details the backend architecture, dialogue engine design, resource estimation, and performance optimization techniques of an AI interview robot used in 58.com’s recruitment platform, illustrating how multi‑branch dialogue flows, RTP communication, session management, and monitoring enable scalable, stable, and efficient online interview services.
This article explains Meituan's non‑intrusive, Go‑based packet‑capture solution for full‑SQL database auditing, details the performance challenges encountered at high QPS, and describes a series of systematic analyses and optimizations—including probe redesign, CPU profiling, data‑masking, scheduling, GC pressure reduction, and packet filtering—that dramatically lowered loss rates and CPU usage.
This roundup covers the official release of HTTP/3 (RFC 9114), key findings from a 2022 frontend development survey highlighting TypeScript dominance, an in‑depth Web3.0 industry panorama, Douyin's Android power‑saving practices, bundler considerations, first‑party cookie guidance, content‑visibility performance analysis, and a detailed Three.js ice‑cream Earth tutorial.
Facing fragmented devices, high memory usage, and unreliable signaling, the Zuoyebang live‑streaming frontend was redesigned with container‑based isolation, a modular SDK, and state‑synchronization mechanisms, resulting in timely memory reclamation, reduced CPU load, and dramatically lower black‑screen incidents.
This article systematically examines the characteristics, architecture, compilation principles, rendering processes, and common performance issues of four popular cross‑platform mobile technologies—Flutter, React Native, Weex, and H5—offering guidance on technical selection and optimization strategies.
This article explains how to dramatically reduce the average response time of a high‑traffic Java service from 250 ms to about 80 ms by applying HttpClient pooling, keep‑alive strategies, proper timeout settings, and idle‑connection monitoring, complete with code examples and configuration details.
This article details Ctrip's comprehensive redesign of its airline ticket order database, covering the background performance bottlenecks, vertical and hot‑cold data splitting, sharding key selection, multi‑level caching, cross‑shard query optimization, dual‑write mechanisms, fault‑tolerance strategies, project planning, and the resulting improvements in scalability and cost.
This article explains how to design and optimize a Java‑based online service that handles over 200,000 queries per second by avoiding relational databases, applying multi‑level caching, leveraging multithreading, using degradation and circuit‑breaker patterns, reducing I/O, managing retries, handling edge cases, and logging efficiently.
This article details ByteDance's 2021 overhaul of its Data Catalog system, the performance regressions encountered after switching to Apache Atlas, and the step‑by‑step backend optimizations—including JanusGraph tuning, Gremlin query refactoring, parallel processing, and write‑path improvements—that reduced latency from minutes to seconds.
This article examines why Elasticsearch slow queries occur in a shared cluster, analyzes a problematic query's structure and data‑type choices, and demonstrates how converting integer fields to keyword mappings and adjusting filter order can reduce latency from over 100 ms to under 10 ms while eliminating slow‑query alerts.
This article details JD Retail's OLAP platform construction, covering control plane design, architecture, business and operation management, real‑time data updates, materialized view usage, join optimizations, high‑concurrency and high‑throughput scenarios, and promotional preparation strategies, illustrated with diagrams and performance metrics.
This article provides a comprehensive introduction to Unity memory concepts—including physical, virtual, native, and managed memory—and offers practical optimization techniques for native and managed resources, graphics rendering, and tooling to improve game performance on both desktop and mobile platforms.
The third article in the Presto SQL Engine series demonstrates how to implement WHERE‑clause filtering with Antlr, contrasting a direct AST‑traversal visitor approach—hampered by branch prediction and JVM inlining issues—with runtime bytecode generation using airlift.bytecode, which yields roughly three‑fold speed gains but adds complexity.
This article analyzes the concurrent rendering problems of OpenSumi's file‑tree component, explains their root causes, and presents a comprehensive solution—including operation prioritization, cancellable updates, and queued rendering—along with implementation code to achieve both high speed and stability.
