BestHub
Sign in
Tagged articles

performance

5000 articles · Page 28 of 50
Python Programming Learning Circle
Python Programming Learning Circle
Apr 7, 2023 · Fundamentals

Lesser‑Known Python Tricks and Techniques

This article introduces a collection of lesser‑known Python tricks—including string cleaning with translate, iterator slicing via itertools, skipping header lines, keyword‑only functions, custom context managers, memory‑saving __slots__, resource limits, import control with __all__, and total_ordering—to help developers write cleaner, more efficient code.

Memory Optimizationcode snippetscontext manager
0 likes · 10 min read
Lesser‑Known Python Tricks and Techniques
Yunxuetang Frontend Team
Yunxuetang Frontend Team
Apr 7, 2023 · Frontend Development

Essential Frontend Techniques & Architecture Trends for Modern Development

This article curates recent front‑end topics—including HTTP Range resumable downloads, H5 app invocation, automation testing adoption, new JavaScript/TypeScript features, Chrome 112 updates, the history of Signals, and industry viewpoints—providing concise insights for developers seeking to stay current.

JavaScriptbrowser updatesfrontend
0 likes · 4 min read
Essential Frontend Techniques & Architecture Trends for Modern Development
Top Architect
Top Architect
Apr 7, 2023 · Databases

MySQL Performance Optimization Guidelines from a Senior Architect

This article presents a senior architect’s comprehensive MySQL optimization guide, covering execution process, naming conventions, storage engine choices, indexing strategies, query writing best practices, transaction handling, partitioning, and other performance‑tuning techniques to improve database efficiency and reliability.

DatabaseOptimizationMySQLSQL
0 likes · 24 min read
MySQL Performance Optimization Guidelines from a Senior Architect
Programmer DD
Programmer DD
Apr 7, 2023 · Backend Development

Why Thread Pools Outperform Direct Thread Creation in High‑Concurrency Java Applications

In high‑concurrency Java scenarios, using a thread pool instead of creating raw Thread objects dramatically reduces resource consumption, prevents CPU overload and memory leaks, and offers reusable threads, controlled concurrency, task scheduling, and configurable rejection policies, all managed by the core ThreadPoolExecutor class.

ExecutorThread Poolperformance
0 likes · 13 min read
Why Thread Pools Outperform Direct Thread Creation in High‑Concurrency Java Applications
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Apr 3, 2023 · Frontend Development

Improving Front-End Project Delivery Quality through Tooling and Process Automation

The article proposes enhancing front‑end project delivery quality by replacing manual standards with automated tooling—static code linting, performance, error, and disaster‑recovery tests—and integrating these checks into DevOps checkpoints that enforce pass, alarm, or block actions, enabling metric‑driven, objective evaluation across teams and outsourced projects.

automationfrontendperformance
0 likes · 11 min read
Improving Front-End Project Delivery Quality through Tooling and Process Automation
JD Retail Technology
JD Retail Technology
Apr 3, 2023 · Fundamentals

How to Master Clean Code: From Learning to Refactoring with Real Examples

This article explores a systematic approach to becoming a better programmer, covering learning mindset, selecting role models, applying knowledge, coding principles, performance considerations, and refactoring techniques, illustrated with a RocketMQ file‑prewarm case study and practical guidelines for writing maintainable, high‑quality code.

LearningRocketMQclean code
0 likes · 17 min read
How to Master Clean Code: From Learning to Refactoring with Real Examples
Top Architect
Top Architect
Apr 2, 2023 · Databases

Optimizing Large-Scale Pagination Queries in MySQL: Data Generation and Index Strategies

This article demonstrates how to generate millions of test rows in MySQL, analyzes the performance impact of deep pagination using LIMIT, explains why non‑clustered index lookups cause costly table scans, and presents two optimization approaches—sub‑query ID filtering and key‑set pagination—to dramatically reduce query latency.

Index OptimizationMySQLSQL
0 likes · 8 min read
Optimizing Large-Scale Pagination Queries in MySQL: Data Generation and Index Strategies
21CTO
21CTO
Apr 2, 2023 · Backend Development

How Codon Turbocharges Python: A Compiler That Rivals C++

Codon, a new Python compiler introduced by IEEE Spectrum, uses static type checking to eliminate runtime overhead, delivering C++‑level performance—10 to 100 times faster than CPython—while targeting genomics, big‑data, and other compute‑intensive domains, though it sacrifices some dynamic Python features.

CodonPythongenomics
0 likes · 7 min read
How Codon Turbocharges Python: A Compiler That Rivals C++
21CTO
21CTO
Mar 31, 2023 · Backend Development

Boost Go Performance: 6 Proven Techniques for Faster, Leaner Apps

This article presents six practical Go performance optimizations—including GOMAXPROCS tuning for Kubernetes, struct field ordering, garbage‑collection limits, zero‑copy unsafe conversions, jsoniter usage, and sync.Pool pooling—that together can dramatically lower CPU, memory, and latency in production services.

GoKubernetesMemory Optimization
0 likes · 9 min read
Boost Go Performance: 6 Proven Techniques for Faster, Leaner Apps
Code Ape Tech Column
Code Ape Tech Column
Mar 31, 2023 · Backend Development

