BestHub
Sign in
Tagged articles
5000 articles
Page 37 of 50
Selected Java Interview Questions
Selected Java Interview Questions
Feb 6, 2021 · Databases

7 Reasons Why Docker Is Unsuitable for Deploying Databases

Although Docker offers many benefits, this article outlines seven key reasons—data safety, performance, networking, statefulness, resource isolation, cloud platform incompatibility, and environment requirements—that make deploying databases in Docker containers generally unsuitable, while also suggesting scenarios where lightweight or distributed databases may still be viable.

ContainerizationData SafetyDatabase
0 likes · 9 min read
7 Reasons Why Docker Is Unsuitable for Deploying Databases
AntTech
AntTech
Feb 5, 2021 · Databases

OceanBase 2020 Review: Record‑Breaking Performance, Independent Operation, Ecosystem Expansion, and Advanced Disaster‑Recovery

In 2020 OceanBase achieved a world‑record TPC‑C benchmark of 7.07 billion tpmC, spun off as an independent company, attracted dozens of marquee customers, built a four‑layer ecosystem, delivered ultra‑high performance for enterprises, and introduced Paxos‑based disaster‑recovery that guarantees RPO = 0 and minute‑level RTO.

EcosystemOceanBasePaxos
0 likes · 13 min read
OceanBase 2020 Review: Record‑Breaking Performance, Independent Operation, Ecosystem Expansion, and Advanced Disaster‑Recovery
Top Architect
Top Architect
Feb 4, 2021 · Backend Development

Performance Impact of Java Reflection: Empirical Tests and Analysis

This article empirically investigates whether Java reflection incurs performance penalties, describing a series of benchmark tests that compare direct method/field access with reflective calls, analyzing results, identifying the main cost factors, and offering practical guidelines to mitigate reflection overhead in production code.

JavaOptimizationReflection
0 likes · 11 min read
Performance Impact of Java Reflection: Empirical Tests and Analysis
Tencent Music Tech Team
Tencent Music Tech Team
Feb 4, 2021 · Mobile Development

Adapting the QQ Music/Karaoke Android App to Arm64 Architecture

The QQ Music/Karaoke team migrated their Android app from 32‑bit to Arm64‑v8a by reconfiguring Gradle builds, recompiling or replacing over 120 native libraries, extending the dynamic‑resource loader for ABI selection, implementing ABI‑aware update channels, and fixing issues such as library path limits, I/O reliability, camera latency, and WebView cache corruption, completing the transition in early 2021.

ARM64AndroidBuild configuration
0 likes · 27 min read
Adapting the QQ Music/Karaoke Android App to Arm64 Architecture
Architect's Tech Stack
Architect's Tech Stack
Feb 3, 2021 · Backend Development

Comparison of Java Microservice Frameworks: Spring Cloud, Vert.x, SparkJava, Micronaut, Javalin, and Quarkus

This article compares several Java microservice frameworks—including Spring Cloud, Vert.x, SparkJava, Micronaut, Javalin, and Quarkus—by describing their features, required infrastructure, and performance results from 30‑second stress tests, while also noting resource consumption and startup times.

MicroservicesSpring BootVert.x
0 likes · 9 min read
Comparison of Java Microservice Frameworks: Spring Cloud, Vert.x, SparkJava, Micronaut, Javalin, and Quarkus
Top Architect
Top Architect
Feb 2, 2021 · Backend Development

Understanding Kafka Zero‑Copy and Parallel FileTransferTo Performance

This article explains Kafka's underlying storage architecture, details the zero‑copy transferTo technique in Java, compares traditional four‑copy I/O with zero‑copy, and presents parallel FileTransferTo performance tests on a multi‑core Linux system environment.

BackendFileTransferToJava
0 likes · 11 min read
Understanding Kafka Zero‑Copy and Parallel FileTransferTo Performance
Xianyu Technology
Xianyu Technology
Feb 2, 2021 · Frontend Development

Xianyu's Server-Side Rendering Architecture and Implementation

Xianyu’s server‑side rendering solution uses a serverless Node.js app on Alibaba Cloud to aggregate backend data and render HTML, routing through Nginx and caching via CDN, which cuts first‑meaningful‑paint time, maintains high stability with low O&M, and seamlessly falls back to client‑side rendering when needed.

FrontendNode.jsSSR
0 likes · 10 min read
Xianyu's Server-Side Rendering Architecture and Implementation
Architect
Architect
Jan 31, 2021 · Fundamentals

Investigating the Performance Impact of Java Reflection

This article presents a series of benchmarks that compare direct method and field access with reflective calls in Java, analyzes where the performance overhead originates, and offers practical guidelines to mitigate reflection‑related slowdown in real‑world applications.

JavaOptimizationReflection
0 likes · 9 min read
Investigating the Performance Impact of Java Reflection
Top Architect
Top Architect
Jan 28, 2021 · Backend Development

Deep Dive into Caffeine Cache: High‑Performance Design, W‑TinyLFU Algorithm, and Implementation Details

