BestHub
Sign in
Tagged articles
5000 articles
Page 12 of 50
Architect
Architect
Jan 20, 2025 · Backend Development

Resolving a 100 ms Latency Issue in Spring Boot’s Embedded Tomcat Using Arthas Tracing

The article details a step‑by‑step investigation of an unexpected ~100 ms latency in a Spring Boot‑based channel system, covering network checks, curl measurements, Arthas trace and watch commands, identification of TomcatJarInputStream’s repeated jar‑resource loading caused by Swagger dependencies, and the final fix by upgrading the embedded Tomcat version.

ArthasSwaggerTomcat
0 likes · 14 min read
Resolving a 100 ms Latency Issue in Spring Boot’s Embedded Tomcat Using Arthas Tracing
Top Architecture Tech Stack
Top Architecture Tech Stack
Jan 20, 2025 · Backend Development

Optimizing SpringBoot Startup Time: Reducing Bean Scanning Overhead and Monitoring Bean Initialization

This article explains how to diagnose and dramatically reduce SpringBoot startup latency by analyzing SpringApplicationRunListener and BeanPostProcessor phases, limiting component scanning paths, using JavaConfig for explicit bean registration, monitoring bean initialization times, and handling auto-configuration pitfalls such as cache manager duplication.

BeanScanningJavaConfigSpringBoot
0 likes · 19 min read
Optimizing SpringBoot Startup Time: Reducing Bean Scanning Overhead and Monitoring Bean Initialization
Java Architect Essentials
Java Architect Essentials
Jan 19, 2025 · Backend Development

Proper Declaration, Monitoring, and Configuration of Java Thread Pools

This article explains how to correctly declare Java thread pools using ThreadPoolExecutor, monitor their runtime status, configure parameters for CPU‑bound and I/O‑bound workloads, assign meaningful names, avoid common pitfalls such as unbounded queues and thread‑local leakage, and leverage dynamic pool frameworks.

Best PracticesConcurrencyJava
0 likes · 16 min read
Proper Declaration, Monitoring, and Configuration of Java Thread Pools
ITPUB
ITPUB
Jan 19, 2025 · Backend Development

Why Java Reflection Slows Down Your Apps and How to Speed It Up

This article examines Java reflection's advantages and drawbacks, analyzes its core API methods, benchmarks its performance against regular calls, explains why it is slower, and demonstrates how using Hutool's ReflectUtil can dramatically improve execution speed.

HutoolJavaOptimization
0 likes · 8 min read
Why Java Reflection Slows Down Your Apps and How to Speed It Up
IT Services Circle
IT Services Circle
Jan 18, 2025 · Fundamentals

Why Multithreading Programming Is So Hard

The article uses everyday analogies to explain why multithreaded programming, especially when dealing with shared data, debugging, and performance optimization, is inherently difficult due to nondeterministic execution, combination explosion, and the challenges of lock granularity.

ConcurrencyDebuggingperformance
0 likes · 4 min read
Why Multithreading Programming Is So Hard
Selected Java Interview Questions
Selected Java Interview Questions
Jan 16, 2025 · Backend Development

Ten Reasons to Prefer Traditional for Loop Over Stream.forEach for List Traversal in Java

Through benchmark tests, memory analysis, and code examples, this article presents ten compelling reasons why using a traditional for loop to traverse Java Lists often outperforms Stream.forEach in terms of performance, memory usage, control flow, exception handling, mutability, debugging, readability, and state management.

DebuggingJavaStream
0 likes · 16 min read
Ten Reasons to Prefer Traditional for Loop Over Stream.forEach for List Traversal in Java
Su San Talks Tech
Su San Talks Tech
Jan 16, 2025 · Backend Development

Boost Java Performance with Virtual Threads: A Hands‑On Guide

This article explains Java 21's virtual threads, their lightweight and auto‑managed nature, demonstrates basic usage and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance tips for high‑concurrency applications.

ConcurrencyJavaSpring Boot
0 likes · 8 min read
Boost Java Performance with Virtual Threads: A Hands‑On Guide
Sohu Tech Products
Sohu Tech Products
Jan 15, 2025 · Backend Development

Deep Dive into Druid Connection Pool: Initialization, Retrieval, and Recycling Explained

This technical guide breaks down Alibaba's Druid JDBC connection pool, detailing its initialization process, how connections are fetched and returned, the internal threads and condition‑signal coordination, execution handling, recommended configurations, and monitoring integration, all illustrated with code snippets and diagrams.

Connection PoolDatabaseDruid
0 likes · 23 min read
Deep Dive into Druid Connection Pool: Initialization, Retrieval, and Recycling Explained
Java Web Project
Java Web Project
Jan 15, 2025 · Backend Development

Why MyBatis foreach Batch Inserts Stall and How to Speed Them Up with ExecutorType.BATCH

The article investigates a MyBatis batch‑insert job that consumes excessive CPU and takes 14 minutes, explains why the foreach‑generated giant INSERT statement is inefficient, and demonstrates how switching to ExecutorType.BATCH or MyBatis dynamic‑SQL batch support reduces the runtime to under two seconds.

Batch InsertExecutorType.BATCHJava
0 likes · 10 min read
Why MyBatis foreach Batch Inserts Stall and How to Speed Them Up with ExecutorType.BATCH
Python Programming Learning Circle
Python Programming Learning Circle
Jan 15, 2025 · Fundamentals

Python Performance Optimization Tools and Libraries

This article introduces a comprehensive set of Python performance‑enhancing tools and libraries—including NumPy, SciPy, PyPy, Cython, Numba, GPU‑based solutions, and various wrappers—explaining how they accelerate code execution, reduce memory usage, and enable efficient single‑ and multi‑processor programming.

