BestHub
Sign in
Tagged articles

Performance

5000 articles · Page 27 of 50
DeWu Technology
DeWu Technology
Jan 9, 2023 · Fundamentals

Understanding JVM Bytecode, JIT Compilation, and Garbage Collection

The article explains how the JVM executes Java bytecode, detailing bytecode structure, lambda compilation, JIT tiers and optimizations such as inlining and escape analysis, describes runtime memory areas and generational garbage collectors—including G1, ZGC, and Shenandoah—and offers key tuning flags for balancing throughput, latency, and heap size.

Garbage CollectionJITJVM
0 likes · 52 min read
Understanding JVM Bytecode, JIT Compilation, and Garbage Collection
Liangxu Linux
Liangxu Linux
Jan 8, 2023 · Databases

Master MySQL: 13 Essential Functions and Commands for Efficient Data Handling

This comprehensive guide walks you through 13 practical MySQL techniques—including group_concat, char_length, locate, replace, now, insert‑select variations, on duplicate key update, show create table, explain, show processlist, and mysqldump—complete with clear examples, SQL snippets, and result screenshots to help you manage and optimize your data effectively.

DatabaseFunctionsMySQL
0 likes · 13 min read
Master MySQL: 13 Essential Functions and Commands for Efficient Data Handling
MaGe Linux Operations
MaGe Linux Operations
Jan 7, 2023 · Backend Development

Mastering Nginx: From Basics to Advanced Load Balancing and Performance Tuning

This article provides a comprehensive overview of Nginx, covering its definition, advantages, application scenarios, request processing flow, high‑concurrency mechanisms, proxy types, directory layout, configuration directives, load‑balancing algorithms, rate‑limiting strategies, health checks, gzip compression, and best practices for deployment and scaling.

PerformanceReverse Proxyhigh concurrency
0 likes · 34 min read
Mastering Nginx: From Basics to Advanced Load Balancing and Performance Tuning
21CTO
21CTO
Jan 6, 2023 · Backend Development

Ruby 3.2 Unveils YJIT and WebAssembly: Boosting Performance by 41%

Ruby 3.2.0, released on December 25, introduces official WebAssembly support via WASI and the first production-ready version of YJIT—a new JIT compiler from Shopify—delivering up to a 41% speed boost over the traditional interpreter, while also enhancing Regexp performance dramatically.

JITPerformanceRuby
0 likes · 4 min read
Ruby 3.2 Unveils YJIT and WebAssembly: Boosting Performance by 41%
Top Architect
Top Architect
Jan 6, 2023 · Databases

Why MySQL Discourages UUID Primary Keys and a Performance Comparison of Auto‑Increment, UUID, and Random Long IDs

This article investigates MySQL's recommendation against using UUIDs as primary keys by creating three tables with auto‑increment, UUID, and random (snowflake) keys, running insertion benchmarks with Spring Boot/JdbcTemplate, analyzing index structures, and discussing the advantages and drawbacks of each key strategy.

IndexingMySQLPerformance
0 likes · 11 min read
Why MySQL Discourages UUID Primary Keys and a Performance Comparison of Auto‑Increment, UUID, and Random Long IDs
Architect's Guide
Architect's Guide
Jan 6, 2023 · Backend Development

Redis Interview Questions: Solving Cache Penetration, Cache Breakdown, and Cache Avalanche

This article explains common Redis caching issues—cache penetration, cache breakdown, and cache avalanche—detailing their causes and practical mitigation techniques such as parameter validation, null caching, Bloom filters, mutex locks, hot‑data strategies, and staggered expiration to ensure system stability.

CacheCache AvalancheCache Breakdown
0 likes · 9 min read
Redis Interview Questions: Solving Cache Penetration, Cache Breakdown, and Cache Avalanche
DataFunTalk
DataFunTalk
Jan 5, 2023 · Big Data

Five Optimization Strategies for Improving DataTester Query Performance

This article describes how DataTester, Volcano Engine's A/B testing platform, achieved over four‑fold query speedup by applying five technical optimizations—including pre‑aggregation, join reduction, GroupBy redesign, AU‑metric caching, and asynchronous query handling—targeting both data construction and execution layers.

A/B testingClickHouseDataTester
0 likes · 12 min read
Five Optimization Strategies for Improving DataTester Query Performance
Tencent Cloud Developer
Tencent Cloud Developer
Jan 3, 2023 · Big Data

How Tencent’s Cloud‑Native Lakehouse Tackles PB‑Scale Performance Challenges

This article analyzes Tencent Cloud’s DLC lakehouse solution, explaining the unified data lake‑warehouse architecture, the performance hurdles of object‑storage‑based analytics, and the multi‑dimensional caching, virtual‑cluster elasticity, and advanced filter techniques that enable second‑level analysis on petabyte‑scale data while reducing costs.

Big DataCachingDLC
0 likes · 13 min read
How Tencent’s Cloud‑Native Lakehouse Tackles PB‑Scale Performance Challenges
ITPUB
ITPUB
Jan 3, 2023 · Databases

How DragonF MPP DB Redefines Cloud‑Native Data Warehousing at Massive Scale

The article details the design, core features, and real‑world performance of the DragonF MPP DB, a cloud‑native, compute‑storage‑separated database that overcomes traditional MPP limitations, supports millions of daily jobs, and outlines its future roadmap for ultra‑large‑scale data platforms.

