BestHub
Sign in
Tagged articles

Performance

5000 articles · Page 35 of 50
IT Architects Alliance
IT Architects Alliance
Aug 28, 2021 · Backend Development

Understanding Message Queues: Sync vs Async, Decoupling, Performance, and Reliability

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.

Asynchronous CommunicationMessage QueuePerformance
0 likes · 9 min read
Understanding Message Queues: Sync vs Async, Decoupling, Performance, and Reliability
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Aug 27, 2021 · Mobile Development

Analysis of Android ANR (Application Not Responding) Causes and Diagnosis

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.

ANRAndroidPerformance
0 likes · 8 min read
Analysis of Android ANR (Application Not Responding) Causes and Diagnosis
Snowball Engineer Team
Snowball Engineer Team
Aug 26, 2021 · Backend Development

Diagnosing and Optimizing Server CPU Spikes Caused by Excessive DateTime Object Creation in Java

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.

CPUGCJava
0 likes · 4 min read
Diagnosing and Optimizing Server CPU Spikes Caused by Excessive DateTime Object Creation in Java
Tencent Cloud Developer
Tencent Cloud Developer
Aug 25, 2021 · Fundamentals

A Comprehensive Guide to JavaScript/TypeScript Decorators and Their Practical Use

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.

AOPDecoratorIOC
0 likes · 10 min read
A Comprehensive Guide to JavaScript/TypeScript Decorators and Their Practical Use
Java High-Performance Architecture
Java High-Performance Architecture
Aug 25, 2021 · Backend Development

13 Essential Java Coding Practices to Boost Performance and Cleanliness

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.

ExceptionsJavaMyBatis
0 likes · 15 min read
13 Essential Java Coding Practices to Boost Performance and Cleanliness
IT Architects Alliance
IT Architects Alliance
Aug 24, 2021 · Backend Development

Distributed ID Generation Schemes and the rpcxio/did Service

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.

ID GenerationPerformanceSnowflake
0 likes · 12 min read
Distributed ID Generation Schemes and the rpcxio/did Service
IT Architects Alliance
IT Architects Alliance
Aug 23, 2021 · Backend Development

Choosing the Right Distributed Cache: Redis Cluster Deep Dive

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.

Cache ClusterPerformanceRedis
0 likes · 13 min read
Choosing the Right Distributed Cache: Redis Cluster Deep Dive
dbaplus Community
dbaplus Community
Aug 22, 2021 · Operations

Master Elasticsearch Performance: Memory, CPU, Shards, and Cluster Tuning

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.

ElasticsearchMemoryPerformance
0 likes · 14 min read
Master Elasticsearch Performance: Memory, CPU, Shards, and Cluster Tuning
Top Architect
Top Architect
Aug 22, 2021 · Databases

Why Using Stored Procedures for Simple Existence Checks Can Be Problematic

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.

Code ReusePerformanceSQL
0 likes · 6 min read
Why Using Stored Procedures for Simple Existence Checks Can Be Problematic
DeWu Technology
DeWu Technology
Aug 21, 2021 · Databases

Performance Issues of Redis Cluster MGET and Optimization Strategies

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.

JavaMGETOptimization
0 likes · 8 min read
Performance Issues of Redis Cluster MGET and Optimization Strategies
ByteDance Web Infra
ByteDance Web Infra
Aug 20, 2021 · Frontend Development

Next.js 11.1 Release: New Features, Rust‑Based Toolchain, and Performance Boosts

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.

ESModulesImageOptimizationNext.js
0 likes · 14 min read
Next.js 11.1 Release: New Features, Rust‑Based Toolchain, and Performance Boosts
Tencent Music Tech Team
Tencent Music Tech Team
Aug 20, 2021 · Mobile Development

How to Slash Flutter App Memory Usage: Practical Image Optimization Strategies

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.

FlutterMemory optimizationMobile Development
0 likes · 9 min read
How to Slash Flutter App Memory Usage: Practical Image Optimization Strategies
macrozheng
macrozheng
Aug 20, 2021 · Databases

Beyond Caching: How Redis Can Serve as a Full‑Featured Database

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.

CachingPerformanceRedis
0 likes · 19 min read
Beyond Caching: How Redis Can Serve as a Full‑Featured Database
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 19, 2021 · Databases

Understanding Redis 6.0 Multithreading Model and Configuration

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.