GPUJITOptimization
0 likes · 8 min read
Python Performance Optimization Tools and Libraries
php Courses
php Courses
Jan 15, 2025 · Backend Development

Challenges of PHP Applications and the Role of User Behavior Analysis

This article examines the current challenges faced by PHP applications—including performance, functionality, and competition—highlights the importance of user behavior analysis for uncovering needs and optimizing experience, and presents practical logging and analysis techniques with PHP code examples to improve performance and enable precise marketing.

LoggingPHPbehavior analysis
0 likes · 13 min read
Challenges of PHP Applications and the Role of User Behavior Analysis
Liangxu Linux
Liangxu Linux
Jan 14, 2025 · Fundamentals

How to Measure Execution Time in C with time(), clock() and gettimeofday()

This guide shows how to benchmark C code by measuring elapsed time using the standard time() function for second‑level precision, clock() for higher CPU‑time accuracy, and gettimeofday() for microsecond‑level resolution, including complete example programs and key considerations.

BenchmarkingC++clock
0 likes · 4 min read
How to Measure Execution Time in C with time(), clock() and gettimeofday()
php Courses
php Courses
Jan 14, 2025 · Databases

MySQL 8 New Features and Network Communication Course Overview

This course introduces MySQL 8's latest features—including performance optimizations, security enhancements, and new data types—while deeply exploring its network communication mechanisms, advanced optimization techniques, and hands‑on projects to improve database performance and security.

CourseDatabaseMySQL
0 likes · 3 min read
MySQL 8 New Features and Network Communication Course Overview
Top Architecture Tech Stack
Top Architecture Tech Stack
Jan 14, 2025 · Databases

Analyzing MySQL Connection Latency in Java Web Applications

This article investigates the detailed steps and time consumption of establishing and closing a MySQL connection from a Java web application, using Wireshark packet captures and code examples to demonstrate why connection pooling is essential for high‑traffic services.

Connection PoolingDatabase ConnectionJava
0 likes · 7 min read
Analyzing MySQL Connection Latency in Java Web Applications
Practical DevOps Architecture
Practical DevOps Architecture
Jan 14, 2025 · Backend Development

Comprehensive E‑commerce Project Tutorial Series: Core Order System, Seckill Service, Microservice Architecture, Performance Optimization, and Cloud‑Native Deployment

This extensive tutorial series provides step‑by‑step video guides covering the design and implementation of an e‑commerce core order system, promotional processes, distributed services, a high‑concurrency seckill platform, performance tuning techniques, microservice architecture with Spring Cloud Alibaba, and cloud‑native deployment using Docker, Kubernetes, Prometheus, and Grafana.

Backendcloud-nativee‑commerce
0 likes · 7 min read
Comprehensive E‑commerce Project Tutorial Series: Core Order System, Seckill Service, Microservice Architecture, Performance Optimization, and Cloud‑Native Deployment
php Courses
php Courses
Jan 13, 2025 · Backend Development

25 Practical PHP Tips for Performance, Security, and Modern Development

These 25 practical PHP tips cover performance optimization, security best practices, code organization, modern language features, error handling, testing, caching, API development, and debugging, providing developers with actionable guidance to write higher-quality, more efficient, and secure server-side applications.

Best PracticesPHPperformance
0 likes · 8 min read
25 Practical PHP Tips for Performance, Security, and Modern Development
Top Architect
Top Architect
Jan 12, 2025 · Backend Development

Optimizing a High‑Concurrency Interface: Reducing Response Time from 30 s to 0.8 s

This article presents a real‑world case study of a high‑concurrency data‑processing interface whose response time was reduced from 30 seconds to under one second by diagnosing SQL bottlenecks, applying PostgreSQL array aggregation, moving logic to the database, and introducing Caffeine caching, with detailed code examples and performance analysis.

BackendCachingMyBatis
0 likes · 13 min read
Optimizing a High‑Concurrency Interface: Reducing Response Time from 30 s to 0.8 s
Liangxu Linux
Liangxu Linux
Jan 11, 2025 · Databases

Does VARCHAR Length Really Impact MySQL Storage and Query Performance?

This article investigates whether the length of VARCHAR columns in MySQL affects both the physical storage size of tables and the execution speed of various queries, revealing that storage remains unchanged while long VARCHARs can dramatically slow down full‑table sorts.

MySQLSortingindex
0 likes · 10 min read
Does VARCHAR Length Really Impact MySQL Storage and Query Performance?
Eric Tech Circle
Eric Tech Circle
Jan 10, 2025 · Industry Insights

MacBook Air vs MacBook Pro: Which Laptop Suits Your Needs?

This article compares the MacBook Air and MacBook Pro across portability, performance, display quality, battery life, additional features, and price, helping readers decide which model best matches their usage patterns, budget, and professional requirements.

Battery LifeDisplayLaptop Comparison
0 likes · 6 min read
MacBook Air vs MacBook Pro: Which Laptop Suits Your Needs?
Xiaolei Talks DB
Xiaolei Talks DB
Jan 10, 2025 · Databases

How Zhihu Solved MongoDB Scaling Pain Points with a Cloud Migration

This article details Zhihu's security anti‑fraud system challenges with its self‑managed MongoDB cluster, the strategic move to Alibaba Cloud MongoDB services, the step‑by‑step migration plan, and the operational and performance benefits achieved after the successful cloud transition.

MongoDBScalabilitydatabase migration
0 likes · 12 min read
How Zhihu Solved MongoDB Scaling Pain Points with a Cloud Migration
Top Architect
Top Architect
Jan 9, 2025 · Backend Development

Common Interface Performance Optimization Strategies for Backend Systems