Big DataData WarehouseMPP
0 likes · 11 min read
How DragonF MPP DB Redefines Cloud‑Native Data Warehousing at Massive Scale
IT Architects Alliance
IT Architects Alliance
Jan 3, 2023 · Fundamentals

Performance Optimization Techniques: Indexing, Caching, Compression, Prefetching, Throttling, and Batch Processing

The article explores a wide range of performance‑optimization strategies—including indexing, caching, compression, prefetching, peak‑shaving, and batch processing—explaining their trade‑offs, practical applications, and how they relate to hardware latency and system design in modern computing environments.

CachingIndexingPerformance
0 likes · 34 min read
Performance Optimization Techniques: Indexing, Caching, Compression, Prefetching, Throttling, and Batch Processing
Code Ape Tech Column
Code Ape Tech Column
Jan 3, 2023 · Big Data

Elasticsearch vs ClickHouse: Performance, Cost, and Deployment Guide

This article compares Elasticsearch and ClickHouse in terms of write throughput, query speed, and server cost, then provides a step‑by‑step deployment guide for a private data pipeline using Zookeeper, Kafka, FileBeat, and ClickHouse, along with common issues and their solutions.

Big DataClickHouseDeployment
0 likes · 15 min read
Elasticsearch vs ClickHouse: Performance, Cost, and Deployment Guide
MaGe Linux Operations
MaGe Linux Operations
Dec 30, 2022 · Big Data

Mastering Kafka: Core Concepts, Architecture, and Performance Optimizations

This comprehensive guide explores Kafka as a distributed messaging middleware, detailing its core concepts, architecture, producer and consumer mechanisms, configuration options, Zookeeper integration, controller responsibilities, network model, performance optimizations such as zero‑copy, page‑cache usage, batching, compression, and partition concurrency.

Distributed MessagingKafkaPerformance
0 likes · 41 min read
Mastering Kafka: Core Concepts, Architecture, and Performance Optimizations
DaTaobao Tech
DaTaobao Tech
Dec 30, 2022 · Backend Development

Practical Guide to Upgrading Java 8 to JDK 11 with G1 GC: Benefits, Steps, and New Features

The article provides a hands‑on migration guide for moving an internal gateway service from Java 8 to JDK 11 with the G1 garbage collector, detailing a checklist of tool and dependency updates, showcasing up to 105 % performance gains, outlining new language features, virtual‑thread usage, and best‑practice recommendations for a smooth, cost‑effective upgrade.

G1GCJDK11Java
0 likes · 32 min read
Practical Guide to Upgrading Java 8 to JDK 11 with G1 GC: Benefits, Steps, and New Features
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 29, 2022 · Fundamentals

How to Achieve Zero‑Copy String Construction Across JDK Versions

This article explains the internal differences of Java's String implementation from JDK 8 to JDK 9+, demonstrates how to use sun.misc.Unsafe and trusted MethodHandles.Lookup to build zero‑copy String objects, and provides practical code examples for high‑performance string handling.

MethodHandlesPerformanceString
0 likes · 12 min read
How to Achieve Zero‑Copy String Construction Across JDK Versions
Architects' Tech Alliance
Architects' Tech Alliance
Dec 27, 2022 · Fundamentals

Understanding Time and Space Trade‑offs in Software Performance Optimization

The article explains how software performance is limited by the time spent in CPU, memory, storage and network operations and by the space consumed by data structures, JVM object headers, thread stacks and protocol overhead, illustrating the need for careful time‑space trade‑offs to achieve efficient optimization.

LatencyOptimizationPerformance
0 likes · 9 min read
Understanding Time and Space Trade‑offs in Software Performance Optimization
ByteFE
ByteFE
Dec 26, 2022 · Frontend Development

Design and Implementation of SpriteJS: A Cross‑Platform WebGL/Canvas2D Rendering Engine

This article details the four‑year development of SpriteJS, a high‑performance, cross‑platform graphics system that supports WebGL and Canvas2D rendering, DOM‑like APIs, responsive design, WebWorker integration, and extensive performance optimizations for visualisation and game applications.

Canvas2DGraphicsPerformance
0 likes · 18 min read
Design and Implementation of SpriteJS: A Cross‑Platform WebGL/Canvas2D Rendering Engine
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Dec 23, 2022 · Frontend Development

Build the Ultimate Front-End Monitoring System & Master Advanced JS Tricks

It introduces a series of front‑end engineering articles covering comprehensive monitoring architecture, CSS‑based click throttling, drag‑and‑drop implementation, 30 essential JavaScript concepts, and a simple responsive data‑dashboard solution, aiming to deepen developers’ skills and showcase resume‑worthy expertise.

FrontendJavaScriptMonitoring
0 likes · 3 min read
Build the Ultimate Front-End Monitoring System & Master Advanced JS Tricks
Programmer DD
Programmer DD
Dec 23, 2022 · Backend Development

Unlock High Performance: 6 Proven Techniques to Supercharge Your Software

This article presents six practical performance‑optimization methods—indexing, compression, caching, prefetching, peak‑shaving, and batch processing—explains their principles, trade‑offs, and real‑world applications, and then dives into four advanced strategies for scaling and parallelism, all illustrated with memorable analogies.

CachingIndexingOptimization
0 likes · 36 min read
Unlock High Performance: 6 Proven Techniques to Supercharge Your Software
Architect
Architect
Dec 22, 2022 · Operations