Comparative Analysis of Drools and LiteFlow Java Rule Engines

This article provides an in‑depth technical comparison between the mature Drools rule engine and the newer LiteFlow framework, covering definitions, expression syntax, Java integration, API usage, coupling, learning curve, tooling, storage, hot‑reloading, UI support, performance benchmarks, and overall suitability for complex business logic.

DroolsJavaLiteFlow
0 likes · 15 min read
Comparative Analysis of Drools and LiteFlow Java Rule Engines
ITPUB
ITPUB
Mar 29, 2023 · Databases

Beyond ACID: A Maslow‑Inspired Hierarchy of Database Needs

Drawing parallels with Maslow’s hierarchy, the article outlines an eight‑level model of database requirements—from core kernel correctness and ACID to advanced observability, automation, and the vision of a truly autonomous database—explaining how each tier maps to functional, security, reliability, ROI, insight, control, and transcendence.

architectureautonomydatabases
0 likes · 12 min read
Beyond ACID: A Maslow‑Inspired Hierarchy of Database Needs
ByteFE
ByteFE
Mar 29, 2023 · Frontend Development

An Introduction to WebAssembly: History, Advantages, and a Mandelbrot Demo

This article introduces WebAssembly, tracing its evolution from asm.js and NaCl to the modern binary format, outlines its performance, portability, and security benefits, and demonstrates its practical use by building a Mandelbrot set application with AssemblyScript and WebAssembly in the browser.

AssemblyScriptMandelbrotWebAssembly
0 likes · 20 min read
An Introduction to WebAssembly: History, Advantages, and a Mandelbrot Demo
DataFunSummit
DataFunSummit
Mar 29, 2023 · Big Data

Gluten Vectorized Engine: Boosting Spark Performance with Native Execution

The article introduces the Gluten vectorized engine, explains why Spark’s CPU bottleneck motivates integrating native vectorized back‑ends via Substrait, details its architecture, component design, current performance gains of up to three‑fold, and outlines ongoing development and future work.

GlutenNative EngineSpark
0 likes · 18 min read
Gluten Vectorized Engine: Boosting Spark Performance with Native Execution
Snowball Engineer Team
Snowball Engineer Team
Mar 29, 2023 · Databases

Mastering Redis: Architecture, Use Cases, Testing Pitfalls & Solutions

This article provides a comprehensive overview of Redis—including its architecture, common data structures, real‑world usage scenarios such as caching, counters, and distributed locks—followed by detailed QA test cases, common pitfalls like cache penetration, and practical mitigation strategies.

CachingRedisdatabase
0 likes · 16 min read
Mastering Redis: Architecture, Use Cases, Testing Pitfalls & Solutions
AI Cyberspace
AI Cyberspace
Mar 28, 2023 · Fundamentals

Why NUMA Slows Multithreaded Apps and How to Optimize It

This article explains NUMA architecture, its multithreaded performance overheads such as remote memory access, cache synchronization, context and mode switches, interrupt handling, TLB misses, and memory copies, and then presents optimization techniques like NUMA and CPU affinity, IRQ tuning, and large‑page usage.

CPU affinityLinuxNUMA
0 likes · 20 min read
Why NUMA Slows Multithreaded Apps and How to Optimize It
Top Architect
Top Architect
Mar 28, 2023 · Backend Development

Optimizing SpringBoot Startup Time: Diagnosing Bean Scanning and Initialization Bottlenecks

This article explains how to identify and reduce the excessive startup latency of a SpringBoot service by profiling the run method, customizing SpringApplicationRunListener and BeanPostProcessor, trimming component‑scan paths, and leveraging JavaConfig and starter mechanisms to avoid unnecessary bean loading and auto‑configuration overhead.

AutoConfigurationBeanScanningJavaConfig
0 likes · 18 min read
Optimizing SpringBoot Startup Time: Diagnosing Bean Scanning and Initialization Bottlenecks
IT Architects Alliance
IT Architects Alliance
Mar 28, 2023 · Big Data

Kafka Core Concepts, Architecture, Performance Optimization, and Production Deployment Guide

This comprehensive guide explains Kafka's core value as a message queue, its fundamental concepts, cluster architecture, high‑performance data handling, resource planning for large‑scale deployments, operational tools, consumer‑group mechanics, offset management, rebalance strategies, and custom partitioner implementation.

Replicationconsumer groupsdeployment
0 likes · 29 min read
Kafka Core Concepts, Architecture, Performance Optimization, and Production Deployment Guide
Top Architect
Top Architect
Mar 27, 2023 · Backend Development

Three MyBatis Batch Insert Methods and Their Performance Comparison

The article explains three ways to perform batch inserts with MyBatis—ordinary single-row inserts, foreach‑based bulk inserts, and ExecutorType.BATCH—analyzes their SQL logs, performance bottlenecks, MySQL limits, and provides practical recommendations for large‑scale data insertion.

Batch InsertExecutorTypeJava
0 likes · 13 min read
Three MyBatis Batch Insert Methods and Their Performance Comparison
Architect
Architect
Mar 25, 2023 · Backend Development

