This article provides an in‑depth technical overview of Ant Financial’s Cube Card system, covering its cross‑platform dynamic UI architecture, high‑performance rendering engine, thread and data models, development workflow, native optimizations, and upcoming business and IoT expansion plans.
This article provides a detailed analysis of HikariCP’s initialization, core components, startup flow, connection acquisition logic, monitoring metrics, and key configuration parameters, illustrating how Spring Boot 2.x leverages this high‑performance JDBC connection pool and offering guidance for tuning and extending it.
This article explains why Node.js services can suffer from memory leaks, explores a V8 engine bug involving generators, walks through heap snapshot comparison and MAT analysis, lists common leak patterns, and presents practical tools and upgrade strategies to resolve the issue.
This article explains how Pika, a disk‑based Redis‑compatible KV store, overcomes Redis’s memory limits with larger capacity, faster backup, and comparable performance, and describes its deployment, management, monitoring, and migration workflows within 360’s HULK cloud platform.
StarRocks 1.19 introduces a Global Runtime Filter that speeds up joins up to six‑fold, adds BE‑level disk balancing, launches an experimental Primary Key table type with near‑duplicate‑key read performance, enables external‑table writes between clusters, and includes a host of CPU‑cache and query‑optimizations.
This article introduces the fundamentals of Android Runtime (ART) garbage collection, covering its historical background, key milestones, core features such as RegionTLAB, read barriers, pause behavior, generational support, target heap size calculations, multiplier impact, GC trigger thresholds, Systrace analysis, and parameter tuning strategies.
This article explains how MyBatis native batch inserts can exceed MySQL's maximum SQL size, causing errors, and demonstrates a solution using Guava's Lists.partition to split the data into smaller chunks, improving performance and avoiding execution failures.
This article examines frequent Redis pitfalls—including unexpected key expiration, blocking DEL commands, RANDOMKEY performance issues, SETBIT memory spikes, MONITOR OOM risks, persistence challenges, and master‑slave replication quirks—providing detailed explanations and practical mitigation strategies for each scenario.
This article explains how to use Java's FutureTask, Callable, and ExecutorService to run multiple API calls concurrently, aggregate their results, and dramatically reduce total response time compared with sequential execution, complete with code examples and performance analysis.
Zhang Chenyu from Lingque Cloud shares a comprehensive enterprise‑level Harbor case study, covering its role as an image registry, migration from 1.x to 2.x with multi‑architecture support, internal governance policies, integration with ACP, community contributions, performance workgroup findings, and the offered Harbor Enterprise edition.
This article shares a practical three‑step method for turning KPI from a hindrance into a catalyst during agile and DevOps transformation, covering urgency creation, pilot projects, and performance‑assessment redesign, while illustrating how integrated tools and feedback loops boost delivery efficiency and business value.
This article explains why UIWebView was deprecated, how WKWebView improves performance and memory usage, details its multi‑process architecture, outlines page loading flow, delegate methods, container design, caching strategies, cookie handling across processes, and solutions for white‑screen crashes in iOS apps.
This article presents a comprehensive guide to MySQL performance, covering maximum data volume and concurrency limits, recommended query response times, practical table‑design rules, index classification and optimization techniques, as well as detailed SQL tuning patterns such as batch processing, operator, OR, IN, LIKE, JOIN and LIMIT improvements.
This article explores the fasthttp library as a high‑performance alternative to Go's net/http client, demonstrates basic and advanced API usage with object pools, shows how to set up a mock test server, and provides complete Go unit‑test examples with output verification.
The article analyzes the rapid growth of the global data‑intensive HPC market, driven by AI and high‑performance data analysis workloads, outlines shifting storage demands, cloud‑HPC adoption, and the technical challenges and opportunities for future HPC storage architectures.
This article explains why LongAdder was introduced to overcome AtomicLong's CAS contention bottleneck, explores the design of Striped64 and its cells, and walks through key source code snippets of LongAdder, DoubleAdder, and the longAccumulate method, highlighting concurrency mechanisms and performance considerations.
This article details the JD Daojia coupon system's high‑traffic architecture, describing its multi‑layer design, Redis cache challenges such as large‑key and hot‑key issues, and practical optimization techniques including key redesign, expiration strategies, and active‑expire algorithms to improve performance and scalability.
This article investigates the high CPU usage and latency observed after expanding a large Redis cluster, analyzes the root cause in the CLUSTER SLOTS implementation and client MOVED handling, proposes an optimized slot‑traversal algorithm, and demonstrates significant performance improvements through benchmarking and profiling.
This article walks through setting up a lab environment with ESXi, H3C VSR, and CentOS hosts, installing iperf, netperf, and qperf, configuring IP addresses and routes, disabling firewalls, and using these tools to measure bandwidth, latency, jitter, and packet loss, revealing surprising high‑throughput results and practical troubleshooting tips.
In large Redis clusters the original CLUSTER SLOTS implementation traversed every master and all 16,384 slots, causing ~52 % CPU usage and high MGET latency during migrations, but redesigning it to iterate the pre‑built slot array reduced complexity to O(total slots), cutting execution time from 2 ms to 0.17 ms and eliminating the CPU hotspot, a fix now merged into Redis 6.2.2.
This article explores the V8 JavaScript engine’s architecture, from its historical origins and source‑code acquisition to its loading strategies, lexical analysis, parsing, compilation, and execution optimizations, illustrating how V8 achieves high performance in browsers and Node.js.
This article explains theoretical formulas and practical guidelines for calculating the optimal thread pool size in Java, covering CPU‑bound and I/O‑bound workloads, how to measure CPU cores and blocking ratios, and provides example calculations and code snippets.
When a MySQL table is sharded into multiple databases or tables, the usual LIMIT offset, pagesize pagination breaks, and this article examines why simple merge fails, then presents three practical approaches—global limit, secondary queries, and jump‑page restriction—highlighting their trade‑offs and limitations.
This article explains the data collection and reporting component of a complete frontend monitoring platform, detailing performance metrics such as FP, FCP, LCP, CLS, and providing practical JavaScript code examples for measuring, observing, and reporting these metrics, along with error and behavior monitoring techniques.
This article lists ten typical Java programming mistakes—including array‑to‑ArrayList conversion errors, inefficient value checks, improper element removal in lists, misuse of Hashtable/HashMap, raw generic types, access‑level issues, and mutable versus immutable objects—explaining why they occur and providing correct code examples to prevent them.
This article analyzes the main factors that contribute to Young Generation GC (YGC) latency in the JVM, covering safe‑point pauses, live object scanning and marking, object copying, GC log overhead, and OS activity, and offers practical tips for diagnosing and reducing pause times.
Effective logging is crucial for debugging and accountability; this guide presents fifteen practical recommendations—from selecting appropriate log levels and formatting to using SLF4J, asynchronous output, and avoiding common pitfalls—designed to help Java developers write clear, performant, and maintainable logs.
The article outlines the Douyin front‑end team's engineering philosophy, covering the need for modularization of HTML, CSS, and JavaScript, component systems, dependency handling, build tools, loaders, and performance‑focused tooling to improve development efficiency and browser runtime speed.
This article provides a comprehensive comparison between RocketMQ and Kafka, covering data reliability, performance, queue capacity, real‑time delivery, retry mechanisms, ordering guarantees, scheduled messages, transactional support, query capabilities, message tracing, consumer parallelism, filtering, and commercial backing, helping engineers choose the right messaging middleware for their workloads.
This article provides a comprehensive overview of Spring WebFlux, covering its reactive fundamentals, key components, auto‑configuration process, functional endpoints, request handling flow, performance benchmarks against Spring MVC, and recommended reactive data stores for high‑concurrency applications.
This article explains the limitations of CSV for big datasets, introduces the Feather binary format, shows how to install and use it with Python and pandas, and compares its saving/loading speed and storage size against CSV, highlighting Feather's advantages for efficient data handling.
This article surveys the most commonly used Java libraries and tools—from Netty and SpringBoot to JUnit, JMH, OkHttp, HikariCP, Caffeine, Hazelcast, logging frameworks, Jackson, Jolokia, Hibernate Validator, and FreeMarker—highlighting their roles, advantages, and integration tips for modern enterprise development.
This article presents a comprehensive guide to speeding up Python programs by applying optimization principles, avoiding global variables and attribute look‑ups, reducing unnecessary abstractions and data copies, improving loop constructs, using built‑in functions like join, leveraging short‑circuit logic, and employing tools such as numba for JIT compilation.
This article explains MySQL indexes, covering their definition, benefits, various types such as B‑tree and B+‑tree, practical techniques for creating high‑performance indexes like prefix, composite, and clustering indexes, and how to inspect and maintain index information and fragmentation.
The article explains why a simple GROUP BY query on a large user‑view table can become inefficient due to temporary tables, filesort, and memory allocation, demonstrates the execution steps with EXPLAIN, and shows how adding a composite index on user_id, viewed_user_age, and viewed_user_sex eliminates temporary tables and improves performance.
The article examines a MySQL optimizer bug where a query with a WHERE clause on uid, ORDER BY id ASC, and LIMIT 1 incorrectly triggers a full table scan despite a usable composite index, explains the optimizer’s cost calculations, and offers workarounds such as FORCE INDEX or a harmless arithmetic trick to force index usage.
The article analyzes common obstacles that prevent effective use of design patterns and code standards in everyday software development—such as performance overhead, class explosion, team skill gaps, project constraints, agile timelines, and staff turnover—and offers practical strategies to balance quality with productivity.
This article explains the concept of Time To Interactive (TTI) for the Kuaishou Android app, details how to quantify the metric using FrameTime instead of FPS, describes data collection methods, offline and online tracing, a performance lab, and comprehensive governance and task‑scheduling strategies to reduce startup lag.
The article explains how double‑brace syntax creates anonymous inner classes for initializing Java collections, discusses the hidden overhead and memory‑leak risks it introduces, and presents cleaner alternatives such as Arrays.asList, Stream.of, Guava immutable factories, and Java 9's of‑methods.
This article introduces Fair 2.0, a Flutter dynamic framework used in the Anjuke Photo App to enable runtime widget updates, explains how to embed dynamic pages, register local widgets and templates, and presents performance data such as package size, memory usage, startup time, and frame rate.
A Monday morning surge in user traffic exposed a Redis performance crisis, where CPU spiked to 100% due to massive keys* commands, and the investigation using Grafana, Redis info, commandstats, and slowlog revealed the root cause and a temporary mitigation strategy.
This article explains how to improve database insertion performance in Java by replacing per‑iteration inserts with MyBatis‑Plus’s saveBatch method, detailing dependency setup, schema creation, entity, controller, service, and mapper code for efficient bulk operations.
This article presents comprehensive Redis usage standards—including key naming conventions, avoiding big keys, efficient serialization, safe command usage, data persistence strategies, and operational recommendations—to ensure high performance, memory efficiency, and reliable service under heavy traffic.
This article presents a comprehensive collection of Java code optimization techniques—including using final modifiers, reusing objects, preferring local variables, proper resource handling, avoiding unnecessary object creation, and efficient looping—to reduce code size, improve execution speed, and enhance overall application performance.
This article explains DataVisor's risk‑control system architecture, outlines the business challenges such as complex logic, massive data, high QPS and low latency, and demonstrates how OpenResty (Nginx + Lua) is used for high‑performance gateways, micro‑service style calls, hot‑loaded scripts, automatic circuit‑breakers, and progressive architectural evolution toward service‑mesh designs.
Chrome 94, released on September 21, 2021, introduces 13 new features—including the groundbreaking WebGPU API, WebCodecs, prioritized scheduler.postTask, Idle Detection API, JS Self‑Profiling API, Canvas color management, and early hints—each detailed with usage examples, performance insights, and their impact on modern web development.
This article explains why MySQL LIMIT with large offsets becomes slow, analyzes the execution flow, and presents four optimization techniques—including subquery, INNER JOIN, tag‑record, and BETWEEN…AND…—with real‑world performance numbers and sample SQL code.
This article explains how CSS3 transforms and related properties promote elements to composite layers, detailing the browser rendering pipeline, the role of the GPU, practical demos, performance observations, and techniques for inspecting and optimizing animation performance in modern front‑end development.
This guide explains the most common JVM startup flags for controlling garbage collection logging, heap sizing, class loading monitoring, and out‑of‑memory handling, providing sample outputs and detailed interpretations to help developers tune memory usage and diagnose performance issues in large Java applications.
This article explains what memory leaks are, how to identify them in Vue SPA projects using Chrome's memory tools, lists common leak patterns, and provides practical code‑level solutions—including proper event unbinding, timer cleanup, and correct use of keep‑alive—to keep your application performant.
Learn the essential Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—along with the commands and tools such as redis-cli, INFO, SLOWLOG, and redis-benchmark to collect, interpret, and act on these metrics for effective database operations.
This roundup highlights the latest frontend advancements, including DevTools' cross‑browser support, Gatsby v4's new features, the high‑performance Kraken rendering engine, regex generator grex, the toolb.dev suite, a web‑to‑desktop framework comparison, plus in‑depth articles on Snowpack and a tenfold Table component speed boost.
This article provides a comprehensive overview of microservice architecture, tracing its history, explaining its benefits over monolithic and SOA approaches, and detailing common cognitive, time, cost, development, testing, and operational traps along with practical mitigation strategies for successful adoption.
This article presents nine actionable Java performance‑optimization techniques—from avoiding premature tweaks and profiling bottlenecks to using StringBuilder, primitive types, and caching—complete with code examples and guidance on building a reliable test suite.
This article compares three popular open‑source configuration centers—Spring Cloud Config, Apollo, and Nacos—across product features, user experience, deployment, multi‑language support, migration, performance, and high‑availability to help engineers choose the most suitable solution for microservice environments.
The DeWu ANR Monitoring Platform replaces Bugly with a comprehensive internal system that collects ProcessErrorStateInfo, tombstone files, main‑thread stack samples, Looper message histories, and app state, parses and aggregates this data, visualizes trends and root‑cause details, and guides developers in mitigating ANRs.
This guide outlines ten Vue.js performance optimization techniques—including using stable keys in v‑for, freezing immutable data, defining component data as a function, lazy‑loading components, separating non‑reactive data, employing event delegation, leveraging functional components, and using provide/inject—to boost rendering speed, cut memory usage, and simplify maintenance.
This article explains why using @Async in Spring Boot can cause memory overflow when many requests trigger parallel tasks, examines the default thread‑pool settings that lead to unbounded queues, and provides step‑by‑step configuration of a safe thread pool to prevent out‑of‑memory failures.
This session explains why Kubernetes monitoring is essential for end-to-end observability, describes the five data sources and layers it covers, and walks through discovering and locating architecture, performance, resource, scheduling, and network issues using topology, anomaly detection, and correlation techniques.
This article explores rendering performance optimization from a hardware viewpoint through to front‑end rendering, detailing the three stages of perception, healing, and corrosion, the critical rendering path, CRP analysis, and practical strategies such as NEON acceleration, OOPD/OOPR, and Lighthouse tooling to achieve smoother, lower‑power web experiences.
WebAssembly is a portable, low‑size binary format that complements JavaScript by letting C, C++, Rust, and other languages compile to fast‑loading modules, offering near‑native speed, easy macOS setup with Emscripten, measurable performance gains such as a 1.9× speed‑up on recursive Fibonacci, and seamless interaction with JavaScript for compute‑heavy web applications.
The article explains how MySQL 8.0’s new doublewrite buffer implementation dramatically slows LOAD performance on a 1 GB file, identifies the innodb_doublewrite_pages default setting as the root cause, and shows that increasing it to 64 restores speeds comparable to MySQL 5.7.
This article explains how to install and use the React Profiler tool to identify performance bottlenecks in React applications, demonstrates analysis of render phases with example code, and discusses optimization techniques such as React.memo, PureComponent, shouldComponentUpdate, and hooks to reduce unnecessary re‑renders.
This article explains the classification of relational and NoSQL databases, analyzes common performance bottlenecks such as query latency, large fields, and write overhead, and presents practical optimization methods including caching, proper indexing, transaction handling, read‑write separation, and sharding for large‑scale systems.
This article lists ten typical Go programming pitfalls—from undefined enum values and misleading benchmarks to pointer misuse, slice initialization, error handling, context misuse, and goroutine closures—explaining why they hurt performance or correctness and offering concrete, idiomatic solutions.
This article explains the fundamentals of browser rendering, frame lifecycle, and dropped‑frame issues, then demonstrates how React Fiber and the requestIdleCallback API can be used to split heavy tasks, improve concurrency, and keep UI interactions smooth.
This article details the full migration of a large‑scale mobile app from React Native 0.51 to 0.62, covering background, major improvements such as Hermes engine adoption, extensive performance testing, risk‑controlled batch rollout, API compatibility handling, tooling support, CI/CD integration, and post‑deployment verification.
This article explains why using a large OFFSET with MySQL LIMIT can cause severe performance degradation, demonstrates the problem with a real‑world 9.5 million‑row table, and shows how rewriting the query with a sub‑query that selects only primary keys can cut execution time from seconds to milliseconds.
This article introduces four popular MySQL performance‑tuning utilities—mysqltuner.pl, tuning-primer.sh, pt-variable-advisor, and pt-query-digest—explaining how to download, run, and interpret their reports to identify configuration issues, memory bottlenecks, and slow‑query problems.
This article explains the impact of slow SQL on database resources and user experience, outlines priority rules for addressing slow queries, details MySQL execution steps, identifies key performance factors, and provides concrete optimization methods including enabling slow‑query logs, indexing, I/O merging, and distributed architecture.
This guide explains how and why to run HAProxy inside Docker containers, covering setup steps, performance impact, security considerations, and practical commands for creating networks, deploying web services, configuring HAProxy, and managing the container lifecycle.
The article evaluates three data‑insertion techniques—repeated single inserts, XML‑based SQL concatenation, and batch processing—within a SpringBoot application using SQL Server, presenting code examples, test results, and recommendations on when to use each method.
This article explores Babel’s role in early ECMAScript feature adoption, explains its plugin ecosystem, compares compile‑time versus polyfill approaches, and offers practical tips to improve build performance and avoid unnecessary code duplication.
JDK 17, the upcoming long‑term support release, brings a suite of enhancements—including strict floating‑point semantics, deprecation of the Security Manager, switch pattern matching, sealed classes, a new vector API, and improved pseudo‑random generators—while also removing outdated RMI activation and experimental compilers.
This article explains the purpose of CPU caches, their classification, placement and replacement strategies, write policies, and coherence protocols, providing a comprehensive overview of cache concepts essential for modern computer architecture.
This article dissects Java’s HashMap implementation, covering lazy initialization, the put workflow, hash mixing, bucket conversion to red‑black trees, core helper methods, removal logic, thread‑safety considerations, and practical usage tips, all illustrated with source excerpts.
Learn how to dramatically improve Java for‑loop performance by applying seven practical techniques—including caching list size, using combined loop variables, iterating backwards, leveraging Iterator, enhanced for‑each syntax, minimizing nested loops, and moving exception handling outside—each with clear pros, cons, and code examples.
This article explains what memory leaks are in JavaScript, how to detect them using Chrome's memory tools, enumerates common causes in Vue SPAs, and provides practical solutions and code examples—including event unbinding and keep‑alive refactoring—to effectively eliminate leaks and improve performance.
This article explains the challenges of iOS crash log symbolication on Linux, evaluates native tools like symbolicatecrash and atos, describes several prototype solutions, and details the final design that pre‑parses DWARF and symbol tables into a distributed cache to achieve massive latency and resource reductions.
This article provides a comprehensive tutorial on setting up a one‑master‑one‑slave Redis replication environment, configuring read‑write separation, verifying data synchronization, testing read‑only behavior, and performing performance benchmarking with redis‑benchmark, complete with command examples and result analysis.
This article details Ctrip’s migration of its hotel direct‑connect service to AWS, describing the background challenges, cloud‑native architectural redesign with EKS, bandwidth and latency optimizations, use of spot instances, DNS caching, cross‑AZ traffic reduction, and the resulting performance and cost benefits.
The article explains how the explosive growth of IoT data makes high‑performance time‑series databases essential, describes Huawei Cloud's GaussDB for Influx architecture and compression breakthroughs, and shares the engineering challenges and real‑world benefits of building a cloud‑native TSDB for massive monitoring workloads.
The article details how Kuayue Group's big‑data center replaced Presto and ClickHouse with DorisDB, achieving sub‑second query latency, simplifying architecture, and enabling both online and real‑time OLAP analytics across millions of daily requests.
This article explores the importance of resource isolation in distributed systems, detailing thread, process, cluster, data‑center, read/write, static, and crawler isolation techniques, with practical code examples from Netty, Dubbo, and Tomcat, and discusses trade‑offs such as thread‑pool versus semaphore isolation.
The article explains the rapid rise of graph databases, outlines their core concepts and advantages, compares them with NoSQL and relational databases, presents performance benchmarks, and reviews leading solutions such as Neo4j and JanusGraph, including their data models and query language.
The article explains why running MySQL in Docker containers can lead to data loss, performance degradation, and inadequate resource isolation, while also outlining specific scenarios where containerizing MySQL may still be appropriate.
Gaode migrated its high‑traffic rendering gateway from Java to Go to halve machine usage, validate middleware stability, and prepare for cloud‑native transformation, overcoming correctness and availability challenges by creating a real‑time traffic‑comparison tool, sandbox stress tests, and a staged gray‑release, ultimately achieving about 50% cost reduction.
This article provides a comprehensive guide to Java thread pools, covering their advantages, internal workflow, creation parameters, task submission methods, lifecycle states, shutdown procedures, performance tuning, monitoring metrics, and common pitfalls for developers seeking efficient concurrency management.
This article presents a step‑by‑step methodology for troubleshooting high RSS memory consumption in Java applications, covering heap size assessment, ARENA region analysis, native memory tracking, off‑heap memory checks, and automation tools to streamline the entire diagnostic process.
This article explains how to identify oversized Redis keys, analyze their impact with built‑in commands and third‑party tools, and safely remove them using UNLINK and lazy‑free configurations to prevent performance bottlenecks.
Through a detailed case study, the author documents the process of optimizing a Python‑based web module—identifying bottlenecks, redesigning architecture with Redis queues, tuning MySQL, adjusting Linux TCP settings, and iteratively load‑testing until achieving 50,000 QPS with sub‑70 ms latency and zero errors.
This article presents an in‑depth overview of ClickHouse's Projection feature, covering its background, definition, storage and query mechanisms, practical use‑case demonstrations, performance comparisons with competing OLAP systems, and real‑world production results that highlight its advantages and limitations.
This article explains how to use Python's multiprocessing module to parallelize a custom preprocessing function on a 537k‑record dataset, demonstrating roughly a thirty‑fold reduction in execution time compared with single‑process execution.
This article explains the fundamentals of message queues, compares synchronous and asynchronous communication, discusses the benefits of sender‑receiver decoupling, outlines performance and reliability considerations, and provides practical guidance for designing robust distributed messaging architectures.
The article explains that Android ANR (Application Not Responding) arises when the UI thread is blocked beyond defined timeouts, classifies the various timeout types, details common root causes such as slow I/O, heavy computation, binder delays, deadlocks, CPU or memory pressure, and outlines a systematic log‑and‑systrace analysis process to pinpoint and resolve these issues.
This article compares Apache HttpClient and OkHttp for Java backend development, explaining how to create clients, configure timeouts, perform GET/POST/PUT/DELETE requests, upload files, cancel requests, and presents performance test results with code examples for each library.
This article documents the author's first experience debugging ClickHouse source code with GDB, explains the memory‑limit issue encountered when importing large MySQL tables, shows how to inspect stack frames, adjust the max_block_size setting, and verify the fix with a test insert.
This article explains how to identify and resolve server CPU spikes caused by excessive DateTime object creation in a Java application, detailing step‑by‑step Linux command usage, JStack and JProfiler analysis, and a refactoring solution that replaces DateTime comparisons with string comparisons to reduce GC pressure.
The guide explains JavaScript/TypeScript decorators—an ECMAScript stage‑2 proposal used in frameworks like Angular, Nest.js, and TypeORM—by distinguishing the decorator pattern, function, and @syntax, demonstrating a four‑step manual implementation that logs execution time, and linking decorators to AOP, IoC, and DI concepts.
This article presents a comprehensive guide to writing more standardized Java code, covering topics such as avoiding "1=1" in MyBatis, iterating Map entrySet, pre‑sizing collections, using StringBuilder, preferring Set for contains checks, proper static initialization, removing unused variables, shielding utility constructors, eliminating redundant exception handling, using String.valueOf, avoiding BigDecimal(double), returning empty collections instead of null, safe equals usage, immutable enum fields, and correctly escaping regex in String.split, each illustrated with clear code examples.