An Introduction to eBPF: Concepts, Use Cases, and Sample Programs

This article explains what eBPF (extended Berkeley Packet Filter) is, compares it with related tracing tools, describes its core mechanisms and common applications such as network monitoring, security filtering and performance analysis, and provides step‑by‑step Python examples with installation instructions and further reading resources.

BCCLinuxPerformance
0 likes · 20 min read
An Introduction to eBPF: Concepts, Use Cases, and Sample Programs
Tencent Cloud Developer
Tencent Cloud Developer
Dec 21, 2022 · Backend Development

Function Call Mechanisms in Go and Performance Optimization

The article explains Go’s caller‑callee model, stack‑frame layout, and how parameter and return‑value passing shifted in Go 1.17.1—using registers for up to nine arguments or results and the stack for any beyond—highlighting the impact on performance and optimization.

Backend DevelopmentFunction CallsPerformance
0 likes · 24 min read
Function Call Mechanisms in Go and Performance Optimization
21CTO
21CTO
Dec 20, 2022 · Databases

Explore PostgreSQL 15: New Features, Performance Boosts, and Upgrade Guide

PostgreSQL 15 introduces a safer permission model, up to four‑fold sorting speed improvements, a MERGE command, enhanced logical replication with two‑phase commit, parallel query execution, JSON logging, Zstandard/ZL4 compression, new regex functions, and shared‑memory server statistics, making it a compelling upgrade for developers and DBAs.

DatabaseNew FeaturesPerformance
0 likes · 6 min read
Explore PostgreSQL 15: New Features, Performance Boosts, and Upgrade Guide
Java High-Performance Architecture
Java High-Performance Architecture
Dec 20, 2022 · Backend Development

Mastering Cache: Concepts, Types, and Best Practices for High‑Performance Systems

Cache stores frequently accessed hot data in memory to reduce database load, improving performance and handling high‑concurrency scenarios; this article explains cache fundamentals, why Redis is preferred, classifications such as local, distributed, and multi‑level caches, their advantages, drawbacks, and implementation tips.

Performancedistributed cache
0 likes · 8 min read
Mastering Cache: Concepts, Types, and Best Practices for High‑Performance Systems
php Courses
php Courses
Dec 20, 2022 · Databases

Redis Memory Not Releasing Issue and Analysis of 20 Million Expiring Keys

This article describes a Redis 5.0 memory leak scenario where 20 million keys with expiration caused memory not to be released, details the investigation steps, findings about the activeExpireCycle, and concludes that memory will eventually be freed, followed by a promotional announcement for a PHP online live class.

DatabasesMemory managementPHP
0 likes · 3 min read
Redis Memory Not Releasing Issue and Analysis of 20 Million Expiring Keys
Top Architect
Top Architect
Dec 19, 2022 · Databases

Performance Comparison of Auto‑Increment, UUID, and Random Keys in MySQL

This article investigates MySQL's recommendation against using UUID or non‑sequential keys, builds three tables with auto‑increment, UUID, and random (snowflake) primary keys, runs insertion and query benchmarks using Spring Boot and JdbcTemplate, analyzes index structures, and discusses the advantages and drawbacks of each approach.

MySQLPerformancePrimary Key
0 likes · 11 min read
Performance Comparison of Auto‑Increment, UUID, and Random Keys in MySQL
Soul Technical Team
Soul Technical Team
Dec 19, 2022 · Mobile Development

Common Flutter Performance Pitfalls and Their Solutions at Soul App

This article details several real‑world Flutter performance problems encountered at Soul—including excessive memory usage for emojis, iOS 14 debug launch restrictions, high CPU consumption of Lottie animations, background‑foreground flickering, and PlatformView memory leaks—and provides concrete mitigation strategies with code examples.

FlutterPerformancePlatformView
0 likes · 11 min read
Common Flutter Performance Pitfalls and Their Solutions at Soul App
DeWu Technology
DeWu Technology
Dec 16, 2022 · Databases

TiDB Adoption and Operational Practices at Dewu

Dewu transitioned from a single‑instance MySQL setup to a distributed TiDB architecture—using three TiDB, PD, and TiKV/TiFlash nodes, automated backups, Prometheus monitoring, and chaos‑engineering controls—which delivered linear scalability, eliminated slow queries, cut infrastructure costs by about 58 % and maintained stable performance during major sales events.

MySQL ComparisonPerformanceTiDB
0 likes · 28 min read
TiDB Adoption and Operational Practices at Dewu
Youku Technology
Youku Technology
Dec 16, 2022 · Frontend Development

GaiaX Layout Solution: Flexbox and Stretch Engine Analysis

GaiaX, Alibaba Entertainment’s cross‑platform dynamic UI framework, adopts Flexbox implemented with the Rust‑based Stretch engine to deliver millisecond‑level layout latency on phones, tablets, OTT, Macs and IoT devices, while fixing iOS 32‑bit crashes, redefining aspect‑ratio logic, adding thread‑safe wrappers and extensive tests, and open‑sourcing the extended library.

FlexboxGaiaXLayout Engine
0 likes · 18 min read
GaiaX Layout Solution: Flexbox and Stretch Engine Analysis
vivo Internet Technology
vivo Internet Technology
Dec 14, 2022 · Product Management

Practical Guide to OKR Setting – Part 1