This article explains Caffeine, a high‑performance Java local cache, comparing it with Guava Cache, detailing its W‑TinyLFU eviction policy, asynchronous read/write buffers, timer‑wheel expiration, and provides extensive source code analysis to illustrate its design and optimization techniques.

AlgorithmsCacheCaffeine
0 likes · 36 min read
Deep Dive into Caffeine Cache: High‑Performance Design, W‑TinyLFU Algorithm, and Implementation Details
MaGe Linux Operations
MaGe Linux Operations
Jan 27, 2021 · Operations

How to Cut Nginx HTTPS Latency by 30%: Practical TLS Tuning Guide

This article explains why Nginx HTTPS latency matters for instant search, describes how TLS handshake round‑trips affect response time, and provides step‑by‑step Nginx TLS configuration tweaks—including HTTP/2, cipher ordering, OCSP stapling, buffer sizing, and session caching—that together reduced real‑world latency by about 30%.

HTTP2HTTPSLatency
0 likes · 13 min read
How to Cut Nginx HTTPS Latency by 30%: Practical TLS Tuning Guide
vivo Internet Technology
vivo Internet Technology
Jan 27, 2021 · Backend Development

Caffeine Cache: Principles, High‑Performance Read/Write, and Practical Usage in Java

Caffeine is a high‑performance Java 8 local‑cache library that replaces Guava by using the W‑TinyLFU algorithm with three‑queue LRU structures and lock‑free read/write buffers, offering extensive configuration, dynamic runtime adjustments, and safe back‑source loading with distributed locks to prevent cache‑stampede.

CacheCaffeineJava
0 likes · 13 min read
Caffeine Cache: Principles, High‑Performance Read/Write, and Practical Usage in Java
21CTO
21CTO
Jan 26, 2021 · Fundamentals

Mastering the 21 Essential Software Architecture Characteristics

This article explains the twenty‑one key non‑functional characteristics of software architecture—such as performance, reliability, scalability, security and maintainability—detailing their definitions, typical metrics, and practical techniques for improvement, while linking each trait to ISO‑25010 and real‑world engineering practices.

DevOpsNon-functional RequirementsReliability
0 likes · 20 min read
Mastering the 21 Essential Software Architecture Characteristics
Didi Tech
Didi Tech
Jan 25, 2021 · Big Data

Migrating Hive SQL to Spark SQL: Design, Implementation, and Performance Evaluation at DiDi

DiDi migrated over 10,000 Hive SQL tasks to Spark SQL using a lightweight dual‑run pipeline that extracts, rewrites, compares, and switches tasks, fixing syntax and UDF differences while adding features such as small‑file merging and enhanced partition pruning, resulting in Spark handling 85 % of workloads with 40 % faster execution, 21 % lower CPU and 49 % lower memory usage.

DataMigrationHiveSQLOptimization
0 likes · 18 min read
Migrating Hive SQL to Spark SQL: Design, Implementation, and Performance Evaluation at DiDi
Programmer DD
Programmer DD
Jan 25, 2021 · Backend Development

Spotting and Solving Backend Bottlenecks: Nginx, Tomcat, Redis, MySQL

This article walks through systematic analysis of backend performance bottlenecks across a typical Nginx‑Tomcat‑Redis‑MySQL stack, covering bandwidth limits, OS ulimit settings, kernel TCP parameters, Nginx connection limits, Tomcat connector modes, Redis key handling, and MySQL query and hardware issues.

OptimizationTomcatnginx
0 likes · 11 min read
Spotting and Solving Backend Bottlenecks: Nginx, Tomcat, Redis, MySQL
Top Architect
Top Architect
Jan 24, 2021 · Backend Development

Why Use Message Queues? Benefits, Drawbacks, and Design Guidelines

This article explains why message queues are essential for decoupling systems, enabling asynchronous processing and peak‑shaving, outlines their advantages and disadvantages, compares popular MQ products, and provides practical guidance on high availability, reliability, ordering, and architectural design.

DecouplingMessage queuearchitecture
0 likes · 12 min read
Why Use Message Queues? Benefits, Drawbacks, and Design Guidelines
Architecture Digest
Architecture Digest
Jan 23, 2021 · Fundamentals

Understanding Linux TCP Socket Implementation and System Tuning

This article explains how Linux manages TCP sockets at the kernel level, demonstrates how to adjust port ranges and file‑descriptor limits, and shows the key data structures and lookup functions that enable high‑concurrency TCP connections, providing practical guidance for scaling client connections.

Linux kernelPort RangeSocket
0 likes · 8 min read
Understanding Linux TCP Socket Implementation and System Tuning
Baidu Geek Talk
Baidu Geek Talk
Jan 22, 2021 · Frontend Development

Why Baidu Chose San: A Deep Dive into Its Performance, Compatibility, and Ecosystem

This article examines Baidu's home‑grown MVVM framework San, tracing its origins, core features, size and performance benchmarks, ecosystem tools such as CLI and DevTools, and real‑world deployments across Baidu App, feed pages, and mini‑programs, highlighting why it became the unified front‑end solution.

