BestHub
Sign in
Tagged articles

Performance

5000 articles · Page 36 of 50
Tencent Cloud Developer
Tencent Cloud Developer
Jul 6, 2021 · Cloud Computing

MicroVMM and Firecracker: Core Technologies Behind Serverless Computing

The talk explains how a purpose‑built microVMM like Firecracker—an ultra‑lightweight, Rust‑based virtual machine monitor running on KVM—delivers the strong isolation, millisecond‑scale startup, and high‑density performance essential for modern serverless platforms, while outlining current benchmarks and future enhancements.

Cloud ComputingFirecrackerMicroVMM
0 likes · 26 min read
MicroVMM and Firecracker: Core Technologies Behind Serverless Computing
MaGe Linux Operations
MaGe Linux Operations
Jul 5, 2021 · Cloud Native

How Do Cloud‑Native Storage Solutions Stack Up? Performance Insights

This article examines typical storage options for stateful applications in cloud‑native environments, compares mainstream cloud‑native storage products through performance testing, discusses the challenges of multi‑cloud deployments, outlines criteria for selecting storage solutions, and highlights the advantages of distributed and cloud‑native storage systems for modern workloads.

Multi-CloudPerformancecloud-native
0 likes · 15 min read
How Do Cloud‑Native Storage Solutions Stack Up? Performance Insights
DeWu Technology
DeWu Technology
Jul 2, 2021 · Databases

MySQL Deep Pagination Optimization

MySQL deep pagination can be dramatically accelerated by ordering on the primary key, indexing the sort column, and using keyset pagination or a sub‑query join instead of scanning millions of rows, while only minor tweaks like increasing sort_buffer_size provide negligible gains.

IndexingMySQLPerformance
0 likes · 10 min read
MySQL Deep Pagination Optimization
Aikesheng Open Source Community
Aikesheng Open Source Community
Jul 2, 2021 · Databases

Observing the Effects of MySQL Group Commit through Experiments

Through a series of experiments using MySQL 8.0, this article demonstrates how group commit reduces I/O operations by consolidating multiple transactions into a single commit group, showing that doubling load increases runtime modestly while transaction count and commit groups rise significantly, highlighting performance benefits.

Group CommitIO optimizationMySQL
0 likes · 4 min read
Observing the Effects of MySQL Group Commit through Experiments
Beike Product & Technology
Beike Product & Technology
Jul 1, 2021 · Backend Development

Understanding Node.js Asynchronous I/O Model and Its Impact on High‑Concurrency Performance

The article analyses a real‑world Node.js service outage caused by sudden 504 timeouts, explains how the asynchronous I/O model creates time‑slice contention under high QPS, presents load‑testing code and results for both I/O‑ and CPU‑bound requests, and offers practical mitigation strategies such as clustering, caching and resource scaling.

CPU BottleneckNode.jsPerformance
0 likes · 20 min read
Understanding Node.js Asynchronous I/O Model and Its Impact on High‑Concurrency Performance
dbaplus Community
dbaplus Community
Jun 30, 2021 · Backend Development

Unlock Kafka’s Speed: Deep Dive into Performance Secrets and Optimizations

This article provides a comprehensive technical guide to Kafka performance, covering the core bottlenecks of network, disk and complexity, detailing optimization techniques such as concurrency, compression, batching, caching and algorithms, and explaining how Kafka’s sequential write, zero‑copy, page cache, reactor‑based network model, batch handling, partition concurrency, and file structure contribute to high throughput.

JavaKafkaPerformance
0 likes · 17 min read
Unlock Kafka’s Speed: Deep Dive into Performance Secrets and Optimizations
Top Architect
Top Architect
Jun 30, 2021 · Databases

Analyzing and Optimizing MySQL Pagination Performance with Large Offsets

This article investigates why MySQL queries with large LIMIT offsets become extremely slow, demonstrates the issue with simulated millions‑of‑row datasets, and presents three optimization strategies—including index‑covering subqueries, remembering the last primary‑key position, and applying offset throttling—to achieve consistent, fast pagination performance.

IndexingMySQLOptimization
0 likes · 12 min read
Analyzing and Optimizing MySQL Pagination Performance with Large Offsets
Liangxu Linux
Liangxu Linux
Jun 29, 2021 · Operations

Mastering System Metrics: QPS, TPS, PV, UV, DAU, and MAU Explained

This article clarifies core web‑service metrics—QPS, TPS, PV, UV, DAU, MAU—explains their differences, shows how concurrency and throughput relate, and outlines key performance‑testing concepts and evaluation methods for modern system capacity planning.

PerformanceQPSSystem Design
0 likes · 9 min read
Mastering System Metrics: QPS, TPS, PV, UV, DAU, and MAU Explained
Programmer DD
Programmer DD
Jun 27, 2021 · Backend Development

Mastering Java Thread Pools: Core Pool, BlockingQueue, and Real-World Tuning