This article presents a comprehensive set of practical techniques—including batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction management, pagination, SQL tuning, and lock granularity—to significantly reduce API latency and improve overall backend performance, illustrated with Java code examples and diagrams.

APIBackendCaching
0 likes · 13 min read
Common Interface Performance Optimization Strategies for Backend Systems
Deepin Linux
Deepin Linux
Jan 8, 2025 · Fundamentals

Deep Dive into C++20 Coroutines: Principles, Components, and Practical Applications

This article explains the fundamentals of C++20 coroutines, describing their lightweight asynchronous execution model, key language constructs such as co_await, co_yield, and co_return, the underlying components like promise objects and coroutine handles, and demonstrates real‑world usage through comprehensive code examples for networking, file I/O, generators, and task scheduling.

C++20Coroutinesco_await
0 likes · 32 min read
Deep Dive into C++20 Coroutines: Principles, Components, and Practical Applications
php Courses
php Courses
Jan 8, 2025 · Backend Development

Managing Integer Ranges in PHP: Techniques and Best Practices

This article explains how to manage integer ranges in PHP using loops, conditional checks, and custom functions, highlighting basic techniques, advanced optimizations like bitwise operations, and best‑practice recommendations for efficient, readable code.

/loopInteger RangePHP
0 likes · 6 min read
Managing Integer Ranges in PHP: Techniques and Best Practices
php Courses
php Courses
Jan 7, 2025 · Backend Development

Key Considerations for Optimizing PHP Function Performance

This article outlines essential practices for improving PHP function performance, including avoiding inline variables, reducing parameter count, declaring parameter types, leveraging built‑in functions, caching results, using static variables, and steering clear of eval(), complemented by a practical optimization case study.

Backend DevelopmentFunction OptimizationPHP
0 likes · 4 min read
Key Considerations for Optimizing PHP Function Performance
php Courses
php Courses
Jan 7, 2025 · Backend Development

PHP Function Caching Performance Optimization Techniques

This article explains how function caching in PHP—using mechanisms such as OPcache, APC, and Zend Opcache—can improve application performance, provides a practical example of enabling OPcache, and outlines additional optimization strategies like using Redis, optimizing database queries, reducing memory usage, and efficient image processing.

Backend DevelopmentCachingOPcache
0 likes · 3 min read
PHP Function Caching Performance Optimization Techniques
ITPUB
ITPUB
Jan 7, 2025 · Databases

Cut Costs 25% and Boost Performance 70%: Retail Giant’s OceanBase Migration

The article details how WanJia Shuke, the tech arm of China Resources Vanguard, tackled retail system fragmentation, user‑experience degradation, complex linkages and scalability limits by migrating dozens of projects to the distributed OceanBase database, achieving up to 70% performance improvement, 25% cost reduction and streamlined operations.

FlinkOceanBaseRetail
0 likes · 15 min read
Cut Costs 25% and Boost Performance 70%: Retail Giant’s OceanBase Migration
21CTO
21CTO
Jan 6, 2025 · Backend Development

When Declarative Beats Imperative: Mastering Java Streams and Annotations

Explore the contrast between declarative and imperative programming, dive into Java Stream fundamentals, benchmark parallel versus sequential execution, and understand the role of annotations, offering practical insights for writing cleaner, more efficient backend code.

JavaStreamsannotations
0 likes · 9 min read
When Declarative Beats Imperative: Mastering Java Streams and Annotations
Architecture Digest
Architecture Digest
Jan 6, 2025 · Backend Development

Optimizing Large IN Queries with Spring AOP and Multithreaded Splitting

This article explains how to improve performance of massive IN‑list queries in PostgreSQL by splitting the parameter list, executing the sub‑queries concurrently with a custom Spring AOP annotation, and merging the results using a configurable thread pool and return‑handling strategy.

AOPJavaPostgreSQL
0 likes · 9 min read
Optimizing Large IN Queries with Spring AOP and Multithreaded Splitting
Top Architecture Tech Stack
Top Architecture Tech Stack
Jan 6, 2025 · Backend Development

10 Essential MyBatis Development Tips for Efficient Backend Programming

This article presents ten practical MyBatis techniques—including dynamic SQL, resultMap, foreach, pagination, annotation proxies, second‑level cache, dynamic table names, custom type handlers, logging, and multi‑datasource configuration—to help Java developers write cleaner, safer, and more performant data‑access code.

JavaMyBatisorm
0 likes · 11 min read
10 Essential MyBatis Development Tips for Efficient Backend Programming
Java Architect Essentials
Java Architect Essentials
Jan 6, 2025 · Backend Development

Understanding API Gateways: Concepts, Design Principles, and Comparison of Popular Implementations

This article explains the fundamental concepts of API gateways, their role in decoupling clients from services, key design considerations such as routing, load balancing, resilience and security, and provides a detailed comparison of popular gateway solutions like OpenResty, Kong, Zuul, and Spring Cloud Gateway.

Design Patternsapi-gatewayarchitecture
0 likes · 27 min read
Understanding API Gateways: Concepts, Design Principles, and Comparison of Popular Implementations
JavaScript
JavaScript
Jan 3, 2025 · Frontend Development

8 Proven Techniques to Supercharge Mobile Touch Event Performance

Discover eight practical strategies—including passive listeners, event delegation, scroll-through prevention, requestAnimationFrame, throttling, hardware acceleration, click-delay elimination, custom gestures, and IntersectionObserver—that dramatically boost mobile touch event responsiveness and deliver silky-smooth user experiences across web applications.

FrontendMobileTouch Events
0 likes · 5 min read
8 Proven Techniques to Supercharge Mobile Touch Event Performance
FunTester
FunTester
Jan 3, 2025 · Backend Development

Java Atomic Package Classes: AtomicBoolean, AtomicInteger, AtomicLong, and LongAdder