BaiduFrameworkFrontend
0 likes · 17 min read
Why Baidu Chose San: A Deep Dive into Its Performance, Compatibility, and Ecosystem
High Availability Architecture
High Availability Architecture
Jan 22, 2021 · Databases

Comprehensive Guide to Diagnosing and Optimizing Redis Performance Issues

Redis can experience latency spikes due to factors such as complex commands, big keys, expiration patterns, memory limits, fork overhead, AOF persistence, CPU binding, swap usage, memory fragmentation, and network saturation, and this article provides a systematic troubleshooting methodology and practical optimization solutions for each scenario.

DatabaseLatencyRedis
0 likes · 38 min read
Comprehensive Guide to Diagnosing and Optimizing Redis Performance Issues
JD Retail Technology
JD Retail Technology
Jan 19, 2021 · Big Data

Design, Implementation, and Performance Evaluation of JD's Remote Shuffle Service for Spark

This article describes JD's research and production deployment of a self‑developed Remote Shuffle Service for Spark, covering its motivations, architectural design, cloud‑native features, monitoring, performance benchmarks against external shuffle solutions, and a real‑world promotion‑period case study that demonstrates improved stability and resource efficiency.

Remote Shuffle ServiceShuffle OptimizationSpark
0 likes · 17 min read
Design, Implementation, and Performance Evaluation of JD's Remote Shuffle Service for Spark
Architects' Tech Alliance
Architects' Tech Alliance
Jan 18, 2021 · Backend Development

Migrating Services to ARM‑Based Kunpeng Cloud Servers: Architecture Evolution, Benefits, and Practical Steps

This article explains the shift from x86 to ARM architectures, outlines why services should be migrated to ARM‑based Kunpeng cloud servers, describes Huawei's migration tools and community support, and provides concrete C/C++ migration examples and common pitfalls for backend developers.

ARMBackend DevelopmentC++
0 likes · 11 min read
Migrating Services to ARM‑Based Kunpeng Cloud Servers: Architecture Evolution, Benefits, and Practical Steps
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 17, 2021 · Databases

Comprehensive Overview of MySQL Architecture, Logs, Indexes, Transactions, Locks, MVCC, Buffer Pool, and Optimization

This article provides an in‑depth guide to MySQL internals, covering the SQL execution process, server and storage engine layers, binlog/redo/undo logs, index structures, transaction isolation levels, lock types, MVCC implementation, buffer pool management, and practical optimization techniques.

DatabaseMySQLOptimization
0 likes · 31 min read
Comprehensive Overview of MySQL Architecture, Logs, Indexes, Transactions, Locks, MVCC, Buffer Pool, and Optimization
Architecture Digest
Architecture Digest
Jan 17, 2021 · Operations

System Performance Issue Analysis and Optimization Process

This article outlines a comprehensive process for diagnosing and optimizing performance problems in production business systems, covering hardware, OS, database, middleware, JVM tuning, code inefficiencies, monitoring tools, and the limitations of pre‑release testing, with practical guidelines and visual references.

APMDatabase TuningSystem Optimization
0 likes · 16 min read
System Performance Issue Analysis and Optimization Process
Programmer DD
Programmer DD
Jan 17, 2021 · Backend Development

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

This article explains the concept of zero-copy I/O, covering buffer types, virtual memory, mmap+write and sendfile techniques in Java, and demonstrates how Java NIO, Netty, and other frameworks like RocketMQ and Kafka leverage zero-copy to reduce data copying and improve performance.

Zero-Copymmapperformance
0 likes · 14 min read
Mastering Zero-Copy in Java: Boost Performance with NIO, Netty, and Sendfile
Practical DevOps Architecture
Practical DevOps Architecture
Jan 16, 2021 · Databases

Redis Configuration Guide: redis.conf Settings, Slowlog, Advanced Options, Replication, and Persistence

This comprehensive guide details the essential redis.conf parameters—including daemonization, networking, memory limits, logging, slowlog, advanced data structure encodings, replication options, and persistence settings—providing clear explanations and recommended values for optimal Redis deployment.

DatabasePersistenceRedis
0 likes · 8 min read
Redis Configuration Guide: redis.conf Settings, Slowlog, Advanced Options, Replication, and Persistence
Amap Tech
Amap Tech
Jan 15, 2021 · Mobile Development

Low-Cost Performance Optimization and Long-Term Control for Super Apps: Gaode Map Case Study

Gaode Map’s low‑cost, long‑term performance strategy for super‑apps combines an adaptive resource‑scheduling framework, full‑dimension monitoring, and closed‑loop control to cut startup time over 70%, shrink memory use 30% and binary size 20%, delivering up to three‑fold speed gains on low‑end devices while preserving development efficiency.

Gaode MapOptimizationSuper App
0 likes · 13 min read
Low-Cost Performance Optimization and Long-Term Control for Super Apps: Gaode Map Case Study
Xianyu Technology
Xianyu Technology
Jan 14, 2021 · Mobile Development