This article explains how Java thread pools work, clarifies common misconceptions about core thread creation, details the role of BlockingQueue, and provides practical guidelines for sizing core, max threads, and queue capacity based on concurrency and GC considerations.

BlockingQueueConcurrencyPerformance
0 likes · 11 min read
Mastering Java Thread Pools: Core Pool, BlockingQueue, and Real-World Tuning
Laravel Tech Community
Laravel Tech Community
Jun 24, 2021 · Backend Development

Performance‑Optimized Alternatives to Common PHP Functions

This article presents faster PHP 7.4 alternatives for typical array and string operations—removing duplicates, picking random elements, alphanumeric checks, and substring replacement—backed by benchmark results and additional coding tips for production performance.

ArrayOptimizationPerformance
0 likes · 6 min read
Performance‑Optimized Alternatives to Common PHP Functions
Python Programming Learning Circle
Python Programming Learning Circle
Jun 24, 2021 · Fundamentals

Is Python Losing Its Charm? An Analysis of Its Strengths, Weaknesses, and Future

The article examines why Python has remained popular due to its readability, extensive libraries, and ease of use, while also highlighting its performance limitations, GIL, memory usage, weak mobile support, and competition from emerging languages, concluding that Python remains a valuable but not universally optimal tool.

PerformancePythondata-science
0 likes · 5 min read
Is Python Losing Its Charm? An Analysis of Its Strengths, Weaknesses, and Future
Java Architect Essentials
Java Architect Essentials
Jun 23, 2021 · Databases

How Redis Read‑Write Separation Boosts Performance and Cuts Costs

This article explains the background, architecture, and replication models of Redis read‑write separation, compares star and chain replication, and outlines its transparent compatibility, high availability, and performance benefits while noting consistency trade‑offs for read‑heavy workloads.

Database ArchitectureHigh AvailabilityPerformance
0 likes · 9 min read
How Redis Read‑Write Separation Boosts Performance and Cuts Costs
Efficient Ops
Efficient Ops
Jun 23, 2021 · Operations

Agent vs Network Data: Choosing the Right Cloud Performance Monitoring Approach

This article compares agent‑based and network‑data approaches to cloud‑native application performance monitoring, discussing their architectures, advantages, challenges, and how combining white‑box and black‑box techniques can improve fault detection, scalability, and operational efficiency in complex cloud environments.

AgentCloud MonitoringOperations
0 likes · 10 min read
Agent vs Network Data: Choosing the Right Cloud Performance Monitoring Approach
IT Architects Alliance
IT Architects Alliance
Jun 20, 2021 · Backend Development

Kafka Architecture, Core Concepts, and Operational Best Practices

This article provides a comprehensive overview of Kafka's architecture, core concepts, high‑throughput design, replication, network model, capacity planning, producer and consumer tuning, custom partitioning, rebalance strategies, broker management, and operational tools for building and maintaining robust distributed messaging systems.

KafkaPerformance
0 likes · 29 min read
Kafka Architecture, Core Concepts, and Operational Best Practices
21CTO
21CTO
Jun 20, 2021 · Fundamentals

Will Python’s Reign End? Analyzing Its Rise, Weaknesses, and Future Competitors

Despite Python’s explosive growth since 2010 and its dominance across data science, AI, and general programming, this article examines the language’s strengths—maturity, readability, extensive libraries—and its drawbacks such as speed, dynamic scope, and limited mobile support, while exploring whether emerging languages like Rust, Go, or Julia might eventually replace it.

JuliaPerformancePython
0 likes · 10 min read
Will Python’s Reign End? Analyzing Its Rise, Weaknesses, and Future Competitors
IT Architects Alliance
IT Architects Alliance
Jun 19, 2021 · Backend Development

Mastering Cache Strategies: From CDN to Distributed Systems

This article provides a comprehensive overview of caching in large‑scale distributed systems, covering cache fundamentals, classification, major implementations such as CDN, reverse‑proxy, local, and distributed caches, detailed analyses of Memcached and Redis, common design challenges, and real‑world industry solutions.

Cache DesignCachingMemcached
0 likes · 12 min read
Mastering Cache Strategies: From CDN to Distributed Systems
Selected Java Interview Questions
Selected Java Interview Questions
Jun 18, 2021 · Fundamentals

Understanding CopyOnWriteArrayList, Vector, and SynchronizedList in Java Concurrency

This article explains the copy‑on‑write optimization, compares Vector, Collections.synchronizedList and CopyOnWriteArrayList, analyzes their fail‑fast behavior, shows how CopyOnWriteArrayList is implemented and iterated, and presents performance benchmarks highlighting their strengths and weaknesses.

CollectionsCopyOnWriteArrayListJava
0 likes · 14 min read
Understanding CopyOnWriteArrayList, Vector, and SynchronizedList in Java Concurrency
iQIYI Technical Product Team
iQIYI Technical Product Team
Jun 18, 2021 · Frontend Development

Improving Nuxt SSR Stability for iQIYI Frontend: Performance, Caching, Rate Limiting, Disaster Recovery, and Logging