Optimizing SpringBoot Startup Time: Diagnosing Bean Scanning and Initialization Bottlenecks

This article analyzes why a SpringBoot service takes minutes to start, identifies the bean‑scanning and bean‑initialization phases as the main performance culprits, and presents practical solutions such as narrowing scan packages, using JavaConfig for explicit bean registration, customizing SpringApplicationRunListener and BeanPostProcessor for timing, and leveraging SpringBoot starter mechanisms to streamline cache configuration.

AutoConfigurationBeanScanningJavaConfig
0 likes · 18 min read
Optimizing SpringBoot Startup Time: Diagnosing Bean Scanning and Initialization Bottlenecks
Python Programming Learning Circle
Python Programming Learning Circle
Mar 25, 2023 · Fundamentals

New Features and Improvements in Python 3.11

Python 3.11, the latest stable release, brings substantial performance gains of up to 60 %, richer error tracebacks, faster code execution via adaptive specialization, new async task‑group syntax, expanded type‑variable support, built‑in TOML parsing, zero‑cost exceptions, exception groups, and quicker interpreter startup, all detailed with examples and benchmarks.

TOMLasyncexceptions
0 likes · 9 min read
New Features and Improvements in Python 3.11
Efficient Ops
Efficient Ops
Mar 22, 2023 · Databases

8 Common SQL Pitfalls and How to Optimize Them for Lightning‑Fast Queries

This article reveals frequent SQL mistakes—such as misuse of LIMIT, implicit type conversion, sub‑query updates, mixed ordering, EXISTS, condition push‑down, premature filtering, and intermediate result push‑down—and provides concrete rewrite techniques that dramatically improve MySQL query performance.

MySQLOptimizationQuery Tuning
0 likes · 14 min read
8 Common SQL Pitfalls and How to Optimize Them for Lightning‑Fast Queries
JD Cloud Developers
JD Cloud Developers
Mar 22, 2023 · Frontend Development

How to Detect and Prevent JavaScript Memory Leaks in Frontend Apps

Understanding JavaScript memory management, this guide explains the fundamentals of memory allocation, usage, and garbage collection, outlines common leak scenarios such as global variables, timers, event listeners, and data structures, and provides practical techniques and tools for detecting, diagnosing, and fixing memory leaks in web applications.

JavaScriptMemory Leakfrontend
0 likes · 15 min read
How to Detect and Prevent JavaScript Memory Leaks in Frontend Apps
HomeTech
HomeTech
Mar 22, 2023 · Mobile Development

Optimizing Complex Android Layout Rendering Performance

This article analyzes Android layout rendering performance issues and presents optimization strategies including AsyncLayoutInflater, X2C framework, and custom view factory approaches to reduce rendering time by 20-35%.

AndroidAsyncLayoutInflaterMobile Development
0 likes · 10 min read
Optimizing Complex Android Layout Rendering Performance
Top Architect
Top Architect
Mar 21, 2023 · Backend Development

Various Ways to Measure Code Execution Time in Java

This article explains several Java techniques for measuring code execution time—including Spring's StopWatch, System.nanoTime, new Date, and System.currentTimeMillis—provides sample code snippets, discusses their usage and output, while also briefly mentions related utilities, and contains promotional links and community invitations.

JavaStopwatchSystem.nanoTime
0 likes · 5 min read
Various Ways to Measure Code Execution Time in Java
ITPUB
ITPUB
Mar 19, 2023 · Databases

Why MySQL 8’s Default utf8mb4 Breaks Legacy utf8 Tables – A Deep Dive

Upgrading MySQL 5.6/5.7 databases to 8.0 can introduce charset mismatches between existing utf8 (utf8mb3) tables and newly created utf8mb4 tables, causing index loss and performance degradation that can be resolved by unifying the character set across all tables.

MySQLSQLperformance
0 likes · 7 min read
Why MySQL 8’s Default utf8mb4 Breaks Legacy utf8 Tables – A Deep Dive
Python Programming Learning Circle
Python Programming Learning Circle
Mar 17, 2023 · Fundamentals

Python Coding Principles and Best Practices

This article presents a comprehensive collection of Python coding principles, covering coding style, function design, library usage, design patterns, internal mechanisms, development tools, testing, and performance optimization to help developers write clean, efficient, and maintainable code.

Librariesbest-practicescoding-standards
0 likes · 9 min read
Python Coding Principles and Best Practices
Top Architect
Top Architect
Mar 16, 2023 · Backend Development

Various Ways to Measure Code Execution Time in Java

This article explains several common techniques for measuring Java code execution time, including System.currentTimeMillis(), Spring's StopWatch utility, System.nanoTime(), and the use of new Date(), providing code examples and a brief overview of StopWatch's API for developers seeking precise performance metrics.

BackendJavaStopwatch
0 likes · 5 min read
Various Ways to Measure Code Execution Time in Java
ITPUB
ITPUB
Mar 15, 2023 · Databases

Why Is Redis So Fast? Deep Dive into Its History, Architecture, and Performance