PowerScrollView: A High‑Performance Flow Layout Solution for Flutter

PowerScrollView is a high‑performance Flutter flow‑layout framework that composes section‑based slivers for lists, grids and waterfalls, adds automatic exposure, scroll‑to‑index, fine‑grained refresh and element‑reuse optimizations, and uses frame‑by‑frame rendering to deliver smooth scrolling across Xianyu’s core pages.

FlutterMobile DevelopmentUI optimization
0 likes · 15 min read
PowerScrollView: A High‑Performance Flow Layout Solution for Flutter
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Jan 13, 2021 · Fundamentals

Understanding Linux I/O: From Buffers to Disk Writes

This article provides a comprehensive overview of Linux I/O fundamentals, covering the layered I/O stack, buffer interactions, system call flow, scheduler algorithms, consistency and safety considerations, and performance characteristics, supplemented with code examples and illustrative diagrams.

IO StackLinux I/Ofile system
0 likes · 10 min read
Understanding Linux I/O: From Buffers to Disk Writes
Code Ape Tech Column
Code Ape Tech Column
Jan 13, 2021 · Backend Development

Getting Started with MapStruct: High‑Performance Java Bean Mapping

This article introduces MapStruct, explains why traditional JavaBean conversion methods like reflection are inefficient, shows how to set up Maven dependencies, define entities and DTOs, write mapper interfaces, run tests, and highlights the performance, debugging, simplicity, and dependency‑free advantages of the generated code.

Annotation ProcessorJavaMaven
0 likes · 8 min read
Getting Started with MapStruct: High‑Performance Java Bean Mapping
Selected Java Interview Questions
Selected Java Interview Questions
Jan 12, 2021 · Backend Development

Various Methods for Measuring Code Execution Time in Java

This article introduces four approaches—simple time‑difference calculation, StopWatch‑like utilities, functional interfaces, and AutoCloseable—to accurately measure arbitrary code segment durations in Java, providing code examples and discussing their advantages and trade‑offs.

Backend DevelopmentCode ProfilingJava
0 likes · 9 min read
Various Methods for Measuring Code Execution Time in Java
Code Ape Tech Column
Code Ape Tech Column
Jan 12, 2021 · Backend Development

How to Build a High‑Performance Search API with SQL and Redis Caching

This article walks through three progressively better implementations for a complex e‑commerce search API—starting with a monolithic SQL query, then splitting the query and adding indexes, and finally using Redis sets and sorted sets to cache filter results, handle pagination, and achieve production‑grade performance.

BackendRedispagination
0 likes · 8 min read
How to Build a High‑Performance Search API with SQL and Redis Caching
High Availability Architecture
High Availability Architecture
Jan 11, 2021 · Cloud Computing

Insights on Serverless: Challenges, Opportunities, and Real‑World Adoption

The article presents an in‑depth interview with Alibaba Cloud Serverless leader Bu Chen, discussing the evolution, technical challenges, performance requirements, functional needs, and real‑world use cases of Serverless computing, while outlining Alibaba Cloud's vision to make Serverless the essential, user‑centric cloud infrastructure.

Alibaba CloudFunction as a ServiceServerless
0 likes · 14 min read
Insights on Serverless: Challenges, Opportunities, and Real‑World Adoption
Java Interview Crash Guide
Java Interview Crash Guide
Jan 10, 2021 · Databases

Boost MySQL Query Speed: Practical SQL Optimization Tips for 2021

This article explains why SQL performance is critical for fast‑response web services, presents database‑agnostic optimization techniques—such as preferring EXISTS over IN, using JOINs, avoiding unnecessary ORDER BY, leveraging UNION ALL, and applying indexes—to dramatically reduce query latency and resource consumption.

IndexesMySQLperformance
0 likes · 15 min read
Boost MySQL Query Speed: Practical SQL Optimization Tips for 2021
Architect's Tech Stack
Architect's Tech Stack
Jan 9, 2021 · Databases

High‑Speed Loading of 2 Billion Rows into MySQL Using TokuDB

This article describes a real‑world requirement to import over 2 billion records into MySQL, analyzes the challenges, introduces XeLabs TokuDB with its optimizations, details the test schema and configuration, demonstrates bulk loading commands, presents performance metrics showing up to 570 k rows per second, and concludes with practical recommendations and environment details.

Database OptimizationLarge DataMySQL
0 likes · 7 min read
High‑Speed Loading of 2 Billion Rows into MySQL Using TokuDB
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 9, 2021 · Backend Development

Preventing Redis Cache Avalanche: Interview Dialogue and Practical Solutions

This article presents an interview scenario where a candidate is asked about Redis cache avalanche, explains the phenomenon, and offers four practical mitigation strategies—including cache pre‑warming, mutex locking, staggered expiration, and high‑availability designs—to keep backend databases from being overwhelmed.