IOMultithreadingPerformance
0 likes · 9 min read
Understanding Redis 6.0 Multithreading Model and Configuration
Sohu Tech Products
Sohu Tech Products
Aug 18, 2021 · Databases

Understanding Slow Queries, Index Optimization, and Search Solutions with MySQL, Elasticsearch, and HBase

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.

ElasticsearchHBaseIndexing
0 likes · 18 min read
Understanding Slow Queries, Index Optimization, and Search Solutions with MySQL, Elasticsearch, and HBase
MaGe Linux Operations
MaGe Linux Operations
Aug 18, 2021 · Backend Development

What’s New in Go 1.17? Performance Boosts, ARM Support, and Unsafe Enhancements

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.

ARM supportGo 1.17Performance
0 likes · 3 min read
What’s New in Go 1.17? Performance Boosts, ARM Support, and Unsafe Enhancements
Aikesheng Open Source Community
Aikesheng Open Source Community
Aug 18, 2021 · Databases

Anti‑Normalization in MySQL: Reducing Joins with Redundant Columns

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.

Anti-NormalizationDatabase DesignDenormalization
0 likes · 11 min read
Anti‑Normalization in MySQL: Reducing Joins with Redundant Columns
Amap Tech
Amap Tech
Aug 18, 2021 · Frontend Development

Investigating and Preventing Memory Leaks in Web Pages Using Chrome DevTools

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.

Chrome DevToolsPerformancememory-leak
0 likes · 20 min read
Investigating and Preventing Memory Leaks in Web Pages Using Chrome DevTools
FunTester
FunTester
Aug 17, 2021 · Backend Development

Boost HTTP Client Performance with Java NIO and Async Callbacks

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.

HTTPHttpClientJava
0 likes · 9 min read
Boost HTTP Client Performance with Java NIO and Async Callbacks
Efficient Ops
Efficient Ops
Aug 16, 2021 · Operations

Master Linux Server Monitoring: top, vmstat, pidstat, iostat, netstat & More

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.

LinuxLinux toolsPerformance
0 likes · 16 min read
Master Linux Server Monitoring: top, vmstat, pidstat, iostat, netstat & More
FunTester
FunTester
Aug 15, 2021 · Mobile Development

Mastering Android Testing: Architecture, ADB Commands, and a Complete Test Checklist

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.

ADBAndroidMobile Development
0 likes · 14 min read
Mastering Android Testing: Architecture, ADB Commands, and a Complete Test Checklist
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 14, 2021 · Databases

Why Your MySQL Queries Are Slow and How to Fix Them with Indexes, ElasticSearch, and HBase

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.

ElasticsearchHBaseIndexing
0 likes · 18 min read
Why Your MySQL Queries Are Slow and How to Fix Them with Indexes, ElasticSearch, and HBase
Aotu Lab
Aotu Lab
Aug 12, 2021 · Frontend Development

How to Optimize glTF/.glb Files for Faster 3D Loading in Web Projects

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.

3D OptimizationPerformancecompression
0 likes · 14 min read
How to Optimize glTF/.glb Files for Faster 3D Loading in Web Projects
Python Programming Learning Circle
Python Programming Learning Circle
Aug 11, 2021 · Databases

Generating One Billion SQLite Rows in Under a Minute: Python, PyPy, and Rust Performance Comparison

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.

PerformancePyPyPython
0 likes · 6 min read
Generating One Billion SQLite Rows in Under a Minute: Python, PyPy, and Rust Performance Comparison
HelloTech
HelloTech
Aug 11, 2021 · Backend Development

Root Cause Analysis and Optimization of Long Young GC Times in gRPC/Netty Services

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.

GC optimizationJavaNetty
0 likes · 6 min read
Root Cause Analysis and Optimization of Long Young GC Times in gRPC/Netty Services
Open Source Linux
Open Source Linux
Aug 10, 2021 · Backend Development

40 Essential Java Code Optimization Tips for Faster, Safer Applications

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.

JVMJavaPerformance
0 likes · 29 min read
40 Essential Java Code Optimization Tips for Faster, Safer Applications
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 9, 2021 · Frontend Development

How We Cut H5 Page Load Time by 50%: A Deep Dive into Performance Optimization

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.

FrontendH5Performance
0 likes · 22 min read
How We Cut H5 Page Load Time by 50%: A Deep Dive into Performance Optimization
Tencent Cloud Developer
Tencent Cloud Developer
Aug 9, 2021 · Fundamentals