To boost iQIYI’s front‑end reliability, the team replaced a Velocity‑based SSR with Nuxt, introduced a centralized page‑config plugin, streamlined legacy‑browser handling, built a visual data‑filtering API, implemented Nginx and component caching, purge endpoints, multi‑layer rate limiting, disaster‑recovery fallback, and comprehensive logging, achieving ~0.5 s first‑screen loads, 0.2 % error rate and near‑100 % availability.

LoggingNuxtPerformance
0 likes · 19 min read
Improving Nuxt SSR Stability for iQIYI Frontend: Performance, Caching, Rate Limiting, Disaster Recovery, and Logging
Alibaba Cloud Native
Alibaba Cloud Native
Jun 17, 2021 · Cloud Computing

What Datadog’s 2022 Serverless Report Reveals About Lambda Usage and Costs

Datadog’s 2022 Serverless report shows a rapid expansion of Lambda usage worldwide, with call frequencies 3.5 times higher than two years ago, average daily runtimes of 900 hours, shorter execution times, growing adoption of Azure Functions and Google Cloud Functions, and detailed cost analyses that highlight both the economic benefits and optimization challenges of serverless architectures.

AWS LambdaCloud ComputingFunction-as-a-Service
0 likes · 13 min read
What Datadog’s 2022 Serverless Report Reveals About Lambda Usage and Costs
WeChatFE
WeChatFE
Jun 17, 2021 · Frontend Development

How Vue 3’s Proxy‑Based Reactivity Beats Vue 2’s Object.defineProperty

This article explains Vue’s reactive system, compares Vue 2.6’s Object.defineProperty approach with Vue 3’s Proxy implementation, details how observers are defined, collected, and triggered, and shows why the asynchronous update queue improves performance and maintainability.

JavaScriptPerformanceReactivity
0 likes · 16 min read
How Vue 3’s Proxy‑Based Reactivity Beats Vue 2’s Object.defineProperty
Xianyu Technology
Xianyu Technology
Jun 17, 2021 · Mobile Development

Flutter-based IM Architecture Redesign for Xianyu

The Xianyu instant‑messaging system, burdened by years of technical debt, was rebuilt with a Flutter‑centric, four‑layer architecture that shares FlutterEngine instances, introduces an entity cache and custom ORM, simplifies synchronization, and delivers up to 40 MB memory savings, lower power use, reduced CPU load and roughly half the development and testing effort.

FlutterIMPerformance
0 likes · 11 min read
Flutter-based IM Architecture Redesign for Xianyu
New Oriental Technology
New Oriental Technology
Jun 17, 2021 · Backend Development

Cache Basics, Types, Patterns, and Common Issues

This article explains why caching is used, distinguishes between local and distributed caches, compares popular Java cache libraries, describes Redis and Memcached differences, outlines the Cache‑Aside pattern, and discusses common cache problems such as inconsistency, penetration, breakdown, avalanche, hot‑key detection, and their mitigation strategies.

JavaLocal CachePerformance
0 likes · 15 min read
Cache Basics, Types, Patterns, and Common Issues
21CTO
21CTO
Jun 16, 2021 · Backend Development

How to Process a 16 GB Log File in Seconds with Go Concurrency

This article explains how to efficiently extract time‑range logs from a massive 16 GB .txt/.log file using Go's bufio.NewReader, sync.Pool for buffer reuse, and concurrent goroutines, achieving processing times of around 25 seconds.

ConcurrencyLog ProcessingPerformance
0 likes · 9 min read
How to Process a 16 GB Log File in Seconds with Go Concurrency
IT Xianyu
IT Xianyu
Jun 15, 2021 · Databases

How to Size Database Connection Pools: Insights from HikariCP Performance Tests

The article explains how to determine the optimal size of a database connection pool by analyzing performance tests, presenting a simple formula based on CPU cores and disk count, and demonstrating that a much smaller pool can dramatically improve response times for high‑concurrency workloads.

HikariCPOptimizationPerformance
0 likes · 11 min read
How to Size Database Connection Pools: Insights from HikariCP Performance Tests
MaGe Linux Operations
MaGe Linux Operations
Jun 14, 2021 · Backend Development

How to Process a 16 GB Log File in Seconds with Go

Learn how to efficiently extract timestamped logs from a massive 16 GB file in seconds using Go's buffered I/O, sync.Pool, and goroutine concurrency, with step‑by‑step code examples, performance tips, and a complete runnable program.

ConcurrencyLog ProcessingPerformance
0 likes · 10 min read
How to Process a 16 GB Log File in Seconds with Go
Alibaba Cloud Native
Alibaba Cloud Native
Jun 14, 2021 · Backend Development

Why RocketMQ Beats Other Open‑Source Queues: A Practical Selection Guide

This article evaluates open‑source message‑queue options by examining company, middleware‑team, and end‑user criteria, then explains why RocketMQ’s low technical and labor costs, stability, rich features, high performance, built‑in management tools, monitoring support, and active community make it a cost‑effective choice over alternatives like Kafka and Pulsar.