BackendRediscache-avalanche
0 likes · 4 min read
Preventing Redis Cache Avalanche: Interview Dialogue and Practical Solutions
iQIYI Technical Product Team
iQIYI Technical Product Team
Jan 8, 2021 · Frontend Development

Front‑End Performance Optimization for iQIYI Video Production Smart Cloud Platform

After replacing its three‑year‑old Arm.js stack with a Vue.js + Node.js architecture, iQIYI’s smart‑cloud video platform tackled loading, rendering, and API bottlenecks by using CDN‑served library DLLs, refined Webpack splitChunks, lazy‑loaded components with skeleton screens, and rewrote the BFF in NestJS, cutting bundle size by two‑thirds, reducing first‑page load to 790 ms and halving core API latency.

FrontendNode.jsOptimization
0 likes · 16 min read
Front‑End Performance Optimization for iQIYI Video Production Smart Cloud Platform
Meituan Technology Team
Meituan Technology Team
Jan 7, 2021 · Operations

Optimizing Build Package Compression for Faster Deployment

By integrating SIMD‑accelerated ISA‑L and parallel Zstandard (Pzstd) into Meituan’s build‑and‑deployment pipeline, compression time for typical 200 MiB–1 GiB packages dropped from over a minute to about one second—a 90%‑plus speedup that preserves gzip compatibility while dramatically accelerating overall build latency.

ISA‑LZSTDbuild
0 likes · 21 min read
Optimizing Build Package Compression for Faster Deployment
ITPUB
ITPUB
Jan 7, 2021 · Databases

52 Proven SQL Performance Optimization Techniques You Must Use

This article compiles 52 practical SQL performance‑tuning strategies—including index best practices, query rewrites, use of temporary tables, proper data types, and server configuration tips—to help developers dramatically speed up MySQL and other relational database queries while avoiding common pitfalls.

IndexesMySQLperformance
0 likes · 19 min read
52 Proven SQL Performance Optimization Techniques You Must Use
Architecture Digest
Architecture Digest
Jan 7, 2021 · Backend Development

Optimizing Complex Search Queries with Redis: A Backend Development Case Study

This article walks backend developers through the challenges of implementing a multi‑criteria search interface, demonstrates three progressive solutions—from a monolithic SQL query to indexed sub‑queries and finally a Redis‑based caching strategy—while addressing performance, pagination, and data‑update concerns.

Backendperformance
0 likes · 8 min read
Optimizing Complex Search Queries with Redis: A Backend Development Case Study
Qunar Tech Salon
Qunar Tech Salon
Jan 7, 2021 · Backend Development

Cache Strategies: From Local Page Cache to Distributed Multi‑Level Caching

This article shares a senior architect’s ten‑year journey with caching, covering local page and object caches, refresh policies, distributed solutions like Redis and Memcached, pagination caching techniques, multi‑level cache architectures, common pitfalls, and practical optimization lessons for high‑performance backend systems.

CachingDistributed Cachemultilevel cache
0 likes · 12 min read
Cache Strategies: From Local Page Cache to Distributed Multi‑Level Caching
Liangxu Linux
Liangxu Linux
Jan 6, 2021 · Databases

52 Proven SQL Performance Tweaks to Supercharge Your Queries

This article compiles 52 practical SQL optimization strategies—including index usage, query rewriting, avoiding full table scans, proper data types, and server configuration tips—to help developers dramatically improve query speed and overall database performance.

IndexesMySQLperformance
0 likes · 22 min read
52 Proven SQL Performance Tweaks to Supercharge Your Queries
Alibaba Cloud Native
Alibaba Cloud Native
Jan 6, 2021 · Backend Development

How RocketMQ 4.8.0 Supercharges DLedger with Massive Performance and Stability Gains

Apache RocketMQ 4.8.0 introduces extensive DLedger enhancements, including asynchronous pipeline processing, batch log replication, extensive chaos‑testing validation, preferred‑leader selection, and batch‑message support, delivering several‑fold throughput improvements, faster recovery from failures, and new functional capabilities for production‑grade messaging.

Apache RocketMQDLedgerMessage queue
0 likes · 8 min read
How RocketMQ 4.8.0 Supercharges DLedger with Massive Performance and Stability Gains
HomeTech
HomeTech
Jan 6, 2021 · Backend Development

Using GraphQL to Reduce API Calls and Manage Data Complexity in Frontend Development

The article explains how the rapid growth of API endpoints and data fields in complex business scenarios can be mitigated by introducing a GraphQL middle‑layer built with Node.js, detailing schema design, resolvers, performance considerations, tooling, custom scalars, response formatting, caching, and security measures.

API optimizationBackendFrontend
0 likes · 15 min read
Using GraphQL to Reduce API Calls and Manage Data Complexity in Frontend Development
Beike Product & Technology
Beike Product & Technology
Jan 6, 2021 · Databases

Analyzing MySQL Deadlock Cases and Prevention Strategies

This article investigates a MySQL InnoDB deadlock observed during a holiday period, explains how gap locks and next‑key locks on a composite index cause mutual waiting, reproduces the issue with large test data, and offers practical guidelines to avoid similar deadlocks in production environments.

