Former Meta engineer Aydyn Tairov quickly ported the Python implementation of Llama2 to the newly released Mojo language, demonstrating that Mojo’s SIMD primitives can accelerate Python code by up to 250 times and even make the Python version run 20% faster than the original C implementation.
The article explains Java's basic concepts of object creation, compares the execution speed of using the new operator versus reflection, analyzes why reflection is slower, and outlines typical scenarios where each method is appropriate, supported by benchmark code and results.
This article explains how StarRocks 3.0 extends real‑time data‑warehouse capabilities to support data‑lake analysis, external catalog integration, Trino compatibility, extensive I/O optimizations, and powerful materialized‑view features that together enable a unified, cloud‑native Lakehouse solution with high performance and flexible resource isolation.
This article documents a comprehensive migration from JDK 8 to JDK 17, detailing new language and JVM features, step‑by‑step upgrade procedures, Maven and SpringBoot version changes, performance benchmarking, and ZGC‑based garbage‑collection tuning to dramatically reduce pause times.
This article introduces Redis as an open‑source, high‑performance in‑memory key‑value store, explains its rich data structures, underlying implementations, performance advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples for Ubuntu systems.
This article examines PHP's continued dominance in web back‑ends by presenting recent market‑share data, CMS adoption figures, large‑scale deployments, and expert opinions, revealing why the language remains a cost‑effective, high‑performance choice for many enterprises despite predictions of its demise.
This article investigates the severe memory growth and latency spikes observed when synchronizing data across data centers in a Netty‑driven online computation service, analyzes the impact of JDK 17 ZGC and direct‑buffer allocation, and presents the debugging steps, source‑code insights, and configuration changes that ultimately resolved the issue.
This article introduces Switchquery, a high‑performance mobile configuration platform that achieves second‑level real‑time delivery through a novel architecture involving a CMS, unified gateway, header‑based version signaling, and SDKs for Android and iOS, and demonstrates its optimization, multi‑app support, and successful large‑scale deployment in major promotional events.
This article examines Linux memory management fundamentals, explains the brk/sbrk and mmap system calls, details the internal architectures, allocation and reclamation processes of ptmalloc and tcmalloc, analyzes key configuration parameters, and presents benchmark and production‑level results that demonstrate their impact on performance and memory usage.
This article explains how to build a high‑performance Go server capable of processing up to one million requests per minute using efficient goroutine‑pool patterns, detailing the design of two worker structures, their dispatch, start, stop mechanisms, and practical optimizations.
Cloudflare replaced Nginx with Pingora, a Rust‑written reverse‑proxy service that delivers higher speed, better efficiency, and stronger security by redesigning the worker model, using multithreading, and optimizing connection reuse, resulting in significant CPU, memory, and latency savings across billions of requests.
This article explores Java's Optional class, explaining its intended purpose, proper usage patterns, common pitfalls, performance considerations, and detailed source code analysis, while comparing it to traditional null checks and demonstrating how methods like map, orElseThrow, and orElseGet behave in practice.
The article analyses the performance, memory, bandwidth and cost of NVIDIA H100, A100 and RTX 4090 GPUs, explains why the 4090 cannot handle large‑model training due to communication and memory limits, and shows how its high compute‑to‑price ratio makes it attractive for inference, backed by detailed parallelism calculations and cost‑per‑token estimates.
An in‑depth analysis of the Tianwang risk‑control Lingji system reveals how JDK 17’s ZGC, Netty’s direct‑memory allocation, and cross‑data‑center channel limits caused severe latency spikes, memory growth, and CPU usage, and outlines the debugging steps and configuration changes that finally resolved the issue.
This article explains how to dramatically reduce HttpClient request latency from 250 ms to about 80 ms in a high‑traffic service by using a singleton client, connection pooling, keep‑alive strategies, proper timeout settings, and efficient response handling, complete with code examples.
By refactoring a high‑traffic Java service to use a singleton HttpClient, enable connection pooling with a custom keep‑alive strategy, and fine‑tune timeout and retry settings, the average request time dropped from 250 ms to about 80 ms, dramatically improving throughput and stability.
The article explains Python’s Global Interpreter Lock—its historical origins, how CPython’s tick‑based and later time‑slice schedulers manage thread execution, why it limits multi‑core performance, common multiprocessing workarounds, and the difficulties of removing it despite recent proposals for a GIL‑free build.
This article introduces Redis as a high‑performance in‑memory key‑value store, explains its core features, data types, caching usage in Spring Boot, and discusses common cache problems such as consistency, avalanche, penetration, and breakdown along with mitigation strategies, plus details on persistence, replication, and Sentinel.
Curve is a high‑performance, easy‑to‑operate, cloud‑native open‑source distributed storage system (CNCF Sandbox) that provides block and file storage for OpenStack, Kubernetes, and PolarFS, featuring Raft‑based consistency, hybrid storage, high availability, and an ongoing roadmap for AI and other workloads.
This article demonstrates how to use MySQL to create employee and performance tables, populate them with sample data, and write SQL statements that first select employees whose salaries exceed their department's average and then filter out those with non‑A performance ratings, providing a complete layoff‑target list.
This article explains the principle of the JIT compiler introduced in PHP 8.0, shows how to enable it via php.ini settings, provides a sample code demonstration, and discusses performance benefits and limitations for PHP developers.
This article explains the key differences and performance trade‑offs among HTTP/1.1, HTTP/2, and HTTP/3, detailing keep‑alive, pipelining, streams, multiplexing, QUIC’s 0‑RTT handshake, connection migration, congestion and flow control, and provides practical guidance on when to adopt each protocol.
This guide explores essential front‑end techniques—from efficiently handling massive data sets and adopting the Svelte framework, to containerizing deployments, mastering Chrome and VSCode debugging, applying clean architecture principles, and dissecting eight classic sorting algorithms—providing practical insights for modern web developers.
The article details a production incident where a containerized Java service experienced a CPU surge due to frequent young and full garbage collections, describing step‑by‑step diagnostics using Linux tools, jstack analysis, and code fixes that ultimately resolved the issue.
This article explains what performance best practices are, why they matter, and provides a comprehensive list of general and Java‑specific techniques—including code optimization, resource management, concurrency, caching, and JVM GC tuning—to help developers build faster, more reliable backend systems.
The article explains how Hologres RoaringBitmap compresses user ID sets into efficient bitmap indexes, splits 64‑bit IDs into buckets, syncs them from MaxCompute, and enables sub‑second user portrait queries that previously took minutes, dramatically improving performance and scalability.
This article demonstrates several techniques—including server‑side data simulation, batch rendering with timers, requestAnimationFrame, pagination components, infinite scroll, and virtual lists—to efficiently display and interact with 100,000 records in a Vue.js front‑end without causing UI freezes or performance degradation.
This article examines WebAssembly’s evolution from a browser‑based binary format to a potential universal runtime, discusses its performance advantages, current limitations, and the impact of initiatives like WASI and Cloud‑Native integration, while questioning whether it will truly become the future of computing.
The team traced near‑100 % CPU spikes in an Elasticsearch cluster during stress tests to frequent JIT deoptimizations triggered by a switch‑based experiment routing logic, and resolved the issue by replacing the switch with a function map, which eliminated deoptimizations and stabilized CPU usage.
This article examines why MySQL columns are often defined as NULL, debunks common myths, and presents several technical reasons—including storage overhead, index complications, query pitfalls, and timestamp issues—that justify using NOT NULL with meaningful default values for better performance and data integrity.
This article explains how Redis 7.0.11’s multithreading mode is enabled through two configuration options, describes when the mode is activated or deactivated based on client write‑backlog, and outlines the read and write processing flow in multithreaded and single‑threaded stages.
This article explains Python decorators, a powerful feature for modifying functions or classes, and provides ten practical custom decorators—including @timer, @memoize, @validate_input, @log_results, @suppress_errors, @validate_output, @retry, @visualize_results, @debug, and @deprecated—each with clear explanations and complete code samples.
The article explains how MJDK, Meituan's OpenJDK‑based distribution, integrates the Intel ISA‑L‑optimized mzlib library into java.util.zip, preserving API and format compatibility while delivering a five‑to‑ten‑fold increase in compression and decompression throughput, backed by benchmark results on the Silesia corpus.
PostgreSQL 11+ lets you define custom statistics with CREATE STATISTICS, dramatically improving query plans for large tables and complex predicates, as shown by step‑by‑step examples that cut execution time by up to 300× and illustrate different statistic kinds such as ndistinct and dependencies.
This article examines whether adding the always‑true condition WHERE 1=1 in MySQL queries prevents index usage, by comparing EXPLAIN plans for queries with and without the clause and proposing a cleaner MyBatis mapping approach.
This article examines the performance difference between Java's List.sort() and Stream.sorted() by presenting simple demos, discussing JIT warm‑up effects, and using JMH benchmarks to show that native list sorting generally outperforms the stream‑based approach.
This article demystifies the actual execution sequence of SQL queries, detailing how FROM and JOIN establish table relationships, WHERE filters rows, GROUP BY groups data, HAVING applies aggregate conditions, SELECT retrieves fields, ORDER BY sorts results, and LIMIT restricts the final output.
The article explains that while observability is not new, cloud‑native systems have driven rapid development of observable platforms, detailing data collection architectures, direct push versus file‑based approaches, and various sampling techniques (head, tail, and local sampling) to balance completeness, real‑time reporting, and performance impact.
The paper presents a high‑performance Android code‑coverage solution that uses standard reflection to read the ClassLoader’s ClassTable, achieving over five‑times faster collection than existing tools while remaining stable, compatible, multi‑process capable, and enabling incremental, cloud‑based reporting for reducing app size.
This article examines why containerizing MySQL with Docker can be problematic, highlighting data safety concerns, performance degradation due to I/O bottlenecks, state management limitations, and resource isolation challenges, while also presenting scenarios where containerization may be feasible and offering mitigation strategies.
The article analyzes the root causes and system‑wide consequences of oversized messages in JD Logistics, explains middleware limits of JMQ and JSF, and presents design principles, code‑level checks, and practical mitigation techniques such as pagination, claim‑check pattern, batch sizing, and monitoring to prevent service outages.
This article explains common rate‑limiting algorithms—including fixed‑window counters, sliding windows, leaky buckets, and token buckets—detailing their principles, advantages, and pitfalls, and provides complete Java code examples to illustrate implementation and testing of each method.
This article explains what Redis hot keys are, how they cause load imbalance in clustered environments, and presents multiple detection techniques and practical mitigation strategies such as rate limiting, second‑level caching, key sharding, and configuration‑center approaches.
This article explains how to replace the default Tomcat container in Spring Boot with Undertow, provides step‑by‑step configuration instructions, and presents benchmark results that show Undertow's superior throughput and lower memory usage under high‑concurrency workloads.
This article explains Redis's LFU eviction algorithm, its implementation details, code-level mechanics, configuration steps, and how it improves upon LRU by using frequency-based counters and decay to make smarter cache eviction decisions.
This article explores the interview question of how many concurrent requests a SpringBoot project can process by building a minimal demo, measuring Tomcat and Undertow thread pool limits, analyzing default configurations, and showing how container settings and annotations like @Async affect the actual request capacity.
This article details a systematic investigation and optimization of a web‑based workflow engine, addressing slow initial rendering, input lag in Element UI components, and excessive memory consumption that caused browser crashes, and presents concrete solutions such as data pruning, Object.freeze, lazy loading, and event cleanup.
This article explains why MySQL joins and subqueries can become performance bottlenecks on large tables, recommends fetching data via indexed single‑table queries and merging in the application layer, outlines advantages, use cases, drawbacks of joins, and offers practical alternatives and tuning tips.
This article explains how repeatedly creating Jackson ObjectMapper instances hurts performance, demonstrates a JMH benchmark comparing new, singleton, and ThreadLocal ObjectMapper usages, and concludes that a single globally shared ObjectMapper can achieve up to ten times faster JSON parsing.
This article analyzes several bugs discovered in a Go goroutine pool implementation—incorrect active count, mismatched execution counters, slow scaling during QPS spikes, and inefficient recycling—and presents detailed code fixes and redesigns to achieve accurate metrics and faster, more graceful worker management.
This guide explains how to analyze Linux load situations—whether CPU and load are both high or CPU is low while load remains high—by using commands like top, vmstat, iostat, sar, and jstack, and provides practical troubleshooting steps for common I/O‑related issues.
This article explains why enhancing bloom (glow) effects is important for visual attention and scene aesthetics, outlines a generic WebGL implementation pipeline, discusses factors influencing bloom quality, and presents the Crystal WebGL engine's optimizations and performance comparisons between traditional and mipmap‑based approaches.
This article walks through a real‑world front‑end performance overhaul, showing how Lighthouse metrics were used to identify bottlenecks, detailing code‑splitting, lazy‑loading, asset compression, SEO fixes, and monitoring setup that together boosted the site’s speed by nearly three times.
The article explains a real‑world issue where the first invocation of a MD5 hash in a Java backend took dozens of seconds, describes how the problem was traced using the Arthas diagnostic tool, reveals that the delay stemmed from BouncyCastle algorithm loading, and shows how replacing the library resolved the performance bottleneck.
This article explains why using NULL in MySQL tables hurts storage, index size, query correctness, and update performance, and shows concrete examples, benchmark data, and official documentation that justify preferring NOT NULL with sensible default values.
This article presents a comprehensive list of thirty‑one practical Java performance optimization techniques—including proper use of singletons, avoiding static variables, minimizing object creation, leveraging final modifiers, choosing appropriate collections, and efficient exception handling—to help backend developers write faster, more memory‑efficient code.
An in‑depth comparison shows that Java's native List.sort() outperforms Stream.sorted() due to lower overhead, demonstrated through simple demos, JMH micro‑benchmarks across various collection sizes, and analysis of stream processing costs, concluding that the performance gap, while measurable, is often negligible in typical use.
This article presents a comprehensive collection of Spring Boot best practices—including proper package structure, design pattern usage, starter dependencies, Lombok integration, constructor injection, SLF4J logging, controller and service design, null‑pointer avoidance, collection handling, pagination, caching, custom exception handling, response objects, code cleanup, meaningful naming, casing conventions, simplicity, consistent formatting, and SonarLint usage—to help developers build efficient, maintainable, and high‑performance backend applications.
This article presents a comprehensive design and implementation of a high‑concurrency memory pool in C++, covering concepts such as fixed‑size block allocation, thread‑local caches, central and page caches, lock‑free techniques, span management, and performance benchmarking against standard malloc.
This article examines why encrypted data hinders fuzzy queries and presents three categories of solutions—naïve, conventional, and advanced—detailing their implementations, performance trade‑offs, and security implications to help developers choose an appropriate approach.
This article examines the business background and challenges of multi‑platform front‑end development, evaluates mainstream cross‑platform technologies, selects Taro as the optimal solution, and details its integration with existing React Native and Web stacks, component and API adaptation, CSS handling, performance testing, cost analysis, and future outlook.
This article explains the different server storage types—including mechanical HDDs, solid‑state SSDs, various interfaces, RAID arrays, and network‑attached storage—while covering their structures, performance characteristics, Linux device handling, and how to choose the right solution based on cost, capacity, speed, and reliability.
The article details a real‑world incident where a Java backend pod experienced 90% CPU usage and excessive young and full garbage collections, describing step‑by‑step diagnostics, stack analysis, and code fixes that resolved the performance problem.
This article explains how to set up a MySQL test table and indexes, then enumerates nine typical scenarios—such as leading‑wildcard LIKE, arithmetic or functions on indexed columns, type mismatches, composite‑index misuse, character‑set differences, and OR conditions with non‑indexed fields—that cause queries to bypass indexes and perform full table scans.
The article examines the drawbacks of using NULL columns in MySQL, explaining how they increase storage space, complicate indexing and query optimization, and can cause performance issues, while providing examples and best practices for defining NOT NULL constraints and handling data correctly.
This article explains what Redis bigkeys are, their impact on performance and memory, how they are generated, methods to detect and analyze them—including built‑in commands, SCAN, memory usage, and RDB file inspection—and practical steps to mitigate their effects.
This quick‑start guide walks readers through ARM assembly development by teaching simple template functions, exposing typical parameter‑passing and register bugs with debugging tricks, and demonstrating a depthwise convolution written in assembly that delivers roughly 4.7× faster inference on a Huawei Mate40 Pro compared to its C++ counterpart, while also covering ARM32/ARM64 register conventions, vector instructions, and floating‑point handling.
The article reviews Doris 2.0's major enhancements—including point‑query concurrency, log‑analysis capabilities, cold‑hot data separation, lakehouse integration, and various performance and usability upgrades—explaining how these changes benefit OLAP workloads and simplify data‑engineering pipelines.
This article demonstrates how to use Alibaba's open‑source Java diagnostic tool Arthas to quickly locate and fix high CPU usage in a Java application, covering installation, attaching to a JVM, using dashboard, thread, jad, watch, and ognl commands, and interpreting the results.
This article investigates the performance difference between Java's native List.sort() method and the Stream.sorted() approach, provides simple demos, explains JIT warm‑up effects, and presents JMH benchmark results that show List.sort() consistently outperforms Stream.sorted() for typical collection sizes.
This article analyzes the challenges of browser caching in micro‑frontend projects, presents a systematic optimization plan—including resource versioning, server‑side URL proxying, nginx cache‑control configuration, and CDN integration—and demonstrates a 48.5% reduction in page‑load time with detailed implementation steps and performance data.
Learn how converting single‑threaded Python crawlers into multithreaded ones can dramatically reduce data‑fetching time, covering process vs thread concepts, practical threading code examples, performance comparisons, and a step‑by‑step guide to building a multithreaded image scraper.
This article explains the common reasons why Redis performance degrades—such as network latency, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, and memory fragmentation—and provides detailed optimization and troubleshooting steps to restore low latency.
This article reviews the evolution of mainstream CPU performance benchmarks such as SPEC and TPC, compares their methodologies and tools, discusses challenges in evaluating heterogeneous CPUs, and outlines future research directions, providing a comprehensive overview for researchers and practitioners.
This article traces the evolution of eBPF from its BPF predecessor, explains its kernel requirements, security model, probe mechanisms, performance impact, tracing capabilities, and potential event‑loss risks, and looks ahead to its expanding role in networking and system observability.
This article examines the advantages and disadvantages of placing try-catch blocks inside versus outside loops in Java, provides concrete code examples, references performance guidelines from the Alibaba Java Development Manual, and outlines scenarios to help developers choose the most appropriate approach.
This article explains how Elasticsearch pagination works with from/size, why deep paging can cause performance problems, and compares alternative techniques such as Scroll, Scroll‑Scan, Sliced Scroll, Search After, and point‑in‑time (PIT) searches for handling large result sets efficiently.
By integrating ZSTD compression into Didi’s Elasticsearch 7.6, the team cut CPU usage by about 15 %, reduced index storage roughly 30 %, boosted write throughput up to 25 %, and eliminated over 20 servers, demonstrating a faster, more storage‑efficient solution for petabyte‑scale log ingestion.
The article explains that Redis achieves exceptional performance through four main factors—its in‑memory storage, optimized data structures, a single‑threaded architecture, and non‑blocking I/O—detailing how each contributes to speed and efficiency.
This article investigates whether Java's list.sort() truly outperforms stream().sorted() by presenting simple demos, explaining the pitfalls of naive timing, and using JMH benchmarks to reveal that list.sort consistently runs faster due to lower overhead, while the performance gap remains small for typical data sizes.
This article explains the OffscreenPageLimit attribute of ViewPager2, how it controls off‑screen page loading, compares its default values with ViewPager, shows code implementations, analyzes performance trade‑offs, and provides practical recommendations for choosing an appropriate limit.
Go 1.21 has been officially released, introducing toolchain improvements such as GA‑ready profile‑guided optimization, new built‑in functions, several standard library packages, performance boosts, and experimental support for the WebAssembly System Interface (WASI).
The article explains why using the KEYS command on a large Redis dataset can block the server, introduces the SCAN command as a non‑blocking alternative with cursor‑based iteration, and provides usage examples and best‑practice tips for safely listing prefixed keys.
This article explains how Ant Design's CSS‑in‑JS implementation uses server‑side rendering and a hash‑based cache to avoid runtime style generation, dramatically improving performance for both application‑level and component‑level styling.
This article introduces a MyBatis‑based SQL analysis component that detects and prevents slow queries before they impact production by performing real‑time EXPLAIN analysis, offering optimization suggestions, and enabling dynamic SQL replacement, while detailing its design, configuration, performance testing, and practical advantages.
The article outlines practical GPU inference optimization for NetEase’s news recommendation, covering model analysis with Netron, multi‑GPU parallelism, memory‑copy reduction, batch sizing, TensorRT conversion and tuning, custom plugins, and the GRPS serving framework to achieve significant latency and utilization gains.
This article details a systematic investigation of MySQL insert slowdown caused by disk I/O anomalies, describing log analysis, blktrace data collection, RAID controller firmware bugs, and the final resolution through firmware upgrade, providing practical guidance for database performance troubleshooting.
This article explains the browser's critical rendering path, detailing how HTML is parsed into a DOM, how CSS is turned into a CSSOM, how the render tree is built, and how JavaScript and CSS can block or delay rendering, providing practical examples and performance testing results.
The article examines performance bottlenecks in Prometheus‑Grafana monitoring dashboards caused by high metric cardinality, explains the internal query processing steps, demonstrates how to analyze and reduce cardinality with PromQL and recording rules, and shows concrete command‑line examples that dramatically improve query latency.
Android ANR occurs when the UI thread is blocked, triggered by time‑outs such as KeyDispatch, Broadcast, Service or ContentProvider, often caused by long I/O, deadlocks, Binder calls or resource exhaustion; diagnosing involves examining traces.txt, thread states, CPU/memory metrics, and using tools like Looper logs, Choreographer, or Tencent Matrix to prevent future freezes.
This article explains how to correctly declare, monitor, and configure Java thread pools, recommends naming conventions, discusses CPU vs I/O workload sizing, highlights common pitfalls such as deadlocks and ThreadLocal misuse, and introduces dynamic pool‑adjustment techniques used by large tech companies.
This article details a real‑world test of loading over 20 billion records into MySQL with XeLabs TokuDB, covering the demand, configuration tweaks, table schema, bulk‑loader commands, performance metrics, comparison with InnoDB, and practical conclusions for large‑scale data ingestion.
The article examines why a Lazada front‑end team is questioning the switch from the long‑standing Alibaba Fusion component library to Ant Design, analyzing design quality, iteration speed, performance, stability, ecosystem impact, CSS‑in‑JS trends, and the overall cost of migration.
This article reviews the limitations of traditional Spark shuffle, introduces Apache Celeborn (Incubating) as a remote shuffle service, and details its design for performance, stability, and elasticity, including push shuffle, partition splitting, columnar shuffle, multi‑layer storage, congestion control, and real‑world evaluation.
This article presents practical MySQL performance tuning techniques, covering query, pagination, join, subquery, order‑by, group‑by, and count optimizations with example code, index strategies, and execution‑plan analysis to improve latency in high‑traffic systems.
This article presents sixteen practical Java coding best‑practice tips—ranging from consistent naming conventions and appropriate data structures to proper resource handling and logging—to help developers write cleaner, more efficient, and more maintainable code.
This article presents ten advanced Python techniques—including assertions, interactive debugging, profiling, comprehensions, efficient data structures, caching, NumPy vectorization, parallel processing, and appropriate storage choices—to help developers improve code quality and execution speed.
This article explains what WebAssembly is, why it is needed for high‑performance web applications, how it works internally, which languages can target it, typical use cases, and provides practical examples of loading and using WebAssembly modules in browsers and Node.js.
This article examines several Java deduplication techniques—including List.contains, HashSet, double-loop removal, and Stream.distinct—by providing sample code, measuring execution time on a 20,000‑element list, and analyzing their time complexities to guide developers toward efficient duplicate‑removal strategies.
This article explains how MySQL 8.0 updates the AUTO_INCREMENT column in INFORMATION_SCHEMA.TABLES, describes the underlying statistics caching mechanism, shows how the information_schema_stats_expiry parameter controls refresh frequency, and provides step‑by‑step tests demonstrating real‑time behavior with code examples.