Backend DevelopmentComparisonMessage Queue
0 likes · 12 min read
Why RocketMQ Beats Other Open‑Source Queues: A Practical Selection Guide
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 12, 2021 · Databases

Which Redis GUI Reigns Supreme? A Deep Dive into 8 Popular Tools

This article compares eight Redis visualization tools—desktop clients, a web app, and an IDE plugin—detailing their features, pricing, platform support, and usability, while also showing how command‑line tricks can enhance JSON handling, helping developers choose the most efficient solution for their workflow.

Database ManagementGUIPerformance
0 likes · 10 min read
Which Redis GUI Reigns Supreme? A Deep Dive into 8 Popular Tools
Java Backend Technology
Java Backend Technology
Jun 12, 2021 · Databases

Why My Spring API Stalled: Debugging Redis Connection Pool Blocking

A Spring‑based service repeatedly hung because Redis connections were never returned to the pool, leading to thread starvation; the article walks through the investigation using top, jstack, Arthas, and code analysis, then shows the proper way to use RedisCallback and release connections to prevent the deadlock.

Connection PoolJavaJedis
0 likes · 9 min read
Why My Spring API Stalled: Debugging Redis Connection Pool Blocking
Aikesheng Open Source Community
Aikesheng Open Source Community
Jun 11, 2021 · Databases

MySQL 8.0.23 Invisible Columns Feature Overview

Starting with MySQL 8.0.23, columns can be marked INVISIBLE, causing them to be omitted from SELECT * queries unless explicitly referenced; this article explains the feature, demonstrates creation, inspection, DML considerations, schema modifications, backup behavior, and its impact on database design.

Database DesignInvisible ColumnsMySQL
0 likes · 8 min read
MySQL 8.0.23 Invisible Columns Feature Overview
Beike Product & Technology
Beike Product & Technology
Jun 11, 2021 · Backend Development

Impact of System Load on libcurl DNS Resolution and HTTP Timeout

This article investigates how high system load affects libcurl's DNS resolution time and overall HTTP request latency, explains the three timeout error types returned by libcurl, presents experiments comparing host‑based, system‑host, and async‑ares resolution methods, and offers optimization recommendations.

DNSPerformanceasync-ares
0 likes · 8 min read
Impact of System Load on libcurl DNS Resolution and HTTP Timeout
Tencent Music Tech Team
Tencent Music Tech Team
Jun 10, 2021 · Mobile Development

iOS Crash Protection: Motivation, Process, and Implementation

After a massive crash caused by a malformed Facebook SDK payload highlighted the lack of fault‑tolerance, this article explains why iOS crash protection is essential, outlines a four‑step handling workflow, and details two main techniques—Aspect‑Oriented Programming hooks and managed zombie objects—along with their pitfalls, performance impact, and memory‑threshold formulas for safe production deployment.

AOPMemory ManagementPerformance
0 likes · 11 min read
iOS Crash Protection: Motivation, Process, and Implementation
Open Source Linux
Open Source Linux
Jun 9, 2021 · Backend Development

How API Gateways Empower Enterprises: Use Cases, Architecture & Selection Guide

This article explores the roles of API gateways—including Open API platforms, microservice gateways, and service management—examines their placement within enterprise architectures, compares open‑source and cloud solutions, and provides criteria for selecting the most suitable gateway based on performance, scalability, openness, and deployment model.

API GatewayCloud SolutionsEnterprise Architecture
0 likes · 12 min read
How API Gateways Empower Enterprises: Use Cases, Architecture & Selection Guide
Baidu App Technology
Baidu App Technology
Jun 9, 2021 · Frontend Development

How to Build a High‑Performance Virtual Tree in Santd for 10k+ Nodes

This article explains the concept of a virtual tree, why it is needed for rendering massive data sets, and provides a step‑by‑step implementation—including flattening the tree, calculating visible nodes, simulating scroll, and decorating the list—demonstrating a speedup from 26 seconds to 0.19 seconds.

FrontendJavaScriptPerformance
0 likes · 11 min read
How to Build a High‑Performance Virtual Tree in Santd for 10k+ Nodes
Selected Java Interview Questions
Selected Java Interview Questions
Jun 9, 2021 · Backend Development

Understanding Java Serialization: Limitations, Performance Comparison, and Alternative Frameworks

The article explains what object serialization is, why it is needed for persistence and network transmission, outlines the major drawbacks of Java's built‑in serialization—including lack of cross‑language support, poor performance, and large payloads—and compares it with a custom ByteBuffer approach while reviewing popular alternative serialization frameworks.

ByteBufferJavaPerformance
0 likes · 7 min read
Understanding Java Serialization: Limitations, Performance Comparison, and Alternative Frameworks
IT Architects Alliance
IT Architects Alliance
Jun 7, 2021 · Databases