This article explores Redis’s evolution from its 2009 inception, outlines major version releases, examines its in‑memory design, efficient data structures, encoding schemes, single‑threaded event loop with epoll, and benchmark results, illustrating why Redis achieves exceptionally high throughput and low latency in real‑world deployments.

Redisbenchmarkencoding
0 likes · 15 min read
Why Is Redis So Fast? Deep Dive into Its History, Architecture, and Performance
HelloTech
HelloTech
Mar 15, 2023 · Mobile Development

Cross‑Platform Mobile Development: Evaluation and Implementation of Flutter and H5 Hybrid Solutions

The team evaluated cross‑platform options, piloted both Flutter and an H5 offline‑Hybrid approach, found Flutter’s self‑rendering engine delivered superior performance and consistency, and consequently adopted Flutter as the primary framework, dramatically improving development efficiency and UI parity across Android and iOS.

FlutterHybrid AppMVVM
0 likes · 14 min read
Cross‑Platform Mobile Development: Evaluation and Implementation of Flutter and H5 Hybrid Solutions
dbaplus Community
dbaplus Community
Mar 14, 2023 · Backend Development

How to Detect and Solve Java Application Performance Bottlenecks: A Practical Guide

This article walks through the evolution of a system’s performance concerns, defines speed and pressure dimensions, explains how to calculate RT, QPS and concurrency, compares QPS with TPS, and provides step‑by‑step methods using tools like Arthas, JMeter and JVM diagnostics to identify and fix CPU, memory and pressure issues before applying layered optimization strategies.

ArthasJMeterJava
0 likes · 12 min read
How to Detect and Solve Java Application Performance Bottlenecks: A Practical Guide
Programmer DD
Programmer DD
Mar 14, 2023 · Backend Development

Stream.toList vs Collectors.toList: Which Java List Conversion Is Faster?

This article compares Java's Stream.toList(), Collectors.toList(), and Collectors.toUnmodifiableList() by explaining their differences, showing benchmark code, presenting performance results for both 1,000 and 10,000 element streams, and concluding which method offers superior speed and efficiency.

CollectorsStreambenchmark
0 likes · 8 min read
Stream.toList vs Collectors.toList: Which Java List Conversion Is Faster?
macrozheng
macrozheng
Mar 14, 2023 · Backend Development

Boost Java Performance: 15 Proven Code Optimization Tricks

This article presents a collection of practical Java performance tips, covering visibility reduction, bit‑shift arithmetic, minimizing repeated calculations, avoiding RuntimeException catches, using local variables, lazy loading, proper static access, StringBuilder concatenation, hashCode implementation, collection pre‑sizing, loop object handling, efficient Map traversal, thread‑safe random usage, LongAdder counters, and reflection reduction.

JavaOptimizationcode
0 likes · 10 min read
Boost Java Performance: 15 Proven Code Optimization Tricks
Liangxu Linux
Liangxu Linux
Mar 13, 2023 · Databases

Why Docker Struggles with MySQL: 5 Key Reasons and Workarounds

The article examines why running MySQL in Docker containers often leads to data‑security, performance, state, and resource‑isolation problems, outlines practical mitigation strategies, and identifies scenarios where containerizing MySQL can still be viable.

DockerMySQLcontainerization
0 likes · 7 min read
Why Docker Struggles with MySQL: 5 Key Reasons and Workarounds
Laravel Tech Community
Laravel Tech Community
Mar 12, 2023 · Databases

Why COUNT(*) May Be Slower Than COUNT(1) in MySQL InnoDB

This article analyses how MySQL 5.7 InnoDB processes COUNT(*) versus COUNT(1), COUNT(id) and COUNT on indexed or non‑indexed columns, showing execution‑plan differences across various index configurations, explaining why count(*) can be unexpectedly slower and offering practical guidance for query optimization.

COUNTInnoDBMySQL
0 likes · 10 min read
Why COUNT(*) May Be Slower Than COUNT(1) in MySQL InnoDB
dbaplus Community
dbaplus Community
Mar 11, 2023 · Databases

Optimizing Distributed Database Sorting with Proxy Buffers and Priority Queues

This article examines the architecture of distributed databases, identifies the challenges of global sorting across shards, and presents both in‑memory and disk‑based proxy sorting solutions, detailing buffer configuration, merge‑sort and priority‑queue techniques, performance trade‑offs, and practical constraints for large‑scale queries.

Proxydistributed databasesexternal merge
0 likes · 10 min read
Optimizing Distributed Database Sorting with Proxy Buffers and Priority Queues
21CTO
21CTO
Mar 10, 2023 · Frontend Development

7 Emerging JavaScript Frameworks to Boost Web Performance in 2023

This article reviews seven up‑and‑coming JavaScript frameworks—Remix, Blitz, Qwik, RedwoodJS, Svelte, SolidJS, and Vue 3—explaining their key features, performance benefits, and suitability for building faster, more automated web applications in 2023.

JavaScriptcomparisonfrontend frameworks
0 likes · 10 min read
7 Emerging JavaScript Frameworks to Boost Web Performance in 2023
ByteDance Web Infra
ByteDance Web Infra
Mar 10, 2023 · Frontend Development

Rspack: A High‑Performance Rust‑Based Web Build Tool – Announcement and Roadmap

