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.
This article explains Redis's fundamental and advanced data structures, outlines its single‑threaded in‑memory architecture, and provides practical guidance on scanning large keyspaces, spreading expiration times, and choosing between AOF and RDB persistence methods.
This article explains Redis's virtual memory (VM) feature, how it swaps cold data to disk while keeping keys in memory, details configuration parameters, describes the two threading models for data swap-in/out, and highlights why Redis's custom VM implementation boosts performance.
This article reviews common ID generation strategies—including UUID/GUID, auto‑increment integers, random numbers, short strings, Twitter's Snowflake, and MongoDB ObjectID—compares their advantages and drawbacks, and introduces the rpcxio/did distributed ID service with performance benchmarks.
This article examines the landscape of cache systems, compares four major categories, evaluates popular distributed caches such as Redis, Memcached, Tair and EvCache, explains Redis Cluster architectures and sharding strategies, and outlines common cache pitfalls with practical mitigation techniques.
The article explains how V8’s built‑in methods, originally placed far from JIT‑generated code, cause costly branch‑prediction failures on 64‑bit CPUs, and how copying these snippets into a nearby memory region reduces mispredictions and improves performance at a modest memory cost.
This guide presents practical best‑practice configurations for Elasticsearch clusters in production, covering JVM heap sizing, CPU thread‑pool tuning, optimal shard counts, replica strategies, hot‑warm node architecture, node role settings, common troubleshooting tips, cache handling, refresh intervals, and essential monitoring APIs.
The article examines a real‑world scenario where a developer tried to reuse existing stored procedures to merely check the presence of Job, Certification, and Disclosure records, discusses the pitfalls of such an approach, and explains why storing this logic in T‑SQL is often fragile and hard to maintain.
This article explains why Redis, despite being single‑threaded, can encounter thread‑safety problems, discusses efficiency bottlenecks caused by network latency, and shows how embedded Lua scripts can create custom atomic commands, with practical examples and important considerations.
In a Redis cluster, bulk MGET calls suffered intermittent latency spikes because keys were distributed across many hash slots, forcing multiple network round‑trips; the issue can be mitigated by grouping keys with a common hash tag (though it reduces HA) or by issuing parallel slot‑wise MGETs with careful tuning, which preserves topology for larger batches.
The Next.js 11.1 release introduces a security patch, experimental ES Modules support, a Rust‑based SWC toolchain, faster data fetching and builds, improved source maps, enhanced ESLint rules, and numerous next/image optimizations, all driven by contributions from SWC author DongYong Kang and Parcel contributor Maia Teegarden.
This article details concrete techniques for reducing Flutter app memory consumption, focusing on image cache sizing, resource cropping, local caching, asset compression, cache thresholds, and page‑stack management, while providing step‑by‑step experiments, code snippets, and visual illustrations to guide developers.
Redis, traditionally seen as a high‑performance cache, also offers rich data structures, persistence options, and clustering modes that enable it to function as a primary database for many internet services, supporting use cases such as user profiles, counters, leaderboards, friend relationships, distributed locks, rate limiting, and more.
The article explains Redis 6.0's new features—especially the multithreaded network I/O model—why earlier versions were single‑threaded, how the IO threads cooperate with the main thread, configuration steps, thread‑count recommendations, and the model's limitations and performance implications.
This article explains why MySQL queries become slow, how proper indexing and index‑pushdown can improve performance, discusses common index‑failure causes, and then introduces Elasticsearch and HBase as complementary search and storage solutions for large‑scale data, including practical usage tips and architectural considerations.
Go 1.17, now officially released, brings roughly a 5% performance uplift, a 2% reduction in amd64 binary size, adds native Windows ARM64 support, introduces pruned module graphs to streamline dependencies, and expands unsafe package capabilities with slice‑to‑array pointer conversion, unsafe.Add, and unsafe.Slice.
The article explains the drawbacks of strict relational normalization, introduces the concept of anti‑normalization (controlled redundancy) to simplify queries, demonstrates it with a set of employee, department, salary tables and four typical query scenarios, and shows how denormalizing the schema can dramatically improve MySQL query performance.
The article shows how to detect and stop memory leaks in web pages with Chrome DevTools—using heap snapshots, allocation‑instrumentation timelines, and the Performance panel—to expose leaks from globals, closures, detached DOM nodes, excess elements, or console logging, and offers practical coding guidelines to avoid them.
This article explains why Redis can encounter thread‑safety‑like problems, how network latency limits its performance, and how embedding Lua scripts lets you create atomic, server‑side commands that overcome these issues while providing practical code examples.
This article explains how Java NIO's non‑blocking I/O can accelerate HTTP interface testing by offloading response handling to separate threads, presents a simple request‑time model, and provides concrete async HttpClient code examples with logging and JSON parsing.
An in‑depth guide walks through essential Linux server monitoring tools—top, vmstat, pidstat, iostat, netstat, tcpdump and others—explaining each command’s output, key metrics, and how to interpret CPU, memory, disk and network statistics for effective troubleshooting and performance tuning.
This article presents Sliver, an Android‑focused method‑trace framework that combines low‑overhead stack sampling, thread‑suspend techniques, and lock‑information capture to reliably detect and diagnose ANR and jank issues in production environments while maintaining minimal performance impact.
This guide provides a comprehensive overview of Android system architecture, explains the ADB communication mechanism, presents a detailed Android app testing checklist covering UI, compatibility, installation, OTA, interaction, concurrency, database, interface, performance, security, and other tests, and lists essential ADB commands and monitoring principles.
This article explains why MySQL queries become slow—covering index misuse, MDL locks, flush waits, row locks, and large‑table bottlenecks—then introduces ElasticSearch’s inverted‑index architecture and HBase’s column‑family storage, offering practical tips for performance tuning and hybrid solutions.
This article introduces a concise Python implementation of the k‑means clustering algorithm, compares its speed with a typical implementation, provides full source code, a data‑generation helper, and demonstrates the results on a synthetic dataset of 10,000 points.
This article explains the glTF format, compares .gltf and .glb, shows how to split and compress glTF assets using tools like gltf‑pipeline, Draco, mesh quantization and meshopt, and presents performance tests across various devices to guide efficient 3D model delivery in web applications.
The article describes how Beike's data platform consolidated multiple OLAP engines into a single DorisDB‑based solution, achieving higher query performance, lower operational complexity, and robust support for diverse analytics workloads such as metrics, dashboards, real‑time updates, and multi‑table joins.
A programmer needed to create a billion‑row SQLite test database within a minute, found a naïve Python script unbearably slow, applied batch inserts and SQLite PRAGMA tweaks, then compared CPython, PyPy, and Rust implementations, ultimately achieving sub‑minute runtimes with Rust and highlighting best‑practice optimizations.
Long Young GC pauses in gRPC/Netty services were traced to Netty’s default thread‑local cache creating many MpscArrayQueue objects, and disabling the cache with the JVM options ‑Dio.netty.allocator.useCacheForAllThreads=false and ‑Dio.grpc.netty.shaded.io.netty.allocator.useCacheForAllThreads=false reduced GC time from up to 900 ms to about 100 ms, stabilizing the service.
This article explains why code optimization is crucial for preventing unexpected runtime errors, outlines the main goals of reducing code size and improving execution efficiency, and provides a comprehensive list of practical Java optimization techniques—from using final modifiers and reusing objects to proper resource handling and avoiding common pitfalls—complete with code examples and performance explanations.
This article details the systematic performance optimization of Penguin Tutor's H5 core pages, covering metric collection, analysis methods, environment setup, and concrete practices such as network tuning, code splitting, lazy loading, resource hints, and server‑side improvements that reduced total bundle size by 50% and cut onload time from over 6 seconds to around 1.2 seconds.
Benchmarking C++ exceptions against error‑code handling reveals that frequent throws incur more than tenfold slowdown due to libc++ runtime functions like __cxa_allocate_exception and stack unwinding, while rare exceptions and empty try blocks add negligible overhead, highlighting the trade‑off between safety and performance.
The article investigates why Python's built‑in json.dumps can be slow on large data structures, compares the performance of ujson, python‑rapidjson, simplejson, and the Rust‑based orjson, provides benchmark code, installation commands, and discusses a bug in ujson's indent handling.
This article explains a systematic process for evaluating and selecting the most suitable high‑performance JSON library for Python, covering the need assessment, benchmark definition, filtering by additional requirements, and detailed benchmark results that highlight orjson as the fastest option for small‑message encoding while discussing trade‑offs such as safety, customizability, and ecosystem support.
This article explains Java NIO buffers, covering how to create them, their four core properties (mark, position, limit, capacity), essential methods like allocate, allocateDirect, flip, rewind, clear, and demonstrates usage with comprehensive code examples and diagrams.
Facebook detailed its multi‑year journey from MySQL 5.6 to 8.0, explaining why it stayed on 5.6 for MyRocks development, the massive patch‑porting effort, replica‑set migration steps, adoption of row‑based replication, extensive automation testing, and the performance and compatibility issues uncovered along the way.
This article explains Java NIO buffers, covering how to create them with allocate() and allocateDirect(), describing their four core properties (position, limit, capacity, mark), and detailing essential methods such as put(), get(), flip(), rewind(), clear(), mark(), reset(), hasRemaining() and remaining() with code examples.
This guide presents a comprehensive set of mandatory, reference, and recommended Redis usage standards—including command restrictions, key naming, data sizing, persistence configurations, monitoring, and deployment strategies—to improve performance, reliability, and operational efficiency for production environments.
This article introduces four practical approaches for measuring code execution time in Java—including simple time‑difference calculation, StopWatch‑style utilities, functional interfaces with Supplier/IntConsumer, and AutoCloseable‑based tracing—providing code examples, usage patterns, and enhancements such as chainable start methods.
The article describes how Beike Real Estate consolidated multiple OLAP engines into a single DorisDB‑based platform, detailing the business challenges, DorisDB’s technical advantages, extensive performance and concurrency benchmarks, and the resulting improvements in stability, query speed, and operational simplicity across various business scenarios.
The article discusses how to approach performance for entire front‑end applications—especially ReactJS—by considering real‑world data flow, state management, caching strategies, and the limitations of benchmark‑driven choices, while offering practical references and future topics.
This article explains the motivation, component types, naming conventions, runtime mechanism, streaming protocol, design goals, and practical considerations of React Server Components, illustrating how they reduce client bundle size and enable progressive server‑side rendering with code examples.