Analyzing and Optimizing MySQL Pagination Performance with Large Offsets

The article examines a production MySQL query that suffers severe slowdown due to large LIMIT offsets, demonstrates how to reproduce the issue with massive test data, analyzes the root cause, and presents three optimization strategies—including index covering, keyset pagination, and offset limiting—to dramatically improve query performance.

IndexingMySQLOptimization
0 likes · 13 min read
Analyzing and Optimizing MySQL Pagination Performance with Large Offsets
Volcano Engine Developer Services
Volcano Engine Developer Services
Jun 7, 2021 · Databases

Why Distributed Database Architectures Matter: From Shared‑Nothing to Shared‑Storage

This article introduces the fundamentals of distributed database architectures, compares Shared‑Nothing and Shared‑Storage designs, explains their three‑tier structure, core engine components, SQL execution flow, performance and cost optimizations, and showcases a real‑world high‑traffic deployment in Douyin’s Spring Festival event.

PerformanceSQLcost optimization
0 likes · 19 min read
Why Distributed Database Architectures Matter: From Shared‑Nothing to Shared‑Storage
Top Architect
Top Architect
Jun 7, 2021 · Backend Development

Transparent Multilevel Cache (TMC): Architecture, Hotspot Detection, and Local Cache Implementation

The article presents the design and implementation of Transparent Multilevel Cache (TMC), a three‑layer caching solution that adds hotspot detection and local cache to reduce distributed cache pressure, explains its transparent Java integration, describes the sliding‑window hotspot discovery pipeline, and showcases performance gains in real‑world e‑commerce campaigns.

JavaLocal CachePerformance
0 likes · 14 min read
Transparent Multilevel Cache (TMC): Architecture, Hotspot Detection, and Local Cache Implementation
JD Tech
JD Tech
Jun 7, 2021 · Operations

Configuring Nginx Reverse Proxy for Persistent (Keep‑Alive) Connections and Performance Optimization

This article explains how to configure Nginx as a reverse proxy to maintain long‑lived HTTP/1.1 keep‑alive connections between client and Nginx and between Nginx and upstream servers, covering required directives, upstream and location settings, performance implications for high QPS workloads, and advanced WebSocket handling.

HTTPNginxPerformance
0 likes · 9 min read
Configuring Nginx Reverse Proxy for Persistent (Keep‑Alive) Connections and Performance Optimization
Top Architect
Top Architect
Jun 6, 2021 · Backend Development

Pitfalls of Java Property Copy Utilities and Safer Alternatives

This article examines the drawbacks of using Java property copy utilities such as Spring BeanUtils, CGLIB BeanCopier, and Apache Commons BeanUtils, demonstrates type‑conversion errors through code examples, compares their performance, and recommends defining explicit conversion classes or using MapStruct for safer, compile‑time‑checked mappings.

BeanUtilsCGLIBJava
0 likes · 7 min read
Pitfalls of Java Property Copy Utilities and Safer Alternatives
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 5, 2021 · Backend Development

Diagnosing and Resolving OutOfMemoryError Caused by Zipkin Reporter in Spring Cloud Applications

This article details a step‑by‑step investigation of a Java OutOfMemoryError caused by the Zipkin reporter in a Spring Cloud application, covering symptom identification, resource monitoring, heap dump analysis, code inspection, and the final fix of upgrading the zipkin‑reporter dependency.

JavaOutOfMemoryErrorPerformance
0 likes · 11 min read
Diagnosing and Resolving OutOfMemoryError Caused by Zipkin Reporter in Spring Cloud Applications
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 5, 2021 · Databases

How Many Rows Can a MySQL InnoDB B+Tree Store?

This article explains InnoDB's storage hierarchy (sector, block, page), calculates how many rows fit in a 16KB page, shows how B+‑tree height and pointer counts determine total record capacity, and demonstrates the I/O cost of primary and secondary index lookups using practical MySQL commands.

B+TreeInnoDBMySQL
0 likes · 8 min read
How Many Rows Can a MySQL InnoDB B+Tree Store?
Ctrip Technology
Ctrip Technology
Jun 3, 2021 · Mobile Development

Trip.com iOS App Launch Optimization Practices

This article details the analysis of the iOS app launch process and presents a series of practical optimization techniques—ranging from reducing dynamic libraries and dead code to binary reordering and task concurrency—that together cut Trip.com’s launch time from two seconds to under one second.

App LaunchMobile DevelopmentPerformance
0 likes · 14 min read
Trip.com iOS App Launch Optimization Practices
IT Architects Alliance
IT Architects Alliance
May 31, 2021 · Backend Development

Inside Nginx: Master/Worker Model, Async I/O, and Core Data Structures Explained

This article explains how Nginx runs as a daemon with a master process and multiple worker processes, why it prefers a multi‑process asynchronous non‑blocking architecture over threads, and details the key internal data structures such as connections, requests, arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees that enable its high‑performance HTTP handling.