This article introduces Java's java.util.concurrent.atomic package, detailing the core atomic classes—AtomicBoolean, AtomicInteger, AtomicLong, and LongAdder—including their constructors, key methods, typical use cases, and performance considerations in high‑concurrency scenarios for developers seeking efficient thread‑safe operations.

Javalongaddermultithreading
0 likes · 9 min read
Java Atomic Package Classes: AtomicBoolean, AtomicInteger, AtomicLong, and LongAdder
dbaplus Community
dbaplus Community
Jan 2, 2025 · Databases

Why the Redis KEYS Command Is Dangerous and How to Replace It

The article explains that Redis's KEYS command scans all keys, blocks the server for seconds, can trigger failover issues, and provides faster alternatives like SCAN or storing keys in a set, while also showing how KEYS works in a Redis Cluster and its real‑world latency measurements.

ClusterKEYS commandRedis
0 likes · 5 min read
Why the Redis KEYS Command Is Dangerous and How to Replace It
Java Tech Enthusiast
Java Tech Enthusiast
Jan 2, 2025 · Backend Development

Essential Java Libraries and Tools for Backend Development

Beyond the JDK, modern Java backend development relies on a core toolkit—including SpringBoot, Netty, Guava or Hutool utilities, JUnit 5 with Mockito, JMH, OkHTTP, HikariCP or Druid pools, Caffeine cache, Hazelcast, SLF4J + Logback, Jackson, Jolokia, Hibernate‑Validator, and FreeMarker—to build robust, high‑performance enterprise services.

JavaSpringBootlibraries
0 likes · 10 min read
Essential Java Libraries and Tools for Backend Development
Xiaohongshu Tech REDtech
Xiaohongshu Tech REDtech
Jan 2, 2025 · Artificial Intelligence

Xiaohongshu's Self-developed RLHF System for Multimodal Large Language Models: Design, Optimization, and Performance

Xiaohongshu’s team unveiled a self‑developed RLHF system that trains multimodal large language models using heterogeneous and homogeneous network architectures, extensive PPO optimizations, and Medusa speculative sampling, achieving over 50% throughput gains, reduced hardware needs, and 5‑20% performance improvements on zero‑shot benchmarks.

PPOPRMRLHF
0 likes · 21 min read
Xiaohongshu's Self-developed RLHF System for Multimodal Large Language Models: Design, Optimization, and Performance
Tencent Cloud Developer
Tencent Cloud Developer
Jan 2, 2025 · Backend Development

Rewriting the News Plugin Integration Layer: Design, Benefits, and Refactoring Timing

The article details a nine‑month rewrite of a fragmented 23‑interface news‑plugin integration layer into a single trpc‑go service, showing how unified architecture cut development effort by half, boosted stability above 99.99 %, slashed resource costs, raised test coverage to 66 %, and provides practical criteria for deciding when to refactor.

Backendcase studyperformance
0 likes · 15 min read
Rewriting the News Plugin Integration Layer: Design, Benefits, and Refactoring Timing
IT Architects Alliance
IT Architects Alliance
Jan 1, 2025 · Backend Development

Comprehensive Guide to IT Architecture Optimization for System Performance

This article explores practical techniques for boosting system performance through IT architecture optimization, covering caching strategies, database query and connection‑pool tuning, load‑balancing, asynchronous messaging, code‑level refinements, memory pooling, network tricks, and real‑world case studies.

AsynchronousCachingCode Optimization
0 likes · 18 min read
Comprehensive Guide to IT Architecture Optimization for System Performance
Raymond Ops
Raymond Ops
Jan 1, 2025 · Backend Development

Unlocking Go’s Switch‑True Trick: Efficient Service Status Checks Explained

This article explores an unconventional Go switch‑true pattern used for checking systemd service status, compares it with equivalent if‑else logic, examines the generated assembly, and discusses when this style is advantageous for handling multiple string‑prefix conditions.

BackendSystemdcode-generation
0 likes · 10 min read
Unlocking Go’s Switch‑True Trick: Efficient Service Status Checks Explained
JavaScript
JavaScript
Dec 31, 2024 · Frontend Development

Detect and Fix Common JavaScript Memory Leaks in Front‑End Development

This guide explains what JavaScript memory leaks are, illustrates typical front‑end leak scenarios such as forgotten timers, detached DOM references, improper closures, global variables, open WebSockets, misuse of Map/Set, and console logs, and provides practical solutions to prevent and resolve each issue.

DebuggingFrontendGarbage Collection
0 likes · 7 min read
Detect and Fix Common JavaScript Memory Leaks in Front‑End Development
JD Tech
JD Tech
Dec 30, 2024 · Big Data

Techniques for Writing Elegant and Efficient SQL in Big Data Environments

The article shares practical methods and code examples for making SQL both readable and high‑performing in large‑scale data platforms, covering predicate push‑down with subqueries, deduplication strategies, bucket utilization, and Python‑driven job parameter handling.

Data engineeringHiveSpark
0 likes · 14 min read
Techniques for Writing Elegant and Efficient SQL in Big Data Environments
DataFunSummit
DataFunSummit
Dec 28, 2024 · Artificial Intelligence

Memory Optimization for Large Model Inference: Virtual Tensor and LayerKV Techniques

This talk presents the Ant Group team's recent work on large‑model inference memory optimization, covering GPU memory challenges, virtual memory management (VMM), the Virtual Tensor framework, LayerKV techniques, performance comparisons with Page Attention and FlashAttention, and extensive experimental results demonstrating reduced latency and higher QPS.

GPUVirtual Memoryattention
0 likes · 25 min read
Memory Optimization for Large Model Inference: Virtual Tensor and LayerKV Techniques
Python Programming Learning Circle
Python Programming Learning Circle
Dec 28, 2024 · Fundamentals