Performance Evaluation and Implementation Overview of C++ Exceptions

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.

AssemblyC++Exception
0 likes · 13 min read
Performance Evaluation and Implementation Overview of C++ Exceptions
Python Programming Learning Circle
Python Programming Learning Circle
Aug 9, 2021 · Backend Development

How to Choose the Fastest JSON Library for Python: A Practical Benchmarking Guide

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.

PerformancePythonRapidJSON
0 likes · 5 min read
How to Choose the Fastest JSON Library for Python: A Practical Benchmarking Guide
Selected Java Interview Questions
Selected Java Interview Questions
Aug 8, 2021 · Backend Development

Understanding Java NIO Buffers: Creation, Core Properties, and Operations

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.

BufferByteBufferJava
0 likes · 12 min read
Understanding Java NIO Buffers: Creation, Core Properties, and Operations
Wukong Talks Architecture
Wukong Talks Architecture
Aug 6, 2021 · Databases

Redis Operational Best Practices and Guidelines

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.

Best PracticesOperationsPerformance
0 likes · 9 min read
Redis Operational Best Practices and Guidelines
Java Architect Essentials
Java Architect Essentials
Aug 5, 2021 · Backend Development

Various Methods for Measuring Code Execution Time in Java

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.

JavaPerformanceStopwatch
0 likes · 10 min read
Various Methods for Measuring Code Execution Time in Java
DataFunTalk
DataFunTalk
Aug 5, 2021 · Big Data

Building a Unified High‑Performance OLAP Platform with DorisDB at Beike Real Estate

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.

AnalyticsBenchmarkBig Data
0 likes · 14 min read
Building a Unified High‑Performance OLAP Platform with DorisDB at Beike Real Estate
ByteFE
ByteFE
Aug 5, 2021 · Frontend Development

Performance Thinking in Front‑End Applications: A ReactJS Perspective

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.

CachingData FlowFrontend
0 likes · 5 min read
Performance Thinking in Front‑End Applications: A ReactJS Perspective
Ctrip Technology
Ctrip Technology
Aug 5, 2021 · Frontend Development

Understanding React Server Components: Concepts, Usage, and Implementation

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.

Code SplittingPerformanceReAct
0 likes · 15 min read
Understanding React Server Components: Concepts, Usage, and Implementation
ByteDance Dali Intelligent Technology Team
ByteDance Dali Intelligent Technology Team
Aug 5, 2021 · Mobile Development

Design and Implementation of a Lightweight Startup Information Collection and Visualization Framework

This article presents a lightweight framework for constructing, collecting, and visualizing Android startup task information, replacing heavy systrace data with concise logs, Kotlin data structures, AspectJ instrumentation, and Python scripts that generate readable timelines and discrete charts to aid performance analysis.

AndroidAspectJPerformance
0 likes · 10 min read
Design and Implementation of a Lightweight Startup Information Collection and Visualization Framework
ByteFE
ByteFE
Aug 3, 2021 · Frontend Development

Effective Debugging Techniques with Chrome DevTools

This article presents a collection of practical Chrome DevTools debugging techniques—including various breakpoint types, logpoints, performance profiling, event tracing, setTimeout tricks, SSR inspection, and a binary-search style approach—to help frontend developers locate and resolve bugs more efficiently.

Chrome DevToolsFrontendPerformance
0 likes · 7 min read
Effective Debugging Techniques with Chrome DevTools
Top Architect
Top Architect
Aug 3, 2021 · Backend Development

Java Serialization vs Binary Encoding: Size and Performance Comparison

The article examines Java's built‑in Serializable interface, highlights its cross‑language incompatibility, large payload size, and low efficiency, then presents benchmark code comparing it with a custom binary encoding, showing significant reductions in data size and processing time, and recommends modern frameworks such as Protobuf or Thrift.

JavaPerformanceThrift
0 likes · 6 min read
Java Serialization vs Binary Encoding: Size and Performance Comparison
Code Ape Tech Column
Code Ape Tech Column
Aug 3, 2021 · Backend Development

Why Does Java Leak Memory? Deep Dive into Causes and Prevention

This article explains what memory leaks are in Java, compares them with C++ leaks, describes the garbage collection mechanism, lists common leak sources such as static collections, listeners, and singletons, and provides practical guidelines and tools to detect and prevent them.

