This article presents practical Python performance optimization techniques, including using local variables, reducing function calls, employing mappings instead of conditionals, iterating directly over sequences, preferring generator expressions, pre-compiling code and regex, and organizing module code to improve speed and memory efficiency.
This article details how YY's data team replaced ClickHouse with StarRocks to create a unified, high‑performance OLAP platform, covering architecture design, engine selection, performance benchmarks, resource isolation, monitoring, user‑friendly tooling, and future roadmap for large‑scale analytics.
This article compiles 66 MySQL interview questions covering fundamentals such as joins, data types, indexes, storage engines, transaction properties, locking mechanisms, replication, sharding, performance tuning, and high‑availability concepts for interview preparation.
This comprehensive guide explains Redis's core and newer data types—including String, List, Hash, Set, Zset, BitMap, HyperLogLog, GEO, and Stream—detailing their internal implementations, essential commands, and practical scenarios such as caching, counting, locking, ranking, geolocation, and reliable message queuing.
This article walks through the author’s decision to continue learning Go for Redis access, outlines a step‑by‑step study plan, compares Go and Java Redis clients, presents a custom Go‑Redis wrapper with full source code, demonstrates usage in unit tests, and shares console output observations.
This article examines MySQL's recommendation to use auto_increment primary keys instead of UUIDs or random keys by creating three comparable tables, inserting large data sets with Spring JdbcTemplate, and analyzing insertion speed, index structure impact, and the trade‑offs of each key strategy.
Git 2.37, released last week, introduces short‑hand aliases for version and help commands, generates external diff temporary files in a dedicated subdirectory, rewrites the interactive add feature in C, begins transport and pack refactoring, and delivers multiple performance improvements and bug fixes.
Over the past two years Alibaba’s DX native dynamic framework has been re‑engineered by moving virtual‑node parsing, layout and drawing to background threads, adding an asynchronous drawing system, a unified rich‑text component, and off‑screen resource management, boosting low‑end device frame rates from ~30 FPS to over 55 FPS and cutting media‑CPU usage by 65 % while paving the way for richer interactive UI features.
This issue curates five technical articles covering Gaode's full‑chain stress testing platform, a distributed web UI automation system, a comprehensive WWDC22 session review, ShouQianBa's efficient automated testing practices, and Autohome's AutoDiff traffic replay for integrated testing.
This article explores common cache challenges such as centralized expiration, cache penetration, avalanche, hot keys, large keys, data consistency, and concurrent pre‑warming, offering practical design patterns and mitigation strategies to build robust, high‑performance backend systems.
The article dissects Android WebView’s evolution to Chromium‑based multi‑process mode, explains the costly initialization steps—including thread checks, provider creation, and Chromium engine startup in a sandbox process—highlights common security pitfalls, and offers idle‑time pre‑initialization and request‑interception techniques to boost performance.
This article explains the design and operation of an external resource manager that improves overseas e‑commerce service stability by employing CDN, local memory, and disk caches, detailing access methods, cache mechanisms, CDN configurations, and practical use cases such as Google Fonts and translation integration.
This article details the design, challenges, and solutions behind Prism, a self‑built front‑end monitoring platform that collects multi‑device SDK data, processes it through Kafka, Flink and ClickHouse, visualizes metrics, integrates with A/B testing, and outlines future enhancements for broader enterprise adoption.
The article explains how Tubi, an ad‑supported streaming platform with tens of millions of users, migrated from a Node.js‑Spark‑Redis stack to a Scala‑based backend to achieve sub‑10‑millisecond recommendation latency, improve fault tolerance, and simplify domain modeling using Akka and functional programming.
This article presents a detailed benchmark of java.util.concurrent.ConcurrentHashMap under high thread counts, explains the test methodology using a Groovy‑based FunTester framework, shares raw performance numbers, and uncovers that CPU limits and random number generation are the primary bottlenecks.
This article reviews Youku's five‑year journey of Android APK size reduction, detailing the shift from special‑project squeezes to sustainable normal governance, the technical measures and analysis tools like Franky, and practical slimming techniques that can help any mobile team manage package size efficiently.
This article examines MySQL's ON DUPLICATE KEY UPDATE clause, explains its official behavior, runs experiments with primary and multiple unique indexes, compares InnoDB row‑level locking to MyISAM table‑level locking, and highlights performance and deadlock risks that developers should avoid.
This guide explains how to use OpenResty’s Lua capabilities to replace Tomcat‑based Redis access with direct Nginx‑Redis integration, apply compression to reduce bandwidth, set up periodic cache refreshes, configure single‑worker timers, and manage cache settings via a signed backend API.
Redis caching can suffer from avalanche, breakdown, and penetration anomalies, but using staggered expirations, mutex locks, double‑key backups, high‑availability clusters, rate limiting, empty‑value caching, Bloom filters, warm‑up and degradation strategies effectively mitigates these risks and protects database stability.
Over five years, Youku’s Android team systematically reduced APK size through specialized and continuous governance, employing remote modules, whole‑package optimizations, and precise analysis tools like Franky, ultimately cutting the app from over 120 MB to under 65 MB while maintaining performance and stability.
This article provides an in‑depth overview of caching, covering its definition, when to use it, core concepts, various cache types (client, server, CDN, reverse‑proxy, in‑process, distributed), eviction policies, multi‑level cache architectures, common pitfalls such as cache avalanche, penetration and breakdown, and practical mitigation techniques.
This article describes how a multi‑layered cache system—including a DAO‑level Redis cache, shared cache components, and global cache planning—was designed, implemented, and deployed to reduce database QPS by over 80%, cut response latency, and improve overall system stability in a high‑traffic e‑commerce platform.
This article walks through Dubbo’s RPC communication using a packet‑as‑narrator metaphor, detailing the thread models of Netty 3 and Netty 4, OS socket handling, and practical troubleshooting steps for latency and timeout issues in a clear, engaging style.
This article demonstrates how to use pandas' merge() and join() functions to combine DataFrames, shows examples of merging, joining with single and multi‑index DataFrames, illustrates horizontal concatenation with concat(), and compares the execution speed of merge versus join on large datasets.
This comprehensive guide explores MongoDB’s core features—including schema flexibility, high availability, sharding, storage engine internals, indexing, and performance tuning—while providing practical examples, configuration tips, and best‑practice recommendations for developers and architects seeking to efficiently deploy and operate MongoDB in production environments.
This article explains how DinamicX (DX) evolved from a limited template platform to a full‑cycle IDE built on VSCode and OpenSumi, detailing its architecture, feature set, workflow stages, code intelligence, preview tools, and future technical directions for improving performance, collaboration, and cross‑platform development.
This article examines Java 8 Stream's data flow operations, compares its performance against traditional iterator loops across various tasks such as mapping, filtering, sorting, reduction, and string joining, and provides recommendations on when to use Stream, parallel Stream, or iterator based on data size and CPU cores.
The article benchmarks cjson, rapidjson, and yyjson JSON libraries on a 6‑core OpenResty setup, shows that combining rapidjson's encode with yyjson's decode reduces 500,000 mixed encode/decode operations to 11 seconds, and describes a Lua wrapper that adds schema validation and improves maintainability.
This article presents a comprehensive analysis and multiple optimization strategies—including multithreaded ClickHouse pagination, Elasticsearch scroll‑scan, an ES‑HBase hybrid approach, and RediSearch + RedisJSON—to efficiently filter and sort up to 10 W records from a pool of tens of millions while reducing query latency and system complexity.
This article details Youku's end‑side solution for real‑time danmaku‑through‑human rendering, covering its background, value, client‑side advantages, technical challenges, OPR architecture, processing pipeline, engineering optimizations, test results, and future outlook for mobile intelligent rendering.
The article explains why MySQL’s high‑performance guide recommends storing IPv4 addresses as a 32‑bit UNSIGNED INT instead of VARCHAR, detailing space savings, faster range queries, conversion functions (INET_ATON/INET_NTOA), associated drawbacks, and provides Java code to convert between string and integer representations.
This article provides a detailed overview of large‑scale RDMA technology, covering basic concepts, major protocols, network‑level techniques such as congestion control, lossless‑to‑lossy evolution and multipath, virtualization, communication libraries for AI training and storage, performance tuning, monitoring, and real‑world deployment experiences.
This article presents a comprehensive summary of backend performance problems encountered in a production system—including slow queries, deep pagination, missing or ineffective indexes, excessive joins, large data volumes, thread‑pool and lock mis‑designs, machine issues, and caching strategies—along with concrete diagnostic steps and code‑level remedies to improve response times and stability.
This article describes how a team tackled stability and performance problems in a SolrCloud‑based search and recommendation stack serving 150,000 requests per minute, detailing root‑cause analysis, memory and GC tuning, replica configuration changes, and the resulting reductions in latency, resource usage, and operational complexity.
This article explains how to describe current system load, choose appropriate load parameters, analyze Twitter's scaling challenges, compare relational and push‑based timeline designs, clarify latency versus response time, emphasize percentile monitoring, and evaluate vertical versus horizontal scaling and hybrid approaches for handling increasing traffic.
This article explains how Python concurrency can boost program performance, covering multithreading, multiprocessing, the Global Interpreter Lock, thread safety, thread pools, and practical code examples for speeding up I/O‑bound and CPU‑bound tasks.
This article introduces GDI and DXGI screen‑capture techniques, shows how to implement them in Qt with complete code examples, compares their performance and visual results, and discusses practical considerations for teacher‑side applications such as multi‑screen and live‑streaming environments.
This article explains how the Crystal WebGL engine leverages IndexedDB to reduce network requests, accelerate three‑dimensional data loading, and implement efficient caching and update mechanisms, thereby significantly improving overall rendering performance and user experience.
This article examines Svelte's key features—its compile‑time approach, lack of virtual DOM, and strong reactivity—compares its bundle size advantages over Vue and React, and details a real‑world mask‑machine H5 project that showcases setup, component structure, lifecycle, state management, routing, UI, testing, and performance optimizations.
PowerImage is a stable, high‑performance Flutter image library that combines native FFI and texture integration to eliminate cache conflicts, enable simulator support, provide custom image channels, preload and animate images, unify memory management, reduce Dart code, achieve extensive test coverage, and invite open‑source contributions for future enhancements.
The 5th Techo TVP Developer Summit explored the surge of data, the strategic role of NoSQL in digital transformation, presented cutting‑edge trends, performance breakthroughs, cloud‑native multi‑model solutions, and real‑world case studies from finance to gaming, highlighting future directions for database technology.
This article provides a comprehensive overview of CPU architecture, explains key monitoring metrics, compares CPU‑intensive and I/O‑intensive workloads, presents experimental results on thread‑count tuning, and walks through real‑world case studies of CPU bottleneck diagnosis and optimization.
This article compares Redis Streams with Kafka, highlighting Redis's simplicity, performance, and built‑in features like consumer groups, while discussing when each solution is appropriate for different project scales and requirements.
This article walks through the background of a production Java service that received many performance complaints, enumerates common causes such as slow MySQL queries, complex business logic, thread‑pool misconfiguration, lock contention and machine issues, and provides concrete diagnostic steps and code‑level solutions including pagination fixes, indexing strategies, async processing, thread‑pool tuning, lock refinement and caching techniques.
This article compares Alibaba Cloud's MSE cloud‑native gateway with the traditional Nginx Ingress Controller across performance, cost, reliability and security, presenting benchmark data, CVE analysis, architectural advantages, and a step‑by‑step migration plan for Kubernetes clusters.
This article examines fastjson2’s design improvements over fastjson1, highlighting its safer AutoType mechanism, performance enhancements, migration strategies—including compatibility mode and new APIs—and provides practical code examples for configuring serializers, updating Maven dependencies, and adapting Spring converters.
This article details Meituan's journey from rapid database growth and operational bottlenecks to a multi‑year roadmap that combines platform‑level monitoring, rule‑based and AI‑enhanced root‑cause analysis, and automated remediation, ultimately delivering measurable improvements in alert accuracy, recall rates, and overall database reliability.
After a year of using C++17 in production, the author lists the ten most practical language features—grouped into syntax sugar, performance boosts, and type‑system enhancements—explaining their benefits, pitfalls, and providing concrete code examples for each.
This article examines the challenges of timer precision in front‑end scenarios such as e‑commerce flash sales, explains the limitations of native setInterval and setTimeout, and introduces a frame‑based timer using requestAnimationFrame, requestIdleCallback and compensation strategies to achieve high‑accuracy scheduling.
This article walks through generating a 10GB file of age data, reading it line‑by‑line on a machine with only 4GB RAM, and compares a single‑thread counting approach with a multithreaded producer‑consumer design, showing performance gains, memory usage, and practical tips.
The Jetpack Compose 1.2 beta introduces numerous enhancements—including text padding control, downloadable fonts, lazy layout APIs, improved CoordinatorLayout interop, window size classes, performance diagnostics, and new Android Studio tools—while highlighting widespread adoption by major Android teams and outlining future roadmap priorities.
This article analyzes the concurrent rendering problems that arise in OpenSumi’s file‑tree after removing throttling, explains their root causes, and presents a comprehensive solution—including operation prioritization, cancellable actions, and queued updates—to achieve both high performance and stable user interaction.
The Kube-OVN v1.10.0 release introduces Windows node support, user‑defined subnet ACLs, enhanced Kubevirt networking, Submariner multi‑cluster integration, and a series of control‑plane performance optimizations that together improve scalability, flexibility, and stability for cloud‑native Kubernetes deployments.
This article presents a comprehensive overview of cache optimization techniques, covering benefits and costs, update policies, granularity control, penetration and avalanche mitigation, hot‑key reconstruction, and distributed batch‑operation strategies, with practical examples using Redis and MySQL.
Matt Hobbs, the front‑end lead at GOV.UK, removed jQuery from 13 applications, cutting JavaScript size by up to 49 % and improving key performance metrics such as processing time, First CPU Idle, and long‑task duration, even under poor network conditions.
The Python team released a beta of Python 3.11, and benchmark tests using Docker on an M1 Pro MacBook Pro show the new version averaging 14% faster than 3.10 and achieving up to 64% speed improvements in many workloads, highlighting notable performance enhancements.
The article explains how CPython 3.11 achieves a 1.25‑times speed boost over 3.10 through a new adaptive bytecode interpreter, outlines the goals of the Faster‑CPython project and PEP 659, and discusses the planned JIT compiler for future Python releases.
This article translates and expands on a HikariCP wiki post, explaining why a small database connection pool often yields better performance than a large one, presenting benchmark data, a practical sizing formula, and guidance for tuning pools in various environments.
This article explains how caching can accelerate read/write performance and reduce backend load, analyzes its benefits and costs, and details practical design patterns such as update policies, granularity control, penetration, bottom‑hole, avalanche, and hot‑key optimizations for reliable high‑performance systems.
This article explains how to tune Apache Solr by configuring caches, SolrCloud, commit strategies, dynamic fields, indexed versus stored fields, copyField, filter queries, and faceting to achieve maximum search performance for production workloads.
This article explains why solid‑state drives outperform mechanical hard drives by detailing their distinct operating principles, covering HDD magnetic storage, SSD floating‑gate transistors, and how these differences affect data writing, reading, erasing, and overall performance, especially for random access.
MaFengWo’s data platform replaced Kylin, Presto, and Druid with StarRocks, redesigning its four‑layer architecture, unifying metadata, and optimizing single‑table, multi‑table, and precise‑deduplication queries, which cut query latency by four times, reduced storage by 87%, and lowered operational complexity.
This report analyzes how popular Chrome extensions affect browser performance by increasing CPU usage, slowing page rendering, and consuming additional memory, presenting data from tests on various websites and highlighting the cumulative impact of multiple extensions on user experience.
This article explains the purpose and implementation of Java's CompletionService, compares it with ExecutorService, shows how it retrieves task results in completion order, provides detailed source code analysis, and discusses typical use cases such as load‑balancing and fast‑result retrieval in concurrent applications.
This article explains ClickHouse's single‑node and distributed JOIN mechanisms, compares ordinary, GLOBAL, Broadcast, Shuffle and Colocate JOINs, illustrates execution flows with code examples, and provides practical recommendations to reduce join size, avoid query amplification, and leverage data pre‑distribution for optimal performance.
This article explains the complete MySQL query processing pipeline, covering the connector, authentication, privilege checks, caching, parser, optimizer, executor, and the detailed SQL execution order with examples of each stage, helping readers understand and optimize their SQL statements.
This article walks through a scenario‑driven capacity assessment for a production‑grade Kafka cluster, covering QPS calculations, storage needs, physical machine count, disk choices, memory, CPU, network bandwidth, deployment steps, and a final resource summary.
This article shares the author’s reflections on designing UC Browser’s next‑generation Web container, outlining typical boundary challenges—such as complex video/audio control, high‑performance long lists, parallax effects, multi‑tab navigation, and local pop‑ups—and argues that extending the container with private APIs can bridge these gaps, improving performance and user experience.
This article explains how Redis achieves high‑performance queries by leveraging in‑memory storage, specialized data structures such as SDS, hash tables, skip‑lists and zip‑lists, a single‑threaded event loop with I/O multiplexing, and progressive rehashing techniques.
The upcoming CPython release in October promises major performance improvements, new browser support, and a potential removal of the Global Interpreter Lock, reflecting industry‑backed efforts from Meta, Microsoft, and the Python core team to modernize the language.
Understanding the data path in Kubernetes systems reveals performance bottlenecks and guides the selection among private‑cloud storage, container‑native storage software, and software‑defined storage to achieve scalable, low‑latency, high‑performance container workloads.
The Asahi Linux project now lets M1‑based Macs run a native Linux system, and this article walks through the preparation, installation steps, performance benchmarks, bug‑fix workflow, and practical considerations for users wanting a dual‑boot experience.
Linux’s multitasking illusion relies on CPU context switches, where the kernel saves and restores registers and program counters for processes, threads, and interrupts, and understanding these mechanisms—including their types, performance costs, and scheduling triggers—reveals why excessive switches can degrade system performance.
This guide compiles fifty practical Java performance recommendations—ranging from judicious use of singletons and static variables to efficient collection handling, memory management, and low‑level optimizations like bit‑shifts and System.arraycopy—each illustrated with concise explanations and code snippets to help developers write faster, leaner Java code.
During the 2022 China Internet Industry Application Salon, JD Cloud’s product manager explained how the Color gateway, an API gateway handling billions of daily requests, overcomes stability, high‑availability, reliability, and performance challenges during peak sales by adopting a cloud‑native ClickHouse data warehouse that boosts processing speed, reduces costs, and provides real‑time analytics.
This article explains the fundamental differences between mechanical hard drives and solid‑state drives, covering HDD structure, magnetic data storage, SSD floating‑gate transistors, write/read/erase mechanisms, performance advantages, endurance limits, and why SSDs deliver superior speed and reliability.
This article demonstrates how a functional, persistent key‑value store can be created with just two shell commands—one to append data and another to retrieve the latest entry—while explaining the underlying grep and sed techniques, performance trade‑offs, and basic indexing concepts.
This article outlines thirteen practical Redis performance‑optimization rules, covering command complexity, key expiration, data‑structure selection, persistence settings, hardware choices, clustering, and memory‑fragmentation monitoring to help developers maximize throughput and reduce latency in production environments.
This article explains what React Server Components are, why they matter, how they address the limitations of traditional API‑driven front‑end architectures such as request waterfall, bundle size and collaboration overhead, and what benefits and challenges they bring to modern web development.
This article explains Lucene's query types, the step‑by‑step query execution flow—including entry, rewrite, weight creation, scoring, and result collection—while providing code examples and performance considerations to help developers troubleshoot and optimize search performance.
Linux kernel version 5.18-rc6 has been released as the weekly candidate, featuring updates to network and RDMA drivers, x86 KVM fixes, wireguard self‑tests, Btrfs patches, and various architecture and core network bug fixes, with the stable 5.18 expected in 2‑3 weeks.
This article analyzes how replacing Java thread‑pool queues with the LMAX Disruptor framework dramatically improves CPU utilization, reduces tail latency, and lowers lock and CAS overhead, backed by detailed benchmarks, code examples, and real‑world deployment results from a high‑throughput feature service.
This article introduces the Go programming language, showcases several high‑traffic production projects built with Go at Autohome, and explains the major Go 1.18 enhancements such as generics, workspaces, and fuzzing, while providing performance comparisons, code samples, and practical optimization tips.
This article examines the emerging React Server Components feature, explains the limitations of traditional API‑driven front‑end/back‑end separation, and outlines how server‑rendered components can reduce bundle size, eliminate request waterfalls, and lower collaboration costs for modern web applications.
Redis 7.0, now officially stable for production, introduces nearly 50 new commands, major features like Redis Functions, ACLv2, command introspection, and Sharded Pub/Sub, while enhancing memory, compute, network, and storage subsystems for better performance and efficiency.
This article analyzes the challenges of aggregating multiple RPC calls in e‑commerce app backends, explains simple and complex concurrency scenarios, introduces grouped concurrency scheduling, and presents a self‑driven concurrency model that automates dependency handling to improve response latency and maintainability.
PayPal’s engineering team detailed their journey of scaling Kubernetes from a few hundred nodes to over 4,100 nodes and 200,000 Pods, describing cluster topology, workload generation, API server bottlenecks, controller manager and scheduler tuning, extensive etcd optimizations, and the resulting performance gains that met Kubernetes SLOs.
This article examines why Ant Design’s Table component often feels sluggish, covering historical design choices, memoization pitfalls with external state, the challenges of virtual scrolling for editable tables, and how the shouldCellUpdate and onCell APIs provide finer‑grained rendering control.
A recent benchmark using the pyperformance suite shows that Python 3.11 beta runs up to 64% faster than Python 3.10 on most tests, with an overall 14% speed increase, highlighting the language’s long‑awaited performance improvements.
This article explains why using SELECT 1 with LIMIT 1 is more efficient than COUNT(*) for existence checks in SQL, shows the typical count‑based approach, provides optimized SQL and Java examples, and discusses the performance benefits and reduced indexing requirements.
This article explains Redis 6's client‑side caching feature, describing its purpose, the two tracking modes (default and broadcast), a forward mode for RESP 2 clients, their advantages over traditional remote caching, and provides step‑by‑step command‑line examples with code snippets.
The New Relic 2022 Java Ecosystem Report reveals that while Java 8 still dominates many production environments, Java 11 usage has surged past 48%, vendor market shares have shifted dramatically with Oracle falling to 34.48% and Amazon rising to 22%, and over 70% of Java applications are now running in containers.
This curated collection highlights essential reads on front‑end performance optimization, reliable metrics, fault‑postmortem practices, insights from Twitter’s source code, the future of micro‑frontends, and building a simple Java editor, offering developers practical guidance and emerging trends across the web development landscape.
This article explains the Linux storage I/O stack, defines the five key disk performance metrics, and shows how to monitor both disk and process I/O using iostat, pidstat, and iotop, with practical command examples and interpretation tips.
This article explains how to use Google Lighthouse to measure key frontend performance metrics such as FCP, LCP and Speed Index, and provides practical optimization strategies—including reducing unused JavaScript, lazy‑loading images, using async/defer, code splitting, and Vue‑specific tricks like functional components and virtual scrolling—to improve scores on both local and production environments.
This article presents four practical Python techniques—including list reversal, variable swapping, in‑function looping, and reducing function calls—that together can shave roughly 10‑20% off your script's execution time.
This article shares a comprehensive summary of common interface performance problems such as slow queries, missing or ineffective indexes, excessive joins, large IN clauses, complex business logic, thread‑pool and lock misconfigurations, and offers practical Java‑based optimization techniques including pagination fixes, index usage, multithreading, caching, and asynchronous callbacks.
This article provides a comprehensive overview of Hubble, a front‑end session recording tool, covering its architecture, deployment methods, core features, encountered challenges, and future enhancements, illustrating how it streamlines bug reproduction and improves development efficiency.
This article analyzes the performance challenges of Taobao Mini Programs, defines a multi‑dimensional experience metric, builds a standardized ops data pipeline, introduces the T2 first‑screen algorithm and a three‑stage performance model, and shares concrete optimization practices that reduced T2 from 2.7 s to 1.9 s while improving business metrics.
The article examines Tinode‑based message‑processing bottlenecks in a multi‑channel customer‑service dashboard and proposes a suite of optimizations—including global deduplication maps, binary‑search insertion sorting, cache reclamation, targeted status updates, and asynchronous keyword interception—that together cut average first‑response time from 8.40 s to 6.82 s and overall response time from 19.9 s to 18.22 s, proving that careful cache design and algorithmic refinements markedly boost real‑time IM performance.