Data StructuresHTTPNginx
0 likes · 18 min read
Inside Nginx: Master/Worker Model, Async I/O, and Core Data Structures Explained
IT Architects Alliance
IT Architects Alliance
May 31, 2021 · Databases

40 Common Redis Interview Questions and Answers

This article compiles 40 frequently asked Redis interview questions covering fundamentals, data types, persistence, clustering, performance tuning, memory optimization, security, and advanced usage such as pipelines and distributed locks, providing concise answers to help candidates prepare confidently for technical interviews.

CachingPerformanceRedis
0 likes · 20 min read
40 Common Redis Interview Questions and Answers
360 Tech Engineering
360 Tech Engineering
May 31, 2021 · Databases

Understanding MongoDB TTL Indexes: Concepts, Operation, Creation Methods, Limitations, and Best Practices

This article explains MongoDB TTL indexes, covering their basic concept as single‑field auto‑deletion indexes, how the background process works, alternative creation methods using an expireAt field, practical limitations, and recommendations for designing efficient data expiration strategies.

Database MaintenanceMongoDBPerformance
0 likes · 7 min read
Understanding MongoDB TTL Indexes: Concepts, Operation, Creation Methods, Limitations, and Best Practices
Python Programming Learning Circle
Python Programming Learning Circle
May 31, 2021 · Fundamentals

Guido van Rossum Discusses the Unlikely Arrival of Python 4.0 and the Future Roadmap

In a recent Microsoft Reactor interview, Python creator Guido van Rossum explained that Python 4.0 is unlikely, outlined the ongoing transition from Python 2 to 3, highlighted upcoming incremental releases like 3.10‑3.13, performance goals for 3.11, and discussed type‑hint evolution and influences from Rust and TypeScript.

Guido van RossumPerformancePython 4
0 likes · 6 min read
Guido van Rossum Discusses the Unlikely Arrival of Python 4.0 and the Future Roadmap
21CTO
21CTO
May 30, 2021 · Backend Development

How Transparent Multilevel Cache (TMC) Eliminates Hotspot Bottlenecks in Java Services

The article introduces Youzan's Transparent Multilevel Cache (TMC), explains why hotspot cache access harms e‑commerce applications, describes its three‑layer architecture, details the Java client integration with Hermes‑SDK for automatic hotspot detection and local caching, and presents real‑world performance gains during large‑scale promotional events.

CacheLocal CachePerformance
0 likes · 14 min read
How Transparent Multilevel Cache (TMC) Eliminates Hotspot Bottlenecks in Java Services
MaGe Linux Operations
MaGe Linux Operations
May 30, 2021 · Fundamentals

Why Python 4 May Never Arrive – Guido van Rossum’s Perspective

Guido van Rossum explains why a Python 4 release is unlikely, detailing the language’s post‑Python‑2 evolution, the focus on incremental 3.x improvements, performance goals, and how future changes like C‑compatibility or removing the GIL could finally trigger a major version jump.

Guido van RossumPerformancePython
0 likes · 6 min read
Why Python 4 May Never Arrive – Guido van Rossum’s Perspective
21CTO
21CTO
May 28, 2021 · Fundamentals

Will Python 4 Ever Arrive? Guido van Rossum Explains Why It Might Not

Guido van Rossum, the creator of Python, reveals in a recent interview that a Python 4.0 is unlikely, explaining the team’s focus on incremental improvements through versions 3.9 to 3.13, performance boosts, type‑hint evolution, and the challenges of maintaining C compatibility, while also sharing his views on other languages like Rust, Go, and TypeScript.

Guido van RossumPerformancePython
0 likes · 6 min read
Will Python 4 Ever Arrive? Guido van Rossum Explains Why It Might Not
Aikesheng Open Source Community
Aikesheng Open Source Community
May 28, 2021 · Databases

Comprehensive MySQL Inspection Checklist and Command Reference

This guide presents a detailed MySQL inspection checklist covering operating‑system metrics, critical MySQL parameters, status queries, replication health, high‑availability components, and useful SQL scripts, enabling DBAs to efficiently monitor performance, detect issues, and maintain reliable database services.

High AvailabilityMySQLPerformance
0 likes · 11 min read
Comprehensive MySQL Inspection Checklist and Command Reference
FunTester
FunTester
May 28, 2021 · Operations

Scaling Fixed‑QPS Load Tests with a Multithreaded Task Generator

The article explains why a single‑threaded request generator fails at high QPS, introduces a multithreaded generator with a configurable per‑thread QPS limit, provides the full Java implementation, and shows that it reliably sustains 10‑20k QPS in practice.

JavaMultithreadingPerformance
0 likes · 5 min read
Scaling Fixed‑QPS Load Tests with a Multithreaded Task Generator
Tencent Cloud Developer
Tencent Cloud Developer
May 27, 2021 · Big Data

An Introduction to Kafka: Architecture, Core Components, Service Governance, Performance Optimizations, and Installation Guide