This first practical installment of the OKR Sword series explains how the 3C formulation principles—Concentrated, Challenging, Controllable—guide objective creation, outlines three sources of goals, and presents a four‑step process (background input, collaborative drafting, alignment, personal definition) for aligning team cognition, motivation, and performance.

OKRPerformanceTeam Alignment
0 likes · 23 min read
Practical Guide to OKR Setting – Part 1
Architecture Digest
Architecture Digest
Dec 14, 2022 · Backend Development

Why Baidu Built Janus: Design and Implementation of a High‑Performance General Gateway

Janus is Baidu’s high‑throughput, multi‑purpose gateway that complements BFE, supporting traffic, business, and hybrid routing for dozens of internal services; the article explains its motivations, architecture, three‑tier routing rules, variable and conditional expressions, plugin system, performance benchmarks, and future extensions.

Backend DevelopmentPerformancePlugin system
0 likes · 12 min read
Why Baidu Built Janus: Design and Implementation of a High‑Performance General Gateway
ELab Team
ELab Team
Dec 13, 2022 · Frontend Development

Boost Your Site’s Traffic: Front‑End SEO Strategies from Zero to Success

This comprehensive guide walks front‑end developers through the entire SEO workflow—from understanding search engine mechanics and optimizing site structure, URLs, and TDK, to performance tuning, sitemap and API submission, link building, structured data, and monitoring—offering practical tactics to increase organic traffic.

FrontendPerformanceSEO
0 likes · 20 min read
Boost Your Site’s Traffic: Front‑End SEO Strategies from Zero to Success
TikTok Frontend Technology Team
TikTok Frontend Technology Team
Dec 13, 2022 · Frontend Development

Understanding Browser Process Architecture and Rendering Pipeline

This article explains how modern browsers use multi‑process architectures, detailing the evolution from single‑process models, the roles of browser, renderer, GPU, network, and plugin processes, and walks through the navigation and rendering pipelines—including DOM construction, style calculation, layout, layering, painting, rasterization, compositing, and their impact on performance.

FrontendPerformanceProcess Architecture
0 likes · 12 min read
Understanding Browser Process Architecture and Rendering Pipeline
Java High-Performance Architecture
Java High-Performance Architecture
Dec 12, 2022 · Backend Development

Java Rate Limiting: Fixed, Sliding, Leaky & Token Bucket Algorithms Explained

This article introduces the concept of rate limiting, explains three core algorithms—fixed window, sliding window, and leaky bucket—along with the token bucket approach, provides Java code examples for each, discusses their principles, advantages, and pitfalls, and outlines practical implementation considerations.

JavaPerformancealgorithm
0 likes · 15 min read
Java Rate Limiting: Fixed, Sliding, Leaky & Token Bucket Algorithms Explained
Python Programming Learning Circle
Python Programming Learning Circle
Dec 12, 2022 · Fundamentals

Pond: An Efficient Python Object Pool Library

The article introduces Pond, a high‑performance Python object‑pool library that reduces memory consumption and GC pressure by reusing objects, explains its design components, automatic eviction strategy, thread‑safe borrowing and returning mechanisms, and provides detailed usage examples with code snippets.

ConcurrencyLibraryObject Pool
0 likes · 11 min read
Pond: An Efficient Python Object Pool Library
Code Ape Tech Column
Code Ape Tech Column
Dec 12, 2022 · Fundamentals

JVM GC Log Analysis and Tuning Practice

This article explains how to enable detailed GC logging in the JVM, interpret both Young and Full GC log entries, configure heap parameters, and use the online visualizer gceasy.io to analyze performance metrics such as throughput, pause latency, and memory usage for effective JVM tuning.

GCJVMJava
0 likes · 9 min read
JVM GC Log Analysis and Tuning Practice
ITPUB
ITPUB
Dec 10, 2022 · Backend Development

Unlock Kafka’s Speed: Deep Dive into Performance Optimizations

This article explores Kafka's performance secrets by examining network, disk, and algorithmic factors, detailing sequential writes, zero‑copy techniques, page‑cache usage, Reactor‑based networking, batching, compression, partition concurrency, and file‑structure optimizations, and provides practical guidance for high‑throughput deployments.

BatchingOptimizationPerformance
0 likes · 18 min read
Unlock Kafka’s Speed: Deep Dive into Performance Optimizations
Top Architect
Top Architect
Dec 9, 2022 · Backend Development

In-Memory Caching with Guava LoadingCache: Design, Algorithms, and Best Practices

This article explains the principles and practical implementation of in‑memory caching using Guava’s LoadingCache, covering cache initialization parameters, put and loading strategies, eviction policies, common algorithms such as LRU, LFU, FIFO, and tips for avoiding memory issues and monitoring cache performance.

CachingGuavaJava
0 likes · 15 min read
In-Memory Caching with Guava LoadingCache: Design, Algorithms, and Best Practices
Top Architect
Top Architect
Dec 8, 2022 · Backend Development

Common MyBatis Batch Insert Techniques and Performance Comparison

This article presents a detailed overview of five commonly used MyBatis and MyBatis-Plus batch insertion methods, including code examples, configuration steps, and performance measurements for inserting ten thousand records, helping developers choose the most efficient approach for large‑scale data insertion in Java backend projects.

Batch InsertJavaMyBatis
0 likes · 11 min read
Common MyBatis Batch Insert Techniques and Performance Comparison
Sohu Tech Products
Sohu Tech Products
Dec 7, 2022 · Backend Development