Best PracticesGarbage CollectionJava
0 likes · 18 min read
Why Does Java Leak Memory? Deep Dive into Causes and Prevention
Java High-Performance Architecture
Java High-Performance Architecture
Aug 3, 2021 · Frontend Development

Which JavaScript Loop Wins? A Speed and Use‑Case Battle of for, forEach, map, for…in and for…of

This article compares five JavaScript iteration constructs—classic for, forEach, map, for...in and for...of—explaining their origins, semantics, performance characteristics, and appropriate use‑cases, while providing concrete code examples and guidance on breaking, continuing, and avoiding common pitfalls.

JavaScriptPerformancefor loop
0 likes · 12 min read
Which JavaScript Loop Wins? A Speed and Use‑Case Battle of for, forEach, map, for…in and for…of
DeWu Technology
DeWu Technology
Aug 1, 2021 · Backend Development

Understanding Service Jitter and JVM JIT Compilation

The article explains how intermittent latency spikes (jitter) in a high‑throughput service can be triggered when the JVM’s Just‑In‑Time compiler activates, detailing interpreter vs. JIT, C1/C2 tiered compilation, hot‑spot detection thresholds and compilation stages, and recommends pre‑warming code, disabling tiered compilation, or tuning thresholds and JVM flags to eliminate jitter.

HotSpotJITJVM
0 likes · 12 min read
Understanding Service Jitter and JVM JIT Compilation
Aikesheng Open Source Community
Aikesheng Open Source Community
Jul 30, 2021 · Databases

Migrating from MariaDB 10.3 to MySQL 5.7.25: Common Issues and Solutions

This article details the practical challenges encountered when migrating a MariaDB 10.3 database to MySQL 5.7.25, explains why certain defaults and engine-specific options cause import errors, and provides step‑by‑step fixes such as adjusting default expressions, removing Aria‑specific parameters, and configuring sql_mode.

MariaDBMySQLPerformance
0 likes · 5 min read
Migrating from MariaDB 10.3 to MySQL 5.7.25: Common Issues and Solutions
FunTester
FunTester
Jul 30, 2021 · Operations

Distributed QPS Amplifier Design in DCS_FunTester Framework

The article describes the concept, architecture, and Java implementation of a distributed request amplifier in the DCS_FunTester framework that multiplies local QPS to achieve high‑throughput performance testing without affecting the tested service's load.

JavaPerformancedistributed system
0 likes · 6 min read
Distributed QPS Amplifier Design in DCS_FunTester Framework
360 Tech Engineering
360 Tech Engineering
Jul 29, 2021 · Backend Development

Understanding HTTP/2: History, Features, and Protocol Mechanics

HTTP/2, now widely supported by browsers and major sites, replaces HTTP/1.1 by introducing a binary framing layer, header compression, stream prioritization, server push, and flow control, addressing head-of-line blocking and inefficiencies while maintaining HTTP semantics, with detailed discussion of its evolution, structure, and deployment considerations.

Backend DevelopmentHTTP/2Header Compression
0 likes · 22 min read
Understanding HTTP/2: History, Features, and Protocol Mechanics
Tencent Database Technology
Tencent Database Technology
Jul 29, 2021 · Databases

Performance Optimization of MongoDB for Million‑Scale Collections Using Shared Table Space Architecture

The Tencent CMongo team analyzed severe memory consumption, slow queries, and hour‑long startup caused by millions of MongoDB collections, identified bottlenecks in WiredTiger’s data‑handle management and schema‑lock handling, and introduced a shared‑table‑space architecture that reduces WT tables to a handful, achieving 1‑2 order‑of‑magnitude speedups and eliminating OOM failures.

MongoDBOptimizationPerformance
0 likes · 19 min read
Performance Optimization of MongoDB for Million‑Scale Collections Using Shared Table Space Architecture
Xianyu Technology
Xianyu Technology
Jul 29, 2021 · Mobile Development

How Xianyu Tackles Android ANR: Monitoring, Diagnosis, and Optimization Strategies

This article explains how Xianyu identifies, monitors, and resolves Android ANR issues by analyzing root causes, implementing SIGQUIT‑based detection, inspecting thread stacks, and applying concrete optimizations such as SharedPreferences replacement, network broadcast caching, and delayed component registration, ultimately cutting ANR rates by more than half.