Gap LockInnoDBMySQL
0 likes · 12 min read
Analyzing MySQL Deadlock Cases and Prevention Strategies
21CTO
21CTO
Jan 5, 2021 · Databases

5 Essential Rules for Writing High‑Performance SQL Queries

This article presents five practical rules—return only needed rows, use proper indexes, avoid subqueries, replace OFFSET pagination with key‑based limits, and understand SQL's logical execution order—to help developers write efficient, high‑performance SQL queries across major relational databases.

Indexespaginationperformance
0 likes · 13 min read
5 Essential Rules for Writing High‑Performance SQL Queries
ITPUB
ITPUB
Jan 5, 2021 · Backend Development

Prevent Redis Cache Penetration, Breakdown, and Avalanche Using Bloom Filters

This article explains common Redis cache problems—penetration, breakdown, and avalanche—detailing their causes, practical mitigation techniques such as request validation, caching empty results, Bloom filters, mutex locks, high‑availability setups, and provides Java code examples for implementing these solutions.

Backendbloom-filterperformance
0 likes · 8 min read
Prevent Redis Cache Penetration, Breakdown, and Avalanche Using Bloom Filters
Programmer DD
Programmer DD
Jan 5, 2021 · Operations

How to Cut Nginx HTTPS Latency by 30%: Proven TLS Tuning Tips

This article explains why low‑latency Nginx HTTPS is crucial for instant search, analyzes how TLS handshakes add round‑trip delays, and provides concrete Nginx TLS configuration changes—such as enabling HTTP/2, adjusting cipher suites, enabling OCSP stapling, tweaking buffer sizes and session caches—that together reduced request latency by about 30% in a real‑world deployment.

HTTP2OptimizationSSL
0 likes · 13 min read
How to Cut Nginx HTTPS Latency by 30%: Proven TLS Tuning Tips
Laravel Tech Community
Laravel Tech Community
Jan 3, 2021 · Backend Development

Apache RocketMQ 4.8.0 Released with Major DLedger Performance Improvements

Apache RocketMQ 4.8.0 has been released, featuring extensive optimizations and bug fixes, with significant performance, functionality, and stability enhancements to the Raft‑based DLedger mode, including asynchronous pipeline processing, batch log replication, and various lock and cache improvements that boost throughput by multiple times.

DLedgerDistributed SystemsMessaging
0 likes · 4 min read
Apache RocketMQ 4.8.0 Released with Major DLedger Performance Improvements
Laravel Tech Community
Laravel Tech Community
Jan 3, 2021 · Databases

52 SQL Query Performance Optimization Strategies

This article presents a comprehensive collection of 52 practical SQL performance optimization techniques, covering indexing, query rewriting, use of EXISTS, avoiding full table scans, proper handling of NULLs, OR/IN clauses, temporary tables, storage engine choices, backup procedures, and other best practices to improve database efficiency.

DatabaseIndexesMySQL
0 likes · 18 min read
52 SQL Query Performance Optimization Strategies
21CTO
21CTO
Jan 2, 2021 · Databases

Why Docker Struggles with Databases: 7 Critical Reasons

The article outlines seven key drawbacks of running databases inside Docker containers—including data safety, performance, networking, statefulness, resource isolation, cloud platform incompatibility, and hardware requirements—while also suggesting scenarios where containerization may still be viable.

Data SafetyDatabaseDocker
0 likes · 8 min read
Why Docker Struggles with Databases: 7 Critical Reasons
ITPUB
ITPUB
Jan 2, 2021 · Databases

Why Deploying Databases in Docker Containers Can Be Risky: 7 Critical Reasons

Although Docker offers many benefits for application deployment, using it for databases introduces serious data safety, performance, networking, statefulness, resource isolation, cloud‑platform, and hardware‑requirement challenges that can lead to data loss and reduced efficiency.

ContainerizationData SafetyDocker
0 likes · 9 min read
Why Deploying Databases in Docker Containers Can Be Risky: 7 Critical Reasons
Architecture Digest
Architecture Digest
Jan 2, 2021 · Databases

52 SQL Query Performance Optimization Strategies

This article presents a comprehensive list of 52 practical SQL optimization techniques, covering index usage, query rewriting, avoiding full table scans, proper data types, transaction handling, backup strategies, and other best practices to improve database performance and scalability.

Optimizationindexingperformance
0 likes · 18 min read
52 SQL Query Performance Optimization Strategies
dbaplus Community
dbaplus Community
Jan 1, 2021 · Backend Development

Mastering Cache: From Local to Multi‑Level Strategies for High‑Performance Systems

This article shares a senior architect’s decade‑long journey with caching, covering page‑level and object caches, refresh mechanisms, distributed solutions like Redis and Memcached, pagination caching techniques, and multi‑level cache architectures, while highlighting practical pitfalls and performance gains.