Kafka is a high‑throughput distributed publish‑subscribe system that uses brokers, topics, partitions, offsets, producers, consumers, and Zookeeper for metadata and leader election, offering fast sequential disk writes, page‑cache zero‑copy transfers, ISR‑based replication, and includes step‑by‑step installation of JDK, Zookeeper, and Kafka.

Big DataDistributed MessagingInstallation
0 likes · 11 min read
An Introduction to Kafka: Architecture, Core Components, Service Governance, Performance Optimizations, and Installation Guide
Wukong Talks Architecture
Wukong Talks Architecture
May 25, 2021 · Backend Development

Elasticsearch Performance Pitfalls and Optimization Strategies

This article examines common performance pitfalls in Elasticsearch—including slow queries, cluster architecture bottlenecks, and business‑scenario challenges—and provides practical guidance such as caching key fields, data pre‑heating, hot‑cold separation, avoiding joins, and using tribe nodes to improve accuracy and response time.

CachingElasticsearchPerformance
0 likes · 9 min read
Elasticsearch Performance Pitfalls and Optimization Strategies
JD Retail Technology
JD Retail Technology
May 25, 2021 · Mobile Development

Optimizing JD Mall Order Business with Swift: Static Dispatch, Value Types, and Functional Techniques

This article describes how JD Mall’s order system migrated key iOS components to Swift, leveraging static dispatch, value‑type structures, protocol‑oriented design, error handling, guard statements, defer, lazy loading, and functional programming to improve performance, safety, and maintainability across mobile and macOS applications.

Error handlingFunctional ProgrammingPerformance
0 likes · 16 min read
Optimizing JD Mall Order Business with Swift: Static Dispatch, Value Types, and Functional Techniques
dbaplus Community
dbaplus Community
May 23, 2021 · Databases

Hidden Redis Pitfalls That Can Crash Your System

This article enumerates common Redis pitfalls—including unexpected key expiration loss, command‑induced blocking, memory‑intensive bitmap operations, AOF and RDB persistence issues, and master‑slave replication quirks—explaining their causes, real‑world impact, and practical mitigation steps.

MemoryPerformancePersistence
0 likes · 29 min read
Hidden Redis Pitfalls That Can Crash Your System
ByteDance Web Infra
ByteDance Web Infra
May 22, 2021 · Frontend Development

Understanding JSX in Vue 3: Concepts, Benefits, and Performance

This article presents a comprehensive overview of using JSX in Vue 3, covering its basic concepts, why Vue supports JSX, the changes introduced in Vue 3, practical scenarios, implementation details, and performance comparisons with the traditional template syntax.

BabelComponentJSX
0 likes · 13 min read
Understanding JSX in Vue 3: Concepts, Benefits, and Performance
UCloud Tech
UCloud Tech
May 21, 2021 · Big Data

How US3 Hadoop Adapter Cuts Big Data Storage Costs and Boosts Performance

This article explains how UCloud's US3 object storage, combined with a custom Hadoop adapter, separates compute and storage, optimizes file system operations, and leverages caching and specialized APIs to dramatically reduce storage costs and improve read/write performance for large‑scale Hadoop workloads.

Big DataCacheHadoop
0 likes · 13 min read
How US3 Hadoop Adapter Cuts Big Data Storage Costs and Boosts Performance
Python Crawling & Data Mining
Python Crawling & Data Mining
May 20, 2021 · Fundamentals

How the Shannon Plan Aims to Make CPython 5× Faster

Guido van Rossum’s recent “Making CPython Faster” talk reveals the Shannon Plan—a four‑year effort, backed by Microsoft, to boost Python’s performance up to five times, with the first milestone targeting a 2× speedup in the upcoming Python 3.11 release through adaptive bytecode interpreters and other optimizations.

CPythonGuido van RossumPEP 659
0 likes · 4 min read
How the Shannon Plan Aims to Make CPython 5× Faster
Tencent Cloud Developer
Tencent Cloud Developer
May 19, 2021 · Industry Insights

How Cloud‑Native Principles Transform Big Data Infrastructure

The article analyzes how cloud‑native concepts such as DevOps, micro‑services, continuous delivery, and containerization can be applied to big‑data foundations, outlining four guiding principles—industrialized delivery, cost quantification, load‑adaptive scaling, and data‑centric design—and describing concrete Hadoop‑based architectures and Tencent Cloud solutions that lower cost while boosting performance.

Big DataData InfrastructureHadoop
0 likes · 22 min read
How Cloud‑Native Principles Transform Big Data Infrastructure
JD Tech Talk
JD Tech Talk
May 17, 2021 · Databases

Design and Optimization of Multi‑Data‑Center Redis Synchronization

This article describes the challenges of native Redis in multi‑data‑center deployments and presents the design, implementation, and performance evaluation of a custom Redis extension that adds bidirectional synchronization, rlog logging, protocol enhancements, and conflict‑resolution mechanisms to achieve reliable cross‑region active‑active operation.