ANRAndroidMobile Development
0 likes · 11 min read
How Xianyu Tackles Android ANR: Monitoring, Diagnosis, and Optimization Strategies
vivo Internet Technology
vivo Internet Technology
Jul 28, 2021 · Backend Development

Using Groovy as a Script Engine in Java Projects: Integration, Performance Optimization, and Security

By adopting Groovy as a JSR‑223 script engine, the Vivo Internet Server team streamlined dynamic query and rule processing in their Java content platform, demonstrating integration via ScriptEngineManager, GroovyShell, and GroovyClassLoader, while optimizing performance through caching and static typing and enforcing security with SecureASTCustomizer and isolated execution.

Dynamic ScriptingGroovyJava
0 likes · 17 min read
Using Groovy as a Script Engine in Java Projects: Integration, Performance Optimization, and Security
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 28, 2021 · Operations

Common Open‑Source Tools for MySQL Operations and Maintenance

This article introduces a curated list of open‑source MySQL operational tools—including online DDL changers, backup and restore utilities, load‑testing frameworks, flashback solutions, slow‑query analyzers, replication consistency checkers, audit platforms, and graphical clients—explaining their principles, usage scenarios, and visual references.

MySQLOperationsPerformance
0 likes · 8 min read
Common Open‑Source Tools for MySQL Operations and Maintenance
ByteDance Dali Intelligent Technology Team
ByteDance Dali Intelligent Technology Team
Jul 28, 2021 · Frontend Development

Advanced Techniques and Best Practices for Using styled-components in React

This article shares practical tips, patterns, and mental models for mastering styled-components in React, covering CSS variables, context styling, component encapsulation, inheritance, margin handling, z-index management, the "as" prop, priority tricks, and related tooling to write cleaner, more maintainable UI code.

Component StylingPerformanceReAct
0 likes · 19 min read
Advanced Techniques and Best Practices for Using styled-components in React
Programmer DD
Programmer DD
Jul 27, 2021 · Databases

How Facebook Overcame the Challenges of Migrating to MySQL 8.0

Facebook’s engineering team detailed a multi‑year, complex migration from MySQL 5.6 to 8.0, highlighting custom‑feature porting, replication compatibility, query changes, performance regressions, and documentation gaps, and explaining how they finally achieved a successful upgrade.

Custom FeaturesFacebookMySQL 8.0
0 likes · 5 min read
How Facebook Overcame the Challenges of Migrating to MySQL 8.0
IT Architects Alliance
IT Architects Alliance
Jul 26, 2021 · Databases

How to Diagnose and Fix Database IO/CPU Bottlenecks with Sharding

The article explains how IO and CPU bottlenecks increase active database connections, then details horizontal and vertical sharding techniques, practical tools, step‑by‑step implementation, and common pitfalls to help engineers relieve pressure on database resources.

CPU BottleneckHorizontal PartitionIO Bottleneck
0 likes · 10 min read
How to Diagnose and Fix Database IO/CPU Bottlenecks with Sharding
Laravel Tech Community
Laravel Tech Community
Jul 23, 2021 · Backend Development

Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies

The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis‑based systems, describes the performance risks they pose to persistent databases, and presents practical mitigation techniques such as Bloom filters, empty‑object caching, hot‑key permanence, distributed locks, high‑availability clusters, rate limiting, and data pre‑warming.

CacheDistributed LockHigh Availability
0 likes · 6 min read
Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies
ByteDance Web Infra
ByteDance Web Infra
Jul 23, 2021 · Backend Development

Design and Refactoring of ByteDance's Node.js RPC Framework

This article explains the motivation, design principles, model architecture, and implementation challenges of rebuilding ByteDance's Node.js RPC system, covering DDD‑based decomposition, protocol and connection abstractions, multi‑protocol nesting, client/server creation APIs, and performance‑optimized context extensions.

Backend DevelopmentDDDNode.js
0 likes · 14 min read
Design and Refactoring of ByteDance's Node.js RPC Framework
Programmer DD
Programmer DD
Jul 23, 2021 · Backend Development

Why ThreadLocalRandom Beats Random in Java: Deep Dive into Unsafe and Memory

This article explores the performance drawbacks of java.util.Random in high‑concurrency scenarios, explains how ThreadLocalRandom leverages Unsafe for per‑thread seeds, examines native getLong/putLong operations, and discusses memory layout nuances such as compressed oops and potential pitfalls.