Comprehensive Guide to Using Caffeine Cache in Java

This article provides an in‑depth tutorial on configuring and using the Caffeine caching library in Java, covering cache creation, property settings such as initial capacity, maximum size, weight, expiration policies, statistics collection, custom listeners, and advanced features like removal listeners and cache writers.

CacheCaffeinePerformance
0 likes · 18 min read
Comprehensive Guide to Using Caffeine Cache in Java
Sohu Tech Products
Sohu Tech Products
Dec 7, 2022 · Databases

How to Diagnose and Resolve Redis Performance Issues

This article explains how to identify Redis latency problems, measure baseline performance, monitor slow commands, and address common causes such as network RTT, forked RDB snapshots, transparent huge pages, swap usage, AOF configuration, key expiration bursts, and big keys, providing practical solutions and a checklist for remediation.

DatabaseLatencyOptimization
0 likes · 18 min read
How to Diagnose and Resolve Redis Performance Issues
ELab Team
ELab Team
Dec 6, 2022 · Frontend Development

Ensuring Smooth, Stable Experiences for Massive Mobile Event Launches

This article outlines the technical strategies and best practices for guaranteeing high‑quality user experiences during large‑scale mobile event rollouts, covering background, core guarantees, business characteristics, performance metrics, high‑concurrency handling, dynamic configuration, loading optimization, runtime safeguards, and monitoring.

FrontendPerformancedynamic-configuration
0 likes · 23 min read
Ensuring Smooth, Stable Experiences for Massive Mobile Event Launches
Programmer DD
Programmer DD
Dec 6, 2022 · Frontend Development

Why We Chose Svelte Over Vue 3: A Real‑World Migration Case Study

This article details a frontend team's decision to migrate from Vue 2/3 to Svelte, covering the motivations, performance benchmarks, type‑checking improvements, code‑size analysis, migration workflow, and the practical benefits and trade‑offs observed after the transition.

PerformanceSvelteType Checking
0 likes · 13 min read
Why We Chose Svelte Over Vue 3: A Real‑World Migration Case Study
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 6, 2022 · Backend Development

How Fury Achieves 20‑200× Faster Java Serialization Than JDK, Hessian, and Kryo

Fury is a JIT‑compiled, multi‑language native serialization framework that fully implements JDK custom serialization, delivering 20‑200× speed improvements over JDK, Hessian, and Kryo, while preserving compatibility across Java, Python, Go, C++, and JavaScript, as demonstrated by detailed protocol analysis and performance benchmarks.

FuryHessianJDK
0 likes · 21 min read
How Fury Achieves 20‑200× Faster Java Serialization Than JDK, Hessian, and Kryo
Laravel Tech Community
Laravel Tech Community
Dec 5, 2022 · Databases

Using MySQL Built‑in Commands for Comprehensive Database Monitoring

This article explains how to collect extensive MySQL performance metrics—including connections, buffer cache, locks, SQL status, statement counts, throughput, server configuration, and slow‑query logs—using only MySQL's native SHOW commands and the performance_schema, providing practical code snippets and optimization tips.

DatabaseMonitoringMySQL
0 likes · 10 min read
Using MySQL Built‑in Commands for Comprehensive Database Monitoring
Tencent Cloud Developer
Tencent Cloud Developer
Dec 5, 2022 · Fundamentals

Chromium Rendering Pipeline Overview

The article details Chromium’s rendering pipeline, tracing how network bytecode becomes on‑screen pixels through 13 stages—from parsing and style calculation to layout, painting, compositing, tiling, rasterization, activation, aggregation, and final display—while explaining process models, component formulas, and synchronous versus asynchronous raster strategies.

ChromiumEnginePerformance
0 likes · 31 min read
Chromium Rendering Pipeline Overview
Programmer DD
Programmer DD
Dec 5, 2022 · Backend Development

Why Our Microservice Overhaul Sparked Explosive Complexity—and What We Learned

A data‑service company migrated 20,000 customers to a microservice architecture, initially gaining visibility, lower deployment costs, and easier scaling, but later faced queue head blocking, shared‑library version chaos, load‑pattern challenges, and management overhead, ultimately prompting a return to a monolith with a new "Centrifuge" component.

DeploymentPerformancearchitecture
0 likes · 12 min read
Why Our Microservice Overhaul Sparked Explosive Complexity—and What We Learned
MoonWebTeam
MoonWebTeam
Dec 4, 2022 · Frontend Development

Why Svelte Beats Vue3 and React: Real-World Performance Gains and Core Mechanics

This article presents a comprehensive investigation of Svelte, detailing its dramatic bundle size reduction, performance improvements, compilation-based architecture, core implementation, advantages, drawbacks, and practical usage guidelines, supported by real project data, npm and GitHub statistics, and code examples to help developers confidently adopt Svelte.

CompilationFrontendJavaScript
0 likes · 30 min read
Why Svelte Beats Vue3 and React: Real-World Performance Gains and Core Mechanics
ByteDance SYS Tech
ByteDance SYS Tech
Dec 2, 2022 · Backend Development

How Sonic‑CPP Boosts JSON Parsing Speed 2.5× Faster Than RapidJSON

Sonic‑CPP, an open‑source C++ JSON library co‑developed by ByteDance’s STE and Service Framework teams, leverages SIMD vectorization, optimized memory layout, on‑demand parsing, and a compact DOM design to achieve up to 2.5× faster parsing than RapidJSON and competitive serialization performance, with extensive benchmark results and production‑grade usage.

