The article explains JD's technical solution for developing HarmonyOS native applications with the Taro cross‑platform framework, detailing the chosen architecture, CSS adaptations, performance optimizations, and future enhancement plans that resulted in significant rendering speed gains.
Rsbuild 1.0, built on the high‑performance Rspack engine, offers a lightweight, easy‑to‑use TypeScript‑friendly API, dramatically faster dev/startup times, fewer dependencies, and a rich plugin ecosystem, positioning it as the most efficient modern frontend build tool compared to CRA, Vite, and Rspack CLI.
This article explores the modern JavaScript global function structuredClone() as a robust solution for deep cloning objects, comparing it with traditional spread, JSON methods, and custom recursion, and covering handling of circular references, functions, undefined values, performance benchmarks, supported types, and limitations.
This article provides a comprehensive guide to MySQL indexing, covering index types, data structures, clustering and non‑clustering indexes, hash indexes, B+Tree mechanics, index lookup, covering indexes, index push‑down, index merge, cost‑based index selection, common pitfalls, and best practices for designing effective indexes.
This article introduces experienced Python developers to advanced techniques and best practices, covering high‑level data structures from the collections module, custom data structures, decorators and context managers, metaclasses, dynamic class creation, concurrent and asynchronous programming, performance tuning, memory management, coding standards, and testing strategies.
This comprehensive guide walks backend architects through six core optimization methods—caching, batch processing, asynchronous handling, data compression, parallelization, and eliminating unnecessary requests—detailing their problem domains, implementation strategies, real‑world scenarios, benefits, and trade‑offs.
This article walks through a Python solution for quickly counting rows in each sheet of a large Excel workbook, comparing pandas with the Calamine engine, Polars, and optimization tips to cut processing time from dozens of seconds to just a few.
In Android, Bundles backed by memory‑efficient ArrayMap use binary search and shrinkable storage, making them far smaller and faster to transmit than HashMaps, whose fixed‑size growth and lack of shrinkage consume more memory; thus Parcelable Bundles are preferred for IPC, while Serializable remains suited only for persistent storage.
This article provides a comprehensive overview of Java garbage collection, covering the principles of reference counting and reachability analysis, detailing major GC algorithms such as mark‑sweep, copying, and mark‑compact, explaining object allocation strategies, and reviewing traditional and modern collectors like Serial, CMS, and G1, with practical tuning tips for each.
This article explains four typical cache problems—penetration, avalanche, breakdown, and distributed cache efficiency—describing their causes and offering practical mitigation strategies such as top‑level filtering, Bloom filters, staggered expirations, null caching, and locking mechanisms.
This report analyzes performance bottlenecks caused by serialization in a search‑recommendation system, presents detailed measurements of request latency, evaluates multiple optimization strategies—including Redis caching, lazy metric handling, and custom byte‑array serialization—and documents the resulting latency reductions and implementation considerations.
This article walks you through a systematic approach to identify the root cause of a Linux server's CPU hitting 100%, from pinpointing the high‑load process with top, tracing the responsible business code, to using a custom shell script that streamlines thread analysis and resolves the overload.
This article explains why traditional Python multithreading tutorials are often overly complex, introduces the concise map‑based approach using multiprocessing and multiprocessing.dummy ThreadPool, demonstrates performance gains with real‑world examples, and provides ready‑to‑run code snippets for efficient parallel execution.
Bun v1.1.25 boasts a benchmark of 1.29 million HTTP requests per second and adds node:cluster support, V8 C++ API bindings, a five‑fold S3 upload boost, standalone worker executables, Windows OMGJIT for WebAssembly, plus numerous Node.js compatibility fixes, all illustrated with code examples.
Laravel’s Benchmark tool enables developers to measure execution time of code snippets, compare multiple scenarios, run iterative tests for accuracy, retrieve results with execution duration, and apply these insights to optimize queries and improve overall application performance.
This article compares Maven and Gradle, outlining their core concepts, build performance, flexibility, learning curve, and stability to help Java developers choose the most suitable build tool for their projects.
This article examines why storing a string's length in a variable can improve loop performance in JavaScript, explains primitive data types and their wrapper objects, and demonstrates the underlying mechanisms with code examples and timing tests.
The Daily Must‑Grab mini‑program order system evolved from a DX XML‑based UI to a React‑like Rax framework and finally to a native Ao Chuang solution, delivering cross‑platform support, smaller bundles, faster launches, better async handling, and extensible plug‑in architecture while leveraging Taobao’s transaction core.
This article explains how MySQL uses B‑tree‑based indexes, covering balanced binary trees, B‑trees, B+‑trees, various index types, data‑type effects, and best practices for creating and using composite indexes to optimize query performance.
This article examines the migration from Thanos to VictoriaMetrics for large‑scale metric storage, detailing background challenges, VictoriaMetrics architecture and storage engine, data write and read processes, and a comparative analysis of performance, scalability, and operational costs between the two systems.
This article analyzes four major performance problems of UI rendering on HarmonyOS—excessive view hierarchy, long communication pipelines, poor list rendering, and secondary layout—and presents a C‑based native component solution with code examples to improve cross‑platform UI performance.
A growing movement among web developers, highlighted by Pieter Levels and Alex Russell, argues that relying on basic HTML, PHP, lightweight jQuery, and progressive‑enhancement principles can outperform heavyweight JavaScript frameworks in speed, maintainability, and accessibility.
This article walks through Elasticsearch’s licensing history, version selection, installation, cluster health monitoring, shard routing, storage mechanisms, refresh and translog processes, segment merging, and practical performance optimizations such as disk choices, index settings, and JVM tuning.
The article compares Maven and Gradle, detailing their histories, core concepts, advantages, disadvantages, and performance differences, and offers practical advice for Java developers on choosing the most suitable build tool for their projects.
The article analyzes a production out‑of‑memory crash triggered by a pagination bug that misused the OFFSET parameter, explains why the error escaped testing and code review, and presents corrected pagination techniques for Oracle, MySQL and MyBatis to prevent similar failures.
This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.
Testing 150 popular domains from four Chinese cities shows OneDNS public version consistently leads with 9‑19 ms latency, followed closely by Alibaba DNS, while 114DNS, Tencent DNSPod and 360DNS lag behind, prompting users to seek free alternatives as Alibaba’s unlimited service becomes paid.
StarRocks 3.3.1 introduces a cloud‑native persistent index that moves index files to object storage, eliminates local‑disk constraints, and supports elastic scaling, delivering up to ten‑fold latency improvement over local‑disk indexes in elastic scheduling while matching performance in batch and real‑time imports.
This article explains why a direct full‑table UPDATE on a massive MySQL table can overwhelm binlog replication, explores the pitfalls of deep pagination and IN‑clauses, and presents a batch‑processing strategy using NO_CACHE and FORCE INDEX to achieve efficient, low‑impact updates.
This article traces the evolution of Java string concatenation from the simple '+' operator through JDK 8’s StringBuilder implementation, the JDK 9+ StringConcatFactory with invokedynamic, and Alibaba’s PR 20273 that introduces hidden‑class bytecode generation, highlighting performance gains and startup‑time improvements.
A Fastly engineer discovered that increasing CPU cores can degrade Go channel performance due to lock contention, and this article reproduces the benchmarks, explains why goroutine count—not CPU count—is the real culprit, and offers practical optimization techniques.
Rspack 1.0, the Rust‑implemented next‑generation JavaScript bundler compatible with webpack APIs, launches with major performance gains, broader plugin compatibility, smaller bundle sizes, Module Federation 2.0 support, and a roadmap that includes faster HMR, portable caches, and deeper TypeScript integration.
This article introduces Python decorators—such as retry, timeout, logging, caching, response validation, parameterization, exception handling, performance monitoring, permission checking, and composite usage—and provides complete code examples showing how they simplify and strengthen automated API testing.
This article dissects the massive 5‑万‑line checker.ts file in the TypeScript compiler, explaining why the team packed the entire type‑system logic into a single file, how low‑level decisions like named‑parameter comments, heavy use of const enum, ESM/CJS export patterns, var usage, and lack of try‑catch affect V8 performance, and what these choices reveal about TypeScript’s evolution.
This article explains how pandas loc and iloc work, demonstrates their slow performance when used inside loops, and shows that using the at and iat accessors provides a dramatically faster alternative for scalar assignments in DataFrames.
This article explains why Python may run slower than compiled languages, introduces methods for detecting performance bottlenecks, and presents six practical techniques—including using timeit, memory_profiler, line_profiler, built‑in functions, f‑strings, list comprehensions, and lru_cache—to significantly speed up Python programs.
This article traces Elasticsearch's transformation from a pure text search engine to a versatile hybrid platform that integrates structured, geospatial, aggregation, and vector search capabilities, highlighting its AI-driven innovations, performance optimizations, and growing adoption across enterprises and academia.
This article explains why pandas loc/iloc operations inside Python loops are extremely slow, demonstrates the performance difference with concrete examples, and shows that using the scalar‑access methods at and iat can speed up the same task by dozens of times.
This article provides a step‑by‑step analysis of MySQL 8.0.32 InnoDB deadlock logs, covering preparation, log extraction, auxiliary information, transaction details, row‑lock structures, and the final summary, with full SQL examples and code snippets for deep understanding.
This article introduces the high‑performance Caffeine caching library for Spring Boot 3.2, explains its core features, demonstrates detailed performance benchmarks, and provides practical code examples covering synchronous and asynchronous operations, eviction policies, removal listeners, refresh mechanisms, and statistics collection.
The article explains how PHP getters and setters encapsulate private properties, reduce coupling, and enable lazy loading and result caching, thereby improving code clarity, maintainability, and overall system performance.
The article shares a developer’s experience migrating two large Webpack projects to Rspack, covering why Rspack was chosen, detailed lessons on TypeScript handling, CSS extraction, service‑worker support, plugin compatibility, CLI differences, performance benchmarks, and future expectations for the Rust‑based bundler.
This article presents a practical guide for backend developers to troubleshoot Linux performance problems, covering essential analysis tools, a systematic diagnosis method, and detailed checklists for CPU, memory, disk I/O, and network I/O issues.
This article analyzes real‑world search query characteristics, breaks down a typical search system architecture, classifies cacheable data, compares result‑level, intermediate‑value and multi‑layer caches, discusses update, prefetch and placement strategies, and highlights common pitfalls such as cache miss, consistency, and resource overhead.
This article examines Netty 4.1.x’s ByteBuf reference‑counting mechanism, explains why reference counting was introduced, traces its original design, shows instruction‑level optimizations, reveals concurrency bugs in version 4.1.17, and details the clever even‑odd redesign that guarantees thread‑safe memory release while preserving high performance.
This article explains ESLint's highly configurable static analysis architecture, clarifies the roles of parsers, processors, configs and plugins, explores the intricacies of its configuration system, and provides practical debugging methods—including performance profiling and a real‑world import/no-cycle case study.
This article walks through the One Billion Row Challenge, explaining the problem, baseline solution, and a series of performance optimizations—from JVM selection and parallel I/O to custom hash tables, unsafe memory access, and SIMD techniques—that shrink execution time from minutes to under two seconds.
This article presents ten practical Python decorator patterns—such as logging, performance measurement, exception handling, retry, status‑code validation, parameter checking, rate limiting, data‑driven testing, environment configuration, and concurrent execution—each illustrated with clear use‑case descriptions and complete code snippets for API testing.
Redis has introduced a multithreaded query engine that dramatically boosts throughput and lowers latency for vector searches, enabling scalable, real‑time retrieval‑augmented generation (RAG) workloads while preserving the low‑latency performance of its core in‑memory database.
This article provides a comprehensive overview of Nginx's high‑performance architecture, including its core, basic and third‑party modules, master‑worker process model, asynchronous event handling with epoll, FastCGI and PHP‑FPM integration, as well as detailed configuration and optimization techniques for production deployments.
Collaborating across TencentOS and database kernel teams, the article details how architecture upgrades—moving to TKE HouseKeeper, switching to AMD CPUs, and adding a portable 16 KB atomic‑write feature—combined with kernel optimizations like huge‑page support, NUMA‑aware qspinlocks, speculative page‑fault handling, and ORC unwinding to deliver up to 30 % mixed workload and over 100 % write‑only performance gains while reducing memory usage.
This article explains the different effects of placing a try‑catch block inside versus outside a for loop in Java, covering usage scenarios, performance impact, memory consumption, and practical recommendations for choosing the appropriate approach during development.
The article investigates Go 1.22’s claim that simple type casting []byte(str) can replace unsafe‑based string‑to‑byte conversions, presents four implementation variants, runs detailed benchmarks on macOS M2 and Linux amd64, analyses compiler inlining and escape behavior, and explains the hidden pitfalls of capacity and mutability in the k8s shortcut.
The article reviews pandas 2.0’s major upgrades—including an Apache Arrow backend that speeds up CSV reads by over 30×, new Arrow dtypes, a nullable‑numpy dtype for missing values, a copy‑on‑write memory model, optional dependencies, and benchmark comparisons with ydata‑profiling—highlighting the library’s enhanced performance, flexibility, and interoperability for data‑intensive Python workflows.
This article provides a comprehensive guide to Java atomic variables, explaining their core concepts, underlying CAS mechanism, key classes such as AtomicInteger, AtomicLong, AtomicReference, and AtomicBoolean, and demonstrating practical code examples, use‑cases, performance benefits, limitations, and comparisons with traditional lock‑based synchronization.
After upgrading an RDS MySQL instance from 5.6 to 8.0, the same ORDER BY query became dozens of times slower, and this article walks through step‑by‑step analysis, profiling, source‑code inspection, and the root cause behind the performance regression.
This article demonstrates how to efficiently insert 300,000 rows into a MySQL table by using MyBatis batch operations, JDBC batch processing, and various performance optimizations such as batch size tuning, transaction management, and connection pooling.
This article explains the history, key technologies, benefits, drawbacks, and practical recommendations for adopting a frontend‑backend separation architecture, especially for startups seeking scalable, maintainable, and efficient web applications.
This article explains the concept of database connection pools, why they are needed, their core principles and runtime mechanisms, compares traditional direct connections with pooled connections, and reviews major Java pool implementations such as DBCP, C3P0, Druid and HikariCP along with configuration tips and best‑practice considerations.
The article introduces xlswriter, a high‑performance PHP C extension for reading and writing Excel 2007+ XLSX files across major operating systems, compares it with PHPExcel, presents benchmark results, explains PECL installation, and provides detailed code examples for exporting, importing, and chart generation.
This article demonstrates how to analyze and optimize Go's garbage collection using go trace, comparing single‑threaded and concurrent implementations, and shows how tuning GOGC and GOMEMLIMIT can dramatically improve runtime and memory usage, with detailed code samples and performance metrics.
This article investigates the performance differences between Java’s ‘+’ operator and StringBuilder for both simple and looped string concatenations, presenting JUnit benchmark results that show ‘+’ is comparable for single concatenations but significantly slower in loops, and recommends using the appropriate method based on context.
This article presents four practical Python performance tricks—including list reversal with slicing versus reverse(), one‑line variable swapping, moving loops inside functions, and reducing function calls—each demonstrated with code examples and timing results that show measurable speed improvements.
This article explains how to quickly test MyBatis SQL statements by bypassing the Spring container, using a minimal MyBatis configuration, adding support for PageHelper pagination and MyBatis‑Plus plugins, and provides code examples and a plugin recommendation for efficient backend development.
This article explains the concept, benefits, and implementation details of memory pools in the Linux kernel, covering allocation functions, design principles, common strategies, and a thread‑safe C++ memory‑pool class with example code.
PRipple is a high‑performance native PHP coroutine framework built on PHP 8.1 fibers and the Revolt library, offering simple APIs for asynchronous I/O, seamless integration with popular PHP frameworks, and easy installation via Composer for developing concurrent, high‑load applications.
The article explains how RocketMQ’s reliance on mmap‑based zero‑copy leads to more data copies and system‑call overhead compared to Kafka’s sendfile approach, resulting in lower throughput, and discusses when to choose each message‑queue system based on functional needs and performance requirements.
This article presents a thorough collection of practical techniques for optimizing backend interface performance, covering index management, SQL tuning, parallel remote calls, asynchronous processing, transaction handling, lock granularity, caching strategies, sharding, and monitoring tools, offering actionable guidance for developers to improve service efficiency.
The article explains how Python's dict uses a hash table to provide constant‑time insertion, deletion, and lookup, demonstrates its speed advantage over lists with benchmarks, and details the handling of collisions, resizing, and the underlying array‑based implementation.
Fast‑Retry is a high‑performance, asynchronous retry framework for SpringBoot that handles millions of concurrent tasks, offering configurable retry attempts, delay, exception handling, and custom result policies, and outperforms traditional synchronous solutions like Spring‑Retry and Guava‑Retry in throughput and resource usage.
Greg Foster investigates why Facebook abandoned Git for Mercurial, revealing that massive repository size caused severe performance bottlenecks, Git’s inability to scale, and the collaborative culture of Mercurial’s maintainers, ultimately shaping Facebook’s tooling decisions and influencing broader industry practices.
This article provides an in‑depth overview of MySQL fundamentals, covering join types, normalization, data types, index structures, locking mechanisms, transaction isolation, MVCC, replication, sharding, and practical performance‑tuning techniques for large‑scale databases.
This guide walks you through obtaining the Linux kernel source, configuring key options, compiling and installing the kernel, tuning sysctl parameters, and continuously monitoring system metrics to achieve higher performance, stability, and security in high‑load environments.
This comprehensive guide explains how to boost WordPress site speed and SEO by applying PHP‑based strategies such as query optimization, regular database maintenance, custom tables, option‑table tuning, indexing, and caching, complete with practical code examples.
This article presents a Bash script that gathers comprehensive Linux system metrics—including CPU core count, utilization percentages, context switches, interrupts, load averages, memory and swap usage, and disk I/O statistics—explaining each command and its purpose for effective server monitoring.
This article details the author's comprehensive refactor of the WorkQueue Go library, covering the redesign of its sorting heap using a red‑black tree, interface improvements, enhanced data structures, extensive performance benchmarks, and a step‑by‑step usage guide for developers.
This article walks through initializing a vue-mini mini‑program project, explains the build.js workflow, details how TypeScript, HTML and CSS files are processed with Babel, Rollup and PostCSS, compares its performance to Taro, and evaluates vue-mini’s current strengths and limitations.
This technical report analyzes a high‑traffic MySQL deployment with three servers, detailing disk usage, table space, QPS and slow‑SQL issues, and presents a comprehensive governance plan that includes data migration, read‑traffic offloading to replicas, MyBatis interceptor implementation, JSF monitoring, and Python automation to reduce disk pressure and improve query performance.
Recent investigations reveal that MySQL versions 8.038, 8.4.1, and 9.0 contain severe bugs causing system crashes when handling over 10,000 tables, with additional performance bottlenecks in InnoDB startup, prompting experts to advise cautious, delayed upgrades and careful code review of related functions.
Swizec Teller argues that in most React projects the useCallback and useMemo hooks are unnecessary, explains how they work, shows common pitfalls, and provides concrete alternatives for writing cleaner, more efficient components without over‑optimizing.
This extensive article presents a systematic approach to front‑end stability, covering observability systems, full‑chain monitoring, high‑availability design, performance management, risk governance, process mechanisms, and engineering practices to ensure reliable user experiences and business continuity.
This article provides a comprehensive overview of Nginx’s high‑performance features, module architecture, process and I/O models, FastCGI integration with PHP‑FPM, configuration best practices, tuning techniques, and common error troubleshooting, offering practical guidance for optimizing and securing Nginx deployments.
This article explains what constitutes a slow SQL query, how to detect and analyze it using MySQL tools, and provides practical optimization steps—including indexing, business logic review, caching, scheduling, and partitioning—to dramatically reduce execution time.
This article presents a comprehensive collection of Python coding principles, best‑practice suggestions, library usage tips, design‑pattern ideas, internal language mechanisms, tooling recommendations, and performance‑profiling techniques to help developers write clean, efficient, and maintainable Python code.
The openEuler 24.03 LTS release introduces a dynamic composite page (large folio) that retains 4 KB base‑page compatibility while enabling 64 KB page performance gains, reducing TLB misses and memory overhead, and delivering double‑digit benchmark improvements for big‑data, Kafka, MySQL, I/O and memory‑allocation workloads.
This article examines why Go's garbage collector can become a CPU bottleneck with large heaps, demonstrates the performance impact with benchmark programs, and presents practical strategies—such as using pointer‑free allocations, mmap‑backed memory, and string interning—to dramatically reduce GC pause times.
This article explains how to reduce Flutter Web startup time by splitting the bulky main.dart.js file using deferred components, configuring CanvasKit assets via CDN, and optimizing font loading, complete with step‑by‑step code examples and performance measurements.
This article examines three categories of techniques—naïve, conventional, and advanced—for enabling fuzzy queries on encrypted data, comparing their implementation steps, performance impact, storage overhead, and security trade‑offs, and provides practical examples and reference links for further study.
GaiaDB 4.0 introduces cloud‑native parallel query execution, allowing the same MySQL‑compatible cluster to handle both OLTP and OLAP workloads with up to fourteen‑fold speedup on complex queries, configurable via global parameters or query hints, and adds columnar indexes for further analytical acceleration.
This article examines Java string concatenation performance by comparing the '+' operator and StringBuilder in both simple and loop scenarios, presenting JUnit test results, bytecode analysis, and practical recommendations for choosing the most efficient approach.
This article evaluates MySQL backup strategies using Percona XtraBackup, comparing local, remote, and streaming modes in terms of backup duration, primary server load impact, and backup file size, and provides practical recommendations based on detailed test results.
This article examines the detailed steps and timing of establishing a MySQL database connection using Java, measures the latency of the TCP handshake and authentication phases, and demonstrates why connection pooling is essential for high‑traffic web applications.
Using JMH, this article benchmarks Java switch statements, comparing the traditional int‑based switch (via String hashCode) against the newer String‑based switch, showing that the int version runs roughly twice as fast while warning about hashCode collisions.
Using JMH, the author benchmarks Java's switch‑case against if‑else and finds switch executes in about 0.44 ns per operation versus 1.55 ns for if‑else, with the gap widening as the number of branches increases.
The 2024 Netdev 0x18 conference in Santa Clara showcased six ByteDance STE presentations covering machine‑learning‑driven Nginx latency tuning, a novel zero‑copy notification, fine‑grained TCP tuning with eBPF, transparent shared‑memory communication, cross‑data‑center traffic management using AI, and asymmetric multi‑processing to cut network jitter.
The article explains how Python’s speed limitations can be overcome with PyPy’s just‑in‑time compilation, showing benchmark results where PyPy outperforms both standard Python and even C, and describes the underlying concepts of AOT, interpretation, and JIT that enable this performance boost.
This article explains how Spring Boot 3.2 can be accelerated with Class Data Sharing, virtual threads, GraalVM native images, ProblemDetail error handling, and new observability features, providing practical commands and code examples for faster startup, lower memory usage, and richer monitoring.
This article explains Java's lock escalation process—covering biased, lightweight, and heavyweight locks—their underlying mechanisms, performance benefits, and the conditions under which each lock type is applied in multithreaded applications.
This article implements seven different HashMap traversal techniques in Java, benchmarks each with JMH, and shows that lambda‑based iteration and entrySet loops are the fastest, followed by Streams, while keySet‑based loops lag behind.
By compressing GLB files into ZIP, extending Three.js loaders to unzip via a Rust‑compiled WASM tool, encrypting small buffers, and caching morph‑target shaders while spreading mesh rendering across frames, the team shrank model size from 50 MB to 11 MB and cut first‑frame render time from 7 seconds to 0.6 seconds, reducing overall page load from 15 seconds to 5 seconds.