Rspack, a Rust‑written web bundler from ByteDance, is officially released as an open‑source project offering dramatically faster dev and build times, strong Webpack compatibility, flexible configuration, and a roadmap that includes richer loader support, advanced caching, plugin APIs, and quality‑assurance measures.

RspackRustWeb Build Tool
0 likes · 9 min read
Rspack: A High‑Performance Rust‑Based Web Build Tool – Announcement and Roadmap
Sanyou's Java Diary
Sanyou's Java Diary
Mar 9, 2023 · Databases

21 Essential SQL Habits to Boost Performance and Avoid Regrets

This guide presents 21 practical SQL habits covering performance tuning, safe data manipulation, and coding standards—such as using EXPLAIN, adding LIMIT to deletes, documenting tables, consistent formatting, proper indexing, and transaction handling—to help developers write more efficient, reliable, and maintainable queries.

SQLcoding standardsdatabase optimization
0 likes · 15 min read
21 Essential SQL Habits to Boost Performance and Avoid Regrets
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 7, 2023 · Frontend Development

From Rookie to Frontend Leader: 8‑Year Journey at Taobao UED

This article chronicles an eight‑year front‑end career at Taobao UED, detailing how the author progressed from a junior developer to a technical leader, embraced data‑driven practices, optimized performance, and built high‑impact teams while sharing personal insights and lessons learned.

Careerdata-drivenfrontend
0 likes · 21 min read
From Rookie to Frontend Leader: 8‑Year Journey at Taobao UED
Java Architect Essentials
Java Architect Essentials
Mar 6, 2023 · Backend Development

Why Property Copy Tools in Java Are Risky: Performance Issues and Safer Alternatives

The article explains why using automatic property copy utilities in Java can lead to performance degradation, hidden type‑conversion bugs, and runtime errors, and demonstrates safer approaches such as manually written converters, IDE‑generated code, and MapStruct with concrete examples and code snippets.

BeanUtilsMapStructperformance
0 likes · 8 min read
Why Property Copy Tools in Java Are Risky: Performance Issues and Safer Alternatives
Laravel Tech Community
Laravel Tech Community
Mar 6, 2023 · Databases

SQL Optimization Best Practices: Avoid SELECT *, Use Specific Fields, Index Strategies, and Other Performance Tips

This article presents a comprehensive set of MySQL performance guidelines, including avoiding SELECT *, preferring specific columns, eliminating OR in WHERE clauses, using numeric types, choosing VARCHAR over CHAR, applying proper JOINs, leveraging LIMIT, UNION ALL, composite indexes, and other practical tips to improve query efficiency and resource usage.

MySQLQuery OptimizationSQL
0 likes · 17 min read
SQL Optimization Best Practices: Avoid SELECT *, Use Specific Fields, Index Strategies, and Other Performance Tips
Sanyou's Java Diary
Sanyou's Java Diary
Mar 6, 2023 · Databases

15 Common MySQL Index Pitfalls and How to Avoid Them

This article compiles fifteen typical scenarios where MySQL indexes become ineffective—covering composite index left‑most matching, SELECT *, arithmetic on indexed columns, functions, LIKE patterns, type conversion, OR/AND logic, range queries, ORDER BY, and optimizer decisions—providing example SQL, EXPLAIN output, and practical tips to help developers prevent costly full‑table scans.

MySQLSQLdatabase
0 likes · 24 min read
15 Common MySQL Index Pitfalls and How to Avoid Them
Python Programming Learning Circle
Python Programming Learning Circle
Mar 6, 2023 · Fundamentals

A Guide to Useful Python Decorators

This article introduces several practical Python decorators—including @lru_cache, @jit, @do_twice, @count_calls, @dataclass, @singleton, @use_unit, and @singledispatch—explaining their purposes, benefits, and providing code examples to demonstrate how they can improve performance, readability, and functionality in Python programs.

LRU Cachedataclassperformance
0 likes · 9 min read
A Guide to Useful Python Decorators
Top Architect
Top Architect
Mar 6, 2023 · Backend Development

Using Caffeine Cache in Spring Boot: Features, Configuration, and Code Examples

This article introduces Caffeine Cache as a modern local caching solution, explains its W‑TinyLFU algorithm advantages over Guava, demonstrates various loading and eviction strategies, and provides detailed Spring Boot integration examples with Maven dependencies, configuration, annotations, and custom bean setups.

CaffeineJavaSpringBoot
0 likes · 24 min read
Using Caffeine Cache in Spring Boot: Features, Configuration, and Code Examples
21CTO
21CTO
Mar 5, 2023 · Backend Development

Why We Rewrote KCL in Rust: 66% Faster Execution and 20× Faster Parsing

This article details the motivations, challenges, and outcomes of rewriting the KCL compiler from Python to Rust, highlighting significant performance gains, reduced bugs, memory savings, and the learning curve associated with adopting Rust for a large‑scale systems project.

KCLRustcompiler
0 likes · 10 min read
Why We Rewrote KCL in Rust: 66% Faster Execution and 20× Faster Parsing
MaGe Linux Operations
MaGe Linux Operations
Mar 4, 2023 · Databases