BackendDistributed Cachemultilevel cache
0 likes · 12 min read
Mastering Cache: From Local to Multi‑Level Strategies for High‑Performance Systems
ITPUB
ITPUB
Dec 31, 2020 · Operations

How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits

This article demystifies common misconceptions about server concurrency, explains the theoretical maximum TCP connections based on the four‑tuple, details Linux file‑descriptor and buffer limits, and walks through a practical experiment that achieves over one million simultaneous connections on a single machine.

ConcurrencyLinuxTCP
0 likes · 7 min read
How Many TCP Connections Can One Server Really Handle? A Deep Dive into Linux Limits
macrozheng
macrozheng
Dec 31, 2020 · Backend Development

20 Java Backend Pitfalls You Must Avoid

This article compiles and explains twenty frequent Java backend development mistakes—from classic NullPointer exceptions and incorrect date formatting to BigDecimal precision issues, improper use of ConcurrentHashMap, ThreadLocal data leakage, misuse of Arrays.asList, transaction pitfalls, and serialization quirks—providing code examples and best‑practice solutions to help developers write safer, more reliable code.

Backend DevelopmentJavacommon pitfalls
0 likes · 27 min read
20 Java Backend Pitfalls You Must Avoid
Top Architect
Top Architect
Dec 30, 2020 · Databases

Redis Latency Analysis: Common Causes and How to Diagnose Them

This article explains why Redis latency can suddenly increase, covering high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network overload, and provides concrete diagnostic commands and mitigation strategies.

LatencyRedismemory
0 likes · 18 min read
Redis Latency Analysis: Common Causes and How to Diagnose Them
Architecture Digest
Architecture Digest
Dec 30, 2020 · Databases

Redis Latency Analysis and Mitigation Strategies

This article examines common causes of increased latency in Redis—including high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides practical monitoring and configuration techniques to diagnose and reduce delays.

LatencyOptimizationRedis
0 likes · 17 min read
Redis Latency Analysis and Mitigation Strategies
Senior Brother's Insights
Senior Brother's Insights
Dec 28, 2020 · Fundamentals

Why Java’s JIT Compiler Matters: How HotSpot Optimizes Your Code

This article explains the role of Java's Just‑In‑Time compiler, how HotSpot combines interpretation and compilation, the mechanisms for hotspot detection, the differences between C1 and C2 compilers, performance testing across modes, and the key optimization techniques that make JIT‑generated code faster.

HotSpotJITJVM
0 likes · 16 min read
Why Java’s JIT Compiler Matters: How HotSpot Optimizes Your Code
Architect
Architect
Dec 27, 2020 · Backend Development

Understanding Cache Penetration, Breakdown, and Avalanche with Redis and Bloom Filters

This article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis, presents common mitigation techniques such as request validation, empty‑value caching, Bloom filters, mutex locks, and high‑availability strategies, and includes Java code examples for practical implementation.

BackendCacheJava
0 likes · 8 min read
Understanding Cache Penetration, Breakdown, and Avalanche with Redis and Bloom Filters
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 27, 2020 · Fundamentals

Six Ways to Write Files in Java: Streams, Buffers, and Performance Comparison

This article introduces six Java file-writing techniques—including FileWriter, BufferedWriter, PrintWriter, FileOutputStream, BufferedOutputStream, and Files—explains their underlying stream concepts, provides code examples, and benchmarks their performance to guide developers in choosing the most efficient method for text or binary data.

BufferedWriterFile I/OFileWriter
0 likes · 16 min read
Six Ways to Write Files in Java: Streams, Buffers, and Performance Comparison
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Dec 25, 2020 · Fundamentals

Utilization Clamping (uclamp) in Linux Kernel Scheduling

Utilization clamping (uclamp) lets user space specify a task’s minimum and maximum CPU utilization, allowing the Linux scheduler to more accurately scale frequency and select cores, improving performance and power efficiency through per‑task, cgroup, and global APIs that replace the older schedtune mechanism.

LinuxUtilization Clampingperformance
0 likes · 7 min read
Utilization Clamping (uclamp) in Linux Kernel Scheduling
政采云技术
政采云技术
Dec 22, 2020 · Frontend Development

V8 Engine Garbage Collection and Memory Allocation

This article explains the architecture of browser engines, the distinction between stack and heap memory, V8's generational garbage collection strategies—including the Scavenge algorithm for the young generation and mark‑sweep/mark‑compact for the old generation—along with optimizations such as write barriers, incremental marking, and parallel/concurrent collection.

Garbage CollectionJavaScript EngineV8
0 likes · 13 min read
V8 Engine Garbage Collection and Memory Allocation
Taobao Frontend Technology
Taobao Frontend Technology
Dec 22, 2020 · Frontend Development

All Highlights & PPTs from the 15th D2 Frontend Tech Forum (Dec 19‑20)

The 15th D2 Frontend Technology Forum was held online on December 19‑20, featuring 21 talks—including international sessions—covering topics such as RxJS refactoring, cross‑platform solutions, web performance, WebAssembly IoT, large‑venue seat selection, AI‑driven code generation, ES2020/2021, fault drills, testing, serverless, SSR, and Node.js, with all presentation PPTs available via a QR code.

