Microsoft’s Faster CPython team, formed with Guido van Rossum and six engineers, aims to accelerate CPython by up to five‑fold through staged improvements, already delivering 10‑60% speed gains in Python 3.11 while emphasizing collaborative development and community value.
This article walks through generating a 10 GB file of age values, reading it line‑by‑line on a 4 GB RAM, 2‑core machine, measuring single‑thread performance, then redesigning the pipeline with a producer‑consumer model, blocking queues and multithreaded string splitting to dramatically boost CPU utilization and cut processing time while managing memory consumption.
Noslate is Alibaba’s new open‑source, cloud‑native serverless JavaScript runtime that combines a custom cold‑start‑optimized Node.js distribution, the Aworker container with Warmfork and V8 startup snapshots for sub‑millisecond launches, a Noslated control plane for flexible worker orchestration, and a Corefile‑based debugger for low‑impact diagnostics.
This article explains MySQL’s three‑tier logical architecture—from client services to core query processing and storage engines—and details the four ANSI SQL transaction isolation levels, highlighting their behavior, advantages, and trade‑offs in MySQL.
This article explains iOS memory architecture, the reasons behind Out‑of‑Memory (OOM) crashes, common sources of memory pressure, and practical approaches—including MLeaksFinder and FBRetainCycleDetector—to monitor, detect, and mitigate memory leaks and abnormal memory growth in iOS applications.
ShaderNN is an open‑source, sub‑2 MB GPU‑shader inference engine that runs TensorFlow, PyTorch and ONNX models directly on mobile graphics textures via OpenGL fragment and compute shaders, delivering real‑time, low‑power AI for image‑heavy tasks while eliminating third‑party dependencies and achieving up to 90 % speed gains.
This article examines the challenges of performing fuzzy searches on encrypted data and compares three categories of solutions—naïve, conventional, and advanced—detailing their implementation methods, performance trade‑offs, storage costs, and security implications for real‑world applications.
This article documents practical experiments comparing four MySQL bulk‑insert techniques—single‑row loop, concatenated SQL, MyBatis‑Plus saveBatch, and loop with batch mode—in a SpringBoot environment, revealing the most efficient approach and key configuration tips.
This guide explains what RAID is, its role in server storage, compares common RAID levels (0, 1, 5, 6, 10) in terms of fault tolerance, performance, and capacity, and offers recommendations for selecting the most suitable RAID configuration based on data safety, speed, and cost considerations.
Python 3.11, the latest official release, brings substantial performance gains, richer error tracebacks, enhanced async task syntax, expanded type‑hint support, built‑in TOML parsing, zero‑cost exceptions, exception groups, faster startup, and numerous other refinements that together make the language both quicker and more developer‑friendly.
This article provides an in-depth overview of Nginx, covering its core concepts, advantages, request handling, load balancing strategies, reverse proxy, static and dynamic resource separation, security, rate limiting, health checks, compression, and practical configuration examples for high‑performance web services.
This article provides a comprehensive walkthrough of Druid's connection‑pool architecture, detailing the initialization, acquisition, validation, eviction, and recycling of connections, while explaining key configuration options, thread‑safety mechanisms, and performance considerations for Java database applications.
The article explains how ByteHouse extends ClickHouse with a full‑featured query optimizer—including rule‑based and cost‑based techniques, analyzer modules, plan construction, and distributed optimization—to overcome ClickHouse limitations and achieve significant performance gains on complex OLAP workloads.
veLinux, an open‑source Linux distribution from Volcano Engine, delivers a stable, high‑performance, and secure operating system for cloud workloads on both x86 and ARM, offering multiple editions, deep kernel optimizations, fast boot, and extensive security features tailored for modern cloud‑native environments.
This article introduces WebAssembly, explains its advantages and compatibility, walks through setting up Rust and wasm‑pack to build a simple demo, compares its performance against JavaScript using a Fibonacci benchmark, and provides guidance on when to adopt WebAssembly in frontend projects.
This guide explains how to monitor Linux system performance by using core commands such as top, vmstat, iostat, and sar to evaluate CPU usage, memory allocation, I/O activity, and network traffic, while also covering load interpretation, cache behavior, huge pages, zero‑copy techniques, and practical command examples.
This article explains the fundamentals of in‑memory caching, introduces Guava's LoadingCache API, discusses cache sizing, eviction policies, common algorithms like FIFO, LRU, LFU, shows a simple LRU implementation using LinkedHashMap, and provides practical guidance on when and how to apply caching for performance optimization.
Oracle’s Enterprise Performance Pack, offered free to Java SE subscribers and OCI users, brings Java 17‑level memory management and performance enhancements—including modern garbage collection, compact strings, and improved observability—to legacy Java 8 applications, delivering up to 40% better memory and CPU efficiency under heavy loads.
This article explains how to assess hardware resources, calculate required Elasticsearch cluster size based on data volume, and perform indexing and search benchmark tests to ensure stable performance and optimal throughput for log and metric workloads in production environments.
This article explains the purpose and proper use of C++'s virtual keyword, illustrating how virtual functions enable polymorphism, detailing class memory layout with vtables and vptrs, comparing performance impacts, and outlining when virtual functions and destructors are truly necessary.
A simple benchmark using Bubble Sort on a 10,000‑element random array compares several popular programming languages, revealing that Python performs the worst while Go (Golang) delivers a striking performance advantage even over Node.js.
This article explains what mapping explosion is in Elasticsearch, why it hurts performance and memory, and presents three practical solutions—strict, false, and runtime dynamic settings—along with code examples and trade‑off discussions.
This article examines the open‑source memory cache Dragonfly, its performance claims against Redis, presents reproduced benchmark results, discusses architectural differences, and outlines Redis’s design principles and testing methodology.
This article explores database optimization from four angles—architecture, hardware, instance parameters, and SQL tuning—detailing practical techniques like distributed caching, read/write splitting, sharding, SSD upgrades, parameter tuning for Oracle, MySQL, PostgreSQL, and DaMeng, and step‑by‑step SQL rewrite with real‑world performance results.
PostgreSQL 15, released on October 13 2022, brings major performance gains such as faster sorting and WAL compression, adds the SQL MERGE command, expands regex and multirange support, improves security with security_invoker, and enhances logical replication, logging, and configuration flexibility for modern data workloads.
This article explains how to employ the Java Virtual Machine Tool Interface (JVMTI) in native Android code to record memory allocation and deallocation events, filter relevant classes, store logs efficiently with mmap, and integrate the agent from the Java layer for comprehensive memory‑leak analysis.
This article walks through what Spring Native is, how it uses GraalVM native images to dramatically reduce Spring Boot startup time, and provides a step‑by‑step setup, performance comparison, and troubleshooting tips for building and running native Spring applications.
This article explains how MySQL 8.0's prefer_ordering_index optimizer switch can be toggled to improve LIMIT queries that involve ORDER BY and GROUP BY, demonstrates the effect with test data, and shows why manual parameter control can yield better execution plans.
This article explains how Java's HashMap stores key‑value pairs using an array of nodes, how hash functions map keys to array indices, how collisions are handled with linked lists and red‑black trees, and why proper hashCode implementations are crucial for performance.
This article details the architectural evolution of China Telecom's Tianyi Account gateway, describing the migration from a Zuul‑based 1.0 system to a Kong‑driven 2.0 and 3.0 platform, the performance improvements, plugin ecosystem, cloud‑native deployment, and operational benefits achieved through each upgrade.
This article details Meituan's real‑world challenges with a 15,000‑node Kafka deployment and explains the application‑layer and system‑layer optimizations—such as disk balancing, migration pipeline acceleration, fetcher isolation, RAID acceleration, cgroup isolation, and an SSD‑based cache—that together dramatically cut read/write latency and simplify large‑scale cluster management.
This article presents thirteen practical guidelines for optimizing Redis performance, covering command selection, key management, data structures, persistence settings, hardware choices, clustering, and memory fragmentation mitigation to achieve significant speed improvements.
The article explains the fundamental differences between row‑based and column‑based storage in databases, compares their write and read performance, presents a practical openGauss experiment showing storage size and insert speed differences, and offers guidance on when to choose each model.
This article explains why Redis delivers high query speed by leveraging its in‑memory architecture, custom data structures such as SDS, linked lists, hash tables, skip‑lists, and intsets, a single‑threaded execution model combined with efficient I/O multiplexing, and recent multithreaded I/O enhancements.
Thor is a unified Android container framework that combines Java and native hooking into a lightweight, dynamically loadable module, ensuring backward compatibility, hot‑plug plugin deployment, fault‑tolerant operation, and cloud‑controlled toggling, while real‑world plugins for threads, I/O, privacy, and memory deliver measurable performance and stability gains.
This article examines the open‑source memory cache Dragonfly, compares its performance and architecture with Redis through detailed benchmark reproductions, discusses the underlying design trade‑offs, and highlights Redis’s continued relevance and future directions in real‑world deployments.
Learn how to use Linux’s top command to dynamically monitor process activity, interpret CPU, memory, and swap statistics, customize displayed columns, and apply useful shortcuts for sorting and filtering, enabling effective real-time system performance analysis and troubleshooting.
This article explains the seven essential configuration parameters of Java's ThreadPoolTaskExecutor, covering thread creation, core and maximum pool sizes, keep‑alive policies, work queues, thread factories, rejection handlers, and practical usage tips with code examples and common pitfalls.
OpenKruise v1.3 introduces the PodProbeMarker CRD for custom probes, adds new features to CloneSet, WorkloadSpread, Advanced DaemonSet, and SidecarSet—including historical version injection and pod annotation policies—while delivering significant performance gains for large‑scale clusters through queue optimizations and reduced CPU/memory usage.
The article analyses the current state of front‑end performance, explains why hybrid solutions fall short of native experiences, and introduces Lath – a pure front‑end container that turns any web page into a seamless SPA with advanced window management, smooth interactions, and progressive enhancement.
This article analyzes traditional POI implementations, compares their strengths and weaknesses, and presents a high‑performance solution using EasyExcel for exporting and importing up to 3 million rows, including batch querying, sheet management, JDBC batch inserts, and detailed performance benchmarks.
This article analyzes the performance pitfalls of Android's SharedPreferences, explains how its apply() method can still cause ANR, introduces Jetpack DataStore as a modern replacement, and provides detailed migration strategies including code examples, coroutine handling, and bytecode transformation techniques.
This article details the challenges of scaling RabbitMQ, the evaluation of RocketMQ versus Pulsar, the design of a new messaging middleware platform with high availability, performance, and rich features, and the step‑by‑step migration strategy that enabled seamless, low‑cost transition for massive business traffic.
The article explains the core performance metrics QPS, TPS, response time (RT), concurrency, and throughput, provides formulas to relate them, demonstrates practical calculations for capacity planning, and discusses how to determine the optimal number of threads for a backend system.
This article explains how to handle large‑scale Excel import and export in Java by comparing traditional POI workbooks, selecting the appropriate implementation based on data volume and requirements, and presenting a high‑performance solution with EasyExcel, batch processing, and JDBC transactions for hundreds of millions of rows.
This article details Meituan's Kafka deployment, describing the current massive scale and associated challenges, and presents a series of optimizations—including read/write latency reductions, application‑ and system‑level improvements, large‑scale cluster management strategies, full‑link monitoring, service lifecycle management, and future directions—to enhance performance, reliability, and scalability of the streaming platform.
This article examines how Zhaunzhuan's product service, a core component of its e‑commerce platform, was optimized by reducing unnecessary data transmission, applying cache‑aside patterns, redesigning Redis storage, and introducing a field‑marking approach, resulting in dramatically lower GC overhead, network traffic, and response times.
This article explains how to build comprehensive system and application monitoring using the USE (Utilization, Saturation, Errors) method, outlines key performance metrics, and details the architecture of tools like Prometheus, Grafana, ELK, and distributed tracing to quickly detect and resolve bottlenecks.
This article introduces RobustDB, a client‑side read‑write splitting framework that replaces the problematic Atlas proxy by routing SQL statements to master or slave databases based on DML/DQL detection, using Spring, AspectJ, thread‑local context, and dynamic data‑source management.
This article presents ten performance‑optimization techniques—including indexing, compression, caching, prefetching, throttling, batch processing, resource squeezing, horizontal scaling, sharding, and lock‑free designs—explained through Naruto‑themed analogies and practical guidance for backend systems.
This article introduces Spring Native, explains how native images built with GraalVM can reduce Spring Boot startup time to under 100 ms, walks through environment setup, project initialization, Docker image creation, performance testing, and provides troubleshooting tips for common issues.
This article explores Java's proxy patterns, detailing static proxy implementation, various dynamic proxy techniques—including JDK, Cglib, Javassist, and ByteBuddy—providing code examples, performance comparisons, and practical guidance for integrating these proxies into backend development for cleaner, more flexible code.
This article documents a hands‑on experiment migrating a Vue 2 project to Vue 2.7 with Vite, covering setup steps, essential plugins, compatibility issues, performance benchmarks against webpack, and practical lessons for both new and legacy frontend applications.
Although a common belief claims that Java's try‑catch blocks severely degrade performance, this article dissects JVM exception handling, bytecode generation, and JIT/AOT optimizations, presents detailed test code and benchmarks, and demonstrates that when no exception occurs, the overhead is negligible.
Effective monitoring combines comprehensive system and application metrics—using the USE (Utilization, Saturation, Errors) method to pinpoint resource bottlenecks, and leveraging tools like Prometheus, Grafana, and ELK stacks for data collection, storage, querying, alerting, visualization, and full‑stack tracing across distributed services.
To replace Elasticsearch, the team built a ClickHouse‑based log platform that uses table‑level TTL and custom storage policies to automatically move data among hot (ESSD PL1), cold (ESSD PL0) and archive (OSS) disks, achieving faster writes, comparable query latency, and over 50 % cost reduction.
The article shares a six-year journey at Taobao, reflecting on front-end architecture principles, the role of a front-end architect, a practical SSR optimization process, and personal insights on becoming a well-rounded architect who balances technical depth, breadth, and business understanding.
This article examines why encrypted data hinders fuzzy queries and compares three categories of solutions—naïve in‑memory decryption, conventional database‑level techniques, and advanced algorithmic methods—highlighting their trade‑offs in security, performance, and storage overhead.
This article introduces Java 19's virtual threads, compares their performance and scheduling with traditional platform threads and Go goroutines, provides practical code examples, benchmark results, and migration guidelines, and explains the underlying M:N scheduling mechanisms that make virtual threads more efficient for high‑concurrency, I/O‑bound workloads.
This article details the systematic analysis and optimization of the 58.com Android app’s startup process, covering profiling, componentized task framework, delayed initialization, merging launch and home activities, layout improvements, monitoring tools, and results that achieved roughly a 50% reduction in cold‑start time.
This article investigates the common belief that Java's try‑catch blocks severely degrade performance by examining JVM exception handling mechanisms, analyzing compiled bytecode, and presenting extensive benchmark tests under various JVM compilation modes to determine the real impact of exception handling on execution speed.
This article explains why using LIMIT with large offsets slows MySQL queries, analyzes the execution flow, and presents four practical optimization techniques—including subqueries, INNER JOIN, bookmark (tag‑record) method, and BETWEEN range scans—backed by real‑world performance data and code examples.
This article provides a comprehensive overview of DDR memory, explaining its basic architecture, the dynamic read/write process, essential commands, timing parameters, performance considerations, and practical tips for debugging and optimization in modern systems.
This article examines Builder.io's performance optimization case, reviews the evolution of lazy‑loading techniques in front‑end development, and explains how Qwik implements ultra‑fine-grained lazy loading and prefetching to eliminate costly hydration and improve page interactivity.
This article demonstrates how the Taichi library can speed up a Python prime‑counting program by roughly two hundred times compared to the unoptimized version and five times faster than using Numba, providing clear code examples and performance results.
The article explores lesser‑used Java Stream APIs—reduce, the matching trio (allMatch, anyMatch, noneMatch) and flatMap—showing practical examples, performance impacts of operation ordering, readability trade‑offs, and when to prefer streams or traditional loops, even mentioning parallelStream considerations.
The first release candidate of PHP 8.2.0 (RC1) has been published, introducing trait constants, a new Random extension, enhanced JIT support, updated MIME types for the built‑in web server, memory optimizations, new socket and Curl options, additional ZipArchive methods, and several performance and cross‑platform improvements.
This guide explains why regular MySQL health checks are crucial and introduces four open‑source performance tools—mysqltuner.pl, tuning-primer.sh, pt‑variable‑advisor, and pt‑query‑digest—detailing how to download, run, and interpret their reports to optimize configuration, detect bottlenecks, and improve security.
This article provides a comprehensive guide to implementing and testing Go Redis Set APIs—including SAdd, SCard, SIsMember, SMembers, SRem, SPop, and SPopN—complete with code examples, a unified test suite, and a performance benchmark that reports QPS and execution time.
This article summarizes a series of technical Q&A from an OSChina event covering Linux networking fundamentals such as port limits, network namespaces, TCP connection handling, C10K problem, packet loss troubleshooting, TCP memory usage, high CPU causes, useful monitoring tools, kernel parameters, and practical socket examples.
The article explains how the Intersection Observer API offloads visibility detection from scroll events to improve performance, details its creation, options, callback structure, and entry data, and describes a polyfill that mimics native behavior using event listeners, mutation observers, and geometric calculations for broader browser support.
Cloudflare has swapped Nginx for its home‑grown Rust proxy Pingora, claiming trillion‑request daily capacity, up to 70% lower CPU and memory usage, faster TTFB, dramatically higher connection reuse, and improved security, while powering its CDN, Workers, and other services.
This article examines the open‑source memory cache Dragonfly, compares its performance and architecture against Redis through detailed benchmark results, discusses Redis’s response and design principles, and provides reproducible test configurations and command lines for both systems.
This article explores how PureComponent and shouldComponentUpdate address unnecessary re‑renders in class components, compares them with functional components and hooks, and provides practical techniques—including React.memo, useCallback, setState updater functions, and refs—to optimize rendering performance in modern React applications.
This article details how Meituan's Kafka platform, serving over 15,000 machines and handling petabytes of daily traffic, faces read/write latency, slow nodes, and large‑scale cluster management challenges, and describes a series of application‑layer, system‑layer, and operational optimizations—including disk balancing, migration pipelines, fetcher isolation, consumer async, SSD caching, isolation strategies, full‑link monitoring, lifecycle management, and TOR disaster recovery—to improve performance and reliability.
Xiaohongshu refactored Android’s AsyncLayoutInflater by introducing a configurable thread‑pool, safe object pools, and a singleton ViewCache, eliminating ArrayMap and LayoutInflater lock issues, which together yielded over 20% faster cold‑starts and page loads, demonstrating significant performance and business benefits.
When a Linux server’s load spikes, you can quickly pinpoint CPU, memory, disk I/O, and network bottlenecks by running ten concise commands—uptime, dmesg, vmstat, mpstat, pidstat, iostat, free, sar, and top—each providing specific metrics for rapid troubleshooting.
This article explains why Redis is used as a cache, outlines common consistency problems such as cache miss, penetration, and avalanche, compares cache‑aside, read‑through, write‑through and write‑behind patterns, and presents practical solutions like delayed double‑delete, retry mechanisms and binlog‑based asynchronous deletion to maintain eventual consistency between cache and database.
This article examines the challenges of achieving view‑level background blur on Android, compares four implementation strategies—including open‑source libraries and custom AOSP modifications—analyzes their performance, compatibility, and visual quality, and provides code examples and practical recommendations for developers.
StarRocks is a high‑performance MPP database whose simplified FE/BE architecture, fully vectorized engine, and CBO optimizer enable fast multi‑table joins, while its partition‑bucket‑tablet storage model supports real‑time metric services and dashboard migrations, accompanied by practical troubleshooting guidance and upcoming enhancements.
This article details Baidu's comprehensive approach to improving Android app launch performance by evaluating existing tracing tools, selecting Perfetto, developing a Gradle-based automatic instrumentation plugin, handling trace collection and analysis with Trace Processor, and implementing automated detection of regressions, lock contention, and method-level CPU and wall‑time degradations.
The nightly service latency spikes were traced to major page faults triggered by the category client’s lazy mmap of a 1.7 GB off‑heap store during package switches, not to GC or CPU throttling, and were resolved by upgrading to a version that pre‑loads the store in 64 MB chunks with brief pauses.
This article examines why encrypted data hinders fuzzy queries, categorizes three implementation approaches—from naive in‑memory decryption to conventional database tricks and advanced algorithmic solutions—evaluates their security, performance, and storage impacts, and provides practical references for real‑world systems.
Velox is Meta's open‑source unified execution engine that consolidates common data‑intensive components, integrates with engines like Presto, Spark, and TorchArrow, and delivers up to ten‑fold speedups on CPU‑bound queries while simplifying development and fostering a reusable, community‑driven ecosystem.
The article outlines a simple, cost‑effective backend architecture for handling up to 20 million daily health‑status queries across a billion users, detailing data storage, sharding by ID, memory requirements, load handling, and redundancy strategies, while noting practical limitations and promotional notes.
This article investigates MySQL's recommendation against using UUIDs as primary keys by creating three tables (auto‑increment, UUID, and random snowflake IDs), benchmarking insert speeds with Spring Boot/JdbcTemplate, analyzing index structures, and discussing the advantages and drawbacks of each key strategy.
This article outlines Alibaba Cloud Redis development guidelines, covering key naming conventions, value design, command usage, client configuration, lifecycle management, and related tools, with practical examples and code snippets to help avoid common pitfalls and improve performance.
This article compares Java object serialization approaches—including default Serializable, explicit SelfDescribingMarshallable, and trivially copyable techniques—by benchmarking them with JMH and Chronicle Queue, showing that explicit serialization is roughly twice as fast as default and trivially copyable is over ten times faster.
This article examines the puzzling 'prevent gc' comment and Thread.sleep(0) call in RocketMQ’s source, explains how it leverages JVM safepoint mechanics to trigger garbage collection, discusses counted vs uncounted loops, and demonstrates practical code modifications to improve performance.
This article explains why enabling method breakpoints in IntelliJ IDEA dramatically slows Java application startup in debug mode, explores the JVM and JPDA mechanisms behind the slowdown, and provides practical steps and configuration tweaks to avoid or mitigate the performance hit.
This article explains how the Cube rendering engine and its FocusEngine enable small, fast, and resource‑efficient large‑screen mini‑programs on low‑end OTT devices, covering hardware constraints, core focus components, implementation details, performance optimizations, development experience, and future directions.
This article explains the architecture, module composition, thread model, and performance optimizations of the Cube mini‑program rendering engine, highlighting its lightweight size, cross‑platform support, advanced CSS capabilities, QuickJS integration, and real‑world use cases on TV and POS devices.
This article describes a comprehensive LLDB‑plugin based monitoring framework that intercepts Xcode’s Script Bridge API to measure and report precise debugging latency for Swift projects, outlines the implementation details, timing scenarios, data reporting, and includes a recruitment notice for the ByteDance client infrastructure team.
This article explains Redis 6.0's shift from a single‑threaded network model to threaded I/O, outlines the performance reasons behind the change, describes the new execution flow, and provides step‑by‑step instructions for configuring multithreading in redis.conf.
The article investigates frequent HttpClient connection‑pool exhaustion caused by excessive CLOSE_WAIT sockets in a high‑traffic Java service, explains the underlying TCP and HttpClient mechanisms, presents diagnostic commands and code snippets, and offers concrete configuration and architectural recommendations to prevent similar issues.
This article presents twenty practical MySQL optimization techniques—from selecting specific columns and avoiding OR in WHERE clauses to proper indexing, join strategies, and using EXPLAIN—helping developers improve query speed, reduce resource consumption, and write more maintainable SQL code.
This article investigates why upgrading the Feishu Android project's CI build environment from JDK 8 to JDK 11 caused a 50% increase in build time, analyzes JVM, Gradle, and Docker interactions, and presents concrete JVM flag and environment‑variable solutions that restored parallelism and reduced build duration back to pre‑upgrade levels.
An in‑depth comparison shows that while Dragonfly claims to be the world’s fastest memory cache, Redis 7.0 often delivers higher throughput and lower latency across multiple benchmark scenarios, highlighting architectural trade‑offs and the potential for future feature adoption from Dragonfly into Redis.
After a recent deployment a backend update operation became extremely slow, revealing RPC retry, thread‑pool misconfiguration, and row‑lock contention between services, which were analyzed and resolved through thread‑pool tuning and transaction separation.
An in‑depth guide explains why using MyBatis’s foreach for bulk inserts can cause severe performance degradation, especially with large tables, and demonstrates how switching to ExecutorType.BATCH or limiting batch sizes to 20‑50 rows dramatically reduces insertion time from minutes to seconds.