C++ParsingPerformance
0 likes · 13 min read
How Sonic‑CPP Boosts JSON Parsing Speed 2.5× Faster Than RapidJSON
Selected Java Interview Questions
Selected Java Interview Questions
Dec 2, 2022 · Backend Development

Understanding Cache: Concepts, Types, and Implementation in Backend Development

This article explains the fundamentals of caching, why caches like Redis are essential for high‑performance and high‑concurrency backend systems, and compares local, distributed, and multi‑level cache architectures, including their advantages, drawbacks, and typical implementation approaches.

Local CacheMulti-level CachePerformance
0 likes · 9 min read
Understanding Cache: Concepts, Types, and Implementation in Backend Development
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Dec 2, 2022 · Frontend Development

Essential Frontend Techniques: Tree‑Shaking, Code Readability, and Performance Hacks

Explore a curated collection of frontend articles covering bundler tree‑shaking, code readability tricks, precision handling with big.js, hidden CSS features, Apple‑style scrolling effects, ready‑made visual dashboard demos, and performance insights like reducing jank and mastering LightHouse workflows.

FrontendJavaScriptPerformance
0 likes · 4 min read
Essential Frontend Techniques: Tree‑Shaking, Code Readability, and Performance Hacks
Watermelon Frontend Tech Team
Watermelon Frontend Tech Team
Dec 1, 2022 · Frontend Development

Ensuring Smooth, Stable Experiences for Massive Mobile Event Launches

This article outlines practical strategies for guaranteeing high‑concurrency, high‑flexibility, and stable performance of large‑scale mobile event pages, covering user experience goals, technical indicators, load and runtime optimizations, dynamic configuration, and monitoring to keep millions of users satisfied.

EventPerformancehigh concurrency
0 likes · 23 min read
Ensuring Smooth, Stable Experiences for Massive Mobile Event Launches
Tencent Cloud Developer
Tencent Cloud Developer
Dec 1, 2022 · Databases

Mastering Redis: From Basics, Installation to Advanced Features and Real‑World Use Cases

This comprehensive guide explains what Redis is, its core data structures, typical scenarios such as caching, counters, message queues and leaderboards, installation steps on Linux, configuration options, advanced features like pipelines, Lua scripting, persistence mechanisms, replication, caching strategies, consistency challenges, and distributed locking techniques.

CachingData StructuresDistributed Locks
0 likes · 64 min read
Mastering Redis: From Basics, Installation to Advanced Features and Real‑World Use Cases
Tencent Cloud Developer
Tencent Cloud Developer
Nov 28, 2022 · Backend Development

Understanding Go Channels: Implementation, Usage, and Performance

The article explains Go’s channel implementation as a lock‑protected FIFO queue composed of a circular buffer, send and receive wait queues, detailing creation, send/receive mechanics, closing behavior, a real‑world memory‑leak example, and why this design offers safe, performant concurrency comparable to mutexes.

ConcurrencyPerformancechannel
0 likes · 29 min read
Understanding Go Channels: Implementation, Usage, and Performance
ELab Team
ELab Team
Nov 25, 2022 · Frontend Development

Why Qwik’s Resumable Architecture Could Redefine Frontend Performance

This article examines the limitations of traditional big‑runtime and Virtual DOM frameworks, explores community solutions like pre‑compile, Islands, and React Server Components, and explains how Qwik’s Resumable approach and Partytown can dramatically improve first‑paint speed and reduce client‑side overhead.

PerformancePrecompileQwik
0 likes · 18 min read
Why Qwik’s Resumable Architecture Could Redefine Frontend Performance
DataFunSummit
DataFunSummit
Nov 22, 2022 · Big Data

BI Platform Practice at Xiaomi: Evolution, Architecture, and Future Directions

This article details Xiaomi's multi‑year journey in building a group‑wide Business Intelligence platform, covering its historical evolution, technical challenges in performance, modeling, visualization and permissions, the current four‑layer architecture, and future plans to make the platform more business‑centric and simpler.

AnalyticsBIBig Data
0 likes · 15 min read
BI Platform Practice at Xiaomi: Evolution, Architecture, and Future Directions
Top Architect
Top Architect
Nov 22, 2022 · Big Data

Efficient Massive Excel Import/Export with POI and EasyExcel in Java

This article explains how to efficiently import and export massive datasets (up to millions of rows) between Excel and databases using Apache POI, SXSSF, and Alibaba's EasyExcel, comparing workbook types, outlining performance considerations, and providing Java code examples for batch processing, paging, and transaction management.

Big DataEasyExcelExcel
0 likes · 23 min read
Efficient Massive Excel Import/Export with POI and EasyExcel in Java
Liangxu Linux
Liangxu Linux
Nov 20, 2022 · Fundamentals

Does Adding More RAM Really Speed Up Your PC? Explained

Adding more RAM can improve performance only when memory is a bottleneck; if your system already has sufficient memory, extra RAM won’t make the CPU run faster, though it does allow more programs to run simultaneously, while insufficient memory can severely slow down tasks.

CPUMemory managementPerformance
0 likes · 7 min read
Does Adding More RAM Really Speed Up Your PC? Explained
Architects' Tech Alliance
Architects' Tech Alliance
Nov 20, 2022 · Databases

