This article demonstrates how compiling OpenCV 3.2 with CUDA 8.0 enables GPU‑accelerated template matching in Python, reducing average processing time from 0.299 seconds on CPU to 0.181 seconds on GPU—a 39.4% performance gain for automated testing image‑recognition APIs.
This article explains how to compile OpenCV‑Python with CUDA support to speed up image template matching, compares CPU and GPU execution times, and shows a practical Python example demonstrating a 39.4% performance improvement using OpenCV 3.2.0 and CUDA 8.0.
This article introduces the fundamentals of time‑series databases, explains why InfluxDB was chosen, describes the TSM storage engine and shard concepts, outlines the internal 360 InfluxDB‑HA architecture, compares its performance with a single node, and provides integration and future‑development guidelines.
The IntelliJ IDEA 2019.3 update brings faster startup, reduced memory usage, enhanced UI responsiveness, support for new microservice frameworks like Micronaut, Quarkus, Helidon, added MongoDB integration, numerous quality improvements, and a host of important bug fixes across platforms.
IntelliJ IDEA 2019.3 has been officially released, delivering faster startup, reduced memory usage, enhanced UI responsiveness, dynamic plugin installation, expanded support for modern micro‑service frameworks like Micronaut, Quarkus, Helidon, and the long‑awaited MongoDB integration, along with numerous bug fixes and quality improvements.
This article analyzes a use‑case where each user must keep up to 10,000 historical IDs, compares two Redis‑based implementations—using a List and a String—by presenting code samples and benchmark results, and explains why understanding underlying data structures can dramatically improve performance.
This article explains how React's virtual DOM and diff algorithm work, identifies situations where renders become costly, and presents practical techniques such as shouldComponentUpdate, PureComponent, higher‑order components, React.memo, and component splitting to reduce unnecessary renders and improve front‑end performance.
A Java service suffered near‑100% CPU usage because a URL‑validation regular expression caused catastrophic backtracking, and the article explains the NFA engine behavior, identifies the regex flaws, and shows how to rewrite the pattern with possessive quantifiers to dramatically improve performance.
This article examines four common database architecture patterns—primary‑standby, dual‑primary, master‑slave read/write separation, and a hybrid dual‑primary + master‑slave—evaluating each against high availability, performance, consistency, and scalability, and then presents practical consistency‑resolution techniques and cache strategies.
This article provides comprehensive best‑practice guidelines for using Redis, covering data classification, key naming, size and connection limits, cache TTL, recommended client‑hash sharding, and a strict list of prohibited commands and operations to ensure performance, reliability, and maintainability.
This article explains how to use MySQL's EXPLAIN command, describes each column in its output—including id, select_type, table, type, possible_keys, key, key_len, ref, rows, filtered, and Extra—provides syntax examples, discusses join type rankings, and outlines the command's limitations for query performance analysis.
This guide walks you through a systematic, step‑by‑step process for diagnosing and resolving poor‑performance or failure incidents on Linux servers, covering everything from gathering context and checking who is logged in to inspecting processes, network services, hardware, I/O, logs, cron jobs and application‑level diagnostics.
This article presents a detailed case study of intermittent container timeout problems in a Kubernetes environment, examining kernel upgrades, NUMA configurations, CPU affinity bindings, kubelet behavior, cadvisor overhead, and hardware faults, and outlines the investigative steps and solutions applied.
This article investigates the implementation of Java's System.currentTimeMillis() on Windows, macOS, and Linux, measures its execution speed, explores the underlying native methods and OS time‑source mechanisms such as TSC, HPET, and RTC, and discusses performance implications and best practices for high‑frequency timestamp retrieval.
This article examines the architectural design of flash‑sale (seckill) systems, covering high performance through dynamic‑static separation, hotspot optimization, consistency handling for inventory deduction, and high‑availability techniques such as traffic shaping, queuing, and fallback plans.
This article introduces Xiaomi's open‑source SOAR tool, explains how to download and install the binary or source versions, walks through quick‑start commands, details key YAML configuration options and output formats, and describes four typical usage scenarios for SQL optimization and rewriting.
This article provides a detailed comparison between ARM's RISC-based processors and Intel's CISC‑based x86 CPUs, covering design philosophies, performance, power consumption, expansion capabilities, operating‑system compatibility, software development tools, cost factors, and suitable application scenarios.
This weekly roundup highlights advanced frontend topics, including an in‑depth analysis of Promise micro‑tasks, a translation on Intersection Observer usage, an overview of browser fingerprinting techniques, the current state and future of modern web development, V8’s JavaScript execution pipeline, and Node.js applications at WeDoctor.
The article details how Ctrip engineers diagnosed sporadic Redis timeouts in containerized deployments, traced the problem to kernel scheduling delays caused by an APIC‑ID bug that inflated the possible‑CPU count, and resolved it by applying a kernel patch, offering verification steps for affected systems.
This article describes how the M page’s user‑perceived performance was dramatically improved by applying techniques such as SSR, skeleton screens, image compression, and a video‑frame analysis testing method that delivers millisecond‑level response‑time measurements, enabling sub‑second load times and eliminating white‑screen delays.
This article explains how IO and CPU bottlenecks increase active database connections, describes horizontal and vertical sharding techniques, outlines practical steps and tools for implementing sharding, and discusses common challenges such as non‑partition key queries and expansion strategies.
At a Shenzhen Elastic Community meetup, ByteDance senior engineer Huang Yangfeng detailed how his team built an Elasticsearch service platform on Kubernetes—addressing isolation and performance‑analysis challenges, outlining a roadmap for cross‑region recovery, monitoring, and automation, and sharing insights on ecosystem growth and community needs.
This article explains the differences between Java's ArrayList and LinkedList, detailing their internal implementations, performance characteristics for adding, inserting, deleting, and iterating elements, and provides code examples and benchmark results to guide when to choose each collection.
This article explains how Java's HashMap stores key‑value pairs, details the hash calculation, index mapping, collision handling via linked lists, the role of load factor, resizing mechanics, and provides annotated source code for core methods such as put, get, and internal Entry class.
This article analyzes the limitations of native Twemproxy, describes how Nginx's master‑worker multi‑process model and related Linux kernel features were integrated to create a high‑performance, highly available cache proxy, and presents extensive online and benchmark results showing significant latency and QPS improvements.
The article explains how modern servers with multiple CPUs and memory modules connect via legacy Front Side Bus and modern NUMA architectures, demonstrates Linux commands to inspect memory topology, and presents benchmark results showing latency differences between intra‑node and inter‑node memory accesses.
The article outlines how integrating CheckStyle, Lint, and FindBugs with a custom Gradle plugin, applying full‑scan optimizations to collect only necessary source and class files and implementing incremental scans that target only files changed in a PR, cuts Android CI static‑analysis time by over 50 %, dropping full scans from nine to five minutes and enabling sub‑minute incremental checks.
The article presents a bytecode‑generation technique that creates dynamic wrapper classes to invoke arbitrary Java methods with near‑native speed, avoiding reflection’s overhead, and details the CallerWrap base, generator, and thread‑safe cache implementation that together enable high‑performance middleware calls.
This article explains how Amap (Gaode) handles billions of daily requests with sub‑millisecond latency by redesigning its gateway layer, adopting full‑asynchronous pipeline architecture, leveraging reactive frameworks like Vert.x and WebFlux, aggregating APIs, and implementing a unit‑based routing solution that paves the way for distributed sidecar and service‑mesh deployments.
To handle the massive memory and CPU demands of modern front‑end map annotations, the article explains JavaScript’s stack‑heap model, object hash‑table storage, and the trade‑offs of plain arrays, TypedArray, DataView, and SharedArrayBuffer, showing that contiguous memory structures and Web‑Worker off‑loading dramatically improve performance and reduce allocations.
This article explains how V8’s compiler, garbage collector, and a bug‑inspired optimization improve async/await performance across Node.js versions, detailing benchmark results, code behavior differences, and the engine’s internal steps for handling await.
This article explains how to optimize Spring Boot applications by adjusting configuration properties and JVM parameters, provides essential Tomcat settings, demonstrates practical tuning steps with and without IDE support, and details the meaning of common JVM flags for improved performance.
This article explains how Linux reports CPU usage with tools like top, the meaning of the fields in /proc/stat, how utilization percentages are calculated, the concepts of run queues, load average, context switching, multi‑core scheduling, and how to use perf and taskset for deeper performance analysis.
This article provides a comprehensive overview of the HTTP/2 protocol, explaining its binary framing, multiplexing, header compression, request prioritization, and server push features, and offers step‑by‑step guidance for upgrading Nginx to support HTTP/2 along with detection methods.
Vue 3 introduces substantial performance gains, a smaller bundle size, tree‑shakable global APIs, a proxy‑based reactivity system, and experimental time‑slicing features, all of which make modern, mobile‑first web development faster and more efficient.
This article provides a comprehensive guide to caching technologies, covering HTTP caching, CDN caching, load‑balancer caching, in‑process caching, and distributed caching, while explaining strategies, algorithms, and common pitfalls such as cache avalanche, penetration, and breakdown.
This article explains various Flutter image loading techniques—including AssetImage, NetworkImage, FileImage, MemoryImage, CachedNetworkImage, and FadeInImage—provides detailed source code analysis of the Image widget and its underlying classes, and discusses performance considerations and potential optimization strategies.
This weekly community newsletter highlights the open‑source launch of the TXLE distributed transaction framework, DBLE user meetups, deep dives into MySQL slow‑query analysis and EXPLAIN ANALYZE, recent DBLE feature developments, bug fixes, community Q&A, and a preview of next week's technical plans.
This article presents fifteen practical Java backend coding guidelines—including avoiding "where 1=1" in MyBatis, iterating Map entrySet, using Collection.isEmpty, pre‑sizing collections, employing StringBuilder, preferring Set for contains checks, initializing static members correctly, removing dead code, shielding utility constructors, eliminating redundant catches, using String.valueOf, avoiding BigDecimal(double), returning empty collections, calling equals on constants, securing enum fields, and escaping regex in split—each illustrated with bad and good code examples to improve readability, safety, and efficiency.
A detailed DBA interview walks through the diagnosis of excessive Oracle RAC GC wait events, revealing that cross‑instance queries, network latency, NIC bonding mode, and unbalanced IRQ handling together caused the slowdown, and shows step‑by‑step fixes that finally eliminated the problem.
The article explains how MySQL 8.0 introduced the instant algorithm for adding columns, compares it with older copy and inplace‑rebuild methods, shows usage examples, performance test results, and outlines the restrictions and version differences of this fast DDL operation.
This article explains the seven Java garbage collectors available up to JDK 1.8, compares their strengths and weaknesses, and shows how to select and tune the appropriate collector—Serial, Parallel, CMS, or G1—based on application characteristics and deployment environments.
The weekly roundup presents concise, actionable articles on font fundamentals, building an AST for arithmetic expressions, cyclomatic complexity metrics, the evolution from HTTP/2 to HTTP/3, native image lazy‑loading, and an overview of CSS Level‑4 selectors, all aimed at front‑end engineers.
The article explains why creating and destroying threads directly is inefficient and risky for high‑traffic services, then introduces thread pools as a solution, detailing four common pool types with code examples, their advantages, limitations, and overall impact on system performance.
qrpc is a lightweight, high‑performance RPC framework that adopts gRPC's streaming and bidirectional concepts without HTTP/2, offering a smaller binary, lower memory usage, up to three‑fold throughput gains, and flexible modes such as blocking, non‑blocking, streaming, push, and bidirectional calls, all demonstrated with Go code examples and real‑world use cases.
This article details the redesign of Tokio's Rust async scheduler, describing its new task system, queue algorithms, task‑stealing strategy, reduced synchronization, memory‑allocation optimizations, Loom‑based concurrency testing, and the resulting ten‑fold performance gains in benchmarks and real‑world workloads.
This article examines C's unmatched hardware efficiency, its safety trade‑offs, the rise of higher‑level languages focused on developer productivity, and why C remains essential for embedded, real‑time, and AI systems despite shifting popularity trends.
This article explains the Serverless architecture, its advantages for front‑end developers, showcases Tencent Education’s Serverless design, discusses its use in educational services, and highlights current challenges such as cold‑start latency and state management, while offering insights from industry experts.
This article analyzes the MySQL slow query log in Percona 5.7, explaining how timestamps, execution time, lock time, and various log fields are derived from the source code, and clarifies the meaning of each output component for accurate performance debugging.
This article enumerates typical Java coding mistakes—such as using "where 1=1" in MyBatis, iterating Map inefficiently, neglecting Collection.isEmpty, omitting collection size hints, concatenating strings in loops, overusing List.contains, misusing static initializers, keeping redundant code, and more—while providing concise, performance‑oriented corrections with clear examples.
This article recounts Dropbox’s multi‑year effort to adopt static type checking with mypy across millions of Python lines, detailing why type checking is essential for large projects, the performance challenges encountered, and the engineering solutions—including incremental checks, a daemon, and a custom compiler—that enabled successful migration.
This article presents sixteen practical Java coding guidelines—ranging from avoiding "where 1=1" in MyBatis to using static blocks for collection initialization, preferring Set over List for contains checks, and returning empty collections instead of null—to help developers write more efficient, readable, and safe backend code.
This article dissects Netty's custom FastThreadLocal and FastThreadLocalThread implementations, showing how they replace JDK ThreadLocal with constant‑time indexed access, padding to avoid false sharing, and customizable initialization and cleanup to boost backend concurrency performance.
This article explains the MySQL Clone plugin introduced in version 8.0.17, describes its underlying mechanism, installation and execution steps, outlines usage constraints and scenarios, and presents a detailed performance comparison with LVM snapshots and Xtrabackup under various workloads.
This article explains why Redis is chosen for projects—highlighting its performance and concurrency benefits, detailing its data types, expiration and eviction policies, and offering solutions to common issues such as cache consistency, avalanche, penetration, and key‑competition.
A recent offline performance test of a Dubbo service revealed that enabling Logback’s default packageData option caused massive AladdinClassLoader lock contention, dramatically increasing response times, and the issue was fixed by upgrading Logback to a version where packageData is disabled by default.
This article compiles and translates the latest Chrome DevTools enhancements from versions 74 to 78, detailing new UI highlights, debugging shortcuts, performance metrics, service‑worker insights, and other practical tools that front‑end developers can immediately apply to improve their workflow.
This article analyzes why iOS apps experience long cold‑start times, explains the pre‑main and main launch phases, shows how to measure each stage using DYLD statistics and timestamp code, and provides concrete optimization strategies to reduce startup latency.
This article benchmarks Java 8 Stream against traditional for‑loops and parallel streams across three experiments—primitive array traversal, string list processing, and complex object reduction—using JUnitPerf to measure execution time and analyze when Stream offers real performance benefits.
This article explains why large numbers of active Python objects can cause memory problems and presents several techniques—including using dicts, class __slots__, namedtuple, recordclass, Cython, and NumPy—to shrink object size and dramatically lower memory consumption.
This article explores the pervasive role of caching in modern systems—from browser and HTTP caches to CDN, load‑balancer, in‑process, and distributed caches—detailing their mechanisms, algorithms, common pitfalls like cache avalanche, penetration and breakdown, and practical mitigation techniques for robust backend performance.
This article explains the differences between Java's HashMap and TreeMap, covering their underlying implementations, performance characteristics, ordering behavior, and how to use a custom comparator to achieve descending order, helping developers choose the appropriate map based on ordering and efficiency needs.
This article explains the concept of skeleton screens, demonstrates how to use the CSS :empty selector, and provides a step‑by‑step Vue implementation—including route‑aware class switching—to reduce white‑screen time on slow networks.
PostgreSQL 12 brings major enhancements—including up to 40% faster queries on large datasets, improved indexing, partitioning, JSON path queries, generated columns, pluggable table access methods, stronger authentication, and built‑in JIT compilation—while also adding better localization, multi‑constraint authorization, and convenient maintenance commands.
This article explores the maximum number of threads a Java Virtual Machine can support, examining factors such as CPU, operating system, JVM version, and memory, and presents real‑world experiments, code examples, and theoretical calculations to help developers understand and manage thread limits effectively.
Flutter Web re‑implements the dart:ui library using HTML, CSS, and Canvas, allowing Dart‑written Flutter apps to run in browsers without plugins; it follows a layered rendering approach, supports image, text, shape, and gesture handling, but currently suffers from large bundle sizes, incomplete feature support, and performance challenges in technical preview.
This article explains why Java’s String.hashCode method multiplies by 31, covering the mathematical derivation, prime‑number benefits, JVM optimization tricks, and experimental results that compare 31 with other multipliers on a large word list.
This article provides a comprehensive technical overview of MinIO, an open‑source, S3‑compatible object storage system, covering its design philosophy, data organization, distributed architecture, erasure‑coding, lock management, lambda notifications, backup strategies, performance optimizations, and a comparative analysis with Ceph, highlighting its suitability for AI, big‑data, and cloud‑native deployments.
This article examines the evolution from backend template engines to SPA, highlights SPA's SEO and first‑paint drawbacks, and presents a detailed Vue server‑side rendering implementation with optimization techniques, degradation strategies, and performance results showing over 300% faster first‑screen rendering.
This article explains what Linux load average measures, how to read the 1‑, 5‑, and 15‑minute values, what they indicate on single‑core and multi‑core systems, and which thresholds should raise alerts for system performance monitoring.
This article explains Go's garbage collection mechanism, describing its Mark‑Sweep model, the three collection phases, latency implications, and practical tips for reducing pause times through memory‑pressure reduction and runtime debugging tools.
This article provides a comprehensive MySQL replication FAQ covering cross‑OS and hardware compatibility, master‑slave connection behavior, monitoring lag, forcing master pause, bidirectional replication considerations, performance improvements, high‑availability setups, and how to exclude GRANT/REVOKE statements from replication.
This article demonstrates how to use MySQL Shell's util.import_table and util.import_json functions to import CSV and JSON data efficiently, compares their performance with the traditional mysqlimport tool, explains required options such as file path, schema, table, dialect, threading, and shows example sessions in both JavaScript and Python modes.
This article explains how multithreaded inserts into a MySQL table can be faster than single‑threaded inserts by reducing connection and parsing overhead, and it details techniques such as prepared statements, multi‑value inserts, and batch transaction commits to boost performance.
V8 Lite, introduced by the V8 team in late 2018, implements a series of memory‑saving techniques—such as lazy feedback allocation, delayed source positions, and bytecode flushing—that together can reduce heap usage by roughly 22% in memory‑constrained scenarios while maintaining acceptable execution performance.
An intriguing experiment shows that replacing a harmless "y += 0" with "y += 0.1f" makes a tight C++ loop run seven times faster, revealing how denormalized floating‑point numbers trigger costly CPU paths and how understanding IEEE‑754 representation can restore performance.
This article details Alibaba's experience deploying Kubernetes at massive scale, describing the performance bottlenecks encountered in etcd, API server, controller, and scheduler components, and presenting the concrete engineering improvements—such as storage sharding, lease‑based heartbeats, load‑balancing, watch bookmarks, and hot‑standby controllers—that enabled stable operation of clusters with tens of thousands of nodes.
This article explains MySQL thread fundamentals, distinguishes PID, LWP ID and Thread TID, shows a small C program to observe these IDs, demonstrates how to map MySQL threads to LWP IDs using system tools and SQL, and provides a step‑by‑step guide to set up a GDB‑based debugging environment on Linux.
By replacing the naïve DSL‑to‑Widget mapping with custom Widget, Element, and RenderObject classes that respect match_parent and match_content semantics and leverage RelayoutBoundary optimizations, the team reduced layout complexity from O(N²) to O(N), boosting long‑list frame rates from about 28 fps to roughly 50 fps while outlining further refinements.
This article explains how java.util.concurrent.atomic.LongAdder provides a more efficient counting mechanism than AtomicLong under high contention, discusses its trade‑offs in space and precision, presents JMH benchmark results, and walks through the internal implementation details such as cells, CAS loops, and hash‑based distribution.
This article explains the three-stage execution process of JavaScript in V8, compares interpreter and compiler approaches, describes how the JIT combines their strengths, and provides practical tips for writing JavaScript that maximizes performance by leveraging V8’s optimization mechanisms.
This guide walks you through essential Linux server monitoring tools—top, vmstat, pidstat, iostat, netstat, sar, and tcpdump—explaining each metric, how to interpret CPU, memory, disk, and network statistics, and offering practical tips for troubleshooting performance bottlenecks.
This article explores why Java faces challenges in the cloud‑native era, demonstrates how multi‑stage Docker builds, OpenJ9 shared class cache, and Micronaut‑GraalVM native compilation can dramatically reduce image size and cut startup time by up to 50 % while also lowering memory consumption.
Although both browsers receive identical data, Chrome and Firefox display sorted results differently due to their distinct underlying sorting algorithms—Firefox uses merge sort while Chrome employs a hybrid of insertion and quick sort—this article explains the issue, demonstrates implementations, and compares performance and optimization techniques.
This article recaps a hardcore Node.js underground salon where experts explored runtime optimization, V8 engine enhancements, Alinode monitoring, fork(2) performance tricks, and core startup processes, highlighting practical insights for Serverless, IoT, and high‑performance backend development.
This article documents a multi‑stage investigation of intermittent GitLab Runner build timeouts and hangs, describing the background, VM configuration, successive diagnostic steps using strace, iotop, perf, and storage‑driver adjustments, and concludes with performance test results and lessons learned.
This article details Meituan's end‑to‑end development of a merchant‑side mobile video feature, covering background needs, architecture design, technology selection, implementation of playback, recording, composition, cutting, processing pipelines, encountered pitfalls, monitoring strategies, and future optimization directions.
This article chronicles the architectural evolution of a web‑based mini‑program engine, detailing the challenges of sandboxing Vue, restricting unsafe tags, handling performance and native capability limits, and ultimately adopting a dual‑thread model to achieve security and control while preserving developer experience.
This article examines how design‑focused techniques such as preloading, non‑blocking scrolling, and efficient DOM recycling can dramatically improve the perceived responsiveness of infinite‑scroll lists, drawing on the Google RAIL model and user‑experience research.
This article examines Alibaba's practical use of Flutter, covering application adoption, infrastructure setup, SDK maturity, hybrid stack routing, iOS packaging scripts, monitoring, performance tuning, upgrade strategies, and a brief look at Flutter for Web, providing actionable insights for mobile developers.
This guide walks through diagnosing a Java portal's high CPU usage by checking system load, identifying the offending thread, analyzing JVM stack traces, pinpointing a slow MySQL query, and resolving the issue with data cleanup and index creation, reducing CPU load from 800% to 40%.
This article compiles essential Redis interview questions covering its advantages over Memcached, performance pitfalls, data structures, persistence options, clustering, scaling strategies, and practical usage patterns such as distributed locks and asynchronous queues, providing concise answers and best‑practice recommendations for each topic.
System.currentTimeMillis() appears fast but under heavy concurrent calls it becomes dramatically slower due to kernel‑mode time‑of‑day queries, and this article explains the root cause, shows benchmark results, and offers a cached‑timestamp solution to restore performance.
This guide shares practical experience and step‑by‑step solutions for migrating C/C++ and other language projects from x86 servers to ARM64 TaiShan platforms, covering compilation differences, code adjustments, compiler options, and performance tuning to achieve stable and efficient execution.
This article explains the fundamentals of CPUs, covering their core functions, internal components, operation stages, key performance metrics such as clock speed, multiplier and external frequency, as well as modern technologies like Turbo Boost, multi‑core, hyper‑threading, and the evolution of CISC and RISC architectures.
This article explains the structure and behavior of System.out.println in Java, covering the System class, the out field, println method, output redirection, performance implications, comparison with logging frameworks, static import shortcuts, and the related System.err and System.in streams.
This article explains the differences between structured, semi‑structured and unstructured data, walks through the evolution stages of relational database architectures, evaluates their advantages and drawbacks, and then compares major NoSQL families—KV, search, column‑oriented and document stores—to help engineers decide the right storage engine for their workloads.
This article analyzes Java 8 Stream API versus traditional iterator approaches across mapping, filtering, sorting, reduction, string concatenation and mixed operations, presenting benchmark results on various data sizes and offering practical recommendations for when to use streams, parallel streams, or iterators.
This article presents nineteen practical MySQL optimization methods—including using EXPLAIN, limiting IN clause size, specifying columns in SELECT, proper use of LIMIT, avoiding costly ORDER BY RAND(), choosing between IN and EXISTS, leveraging full‑text indexes, and applying join and index best practices—to improve query performance and reduce resource consumption.
This article provides a comprehensive overview of the JVM runtime memory areas, explains how the JVM determines garbage objects, reviews major GC algorithms and collectors—including the latest ZGC—and offers practical code examples and command‑line instructions for reproducing various OutOfMemoryError scenarios.