Comprehensive Guide to String Concatenation Methods in Python

This article presents a comprehensive overview of seven Python string concatenation techniques—including the plus operator, comma printing, implicit literal concatenation, percent formatting, format method, join function, f‑strings, and the multiplication operator—along with performance tips and usage recommendations.

String concatenationperformanceprogramming
0 likes · 5 min read
Comprehensive Guide to String Concatenation Methods in Python
ByteDance SYS Tech
ByteDance SYS Tech
Dec 27, 2024 · Backend Development

How ByteDance Tackled C++ Compilation Bottlenecks and Massive Binary Bloat

ByteDance's STE team dissected the severe compile‑time delays and oversized binary artifacts in their data‑center C++ applications, presenting root‑cause analyses, LLVM bug fixes, and a suite of optimization techniques that together cut build times by up to 50% and reduced binary size by over 80%.

C++LLVMcompilation
0 likes · 26 min read
How ByteDance Tackled C++ Compilation Bottlenecks and Massive Binary Bloat
Code Ape Tech Column
Code Ape Tech Column
Dec 27, 2024 · Backend Development

Object Pool Pattern: Principles, Apache Commons Pool Implementation, and Practical Use Cases

This article explains the object pool design pattern, its working mechanism, advantages and disadvantages, and provides step‑by‑step Java code using Apache Commons Pool along with real‑world examples for web servers and game development to improve performance and resource management.

Apache Commons Pooldesign patternobject pool
0 likes · 14 min read
Object Pool Pattern: Principles, Apache Commons Pool Implementation, and Practical Use Cases
Architect's Guide
Architect's Guide
Dec 27, 2024 · Backend Development

Fast‑Retry: High‑Performance Asynchronous Retry Framework for Java

Fast‑Retry is a high‑throughput Java retry library that enables asynchronous, non‑blocking retries for massive task volumes, offering programmable and annotation‑based APIs, custom retry policies, and significant performance gains over traditional synchronous frameworks like Spring‑Retry and Guava‑Retry.

BackendJavaRetry
0 likes · 11 min read
Fast‑Retry: High‑Performance Asynchronous Retry Framework for Java
Architecture Digest
Architecture Digest
Dec 26, 2024 · Backend Development

Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison

This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.

ConcurrencyJavaSpring Boot
0 likes · 7 min read
Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
JavaScript
JavaScript
Dec 26, 2024 · Frontend Development

12 Essential Mobile Web Issues and How to Fix Them

This article outlines twelve common mobile web challenges—from 1px borders and 300 ms click delays to safe‑area handling and image loading optimization—providing concise CSS and JavaScript solutions to improve responsiveness, usability, and performance across diverse devices.

FrontendJavaScriptMobile
0 likes · 6 min read
12 Essential Mobile Web Issues and How to Fix Them
Java Architect Essentials
Java Architect Essentials
Dec 25, 2024 · Backend Development

Understanding Java Connection Pools: Commons Pool 2, Jedis, and HikariCP Performance

This article explains the principles of object pooling in Java, introduces the Commons Pool 2 library and its use in Redis client Jedis, compares pool and non‑pool performance with JMH benchmarks, and details the fast HikariCP database connection pool along with configuration tips and interview questions.

Commons-PoolConnection PoolHikariCP
0 likes · 15 min read
Understanding Java Connection Pools: Commons Pool 2, Jedis, and HikariCP Performance
JavaScript
JavaScript
Dec 25, 2024 · Frontend Development

7 Essential JavaScript Array Methods Every Developer Should Master

This guide explores seven powerful JavaScript array methods—map, filter, reduce, forEach, find, some, and every—detailing their syntax, practical examples, performance tips, and how to combine them for efficient data manipulation in modern web development.

JavaScriptMAParray methods
0 likes · 9 min read
7 Essential JavaScript Array Methods Every Developer Should Master
Su San Talks Tech
Su San Talks Tech
Dec 24, 2024 · Backend Development

10 Must‑Know MyBatis Tricks to Supercharge Your Java Backend

Discover ten powerful MyBatis techniques—from dynamic SQL and resultMap customization to batch operations, pagination, annotation‑based mappers, caching, dynamic table names, custom type handlers, logging, and multi‑datasource configuration—that can dramatically improve Java backend development efficiency and code quality.

Javaormperformance
0 likes · 10 min read
10 Must‑Know MyBatis Tricks to Supercharge Your Java Backend
Java Tech Enthusiast
Java Tech Enthusiast
Dec 22, 2024 · Backend Development

Common Java ThreadPool Pitfalls and How to Avoid Them

Java developers should avoid ten common thread‑pool mistakes—such as using unbounded queues, misconfiguring thread counts, neglecting shutdown, ignoring rejection policies, swallowing task exceptions, submitting blocking work, overusing pools, lacking monitoring, and missing dynamic tuning—by configuring bounded queues, proper sizes, explicit policies, exception handling, and runtime adjustments.

Best PracticesConcurrencyJava
0 likes · 8 min read
Common Java ThreadPool Pitfalls and How to Avoid Them
dbaplus Community
dbaplus Community
Dec 22, 2024 · Fundamentals

Why Row‑Major Traversal Beats Column‑Major: Unveiling Cache, Prefetch, and False‑Sharing Secrets

This article builds a practical hardware‑mind model by benchmarking Rust code to show how cache layout, prefetching, cache associativity, false sharing, pipeline stalls, and data dependencies affect the performance of row‑major versus column‑major traversals, random accesses, and multithreaded loops, and it offers concrete fixes such as cache‑line alignment.