Columnar Storage vs Row Storage: Overview, Write/Read Comparison, Pros, Cons, and Use Cases

This article explains the differences between row-based and column-based storage, comparing their write and read performance, outlining advantages and disadvantages, and describing suitable scenarios such as OLAP queries, column families, compression, and indexing, to help choose the appropriate storage model.

Big DataColumnar StorageDatabase
0 likes · 10 min read
Columnar Storage vs Row Storage: Overview, Write/Read Comparison, Pros, Cons, and Use Cases
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Nov 19, 2022 · Frontend Development

Top Frontend Techniques: Lodash, Iterators, Web3D, Performance Tips

This guide surveys essential frontend topics—including deep dives into lodash usage, iterator and generator concepts, Web3D visualizations, hybrid remote debugging, long‑task performance optimization, Chrome DevTools measurement, and creative image‑loading effects—offering practical insights for modern web developers.

FrontendPerformanceWeb Development
0 likes · 3 min read
Top Frontend Techniques: Lodash, Iterators, Web3D, Performance Tips
JD Tech
JD Tech
Nov 18, 2022 · Backend Development

Paginated Loading of Shopping Cart Auxiliary Information in JD E‑commerce Platform

This article examines the challenges of scaling JD's shopping cart, proposes a paginated loading strategy for auxiliary product information to reduce backend load and improve user experience, and details the technical design, pagination options, pre‑loading mechanisms, and measured performance benefits.

Asynchronous LoadingPerformanceShopping Cart
0 likes · 14 min read
Paginated Loading of Shopping Cart Auxiliary Information in JD E‑commerce Platform
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 17, 2022 · Frontend Development

Deep Dive into requestIdleCallback API and Its Use with React

This article explains the requestIdleCallback web API, its syntax, execution timing, task‑queue handling, performance characteristics, compatibility issues, and practical integration with React and requestAnimationFrame to off‑load low‑priority work without blocking UI rendering.

Idle TasksJavaScriptPerformance
0 likes · 14 min read
Deep Dive into requestIdleCallback API and Its Use with React
Laravel Tech Community
Laravel Tech Community
Nov 16, 2022 · Databases

DuckDB New Release Highlights and Feature Changes

The article introduces DuckDB, a high‑performance embedded analytical database, outlines its new release’s storage, performance, and memory improvements, describes its C/C++ integration and build process, and lists key feature changes such as parallel execution, novel compression methods, and enhanced SQL capabilities.

DuckDBEmbedded DatabasePerformance
0 likes · 3 min read
DuckDB New Release Highlights and Feature Changes
Su San Talks Tech
Su San Talks Tech
Nov 16, 2022 · Databases

Why count(*) Slows Down MySQL and How to Optimize It

This article explains why MySQL's count(*) can become a performance bottleneck, especially with InnoDB, and presents practical optimization techniques such as Redis caching, second‑level in‑memory caches, parallel execution, reducing unnecessary joins, and using column‑store databases like ClickHouse.

COUNTClickHouseMySQL
0 likes · 10 min read
Why count(*) Slows Down MySQL and How to Optimize It
vivo Internet Technology
vivo Internet Technology
Nov 16, 2022 · Operations

Understanding and Mitigating Bigkey Issues in Redis Operations

Bigkeys—Redis values over 1 MB or structures with more than 2,000 elements—cause memory imbalance, command blocking, network overload, and migration failures, so DBAs must detect them using built‑in commands or RDB analysis, split or partition oversized keys, and tune migration settings to preserve performance and availability.

Database operationsPerformanceRedis
0 likes · 14 min read
Understanding and Mitigating Bigkey Issues in Redis Operations
Su San Talks Tech
Su San Talks Tech
Nov 16, 2022 · Databases

Why count(*) Is Slow in MySQL InnoDB and How to Speed It Up

This article explains why MySQL's count(*) can be slow on InnoDB, compares different count variations, and presents practical optimization techniques such as Redis caching, second‑level caches, multithreading, reducing joins, and using ClickHouse for massive datasets.

COUNTClickHouseInnoDB
0 likes · 12 min read
Why count(*) Is Slow in MySQL InnoDB and How to Speed It Up
Efficient Ops
Efficient Ops
Nov 15, 2022 · Operations

Master Linux Performance: Key Metrics, Tools, and Optimization Strategies

This comprehensive guide explains Linux performance optimization by defining key metrics such as throughput and latency, interpreting average load, analyzing CPU context switches, memory management, and I/O behavior, and recommending practical tools and techniques—including vmstat, pidstat, perf, and dstat—to identify and resolve bottlenecks.

CPULinuxMonitoring
0 likes · 45 min read
Master Linux Performance: Key Metrics, Tools, and Optimization Strategies
21CTO
21CTO
Nov 15, 2022 · Backend Development

Elon Musk’s Twitter RPC War: Engineers Clash Over 1200 vs 200 Microservice Calls

After Elon Musk apologized for Twitter’s sluggish performance, a heated exchange erupted on the platform as engineers disputed his claim of over 1,200 RPC calls per request, revealing internal tensions, firings, and debates over microservice usage and GraphQL knowledge within Twitter’s backend architecture.

Elon MuskPerformanceRPC
0 likes · 6 min read
Elon Musk’s Twitter RPC War: Engineers Clash Over 1200 vs 200 Microservice Calls
Huolala Tech
Huolala Tech
Nov 15, 2022 · Mobile Development