Why Docker Struggles with MySQL: 7 Critical Reasons

This article examines why running MySQL in Docker containers often leads to data‑security risks, performance bottlenecks, state management issues, and resource‑isolation problems, while also outlining scenarios where containerization can still be viable and offering practical mitigation strategies.

Dockercontainerizationdatabase
0 likes · 7 min read
Why Docker Struggles with MySQL: 7 Critical Reasons
Selected Java Interview Questions
Selected Java Interview Questions
Mar 4, 2023 · Backend Development

Analyzing the Performance Impact of try-catch in Java

This article investigates the common belief that using try-catch in Java severely degrades performance by examining JVM exception handling, bytecode generation, compilation optimizations, and extensive benchmark tests, ultimately showing that the overhead is negligible in most scenarios.

JVMJavabenchmark
0 likes · 16 min read
Analyzing the Performance Impact of try-catch in Java
Python Programming Learning Circle
Python Programming Learning Circle
Mar 3, 2023 · Backend Development

Accelerating Image Pre‑processing in Python with a Three‑Line Multiprocessing Trick

This article demonstrates how to boost the speed of image‑preprocessing tasks in Python by replacing a conventional single‑process loop with a three‑line concurrent.futures ProcessPoolExecutor implementation, achieving up to six‑fold performance gains on multi‑core CPUs.

concurrent.futuresdata-preprocessingimage-processing
0 likes · 7 min read
Accelerating Image Pre‑processing in Python with a Three‑Line Multiprocessing Trick
Programmer DD
Programmer DD
Mar 3, 2023 · Fundamentals

Why Clean Code Can Slow Your C++ Programs by 15× – A Performance Deep Dive

An extensive performance analysis shows that strictly following clean‑code rules—such as using polymorphism, avoiding switch statements, and keeping functions tiny—can dramatically increase execution time, with measured slowdowns up to fifteen times, while alternative table‑driven or flat‑structure approaches achieve orders‑of‑magnitude speed gains.

C++OptimizationPolymorphism
0 likes · 24 min read
Why Clean Code Can Slow Your C++ Programs by 15× – A Performance Deep Dive
MaGe Linux Operations
MaGe Linux Operations
Mar 1, 2023 · Backend Development

How to Prevent Redis Cache Avalanche, Penetration, and Breakdown

This article explains the concepts of Redis cache avalanche, penetration, and breakdown, illustrates real‑world incidents, and provides pre‑, during‑, and post‑failure strategies such as high‑availability setups, local caches with rate limiting, and defensive caching of empty values.

Cache AvalancheCache BreakdownCache Penetration
0 likes · 7 min read
How to Prevent Redis Cache Avalanche, Penetration, and Breakdown
Xianyu Technology
Xianyu Technology
Mar 1, 2023 · Mobile Development

Flutter Performance Tips: Quick Identification and Raster Cache Optimization

By using a quick identification tip and a unified smoothness metric, developers can see that Flutter often out‑performs native pages on high‑refresh iOS devices and, on Android, can be measured across devices, while optimizing rasterCache hit rates—through flags like will_change, is_complex, complexity_score, visibility rules, and limiting cached items to three per frame—significantly improves rendering performance.

Flutterfpsperformance
0 likes · 6 min read
Flutter Performance Tips: Quick Identification and Raster Cache Optimization
MaGe Linux Operations
MaGe Linux Operations
Feb 28, 2023 · Fundamentals

Why Protocol Buffers Outperform JSON: A Hands‑On Java Benchmark

This article introduces Google’s Protocol Buffers, explains its compilation process, walks through a complete Java example, and compares its encoding speed, data size, and memory usage against JSON, showing that ProtoBuf becomes significantly faster and more compact as the number of operations increases.

Data FormatsProtocol Buffersperformance
0 likes · 9 min read
Why Protocol Buffers Outperform JSON: A Hands‑On Java Benchmark
Top Architect
Top Architect
Feb 28, 2023 · Fundamentals

JVM Lock Optimization, Escape Analysis, and Synchronization Elimination

This article explains how the JVM improves concurrency performance through lock optimization techniques such as spin locks, lock elimination, lock coarsening, and escape analysis, illustrating each concept with code examples and discussing related optimizations like stack allocation and scalar replacement.

JVMJavaconcurrency
0 likes · 9 min read
JVM Lock Optimization, Escape Analysis, and Synchronization Elimination
ITPUB
ITPUB
Feb 27, 2023 · Databases

Mastering SQL Joins: Boost Performance When Migrating from Oracle to Open‑Source Databases

This article explains why SQL join execution plans often cause severe performance drops after moving from Oracle to domestic or open‑source databases, demonstrates each join type with PostgreSQL examples, shows how plan choices like HASH JOIN versus NESTED LOOP affect speed, and offers rewrite techniques such as NOT EXISTS or UNION to restore efficiency.

JOINOptimizationOracle
0 likes · 8 min read
Mastering SQL Joins: Boost Performance When Migrating from Oracle to Open‑Source Databases
Programmer DD
Programmer DD
Feb 27, 2023 · Big Data

Why Hadoop/Spark Feel Heavy and How SPL Offers a Lightweight Big Data Solution