CPU architectureRustfalse sharing
0 likes · 19 min read
Why Row‑Major Traversal Beats Column‑Major: Unveiling Cache, Prefetch, and False‑Sharing Secrets
Alibaba Cloud Native
Alibaba Cloud Native
Dec 19, 2024 · Big Data

Boosting SLS SQL: 3× Faster Queries on Trillion‑Row Logs

Alibaba Cloud’s Serverless Log Service (SLS) has overhauled its SQL engine with a C++‑based compute engine, SIMD acceleration, storage‑compute fusion, and optimized scheduling, delivering up to three‑fold speed gains, 50% latency reduction, and significant improvements across high‑cardinality, JSON, IP, and join queries.

Big DataLog Analyticscloud
0 likes · 12 min read
Boosting SLS SQL: 3× Faster Queries on Trillion‑Row Logs
Alibaba Cloud Big Data AI Platform
Alibaba Cloud Big Data AI Platform
Dec 19, 2024 · Big Data

MaxCompute Bloomfilter Index: Faster Emergency Tracing Queries, Reduced Storage

The article explains how MaxCompute’s newly introduced Bloomfilter index dramatically improves emergency data tracing by cutting query time and resource consumption, replacing costly secondary indexes, reducing storage by over 45%, and providing a lightweight, high‑efficiency solution for large‑scale point‑lookup scenarios.

Big DataBloomFilterMaxCompute
0 likes · 12 min read
MaxCompute Bloomfilter Index: Faster Emergency Tracing Queries, Reduced Storage
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 17, 2024 · Mobile Development

Synchronized Frame Animation Across Multiple Android Views (Mirror Frame Animation)

This article explains the concept of "same‑frequency same‑frame" animation, analyzes the limitations of existing animation engines, and presents a Drawable‑based projection technique with code examples to synchronize animation frames across multiple Android views while reducing memory and CPU overhead.

AndroidAnimationDrawable
0 likes · 16 min read
Synchronized Frame Animation Across Multiple Android Views (Mirror Frame Animation)
JavaEdge
JavaEdge
Dec 16, 2024 · Backend Development

Why Nginx’s Event‑Driven Architecture Beats Traditional Thread‑Per‑Request Servers

Unlike traditional one‑request‑per‑process servers, Nginx uses a fixed number of worker processes with a non‑blocking, event‑driven model that reduces context switches, leverages epoll/kqueue, and handles thousands of connections efficiently, making it the preferred high‑performance web server.

Event-drivenNon-blocking I/Operformance
0 likes · 8 min read
Why Nginx’s Event‑Driven Architecture Beats Traditional Thread‑Per‑Request Servers
JD Cloud Developers
JD Cloud Developers
Dec 16, 2024 · Operations

Uncovering Java Call Latency Spikes: Memory, GC, and Network Bottlenecks

A Java service experienced occasional five‑minute latency spikes despite similar provider response times, prompting a systematic investigation of container memory usage, page‑cache behavior, young‑generation GC pauses, and network bottlenecks, ultimately revealing and mitigating the root causes.

ContainerJavagc
0 likes · 8 min read
Uncovering Java Call Latency Spikes: Memory, GC, and Network Bottlenecks
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 16, 2024 · Mobile Development

Implementing Custom Text Overflow with Highlight Support in ExtendedText for Flutter and HarmonyOS

This article explains how the ExtendedText component adds custom text‑overflow effects, including start, middle, end and auto modes, supports highlighted keywords with keep‑visible spans, and improves performance by replacing binary search with range estimation across Flutter, Android, iOS, Web and HarmonyOS platforms.

Custom Text OverflowExtendedTextFlutter
0 likes · 13 min read
Implementing Custom Text Overflow with Highlight Support in ExtendedText for Flutter and HarmonyOS
21CTO
21CTO
Dec 15, 2024 · Backend Development

How PHP 8.4 Boosts Performance: JIT, Optimized Calls, and New Data Structures

The article explains how PHP 8.4 achieves major speed and memory improvements through the introduction of a JIT compiler, optimized function calls and array handling, new data structures like red‑black trees, and various internal bug fixes and garbage‑collection enhancements.

Backend DevelopmentJITPHP
0 likes · 4 min read
How PHP 8.4 Boosts Performance: JIT, Optimized Calls, and New Data Structures
Architecture Digest
Architecture Digest
Dec 15, 2024 · Databases

Impact of VARCHAR Length on MySQL Storage and Query Performance

This article investigates whether the declared length of VARCHAR columns (e.g., VARCHAR(50) vs VARCHAR(500)) affects MySQL storage size and query performance by creating two tables, inserting one million rows, measuring disk usage, and benchmarking various SELECT and ORDER BY operations.

MySQLindexperformance
0 likes · 10 min read
Impact of VARCHAR Length on MySQL Storage and Query Performance
Java Tech Enthusiast
Java Tech Enthusiast
Dec 13, 2024 · Databases

Impact of VARCHAR Length on MySQL Storage and Query Performance

Testing shows that VARCHAR(50) and VARCHAR(500) occupy identical storage, yet while simple lookups perform similarly, sorting on the longer column triggers disk‑based mergesort and can be several times slower, demonstrating that excessive VARCHAR length harms query performance without saving space.

MySQLindexperformance
0 likes · 10 min read
Impact of VARCHAR Length on MySQL Storage and Query Performance
Code Ape Tech Column
Code Ape Tech Column
Dec 13, 2024 · Backend Development

Performance Tuning of a Java Spring Backend: From 50 TPS to Over 200 TPS

The article details a step‑by‑step performance investigation of a Java Spring backend that initially handled only 50 requests per second under load, covering slow SQL, excessive logging, thread‑pool misconfiguration, prototype‑scoped Redis beans, JVM memory settings, and the resulting optimizations that raised throughput to over 200 TPS.

