This article shares the JD developer’s experience at the 2025 Huawei Developer Conference, detailing how the Cangjie language and a dual‑thread architecture were used to analyze and optimize high‑frequency JS API calls in JD mini‑programs on HarmonyOS, achieving up to 50% faster execution and a 20% reduction in cold‑start time.
This article explains the architecture, core thread responsibilities, and performance enhancements of the Skyline rendering engine for WeChat Mini Programs, detailing version support, multi‑threaded design, custom routing, snapshot and lazy‑mount features, and provides practical code examples for developers.
The latest SPL update introduces powerful operators like pack-fields, log-to-metric, and metric-to-metric, delivering dramatic performance gains, richer data transformation capabilities, and enhanced observability for cloud‑native log processing pipelines.
This article surveys how seventeen leading technology companies—from Uber and Netflix to Google and Capital One—have adopted Golang for backend services, micro‑services, and infrastructure, highlighting the performance gains, cost savings, and developer productivity improvements that make Go a strategic choice across diverse industries.
The article explores why architects at leading tech firms command six‑figure salaries while those in traditional companies earn far less, highlighting gaps in technical depth, massive data handling, performance optimization, business insight, continuous learning, and the scarcity of true senior architects.
This comprehensive guide explains why batch processing is essential, walks through typical banking, e‑commerce, logging and medical data scenarios, details Spring Batch's core architecture and components, provides step‑by‑step setup and code examples, and presents a production‑grade bank reconciliation case with monitoring and troubleshooting tips.
This article explains why quantizing massive AI models is essential for deploying them on resource‑constrained devices, outlines core quantization concepts, techniques, and methods, compares their pros and cons, and presents practical application scenarios such as smartphones, autonomous driving, IoT, and edge computing.
This article walks through optimizing a 60,000‑row XML‑to‑MySQL import by profiling the environment, measuring baseline performance, and applying JDBC batch rewriting, write aggregation, and asynchronous writes with LMAX Disruptor, ultimately reducing execution time from 300 seconds to about four seconds while keeping memory usage reasonable.
Despite the hype around Flink and AI models, Spark 4.0’s release brings a lightweight Python client, Spark Connect GA, enhanced SQL optimization, vectorized execution, and AI integration, reaffirming its leading position in the big‑data ecosystem while hinting at future challenges and innovations.
This article details a high‑performance, cross‑platform HarmonyOS mini‑program development practice that analyzes architecture, identifies JS API bottlenecks, demonstrates a step‑by‑step API call breakdown, and shows how the Cangjie language reduces getSystemInfo latency by over 50% while improving overall startup speed.
This article shares the author's experience at the 2025 Huawei Developer Conference, detailing how the JD.com mini-program team leveraged the Cangjie language to analyze and optimize API calls, reduce main-thread load, and achieve up to 50% faster getSystemInfo execution on HarmonyOS.
At the 2025 Huawei Developer Conference, JD’s team demonstrated how integrating the Cangjie language into HarmonyOS mini‑programs can halve API execution time, reduce main‑thread load, and improve cold‑start performance by over 20%, offering a high‑performance, cross‑platform development solution.
This article explores the pain points of a 700‑million‑row MySQL order table, presents vertical and horizontal sharding strategies, introduces gene‑based Snowflake IDs, details routing logic, migration steps, common pitfalls, and shows performance gains after applying the final architecture.
After noticing API endpoints taking up to a second, the author discovered that misusing FastAPI's Depends() with a get_db() function that recreated the database engine on each request caused severe latency, and by refactoring get_db() into a proper generator that reuses a single engine, response times were roughly halved.
Facing the challenge of moving 15 billion image files from Cassandra to S3, we iteratively redesigned the migration pipeline—from a single‑process approach to multi‑process, queue‑driven, and multi‑cluster deployments—reducing the projected 120‑day effort to just 40 days while ensuring reliability and performance.
This article details the end‑to‑end process of researching, adapting third‑party and custom plugins, recompiling, and testing the Zhiyinlou desktop client as it migrated from Electron 15 to the latest stable 29, highlighting challenges, solutions, and performance gains.
This article presents ten practical rules for designing database indexes—covering business‑scenario analysis, the left‑most prefix principle, avoiding over‑indexing, using covering indexes, data‑type choices, function traps, prefix indexes, NULL handling, maintenance scripts, and monitoring—each illustrated with SQL examples, diagrams, and real‑world performance gains.
This article explains why traditional large‑file uploads fail, introduces the benefits of chunked uploading, and provides a complete Spring Boot implementation—including backend controllers, high‑performance merging, Vue front‑end code, enterprise‑level optimizations, performance benchmarks, and best‑practice recommendations—for building a robust, resumable file transfer solution.
The article chronicles Xavier Xia’s iterative patches to the Linux kernel’s contpte_ptep_get() function, showing how early‑exit logic and subsequent refinements ultimately yielded consistent performance gains across diverse dirty/young page table scenarios, backed by benchmark data that convinced skeptical reviewers.
This guide explains how Nginx implements both client‑side (strong and negotiated) caching and server‑side proxy caching, detailing HTTP headers, cache control directives, and practical configuration examples for enabling, tuning, and troubleshooting Nginx cache behavior.
This article details the design, technology choices, functional modules, core implementation, performance optimizations, and future roadmap of Ops‑Nexus, an AI‑driven intelligent operations platform that streamlines alarm analysis, log processing, and host health checks for large‑scale monitoring environments.
This article explains the core principles of TCP's retransmission mechanisms, outlines four common strategies, discusses how high retransmission rates indicate network or server issues, and provides practical methods for test engineers to diagnose, monitor, and optimize TCP reliability in performance testing scenarios.
This article traces the evolution of Linux I/O from blocking and non‑blocking models through epoll to the modern io_uring framework, explains its design goals, core concepts, system‑call workflow, and provides practical code examples and performance comparisons for high‑concurrency network and storage applications.
Facing petabyte‑scale log traffic, the Qunar team identified low compression rates in their Kafka‑Filebeat pipeline as the main bottleneck and, through systematic tuning of batch size, memory queues, and round‑robin settings, achieved a 35% reduction in traffic and a 30‑42% drop in request volume while raising per‑minute throughput by 35%.
This article walks through Apache Doris’s lakehouse‑in‑one architecture, explains its core value and paradigm, details the system’s components and use cases, examines technical challenges such as file‑format diversity and I/O stability, and presents a suite of optimizations—from predicate push‑down and partition pruning to metadata caching and dynamic scheduling—that dramatically improve query performance and resource utilization, while also outlining future roadmap plans.
The article explains two simple yet powerful rules—"Push Ifs Up" and "Push Fors Down"—showing how moving condition checks out of functions and placing bulk processing loops later can reduce duplicated checks, improve readability, and unlock performance gains.
Facing rapid growth of the KuaiPin hiring platform, the team tackled labor‑intensive image and AIGC template creation by building the Fuxi Workbench, which automated template production, introduced D2C conversion, a DSL editor, and layered architecture, ultimately boosting efficiency, scalability, and stability while reducing costs dramatically.
This article delves into Go’s runtime, explaining the Goroutine scheduler’s G‑P‑M model and work‑stealing, the concurrent tri‑color garbage collector with its phases and tuning flags, the memory allocation hierarchy and escape analysis, and practical tips for high‑performance Go applications.
This article explains what Kafka message backlog is, its symptoms such as consumer latency and broker disk growth, and presents three practical solutions—expanding consumer instances, optimizing consumption logic, and increasing partition count—to effectively eliminate backlog and keep systems stable.
smart-mqtt v1.2.0 introduces async batch processing, smart resource management, and a refactored subscription model, and a three‑million‑reconnection stress test shows the broker remains stable under extreme network churn, with no packet loss, service interruption, or resource spikes.
This guide walks you through identifying MySQL bottlenecks, using EXPLAIN, optimizing indexes, rewriting queries, tuning configuration, applying architectural patterns, and learning from real‑world cases to dramatically speed up your database.
React MCP Server, an experimental addition to the React repository, bridges large language models with the React compilation toolchain via the MCP protocol, offering AI‑driven compile optimization and documentation lookup, enabling automated performance tuning of components through a closed‑loop of compilation, measurement, and improvement.
This guide explains how to improve Spring Boot 3 applications by using Actuator for monitoring, enabling caching, optimizing database connections with HikariCP, and applying asynchronous request handling and tasks to achieve faster response times and better resource utilization.
This article details how the 星图 platform evolved from a monolithic customer‑service system into a modular, configurable backend architecture, covering its API management capabilities, process orchestration, caching strategies, JVM tuning, concurrency model, code optimizations, and the resulting performance gains and business benefits.
This comprehensive guide walks you through installing and configuring Nginx, implementing access control, setting up virtual hosts, building a complete LNMP stack with MySQL and PHP‑FPM, applying performance optimizations, hardening security, and establishing monitoring for high‑performance web services.
ovCompose is a newly released cross‑platform framework that fully supports HarmonyOS, Android, and iOS, leveraging Kotlin Multiplatform and the native‑focused KuiklyBase to deliver native‑level performance, unified UI rendering, advanced memory and GC optimizations, and a rich component ecosystem, with open‑source repositories for community collaboration.
This article walks through real‑world high‑concurrency Linux network bottlenecks, explains critical kernel parameters, shows how to diagnose connection‑state issues, and provides step‑by‑step sysctl and script tweaks that dramatically reduce TIME_WAIT buildup, expand queue capacities, and double throughput for millions of simultaneous connections.
This article introduces ovCompose and KuiklyBase, Tencent Video's cross‑platform development framework built on Compose Multiplatform, explains the background, key advantages, implementation details, performance optimizations for Android, iOS and HarmonyOS, provides repository information and outlines future plans.
Optimizing Python is challenging due to its dynamic nature, but various strategies—from using NumPy, Numba, and Cython to upcoming CPython enhancements like adaptive specialization, JIT, and GIL‑free versions—show promise for improving performance while preserving the language’s flexibility.
Zhihu’s evolving data architecture transitioned from a single MySQL setup to a heterogeneous ecosystem of SQL, NoSQL, and graph databases, ultimately adopting OceanBase for its multi‑tenant, high‑compression capabilities, supported by tools like OMS, OCP, and ob‑operator to achieve cost savings, performance gains, and robust operations.
The article explains what Elasticsearch coordinating nodes are, why dedicated coordinating‑only nodes can off‑load HTTP handling from data and master nodes to reduce load, lower latency and simplify client configuration, and outlines the associated hardware and cluster‑state costs, usage scenarios, deployment steps and monitoring tips.
Kuikly, Tencent’s Kotlin Multiplatform‑based cross‑platform framework, has been extended to support HarmonyOS with native performance, offering Compose DSL, high‑performance rendering, Kotlin Native adaptation, debugging tools, and detailed optimization strategies that achieve near‑native speed and dynamic UI capabilities across Android, iOS, Web, and mini‑programs.
This article details WeChat's migration of large‑scale big data and AI workloads to a cloud‑native Kubernetes platform, discussing performance bottlenecks, API server and ETCD overload protection, scheduler enhancements, observability solutions, resource utilization gains, and future serverless directions.
This article explains how removing unnecessary else clauses and using early return guard statements can streamline JavaScript functions, reduce nesting, cut condition checks, and improve execution speed, illustrated with before-and-after code examples and best‑practice guidelines for loops and async operations.
This article outlines six practical PHP performance optimization techniques—including opcode caching, database query tuning, reducing redundant calculations, choosing efficient data structures, employing lazy loading, and leveraging built‑in functions—to help developers significantly improve the speed and scalability of their backend applications.
This article explains how to assess MySQL table size from table capacity, disk usage, and instance limits, describes why large tables degrade performance due to B+‑tree depth, and presents three practical solutions—partitioning, sharding, and hot‑cold archiving—to improve query speed and manage growth.
This article explains the hardware basis of NUMA, how Linux reads ACPI SRAT and SLIT tables to discover CPU‑memory topology, the kernel functions that initialize NUMA structures, and how the memblock allocator incorporates this information to enable performance‑optimizing tools like numactl.
This guide presents practical, cross‑industry techniques for advancing embedded software engineers, covering deep memory‑management practices, cache and compiler tuning, real‑time analysis, RTOS kernel customization, security hardening, layered architecture design, and power‑saving strategies such as DVFS and tickless idle.
Discover twelve practical SpringBoot performance optimization techniques—from connection pool tuning and JVM memory settings to caching, async processing, and full‑stack monitoring—each illustrated with code snippets and actionable guidance to prevent full‑table scans, OOM errors, and latency spikes in high‑traffic applications.
This article examines a real‑world MySQL master‑slave replication lag issue caused by massive multi‑table transactions during a sharding operation, details the investigative steps using system tables, binlog parsing, and my2sql analysis, and proposes three practical mitigation strategies.
This article details the evolution of a fast‑growing e‑commerce finance platform from a monolithic microservice architecture plagued by data inconsistency, low processing efficiency, and scalability limits to a robust, distributed big‑data warehouse using SparkSQL, layered data models, and optimized scheduling, achieving ten‑fold performance gains and near‑zero failure rates.
This article analyses why Spring Boot startup can take dozens of seconds, breaks down the most time‑consuming phases such as prepareEnvironment and refreshContext, shows profiling code and screenshots, compares a simple MVC demo with a real‑world project, and identifies external client connections and configuration loading as the biggest bottlenecks.
The article examines the rapid growth of unstructured data, explains the fundamentals and resource‑intensive nature of vector retrieval, presents Ant Group’s engineering practices—including hybrid HNSW‑DiskANN indexing, performance tricks like BSA pruning and memory prefetching, sparse‑vector and feedback‑driven recall improvements—and outlines the open‑source VSAG roadmap and ecosystem integrations.
LoongCollector, the 2025 evolution of iLogtail, delivers a comprehensive overhaul of log collection with high‑performance C++/Go pipelines, dynamic plugin combos, hot‑reload isolation, adaptive network throttling, enhanced tag handling, seamless migration, and robust monitoring for cloud‑native environments, achieving up to 80% higher throughput while cutting CPU usage by 35% and memory by 10%.
This article provides a comprehensive guide to Elasticsearch index architecture, covering fundamental concepts, index mapping, field types, alias usage, shard and replica strategies, shard planning, resource impact, and practical recommendations for optimizing performance and stability in production environments.
This article provides a detailed technical walkthrough of the DSearch search engine evolution, covering the RCU‑based 1.0 index architecture, the segment‑merge enhancements in 2.0, and the async non‑blocking graph framework introduced in 3.0, together with performance benchmarks and implementation details.
This article explains how to measure, analyze, and improve CPU usage in software by examining key metrics, choosing efficient algorithms and data structures, leveraging compiler options, exploiting cache behavior and SIMD vectorization, and applying practical case studies with Linux profiling tools.
This article provides a comprehensive overview of NGINX, covering its architecture, module types, multi‑process event model, FastCGI integration for PHP, configuration best practices, performance optimizations, error troubleshooting, and a notable security vulnerability.
This article presents ten practical SQL optimization techniques—including replacing DISTINCT with GROUP BY, using UNION ALL instead of OR, avoiding functions on indexed columns, leveraging EXISTS over IN, creating covering indexes, partitioning large tables, and more—each illustrated with before-and-after code examples to dramatically improve query speed and reduce server load.
This article walks through Nginx's role as a high‑performance reverse proxy and load balancer, explains core concepts, provides step‑by‑step configuration examples—including upstream pools, server blocks, and location directives—and details performance optimizations such as gzip, connection reuse, worker settings, static‑file caching, and proxy caching.
The article describes how a large‑scale dispatch system was re‑engineered with NVIDIA TritonServer to unify GPU‑accelerated operations‑research kernels and deep‑learning models, detailing a three‑stage architecture (in‑process, cross‑process, cross‑node), the performance, stability and memory challenges addressed, and future plans for heterogeneous GPU scaling.
This article provides an in‑depth overview of CPU performance metrics, practical optimization techniques—including algorithm selection, compiler flags, cache‑aware programming, and vectorization—along with real‑world case studies and a detailed survey of Linux profiling and analysis tools for developers.
This guide walks you through cross‑platform environment variable configuration, Docker containerization, GPU resource strategies, concurrency tuning, and security hardening for Ollama, providing practical code snippets and best‑practice tables to unleash its full potential in development and production.
This comprehensive guide explores Nginx’s core functionalities, detailing forward and reverse proxy concepts, deployment procedures, configuration parameters, security hardening, rewrite module intricacies, performance optimization, and cloud‑native integration, while offering practical code examples and comparative analysis for real‑world scenarios.
Tencent open-sources Kuikly, a Kotlin Multiplatform framework used in 15+ apps with billion daily PVs, achieving native performance via two-tree rendering and declarative DSL while supporting dynamic updates across Android, iOS, HarmonyOS, Web, and mini-programs.
This article presents practical Python performance optimization techniques, covering principles such as avoiding premature optimization, reducing global variables, minimizing attribute access, eliminating unnecessary abstractions, avoiding data copying, using efficient string concatenation, leveraging short‑circuit logic, loop optimizations, JIT compilation with Numba, and selecting appropriate data structures.
The article outlines seven practical performance‑optimization techniques for high‑throughput back‑ends—including replacing protobuf with native C++ classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc, implementing lock‑free double buffers, simplifying structs for specific scenarios, and leveraging profiling tools—while stressing balanced, incremental improvements.
This article presents ten practical Hive SQL scenarios—including window functions for ranking, LAG for time‑interval analysis, random‑salt techniques to mitigate data skew, dynamic partition writes, JSON parsing with UDFs, retention calculations, consecutive‑login detection, regex‑based path analysis, CUBE multi‑dimensional aggregation, and ORC storage optimizations—each accompanied by optimization tips and complete code examples.
Facing massive query latency, deadlocks and costly vertical scaling, our team abandoned a textbook‑perfect PostgreSQL setup, tried extensive SQL optimizations, added Redis caching and read replicas, and finally migrated critical order services to MongoDB, achieving five‑fold capacity, zero downtime and significant cost savings.
This article analyzes the evolution of distributed storage—from traditional compute‑storage separation to edge‑centric, AI‑enabled architectures—covering service models, key technologies such as CXL and erasure coding, reliability strategies, performance optimizations, vendor landscapes, and emerging green and intelligent trends.
This article provides a comprehensive guide to Elasticsearch index concepts, covering index definitions, alias usage, mapping and field types, shard architecture, and practical recommendations for planning shards and optimizing resource consumption to ensure stable and efficient ES clusters.
This article presents a comprehensive collection of practical PHP performance optimization methods—including code-level improvements, database query tuning, caching strategies, memory management, file operation reductions, profiling tools, and miscellaneous tips—to help developers build faster, more efficient web applications.
In this interview-style article, the interviewer probes a candidate on why Redis is exceptionally fast, covering its in‑memory storage, single‑threaded design, I/O multiplexing, optimized data structures, memory management tricks, and practical performance‑tuning strategies.
In 2024 DGraph upgraded its architecture by splitting single clusters into multiple business‑specific clusters, adopting a sharded active‑active topology, and replacing its 1:N thread‑pool with an M:N grouped execution model that uses atomic scheduling, while parallelizing FlatBuffer encoding, streamlining SDK conversions, adding DAG debugging, timeline analysis, and dynamic sub‑graph templates to boost scalability, stability and developer productivity.
This article explains how Python's eager import mechanism can cause startup delays in large projects and demonstrates various lazy import techniques—including function-level imports, custom LazyLoader classes, standard library LazyLoader, and context manager approaches—to improve startup performance and reduce memory usage, supported by benchmark data and best‑practice recommendations.
This guide explains how to use Android's Monkey tool with advanced options such as package whitelists and blacklists, event‑type weighting, crash ignoring, throttle settings, seed values, and integration with systrace to achieve more precise, efficient, and repeatable mobile app testing.
This article details a real‑world case where massive multi‑line log volumes overwhelmed iLogtail, explains the performance bottlenecks caused by full‑line regex matching, describes the switch to prefix‑only matching and IngestProcessor, and shows how these changes lifted throughput from under 100 MB/s to over 300 MB/s while halving CPU usage.
This article explains how Web Workers can dramatically improve frontend performance by offloading heavy computations from the main thread, detailing their benefits, common misconceptions, practical use cases like data processing and image filtering, and providing a concrete code example for real‑world implementation.
Didi replaced its legacy agent with Alibaba’s open‑source iLogTail, re‑architected it to use a shared thread‑pool and SIMD‑accelerated parsing, rewrote critical plugins in C++ and added robust Kafka retry logic, achieving over twice the throughput while cutting CPU usage by more than half and maintaining near‑zero latency at massive scale.
JD Logistics transformed its one‑stop self‑service analytics platform, UData, by migrating from an integrated storage‑compute architecture to a storage‑compute separated design powered by StarRocks, achieving sub‑10‑second P95/P99 query latency, reducing storage costs by 90%, and cutting compute expenses around 30% while supporting massive data volumes.
This article details the architectural overhaul of iLogtail into LoongCollector, explains why generalization caused a 15% performance drop, and walks through four systematic optimizations—including memory arenas, eliminating shared_ptr, event pooling, and direct serialization—that ultimately restored and doubled log‑collection throughput.
PageCache is an operating‑system mechanism that uses physical memory to cache disk blocks, dynamically resizing with available RAM and employing LRU replacement and read‑ahead, turning slow storage accesses into fast memory reads, yielding up to twenty‑fold speed gains for tasks such as compilation, video editing, and database operations.
This comprehensive tutorial covers Python string fundamentals, including creation, indexing, slicing, common methods, formatting, encoding, regular expressions, performance optimizations, and real‑world examples, providing practical code snippets to enhance text processing efficiency for developers.
By replacing the legacy FLV recorder with an m3u8‑based service, introducing a short‑segment, state‑machine transcoder, and deploying an event‑driven proxy and instant‑clipping UI, the team cut the 4‑hour‑40‑minute Spring Festival Gala’s live‑to‑VOD processing from 41 minutes to about eight minutes, achieving roughly a five‑fold speedup.
This article explains why Java performance matters, outlines fundamental principles, and provides concrete code, memory, concurrency, I/O, and database optimization techniques, along with profiling tools, common pitfalls, real‑world case studies, and emerging trends to help developers build faster, more stable applications.
This article examines the most frequent Redis performance bottlenecks—including high memory usage, network latency, misconfiguration, poor data‑structure choices, and suboptimal persistence—explains why they occur, and provides concrete optimization techniques, monitoring commands, real‑world case studies, and emerging trends to keep your cache fast and stable.
This article compiles the most frequently asked Redis interview questions, covering fundamentals, data structures, persistence mechanisms, high‑availability features, clustering, performance tuning, and troubleshooting, providing clear explanations and practical guidance to help candidates confidently tackle any Redis interview.
This comprehensive guide presents Python coding principles, practical conventions, library usage, design patterns, internal mechanisms, tooling for project development, and performance profiling techniques to help developers write clean, efficient, and maintainable code.
This article describes how Tubi improved the latency of its Redis‑backed online feature store for machine‑learning inference by analyzing query patterns, measuring client‑side bottlenecks, and applying optimizations such as binary Avro encoding, MGET usage, virtual partitioning, and parallel deserialization to meet a sub‑10 ms SLA.
Gaode Map’s new integrated container architecture, combined with on‑demand loading, package slimming, and multi‑system/device/language support, delivers ultra‑stable, high‑availability navigation with second‑level startup, halved binary size and traffic, enabling efficient, cross‑platform mobile mapping for diverse hardware.
This article introduces Java’s emerging Vector API, explains its SIMD‑based design, provides practical code examples for array addition, dot product, and complex calculations, and details performance benchmarks, integration with vector databases, usage considerations, and future development prospects.
This article walks through the One Billion Row Challenge, explaining the problem, baseline Java solution, and a series of deep performance optimizations—from parallel streams and custom hash tables to unsafe memory access and SIMD techniques—that shrink execution time from minutes to under two seconds.
Learn how to replace traditional, resource‑heavy infinite scroll implementations with a concise seven‑line JavaScript solution that leverages IntersectionObserver, DOM recycling, state locking, and lazy image loading, delivering dramatically lower CPU and memory usage while boosting frame rates to smooth 60 fps experiences.
The article summarizes Zhihu's machine‑learning platform lead Wang Xin's presentation on the ZhiLight large‑model inference framework, covering model execution mechanisms, GPU workload analysis, pipeline and tensor parallelism, GPU architecture evolution, open‑source engine comparisons, ZhiLight's compute‑communication overlap and quantization optimizations, benchmark results, supported models, and future directions.
The article explains how CPU computation latency arises from memory speed, bandwidth, and access delays, detailing the relationships among memory, bandwidth, and latency, and examines key factors such as clock frequency, pipelining, parallelism, cache hit rate, and signal propagation distances that together determine overall system performance.
Optimizing PHP applications involves a combination of code-level improvements—such as caching, efficient algorithms, and query optimization—and server-side configurations like upgrading PHP, enabling opcode caches, tuning web servers, and leveraging CDNs, along with monitoring tools and asynchronous processing to achieve faster, more scalable performance.
This article explains three.js shadow‑mapping mechanisms, compares shadow types, and provides concrete code‑level optimizations for global and ground shadows that improve visual quality while keeping performance suitable for mobile web applications.
This article explains the challenges of storing and serving trillion‑level count data for a massive micro‑blogging platform and presents a step‑by‑step backend design that evolves from simple MySQL tables to sharded databases, Redis caching, message‑queue write‑sharding, and memory‑efficient custom data structures to achieve high performance, low cost, and strong consistency.
This article analyzes eBPF tracing hook mechanisms—kprobe, tracepoint/raw_tp, and fentry—explaining their implementation, performance trade‑offs, kernel version support, and benchmark results, to guide developers in choosing the most efficient hook for production workloads.
This article explains how Linux’s real‑time scheduler works, covering the underlying concepts, key kernel data structures such as rt_rq and rt_prio_array, the SCHED_FIFO and SCHED_RR policies, practical code examples, configuration APIs, and optimization tips for industrial and multimedia applications.