With data volumes soaring, traditional Hadoop and Spark clusters become costly and cumbersome for small to medium workloads, prompting many to seek lighter alternatives; this article examines the technical, operational, and financial burdens of Hadoop/Spark and introduces the open‑source SPL engine as a fast, low‑cost, easy‑to‑use big‑data solution.

Cost EfficiencyHadoopSpark
0 likes · 16 min read
Why Hadoop/Spark Feel Heavy and How SPL Offers a Lightweight Big Data Solution
Su San Talks Tech
Su San Talks Tech
Feb 26, 2023 · Backend Development

Does a try‑catch Inside a Java for‑loop Really Slow Down Your Code?

A practical benchmark compares placing a try‑catch inside a Java for‑loop versus wrapping the loop with try‑catch, revealing that the performance difference is negligible and that the real impact depends on exception frequency and code design rather than the try‑catch placement.

Effective JavaJMHJava
0 likes · 6 min read
Does a try‑catch Inside a Java for‑loop Really Slow Down Your Code?
Python Programming Learning Circle
Python Programming Learning Circle
Feb 23, 2023 · Fundamentals

Why Python Uses Indentation, Handles Floats, and Other Design Decisions – A Comprehensive FAQ

This article explains Python's design choices such as mandatory indentation, floating‑point arithmetic quirks, immutable strings, the absence of switch statements, memory management, and many other language features, providing clear reasoning, code examples, and best‑practice recommendations for Python developers.

best-practicesinterpreterlanguage-design
0 likes · 26 min read
Why Python Uses Indentation, Handles Floats, and Other Design Decisions – A Comprehensive FAQ
Ctrip Technology
Ctrip Technology
Feb 23, 2023 · Frontend Development

Understanding Qwik: The First O(1) JavaScript SSR Framework and Its Resumable Architecture

This article explains the fundamentals of server‑side rendering versus client‑side rendering, highlights the performance drawbacks of traditional hydration, and introduces Qwik’s resumable approach that serialises state and events into HTML to achieve near‑zero hydration overhead while maintaining interactivity.

QwikResumabilitySSR
0 likes · 23 min read
Understanding Qwik: The First O(1) JavaScript SSR Framework and Its Resumable Architecture
JD Retail Technology
JD Retail Technology
Feb 23, 2023 · Operations

Understanding and Tuning JVM ParallelGCThreads and Related Memory Parameters

This article explains the trade‑off between throughput and pause time in JVM garbage collection, details how the ParallelGCThreads, ConcGCThreads, and CICompilerCount parameters are calculated and affect performance, presents experimental results, and provides concrete configuration recommendations for both on‑heap and off‑heap memory in containerized Java applications.

DockerGCJVM
0 likes · 14 min read
Understanding and Tuning JVM ParallelGCThreads and Related Memory Parameters
ITPUB
ITPUB
Feb 20, 2023 · Databases

18 Must‑Know MySQL 8.0 Management Features to Boost Your DBA Skills

Discover 18 essential MySQL 8.0 management enhancements—including persistent global variables, admin IP/port settings, minimal installation packages, resource groups, read‑only databases, improved SHOW PROCESSLIST, instant DDL, faster DROP/TRUNCATE, OS thread visibility, connection memory limits, enriched slow‑log details, backup options, Clone plugin, upgrade process, client defaults, and RESTART command usage.

8.0MySQLSQL
0 likes · 12 min read
18 Must‑Know MySQL 8.0 Management Features to Boost Your DBA Skills
Open Source Linux
Open Source Linux
Feb 20, 2023 · Databases

8 Common SQL Pitfalls and How to Optimize Them for Lightning‑Fast Queries

This article examines eight frequent SQL anti‑patterns—including misuse of LIMIT, implicit type conversion, sub‑query updates, mixed ordering, EXISTS clauses, condition push‑down, premature data reduction, and intermediate result handling—explaining why they degrade performance and providing concrete rewrite strategies and code examples to dramatically speed up queries.

MySQLOptimizationSQL
0 likes · 14 min read
8 Common SQL Pitfalls and How to Optimize Them for Lightning‑Fast Queries
Java High-Performance Architecture
Java High-Performance Architecture
Feb 18, 2023 · Backend Development

How We Scaled a Live‑Streaming Danmaku System to 1M Concurrent Users

This article details the design, bandwidth optimization, and reliability engineering behind a custom live‑streaming danmaku service that supports up to one million simultaneous users, covering problem analysis, compression techniques, polling strategies, service splitting, and performance results from a major traffic event.

Backenddanmakulive streaming
0 likes · 10 min read
How We Scaled a Live‑Streaming Danmaku System to 1M Concurrent Users
Programmer DD
Programmer DD
Feb 17, 2023 · Fundamentals

Why Java’s New Virtual Threads Could Transform High‑Scale Applications

Java 19 introduces preview virtual threads—a lightweight alternative to platform threads that store stack frames on the heap, dramatically reduce memory overhead, and eliminate the thread‑count scalability bottleneck, enabling a simple “one task per thread” model for IO‑bound workloads without sacrificing existing thread semantics.