Tomcatperformance
0 likes · 13 min read
Performance Tuning of a Java Spring Backend: From 50 TPS to Over 200 TPS
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 12, 2024 · Backend Development

Unlock Nginx: How Its Master‑Worker Architecture Powers High‑Performance Web Services

This article explains Nginx’s core architecture—including the master and worker processes, caching mechanisms, and request handling workflow—showing how it achieves high concurrency, efficient resource use, and reliable performance for modern web applications, while also offering additional resources for deeper learning.

architectureperformance
0 likes · 4 min read
Unlock Nginx: How Its Master‑Worker Architecture Powers High‑Performance Web Services
Tencent Cloud Developer
Tencent Cloud Developer
Dec 12, 2024 · Backend Development

Common Rate Limiting Algorithms: Fixed Window, Sliding Window, Sliding Log, Leaky Bucket, and Token Bucket

The article examines five common rate‑limiting algorithms—Fixed Window, Sliding Window, Sliding Log, Leaky Bucket, and Token Bucket—detailing their principles, pros and cons, and providing complete C++ implementations to help developers choose the best approach for controlling traffic bursts and ensuring system stability.

BackendC++Distributed Systems
0 likes · 14 min read
Common Rate Limiting Algorithms: Fixed Window, Sliding Window, Sliding Log, Leaky Bucket, and Token Bucket
Sohu Tech Products
Sohu Tech Products
Dec 11, 2024 · Frontend Development

Mastering React Rendering: When and How Components Re‑Render

This article explains React's rendering pipeline—including initial and update renders—identifies the factors that cause component re‑rendering, and demonstrates how to use React.memo, useMemo, and useCallback to eliminate unnecessary renders and improve performance.

FrontendReActReact.memo
0 likes · 12 min read
Mastering React Rendering: When and How Components Re‑Render
JD Tech
JD Tech
Dec 11, 2024 · Backend Development

Optimizing SpringBoot Application Startup Speed: Diagnosis and Solutions

This article details how a SpringBoot advertising platform service with startup times of 400‑500 seconds was analyzed and optimized through Actuator monitoring, log inspection, Tomcat TLD scan disabling, asynchronous HBase warm‑up, custom BeanPostProcessors, async JSF consumer initialization, Tomcat version tuning, and hardware upgrades, achieving roughly a 60% reduction in launch time.

AsyncBackendBeanPostProcessor
0 likes · 20 min read
Optimizing SpringBoot Application Startup Speed: Diagnosis and Solutions
DaTaobao Tech
DaTaobao Tech
Dec 11, 2024 · Backend Development

Resolving Metaspace and Off‑Heap Memory Issues After JDK 11 Upgrade

After upgrading core services to JDK 11, the team encountered a Metaspace rise and off‑heap memory growth caused by class‑loading changes and Netty’s disabled native buffers, which were resolved by expanding Metaspace to 768 MB and adding JVM options to enable Netty reflection and open required modules, restoring normal memory usage.

JDK11JVMMemoryLeak
0 likes · 8 min read
Resolving Metaspace and Off‑Heap Memory Issues After JDK 11 Upgrade
Python Programming Learning Circle
Python Programming Learning Circle
Dec 11, 2024 · Artificial Intelligence

Key Python 3.13 Features Boosting AI and Machine Learning Performance

Python 3.13 introduces experimental free‑threading, a JIT compiler, enhanced type system, asyncio improvements, new standard‑library modules, security updates, and expanded platform support, all of which aim to increase performance, productivity, and reliability for machine‑learning and artificial‑intelligence developers.

AIJITmachine learning
0 likes · 22 min read
Key Python 3.13 Features Boosting AI and Machine Learning Performance
php Courses
php Courses
Dec 11, 2024 · Backend Development

Debunking Common Misconceptions About PHP

This article systematically dispels ten widespread myths about PHP—covering threading, project scale, security, modern relevance, usage scope, code quality, performance, object‑oriented support, learning depth, and scalability—showing that modern PHP remains a powerful, secure, and versatile backend technology.

ConcurrencyPHPScalability
0 likes · 8 min read
Debunking Common Misconceptions About PHP
Architecture Digest
Architecture Digest
Dec 10, 2024 · Backend Development

Understanding Java Virtual Threads and Their Use in Spring Boot

This article explains Java 21's virtual threads, their lightweight and high‑concurrency advantages, demonstrates basic creation and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance optimization techniques.

ConcurrencyJavaSpring Boot
0 likes · 7 min read
Understanding Java Virtual Threads and Their Use in Spring Boot
macrozheng
macrozheng
Dec 10, 2024 · Backend Development

Boost MySQL Performance with Redis: Local & Remote Caching Strategies

Learn how to prevent MySQL overload by adding Redis as a caching layer, covering local in‑memory caches, remote cache services, support for multiple data types, expiration policies, persistence mechanisms like RDB and AOF, and simplified TCP protocols to achieve high‑throughput, resilient data access.

Backend DevelopmentCachingPersistence
0 likes · 11 min read
Boost MySQL Performance with Redis: Local & Remote Caching Strategies
IT Services Circle
IT Services Circle
Dec 10, 2024 · Fundamentals

Six Common Mistakes When Using Java BigDecimal and How to Avoid Them

This article explains six typical pitfalls when using Java's BigDecimal for precise calculations—such as initializing with floating‑point literals, neglecting scale in division, misusing equals, confusing scale with precision, ignoring immutability, and performance overhead—and provides clear code‑based solutions to each problem.

ArithmeticBest PracticesBigDecimal
0 likes · 7 min read
Six Common Mistakes When Using Java BigDecimal and How to Avoid Them
Su San Talks Tech
Su San Talks Tech
Dec 10, 2024 · Databases