ConcurrencyJavaPerformance
0 likes · 10 min read
Why ThreadLocalRandom Beats Random in Java: Deep Dive into Unsafe and Memory
ByteFE
ByteFE
Jul 22, 2021 · Frontend Development

A Practical Guide to Chrome DevTools for Front‑End Engineers

This article provides a practical, experience‑based guide to Chrome DevTools for front‑end engineers, illustrating common features and real‑world scenarios to help developers efficiently debug, profile, and optimize web applications, overcoming the limitations of generic feature‑only tutorials.

Chrome DevToolsFront-endPerformance
0 likes · 2 min read
A Practical Guide to Chrome DevTools for Front‑End Engineers
Sohu Tech Products
Sohu Tech Products
Jul 21, 2021 · Frontend Development

Chrome RenderingNG: Overview of the Next‑Generation Rendering Architecture

The article introduces Chrome's next‑generation rendering engine RenderingNG, detailing its core features, design philosophy, stability efforts, scalable performance techniques, caching, GPU acceleration, and new web APIs that together aim to provide faster, more reliable, and cross‑platform web rendering.

ChromePerformanceRenderingNG
0 likes · 12 min read
Chrome RenderingNG: Overview of the Next‑Generation Rendering Architecture
Architect
Architect
Jul 21, 2021 · Databases

MySQL 100 Interview Questions: Indexes, Transactions, Table Design, and Storage Engines

This article compiles 100 common MySQL interview questions for developers, covering index structures and optimization, transaction ACID properties and isolation levels, primary‑key design, storage‑engine choices, sharding strategies, and miscellaneous SQL nuances such as binlog formats and MyBatis parameter handling.

IndexesMySQLPerformance
0 likes · 20 min read
MySQL 100 Interview Questions: Indexes, Transactions, Table Design, and Storage Engines
Aikesheng Open Source Community
Aikesheng Open Source Community
Jul 21, 2021 · Databases

MySQL Index Design Specification and Best Practices

This article summarizes comprehensive MySQL index design guidelines, covering naming conventions, column selection criteria, index count control, handling of frequently updated columns, function and duplicate indexes, small‑table considerations, and index ordering to optimize query performance.

Database DesignIndexingMySQL
0 likes · 8 min read
MySQL Index Design Specification and Best Practices
KooFE Frontend Team
KooFE Frontend Team
Jul 20, 2021 · Frontend Development

How to Build a High‑Performance Poster System with Server‑Side Rendering

This article explains the business background, technical architecture, and implementation details of a scalable poster generation system that uses template‑based design and server‑side rendering to produce high‑quality, personalized images efficiently for online marketing campaigns.

PerformanceServer-side Renderingposter
0 likes · 14 min read
How to Build a High‑Performance Poster System with Server‑Side Rendering
Java Interview Crash Guide
Java Interview Crash Guide
Jul 19, 2021 · Backend Development

Mastering Zero-Copy in Java: Boost Performance with NIO, Netty, and More

Zero-copy techniques eliminate unnecessary data copying between user and kernel space, dramatically improving I/O performance; this article explains core I/O concepts, explores Java implementations like MappedByteBuffer, DirectByteBuffer, channel-to-channel transfers, and demonstrates Netty’s composite buffers, plus examples from Kafka and RocketMQ.

JavaMemory Mapped FilesNIO
0 likes · 14 min read
Mastering Zero-Copy in Java: Boost Performance with NIO, Netty, and More
Java Captain
Java Captain
Jul 17, 2021 · Databases

Optimizing Existence Checks: Use SELECT 1 LIMIT 1 Instead of SELECT count(*)

Developers often use SELECT count(*) to check record existence, but replacing it with SELECT 1 … LIMIT 1 improves performance by stopping after the first match, allowing simpler Java null checks and potentially reducing index usage, especially when only a binary presence test is needed.

Existence CheckJavaPerformance
0 likes · 3 min read
Optimizing Existence Checks: Use SELECT 1 LIMIT 1 Instead of SELECT count(*)
Top Architect
Top Architect
Jul 14, 2021 · Databases

Redis Read‑Write Separation Architecture: Star vs. Chain Replication

This article explains Alibaba Cloud's Redis read‑write separation architecture, comparing star and chain replication models, their performance and scalability trade‑offs, and how transparent compatibility, high availability, and high performance are achieved through redis‑proxy, HA monitoring, and optimized binlog replication.