Node.jsServerlessconference
0 likes · 10 min read
All Highlights & PPTs from the 15th D2 Frontend Tech Forum (Dec 19‑20)
Laravel Tech Community
Laravel Tech Community
Dec 21, 2020 · Backend Development

New Features and Performance Improvements in PHP 8.0

This article outlines the major new features and performance enhancements introduced in PHP 8.0, including JIT compilation, named parameters, union types, attributes, match expressions, null‑safe operator, WeakMap, constructor property promotion, and numerous syntax improvements, accompanied by illustrative code examples.

Code ExamplesNew FeaturesPHP 8
0 likes · 12 min read
New Features and Performance Improvements in PHP 8.0
Code Ape Tech Column
Code Ape Tech Column
Dec 21, 2020 · Backend Development

13 Proven Redis Performance Tweaks Every Engineer Should Apply

This article presents thirteen practical Redis performance‑optimization rules—covering command complexity, key expiration, data structures, persistence, hardware choices, clustering, memory fragmentation, and client‑side techniques—to help developers identify bottlenecks and boost throughput and latency in production environments.

BackendCachingOptimization
0 likes · 12 min read
13 Proven Redis Performance Tweaks Every Engineer Should Apply
Node Underground
Node Underground
Dec 20, 2020 · Backend Development

Explore the Ultimate Node.js Best Practices Repository

The article introduces the widely‑starred GitHub project “Node.js Best Practices,” highlighting its multilingual documentation, comprehensive coverage of project structure, error handling, coding standards, testing, production, security, and performance, and encourages readers to visit the repository for detailed guidance.

Backend DevelopmentBest PracticesProject Structure
0 likes · 2 min read
Explore the Ultimate Node.js Best Practices Repository
Beike Product & Technology
Beike Product & Technology
Dec 19, 2020 · Backend Development

Evolution of Beike Mini‑Program Backend Platform: From PHP to Golang, Microservices, and Cloud‑Native Architecture

The article details the progressive transformation of Beike's mini‑program backend—from rapid PHP prototyping to Golang‑based gateways, microservice decomposition, Redis and TiDB optimizations, and cloud‑native stability measures—illustrating how performance, scalability, and platform‑wide capabilities were systematically enhanced.

BackendGolangMicroservices
0 likes · 16 min read
Evolution of Beike Mini‑Program Backend Platform: From PHP to Golang, Microservices, and Cloud‑Native Architecture
ITPUB
ITPUB
Dec 17, 2020 · Databases

5 Essential Rules to Write High‑Performance SQL Queries

This article presents five practical rules for writing efficient SQL queries—including selecting only needed rows, using proper indexes, avoiding subqueries, replacing OFFSET pagination, and understanding the logical execution order—supported by examples, execution plans, and performance tips for various relational databases.

Indexesperformancequery optimization
0 likes · 14 min read
5 Essential Rules to Write High‑Performance SQL Queries
Aikesheng Open Source Community
Aikesheng Open Source Community
Dec 17, 2020 · Operations

Root Cause Analysis of MySQL "Opening tables" Stalls Caused by Poor Disk Write Performance and InnoDB Redo Log Flush

The article investigates why a MySQL instance experiences frequent "Opening tables" states, analyzing stack traces, identifying a data dictionary lock held by the dict_stats_thread, and concluding that slow disk writes trigger InnoDB's synchronous dirty‑page flush, blocking many operations.

InnoDBMySQLOpening tables
0 likes · 14 min read
Root Cause Analysis of MySQL "Opening tables" Stalls Caused by Poor Disk Write Performance and InnoDB Redo Log Flush
Xianyu Technology
Xianyu Technology
Dec 17, 2020 · Cloud Native

Elastic Scaling in Serverless Cloud‑Native Applications

Elastic scaling, a cornerstone of Xianyu’s shift to serverless cloud-native architecture, leverages Kubernetes autoscaling components—Cluster‑Autoscaler, HPA, VPA—to dynamically adjust resources via reactive thresholds or predictive models, yet faces challenges like cold‑starts, lack of scale‑to‑zero, and optimal pod‑pool buffering, prompting ongoing research for faster, smarter, safer scaling.

Auto ScalingCloud-nativeServerless
0 likes · 19 min read
Elastic Scaling in Serverless Cloud‑Native Applications
MaGe Linux Operations
MaGe Linux Operations
Dec 15, 2020 · Fundamentals

Boost Python Speed: 5 Proven Techniques to Outrun C and Java

Although Python is slower than C, Java, or JavaScript for CPU‑intensive tasks, several projects—including PyPy, Pyston, Nuitka, Cython, and Numba—offer distinct approaches such as JIT compilation, LLVM back‑ends, or C conversion to significantly improve Python’s runtime performance.

CythonJITLLVM
0 likes · 5 min read
Boost Python Speed: 5 Proven Techniques to Outrun C and Java