Master MySQL: 13 Essential Functions & Commands Every Developer Should Know

This article walks through 13 practical MySQL techniques—including group_concat, char_length, locate, replace, now, various INSERT variations, SELECT FOR UPDATE, on duplicate key update, SHOW CREATE TABLE, CREATE TABLE … SELECT, EXPLAIN, SHOW PROCESSLIST, and mysqldump—providing clear examples, SQL snippets, and screenshots to help developers write more efficient and reliable queries.

DatabaseFunctionsMySQL
0 likes · 14 min read
Master MySQL: 13 Essential Functions & Commands Every Developer Should Know
Efficient Ops
Efficient Ops
Dec 8, 2024 · Operations

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

This guide explains how to analyze and troubleshoot situations where a Linux system shows high load averages despite low CPU usage, covering common load analysis methods, key commands like top, vmstat, iostat, and practical solutions for I/O bottlenecks and stuck processes.

CPULinuxLoad
0 likes · 11 min read
Diagnosing High Load with Low CPU on Linux: Commands and Tips
Java Tech Enthusiast
Java Tech Enthusiast
Dec 8, 2024 · Backend Development

Performance Comparison of Spring Boot Native Image, JAR, Go, and Rust Deployments

The article benchmarks a Spring Boot 3 service as a GraalVM native image, a traditional JAR, and Go and Rust versions, showing the native binary starts in under a second with ~70 MB memory and 7 k requests/s, the JAR needs seconds and 200 MB, while Go and Rust use 10 MB and 3 MB respectively with throughput, illustrating native images’ fast startup and lower runtime footprint despite longer compilation.

GoJavaRust
0 likes · 9 min read
Performance Comparison of Spring Boot Native Image, JAR, Go, and Rust Deployments
Open Source Tech Hub
Open Source Tech Hub
Dec 7, 2024 · Backend Development

Detecting and Preventing Memory Leaks in the Webman PHP Framework

This article explains what memory leaks are, why they matter for the long‑running Webman PHP framework, outlines the two conditions that cause leaks, demonstrates a faulty static‑array implementation with load‑testing results, provides corrected code, and summarizes best practices to avoid unbounded memory growth.

Memory LeakPHPWebman
0 likes · 5 min read
Detecting and Preventing Memory Leaks in the Webman PHP Framework
IT Services Circle
IT Services Circle
Dec 7, 2024 · Frontend Development

React 19 New Features and Updates Overview

React 19 introduces a suite of new features including Actions with useActionState, optimistic UI with useOptimistic, the use hook for resource reading, enhanced form handling via useFormStatus, server components, static rendering APIs, improved hydration, ref-as-prop, metadata handling, stylesheet and async script support, and advanced resource preloading.

ReActReact19ServerComponents
0 likes · 20 min read
React 19 New Features and Updates Overview
Su San Talks Tech
Su San Talks Tech
Dec 6, 2024 · Fundamentals

6 Common BigDecimal Mistakes in Java and How to Avoid Them

This article explains six typical pitfalls when using Java's BigDecimal—such as initializing with floating‑point literals, ignoring scale in division, misusing equals, misunderstanding scale, overlooking immutability, and performance costs—and provides clear code examples and best‑practice solutions to prevent precision loss and inefficiency.

ArithmeticBigDecimalJava
0 likes · 7 min read
6 Common BigDecimal Mistakes in Java and How to Avoid Them
Liangxu Linux
Liangxu Linux
Dec 5, 2024 · Cloud Native

Why Does Containerization Slow Down Your App? A Deep Dive into Performance Loss and Network Optimizations

Although containerization brings agility and resource efficiency, this article reveals that moving an application from a VM to Kubernetes containers can increase latency by 25% and reduce QPS by 29%, analyzes the root cause in network soft‑interrupt overhead, and proposes optimizations such as ipvlan, macvlan, and Cilium.

CiliumContainerizationcloud-native
0 likes · 8 min read
Why Does Containerization Slow Down Your App? A Deep Dive into Performance Loss and Network Optimizations
Architect
Architect
Dec 5, 2024 · Frontend Development

How Mako Redefines Web Bundling: Architecture, Performance, and Plugins

Mako is a Rust‑based web bundler that offers zero‑config, production‑grade speed, hot‑module replacement, code‑splitting and module concatenation, and its architecture—spanning entry, compiler, load, parse, transform, dependency analysis, module creation, and plugin orchestration—is detailed with benchmarks and code examples.

Build ToolFrontend DevelopmentMako
0 likes · 20 min read
How Mako Redefines Web Bundling: Architecture, Performance, and Plugins
IT Services Circle
IT Services Circle
Dec 5, 2024 · Databases

Understanding High-Concurrency Connection Issues in PostgreSQL and the Benefits of Using pgBouncer

The article explains how thousands of simultaneous client connections to a single PostgreSQL primary can cause severe write‑performance degradation, how introducing a connection pool such as pgBouncer reduces active backend processes dramatically, and why external pooling is preferred over built‑in solutions, illustrated with real‑world examples and a reference to the open‑source Pigsty distribution.

Connection PoolingDatabase ArchitecturePgBouncer
0 likes · 7 min read
Understanding High-Concurrency Connection Issues in PostgreSQL and the Benefits of Using pgBouncer
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 5, 2024 · Fundamentals

Unlock Java’s Functional Power: Real‑World Examples and Performance Insights

This article explains functional programming concepts in Java, including immutability, stateless functions, higher‑order functions, closures, currying, recursion, lazy evaluation, and referential transparency, and demonstrates each with practical code samples and JMH performance benchmarks.

Functional ProgrammingHigher-Order FunctionsJMH
0 likes · 13 min read
Unlock Java’s Functional Power: Real‑World Examples and Performance Insights