DatabasesHigh AvailabilityPerformance
0 likes · 8 min read
Redis Read‑Write Separation Architecture: Star vs. Chain Replication
MaGe Linux Operations
MaGe Linux Operations
Jul 12, 2021 · Backend Development

Boost Python API Testing Speed with Async httpx: A Practical Guide

This article explains what coroutines are, compares them with threads, outlines when to use them, introduces the async‑capable httpx library, shows installation and sample code, and demonstrates a performance test where asynchronous requests cut execution time by about 73% compared to synchronous requests.

PerformancePythonTesting
0 likes · 7 min read
Boost Python API Testing Speed with Async httpx: A Practical Guide
ByteDance Web Infra
ByteDance Web Infra
Jul 12, 2021 · Frontend Development

Dan’s Live Interview on React Core: State Management, Hooks, Concurrent Mode, and Future Directions

In this extensive live interview, React core maintainer Dan discusses his programming origins, the philosophy behind React state management and Hooks, practical advice for newcomers, the challenges of Concurrent Mode and Server Components, and his vision for React’s evolution and competitiveness.

Concurrent ModeHooksPerformance
0 likes · 44 min read
Dan’s Live Interview on React Core: State Management, Hooks, Concurrent Mode, and Future Directions
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 12, 2021 · Backend Development

How to Compress Large Java int/long Arrays for Massive Memory Savings

This article explains how to reduce memory usage of massive Java int/long arrays by applying real‑time compression, eliminating redundancy, using indexed buckets, offset storage, and a series of low‑level optimizations that boost TPS from dozens to over a thousand while preserving random‑access capabilities.

ArrayMemory optimizationPerformance
0 likes · 14 min read
How to Compress Large Java int/long Arrays for Massive Memory Savings
Top Architect
Top Architect
Jul 10, 2021 · Backend Development

Optimizing Complex Search Queries with Redis: A Backend Development Demo

This article explores how backend developers can handle intricate e‑commerce search filters by first attempting a monolithic SQL solution, then improving performance with index analysis and query splitting, and finally achieving fast, scalable results using Redis sets, sorted sets, and transaction commands.

Backend DevelopmentCachingPerformance
0 likes · 8 min read
Optimizing Complex Search Queries with Redis: A Backend Development Demo
dbaplus Community
dbaplus Community
Jul 8, 2021 · Databases

Why ClickHouse Outperforms Elasticsearch for Log Storage and Analytics

This article compares ClickHouse and Elasticsearch for API log storage, detailing development activity, schema handling, query performance, statistical functions, MySQL integration, new features, and practical drawbacks, while providing concrete SQL examples and migration tips.

AnalyticsClickHouseElasticsearch
0 likes · 14 min read
Why ClickHouse Outperforms Elasticsearch for Log Storage and Analytics
TAL Education Technology
TAL Education Technology
Jul 8, 2021 · Frontend Development

Resolving WeChat H5 Authorization Loops, Poster Generation, and Page Performance Tracking

This article details the challenges encountered when developing WeChat H5 pages—such as authorization‑loop redirects, cross‑origin poster creation with html2canvas, iPhone 100vh scrolling bugs, and precise performance timing using window.performance—and presents practical code‑based solutions and compatibility tips for both iOS and Android devices.

AuthorizationCanvasFrontend
0 likes · 12 min read
Resolving WeChat H5 Authorization Loops, Poster Generation, and Page Performance Tracking
Liulishuo Tech Team
Liulishuo Tech Team
Jul 7, 2021 · Frontend Development

Evaluation and Evolution of Mini‑Program Development Frameworks for Frontend Teams

This article reviews the background, key considerations, architectural principles, evolution, performance comparison, and a customized solution for building mini‑programs using frameworks such as WePY, Taro, and UniApp, highlighting cross‑platform support, TypeScript integration, and development experience improvements.

EvaluationPerformanceframework
0 likes · 12 min read
Evaluation and Evolution of Mini‑Program Development Frameworks for Frontend Teams
Selected Java Interview Questions
Selected Java Interview Questions
Jul 7, 2021 · Operations

Redis Monitoring Metrics and Commands Guide

This article provides a comprehensive overview of Redis monitoring metrics—including performance, memory, basic activity, persistence, and error indicators—along with recommended monitoring tools, configuration settings, and command-line examples for gathering and interpreting these metrics in production environments.

OperationsPerformanceRedis
0 likes · 7 min read
Redis Monitoring Metrics and Commands Guide