Data synchronizationMulti-Data CenterPerformance
0 likes · 16 min read
Design and Optimization of Multi‑Data‑Center Redis Synchronization
vivo Internet Technology
vivo Internet Technology
May 12, 2021 · Big Data

Kafka at Trillion-Scale: Ensuring High Availability, Performance, and Operational Best Practices

The article presents a comprehensive guide for running Kafka at trillion‑record daily traffic, detailing version upgrades, data migration, traffic throttling, monitoring, load balancing, resource isolation, security, disaster recovery, Linux tuning, platform automation, performance evaluation, future roadmap, and community contribution practices.

KafkaPerformance
0 likes · 34 min read
Kafka at Trillion-Scale: Ensuring High Availability, Performance, and Operational Best Practices
Aikesheng Open Source Community
Aikesheng Open Source Community
May 12, 2021 · Databases

Understanding MySQL Full-Text Indexes: Structure, Auxiliary Tables, Buffer Pool, and Transaction Handling

This article explains MySQL full-text (inverted) indexes, their underlying auxiliary tables, buffer pool configuration, document ID handling, and the special transaction semantics required for inserting and querying indexed data, providing practical SQL examples and performance considerations.

Full-Text IndexInnoDBMySQL
0 likes · 9 min read
Understanding MySQL Full-Text Indexes: Structure, Auxiliary Tables, Buffer Pool, and Transaction Handling
Programmer DD
Programmer DD
May 11, 2021 · Backend Development

Elegant Java Code Timing: From Simple Diff to AutoCloseable TraceWatch

This article explores various Java techniques for measuring code execution time—from basic start‑end time differences and StopWatch utilities to functional wrappers and AutoCloseable‑based TraceWatch—offering cleaner, less intrusive alternatives for performance profiling.

Performanceautocloseablecode
0 likes · 11 min read
Elegant Java Code Timing: From Simple Diff to AutoCloseable TraceWatch
Code Ape Tech Column
Code Ape Tech Column
May 11, 2021 · Databases

How to Speed Up MySQL LIMIT Pagination for Millions of Rows

This article analyzes six MySQL pagination techniques, presents benchmark results showing how query time grows with offset, and offers practical index‑based optimizations—including covering indexes, subqueries, and composite index design—to make LIMIT pagination fast even on very large tables.

LIMITMySQLPerformance
0 likes · 12 min read
How to Speed Up MySQL LIMIT Pagination for Millions of Rows
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 10, 2021 · Databases

MySQL Index Design Principles and Common Index Pitfalls

This article explains MySQL index fundamentals, covering primary and unique indexes, best practices for choosing indexed columns, handling functions and large fields, avoiding excessive or frequently updated indexes, and enumerates typical scenarios where indexes become ineffective.

MySQLPerformanceSQL
0 likes · 12 min read
MySQL Index Design Principles and Common Index Pitfalls
dbaplus Community
dbaplus Community
May 9, 2021 · Databases

Why MySQL Index Merge Triggers Deadlocks and How to Fix Them

This article examines a real‑world MySQL deadlock caused by the Index Merge optimizer, explains InnoDB's lock‑on‑index mechanism, walks through the deadlock logs, and presents four practical solutions including force‑index hints, disabling Index Merge, creating a composite index, and a two‑step update approach.

DeadlockInnoDBLocking
0 likes · 15 min read
Why MySQL Index Merge Triggers Deadlocks and How to Fix Them
Architecture Digest
Architecture Digest
May 9, 2021 · Databases

Optimizing MySQL Pagination with LIMIT: Methods, Experiments, and Index Strategies

This article examines the performance drawbacks of MySQL's LIMIT pagination on large tables, presents six practical query methods—including direct LIMIT, primary‑key indexing, index‑based ordering, prepared statements, covering indexes, and sub‑query/join techniques—provides extensive benchmark results, and offers concrete indexing recommendations to achieve fast, stable pagination even with millions of rows.

IndexingLIMITLarge Data
0 likes · 12 min read
Optimizing MySQL Pagination with LIMIT: Methods, Experiments, and Index Strategies
php Courses
php Courses
May 8, 2021 · Backend Development

Efficient CSV Export in PHP for Large Datasets

This article explains how to efficiently export large datasets to CSV files using PHP, describing the CSV format, why a simple streaming approach outperforms PHPExcel, performance expectations for 200,000 rows, and provides a complete PHP function that handles encoding, buffering, and memory‑friendly output.

CSVPHPPerformance
0 likes · 3 min read
Efficient CSV Export in PHP for Large Datasets
Liangxu Linux
Liangxu Linux
May 5, 2021 · Operations

Mastering Linux Load Average: How to Read and Interpret top Output

This article explains what the Linux Load Average metric means, how the three numbers are calculated, and walks through each line of the top command output—including CPU, memory, swap, and process details—to help you diagnose server load issues effectively.

LinuxPerformanceSystem Monitoring
0 likes · 7 min read
Mastering Linux Load Average: How to Read and Interpret top Output