How We Reduced iOS App Launch Time by Up to 99% on Low-End Devices

This article details a multi‑phase approach to dramatically improve iOS app launch performance, especially on low‑end iPhone models, by analyzing slow functions, applying image compression, lazy loading, run‑loop monitoring, and eliminating unnecessary background tasks, achieving launch times under 3 seconds for 99.7% of users.

Objective‑CPerformanceSwift
0 likes · 28 min read
How We Reduced iOS App Launch Time by Up to 99% on Low-End Devices
21CTO
21CTO
Nov 14, 2022 · Fundamentals

How Microsoft’s Faster CPython Team Is Boosting Python Performance by Up to 60%

Microsoft assembled a six‑engineer team, including Guido van Rossum, to accelerate CPython according to a multi‑phase plan, resulting in Python 3.11 delivering 10‑60% speed improvements and showcasing how coordinated open‑source effort can overcome Python’s historic performance limitations.

CPythonLanguage DevelopmentMicrosoft
0 likes · 6 min read
How Microsoft’s Faster CPython Team Is Boosting Python Performance by Up to 60%
MaGe Linux Operations
MaGe Linux Operations
Nov 14, 2022 · Fundamentals

How to Boost Linux Pipe Throughput from 3.5 GiB/s to 65 GiB/s

Using a step‑by‑step example program, this article shows how to dramatically improve Linux pipe read/write performance—from an initial 3.5 GiB/s to 65 GiB/s—by applying zero‑copy techniques, ring buffers, paging insights, vmsplice/splice system calls, huge pages, and busy‑loop optimizations.

HugePagesLinuxPerformance
0 likes · 29 min read
How to Boost Linux Pipe Throughput from 3.5 GiB/s to 65 GiB/s
Top Architect
Top Architect
Nov 14, 2022 · Databases

Performance Comparison of Auto‑Increment ID vs UUID Primary Keys in MySQL

The article presents a detailed performance comparison between auto‑increment integer primary keys and UUID string primary keys in MySQL, including table definitions, 5‑million‑row and 10‑million‑row test results for read, range, write, backup, and storage efficiency, and offers practical recommendations for choosing the appropriate key strategy in distributed environments.

MySQLPerformancePrimary Key
0 likes · 13 min read
Performance Comparison of Auto‑Increment ID vs UUID Primary Keys in MySQL
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Nov 11, 2022 · Frontend Development

Explore Frontend Trends: Vite, Low‑Code, Functional Programming, JMeter, and Security

This collection highlights essential frontend topics—including Vite's performance debate, low‑code concepts, functional programming fundamentals, JMeter performance testing, strategies for managing module dependencies and theme switching, as well as practical guidance on preventing XSS and CSRF attacks—offering developers a concise roadmap to modern web development.

FrontendFunctional ProgrammingPerformance
0 likes · 5 min read
Explore Frontend Trends: Vite, Low‑Code, Functional Programming, JMeter, and Security
ITPUB
ITPUB
Nov 9, 2022 · Databases

Mastering Redis Persistence: RDB vs AOF Explained

This article provides a comprehensive guide to Redis persistence, covering the theory and configuration of both RDB snapshotting and AOF append‑only logging, their advantages, drawbacks, practical setup commands, recovery procedures, and performance‑tuning tips for reliable data durability.

AOFPerformancePersistence
0 likes · 16 min read
Mastering Redis Persistence: RDB vs AOF Explained
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 9, 2022 · Mobile Development

Using Isolates and the compute Function in Flutter to Offload Heavy Computation

This article explains how to prevent UI blocking in Flutter by moving intensive calculations to background isolates using the compute helper and raw Isolate APIs, demonstrates code examples for task execution, progress reporting, and inter‑isolate communication, and discusses performance considerations and best practices.

ComputeDARTFlutter
0 likes · 15 min read
Using Isolates and the compute Function in Flutter to Offload Heavy Computation
Efficient Ops
Efficient Ops
Nov 8, 2022 · Operations

Diagnosing High Load with Low CPU on Linux: Tools and Tips

This guide explains how to analyze and troubleshoot situations where Linux systems show high load averages despite low CPU usage, covering common load analysis methods, key commands like top, vmstat, iostat, sar, and ps, and practical solutions for I/O bottlenecks and D‑state processes.

CPULinuxLoad
0 likes · 11 min read
Diagnosing High Load with Low CPU on Linux: Tools and Tips
Top Architect
Top Architect
Nov 8, 2022 · Backend Development

Understanding In-Memory Caching with Guava LoadingCache and LRU Implementation in Java

This article explains the fundamentals of in‑memory caching, compares it with buffering, introduces Guava's LoadingCache configuration and operations, discusses eviction strategies, illustrates common cache algorithms (FIFO, LRU, LFU), provides a simple LRU implementation using LinkedHashMap, and offers practical guidelines for when and how to apply caching to improve backend performance.

CachingGuavaJava
0 likes · 14 min read
Understanding In-Memory Caching with Guava LoadingCache and LRU Implementation in Java
Efficient Ops
Efficient Ops
Nov 7, 2022 · Operations

Essential Redis Monitoring Metrics and Commands for Effective Operations

This guide details key Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—along with practical commands, configuration settings, and code snippets to help operators efficiently track and troubleshoot Redis instances.

LinuxMonitoringOperations
0 likes · 6 min read
Essential Redis Monitoring Metrics and Commands for Effective Operations