java19performancevirtual-threads
0 likes · 28 min read
Why Java’s New Virtual Threads Could Transform High‑Scale Applications
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Feb 16, 2023 · Industry Insights

Why Alibaba’s DAC Strategy Revolutionized Data Center Networking

This article analyzes how Alibaba’s large‑scale deployment of Direct Attach Cables (DAC) transformed data‑center physical networking by cutting costs, reducing power consumption, improving reliability and latency, and driving architectural innovations that address past adoption barriers and future challenges.

AOCAlibabaDAC
0 likes · 19 min read
Why Alibaba’s DAC Strategy Revolutionized Data Center Networking
Architect's Tech Stack
Architect's Tech Stack
Feb 16, 2023 · Backend Development

A Comprehensive Guide to Java Microbenchmarking with JMH

This article introduces Java Microbenchmark Harness (JMH), explains why warm‑up is necessary, details common annotations, shows how to set up a Maven project, provides a complete benchmark example comparing LinkedList iteration methods, and demonstrates how to run and interpret the results.

BenchmarkingJMHJava
0 likes · 13 min read
A Comprehensive Guide to Java Microbenchmarking with JMH
Code Ape Tech Column
Code Ape Tech Column
Feb 16, 2023 · Databases

Understanding and Solving BigKey and HotKey Issues in Redis Clusters

BigKey and HotKey are common Redis cluster problems that can degrade performance, cause timeouts, network congestion, and even system-wide failures; this article explains their definitions, impacts, detection methods, and practical mitigation strategies—including key splitting, local caching, and migration optimizations—based on real-world production cases.

BigKeyHotKeydatabase
0 likes · 22 min read
Understanding and Solving BigKey and HotKey Issues in Redis Clusters
Huolala Tech
Huolala Tech
Feb 14, 2023 · Frontend Development

When Does a React Component Re‑Render and How to Optimize It?

This article explains what triggers a React component re‑render, distinguishes required from unnecessary renders, and presents practical techniques—such as narrowing render scope, using memo, useMemo, useCallback, and context selectors—to improve performance in complex applications.

HooksOptimizationReact
0 likes · 11 min read
When Does a React Component Re‑Render and How to Optimize It?
JD Retail Technology
JD Retail Technology
Feb 13, 2023 · Frontend Development

What’s New in NutUI 4.0? A Deep Dive into Features, Performance Gains, and Migration Tips

NutUI 4.0 introduces a dynamic CSS‑variables theme, a dedicated icon library, automatic on‑demand component import, new components such as Tour and PullRefresh, extensive component refinements, significant bundle‑size reductions, upgraded build tools, and updated type declarations, providing a lighter, more flexible frontend solution.

Component LibraryUI libraryVue
0 likes · 9 min read
What’s New in NutUI 4.0? A Deep Dive into Features, Performance Gains, and Migration Tips
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Feb 13, 2023 · Frontend Development

Advanced Tips and Common Pitfalls for React Hooks (useState, useEffect, useContext, useReducer, etc.)

This article provides in‑depth guidance on using React hooks such as useState, useEffect, useContext, useReducer, and related utilities, covering lazy initialization, functional updates, performance‑optimising patterns, state sharing strategies, and advanced techniques like useImmer and react‑tracked to reduce mental overhead and avoid bugs.

HooksReactperformance
0 likes · 16 min read
Advanced Tips and Common Pitfalls for React Hooks (useState, useEffect, useContext, useReducer, etc.)
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Feb 13, 2023 · Backend Development

How NEMichelinCache Cuts Crashes and Boosts Performance in Cross‑Platform RN/H5 Apps

The article details the design and implementation of NEMichelinCache, a cross‑platform cache library for React Native and H5, explaining the problems of the legacy cache, the architectural choices made, the modules introduced, and the measurable improvements in stability and speed achieved after deployment.

React Nativearchitecturecache
0 likes · 12 min read
How NEMichelinCache Cuts Crashes and Boosts Performance in Cross‑Platform RN/H5 Apps
Code Ape Tech Column
Code Ape Tech Column
Feb 13, 2023 · Backend Development

Performance Comparison and Source Analysis of Java Bean Copy Utilities

This article analyzes the performance and implementation differences of various Java object‑copy utilities—including Apache BeanUtils, PropertyUtils, Spring BeanCopier, and Spring BeanUtils—by examining source code, benchmarking copy operations, and recommending alternatives to avoid the inefficiencies of Apache BeanUtils.

ApacheBeanUtilsJava
0 likes · 11 min read
Performance Comparison and Source Analysis of Java Bean Copy Utilities
37 Interactive Technology Team
37 Interactive Technology Team
Feb 10, 2023 · Backend Development

Analysis of Golang SQL Connection Pool Mechanism and Usage

The article examines Go’s database/sql connection pool implementation, showing how reusing connections cuts latency, explains idle/in‑use/closed state transitions, details configuration parameters such as MaxIdleConns and MaxOpenConns, demonstrates metric collection via Gorm DBStats for monitoring, and provides a stress‑test illustrating the impact of proper tuning.

GORMSQLconnection pool
0 likes · 10 min read
Analysis of Golang SQL Connection Pool Mechanism and Usage