BestHub
Sign in
Tagged articles
151 articles
Page 1 of 2
Architect's Guide
Architect's Guide
May 11, 2026 · Backend Development

Why UUID Falls Short and How Snowflake Solves Distributed ID Generation

The article examines the limitations of UUIDs for distributed systems, outlines the strict requirements for global unique IDs, compares common approaches such as database auto‑increment and Redis, and provides a detailed analysis of Twitter's Snowflake algorithm with its structure, Java implementation, advantages, drawbacks, and mitigation strategies.

Backenddistributed-idjava
0 likes · 14 min read
Why UUID Falls Short and How Snowflake Solves Distributed ID Generation
Sohu Tech Products
Sohu Tech Products
Apr 22, 2026 · Databases

How to Resolve ID Conflicts After Sharding? 5 Proven Solutions

When sharding databases, independent auto‑increment IDs can collide, causing data integrity issues; this article explains why the conflict occurs and walks through five practical solutions—including UUID, custom auto‑increment steps, segment mode, Snowflake, and Meituan Leaf—detailing their trade‑offs, performance, and implementation steps.

ID generationLeafdatabase
0 likes · 15 min read
How to Resolve ID Conflicts After Sharding? 5 Proven Solutions
Tech Musings
Tech Musings
Apr 22, 2026 · Fundamentals

Go Standard Library Adds UUID Support with a Streamlined V4/V7 API

The Go team introduced a new uuid package to the standard library, offering lightweight functions for generating, parsing, serializing, and comparing UUID version 4 and version 7 values, integrating with database/sql, using a [16]byte type compatible with google/uuid, and providing detailed design rationale, implementation details, and a comparison with the existing third‑party library.

GoStandard Libraryapi-design
0 likes · 11 min read
Go Standard Library Adds UUID Support with a Streamlined V4/V7 API
Java Companion
Java Companion
Apr 17, 2026 · Backend Development

Resolving ID Conflicts After Sharding: 5 Practical Solutions

When sharding databases, independent auto‑increment IDs can collide; this article explains why the conflict occurs and evaluates five concrete solutions—UUID, MySQL auto‑increment step, segment allocation, Snowflake algorithm, and Meituan Leaf—detailing their mechanisms, trade‑offs, performance, and suitability.

ID generationMeituan LeafSegment
0 likes · 14 min read
Resolving ID Conflicts After Sharding: 5 Practical Solutions
Java Companion
Java Companion
Apr 2, 2026 · Backend Development

Why Java 26’s New UUID API Fixes the Biggest UUID Pitfall

The article explains how random UUIDs degrade database write performance, introduces the RFC 9562 UUIDv7 format that embeds a timestamp for natural ordering, shows JDK 26’s new UUID.ofEpochMillis() API, discusses its monotonicity limitation, and compares UUIDv7 with Snowflake and ULID for practical ID generation.

ULIDUUIDv7database indexing
0 likes · 12 min read
Why Java 26’s New UUID API Fixes the Biggest UUID Pitfall
Coder Trainee
Coder Trainee
Feb 19, 2026 · Fundamentals

Why Switch from UUID to ULID? Exploring Benefits and Features

The article explains why developers are moving from UUID to ULID, detailing ULID’s 128‑bit compatibility, massive per‑millisecond uniqueness, lexicographic sorting, compact 26‑character Base32 encoding, timestamp integration, strong randomness, and practical use cases such as distributed systems and database sharding.

Base32Distributed SystemsULID
0 likes · 3 min read
Why Switch from UUID to ULID? Exploring Benefits and Features
DevOps Coach
DevOps Coach
Jan 31, 2026 · Databases

7 Overlooked PostgreSQL Architecture Mistakes That Kill Performance

The article reveals seven common PostgreSQL architectural oversights—such as neglecting vacuum, misusing UUID primary keys, treating the database as a queue, missing indexes, over‑relying on ORMs, ignoring write‑side scaling, and failing to partition large tables—that silently degrade performance and reliability, and provides concrete fixes and best‑practice configurations.

ORMPartitioningVacuum
0 likes · 7 min read
7 Overlooked PostgreSQL Architecture Mistakes That Kill Performance
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 25, 2025 · Backend Development

Choosing the Right Distributed ID Generation Strategy: Auto‑Increment, UUID, Snowflake, and Redis

This guide compares four common distributed ID generation techniques—database auto‑increment, UUID, Twitter’s Snowflake, and Redis INCR—detailing their advantages, drawbacks, and ideal use‑cases, helping architects select the most suitable method for their system’s scalability and performance requirements.

Backendauto_incrementdistributed-id
0 likes · 4 min read
Choosing the Right Distributed ID Generation Strategy: Auto‑Increment, UUID, Snowflake, and Redis
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 25, 2025 · Backend Development

Comparing Four Distributed ID Generation Strategies: Auto‑Increment, UUID, Snowflake, and Coordination Services

This article compares four major distributed ID generation approaches—database auto‑increment, UUID, Snowflake, and coordination‑service based allocation—detailing their mechanisms, advantages, drawbacks, and suitable scenarios for backend system design.

BackendID generationdatabase auto-increment
0 likes · 5 min read
Comparing Four Distributed ID Generation Strategies: Auto‑Increment, UUID, Snowflake, and Coordination Services
Java Backend Technology
Java Backend Technology
Dec 24, 2025 · Databases

Why UUID Primary Keys Slow Down MySQL and How to Optimize Them

Using UUIDs as primary keys in MySQL can dramatically degrade performance on large tables due to larger index size, random inserts causing index splits, slower comparisons, and costly index refreshes on updates, but the impact can be mitigated with ordered UUIDs, binary storage, hybrid keys, or table partitioning.

indexmysqlprimary key
0 likes · 8 min read
Why UUID Primary Keys Slow Down MySQL and How to Optimize Them
JavaScript
JavaScript
Dec 16, 2025 · Frontend Development

Why Timestamp+Random Fails and How crypto.randomUUID() Guarantees Truly Unique IDs

This article explains common pitfalls of generating unique IDs with timestamps and simple counters in JavaScript, demonstrates why those methods can collide under high concurrency, and shows how the built‑in crypto.randomUUID() provides a standards‑based, cryptographically secure solution.

JavaScriptbest-practicescrypto
0 likes · 5 min read
Why Timestamp+Random Fails and How crypto.randomUUID() Guarantees Truly Unique IDs
DevOps Coach
DevOps Coach
Dec 8, 2025 · Databases

Why UUID Primary Keys Halve Your Database Throughput (And How to Fix It)

Using random UUID primary keys forces PostgreSQL to write to unpredictable index pages, causing heavy CPU usage, large index size, and dramatically higher insert latency, while switching to a sequential bigint key restores performance and reduces write amplification.

Database Performancebenchmarkbigserial
0 likes · 7 min read
Why UUID Primary Keys Halve Your Database Throughput (And How to Fix It)
SpringMeng
SpringMeng
Dec 8, 2025 · Databases

Why Using Snowflake IDs or UUIDs as MySQL Primary Keys Hurts Performance

This article experimentally compares auto‑increment, UUID and Snowflake‑generated primary keys in MySQL, analyzes their index structures, shows insertion‑time benchmarks, discusses the trade‑offs of each approach, and concludes that sequential auto‑increment keys deliver the best overall performance.

InnoDBSnowflake IDauto_increment
0 likes · 10 min read
Why Using Snowflake IDs or UUIDs as MySQL Primary Keys Hurts Performance
macrozheng
macrozheng
Dec 5, 2025 · Databases

Why UUID Primary Keys Slow Down MySQL and How to Optimize Them

This article explains how using UUIDs as primary keys in MySQL can degrade index efficiency, insert and query performance, and cause costly index refreshes on updates, then presents practical techniques such as ordered UUIDs, binary storage, hybrid keys, and partitioning to mitigate these issues.

indexmysqloptimization
0 likes · 8 min read
Why UUID Primary Keys Slow Down MySQL and How to Optimize Them
Top Architect
Top Architect
Nov 30, 2025 · Databases

Why UUID Primary Keys Slow Down MySQL and How to Fix Them

Using UUIDs as primary keys in MySQL can severely degrade performance due to larger index size, random insertion order, and costly updates, but the article explains the underlying reasons and offers practical optimizations such as ordered UUIDs, binary storage, hybrid auto‑increment keys, and table partitioning.

indexmysqloptimization
0 likes · 8 min read
Why UUID Primary Keys Slow Down MySQL and How to Fix Them
Java Architect Handbook
Java Architect Handbook
Nov 26, 2025 · Databases

Why UUID Primary Keys Slow Down MySQL and How to Optimize Them

This article explains the performance drawbacks of using UUIDs as primary keys in MySQL—including larger indexes, random inserts, and slower comparisons—details why data updates trigger index refreshes, and offers practical optimization techniques such as ordered UUIDs, binary storage, hybrid auto‑increment keys, and table partitioning.

Binary StorageDatabase PerformanceIndex Optimization
0 likes · 8 min read
Why UUID Primary Keys Slow Down MySQL and How to Optimize Them
Senior Brother's Insights
Senior Brother's Insights
Nov 4, 2025 · Databases

Why Using UUIDs as MySQL Primary Keys Can Hurt Performance—and How to Fix It

UUIDs provide globally unique identifiers useful in distributed systems, but using them as MySQL primary keys can degrade insert speed, increase storage, and cause page splits; this article explains UUID versions, their structures, performance impacts, and best‑practice techniques such as binary storage, ordered UUIDs, and alternative ID schemes.

Binary Storagemysqlordered UUID
0 likes · 11 min read
Why Using UUIDs as MySQL Primary Keys Can Hurt Performance—and How to Fix It
JavaScript
JavaScript
Oct 6, 2025 · Frontend Development

Why Timestamp+Random Fails and How to Generate Truly Unique IDs in JavaScript

Generating unique IDs may seem trivial, but common approaches like combining Date.now() with Math.random() or using a simple counter suffer from timestamp precision limits and non‑cryptographic randomness, whereas the modern, standards‑based crypto.randomUUID() provides collision‑free, cryptographically secure identifiers across browsers and Node.js.

JavaScriptUnique IDcrypto.randomUUID
0 likes · 4 min read
Why Timestamp+Random Fails and How to Generate Truly Unique IDs in JavaScript
Data STUDIO
Data STUDIO
Sep 4, 2025 · Fundamentals

Seven Must‑Know Python 3.14 Features That Boost Performance and Developer Experience

The upcoming Python 3.14 release introduces seven major enhancements—including template strings (PEP 750), lazy type‑annotation evaluation (PEP 649), an external debugger API (PEP 768), native Zstandard compression (PEP 784), an upgraded REPL, UUID module improvements, and stricter finally‑block rules—each aimed at improving speed, safety, and usability for developers.

Pythondebugger-apifinally
0 likes · 11 min read
Seven Must‑Know Python 3.14 Features That Boost Performance and Developer Experience
macrozheng
macrozheng
Jul 16, 2025 · Databases

Why Auto‑Increment Beats UUID in MySQL: Performance Tests and Deep Dive

An in‑depth MySQL study compares auto‑increment, UUID, and random Snowflake keys by building three identical tables, running insert‑performance tests with Spring Boot/JdbcTemplate, and analyzing index structures, revealing why auto‑increment keys outperform UUIDs despite the latter’s uniqueness.

Spring Bootauto_incrementdatabase indexing
0 likes · 11 min read
Why Auto‑Increment Beats UUID in MySQL: Performance Tests and Deep Dive
JavaScript
JavaScript
Jul 14, 2025 · Frontend Development

Why Timestamp+Random Fails and How crypto.randomUUID() Guarantees True Uniqueness

This article explains common pitfalls of generating unique IDs with timestamps and Math.random(), shows why naive counters are unreliable in browsers, and demonstrates the robust, standards‑based solution using the built‑in crypto.randomUUID() method, which offers cryptographic security and near‑zero collision risk.

JavaScriptUnique IDcrypto
0 likes · 5 min read
Why Timestamp+Random Fails and How crypto.randomUUID() Guarantees True Uniqueness
JakartaEE China Community
JakartaEE China Community
Jun 30, 2025 · Backend Development

7 Key Features Introduced in Jakarta EE 10

Jakarta EE 10, now governed by the Eclipse Foundation, brings vendor‑neutral APIs and seven notable enhancements—including managed executor definitions, a new @Asynchronous annotation, multipart/form‑data support, OpenID authentication, UUID primary keys, expanded numeric and date‑time functions, and a pure‑Java view for Jakarta Faces—while inviting community contributions for its upcoming final release.

Jakarta EE 10Java EEOpenID
0 likes · 10 min read
7 Key Features Introduced in Jakarta EE 10
dbaplus Community
dbaplus Community
Jun 22, 2025 · Backend Development

Why UUIDv7 Is the New Go-To Primary Key for Distributed Databases

The article explains the drawbacks of traditional random UUIDs as primary keys, introduces the time‑ordered design of UUIDv7, compares it with earlier versions, and provides practical Java code and SQL examples for generating and using UUIDv7 in databases.

Distributed SystemsUUIDv7primary key
0 likes · 8 min read
Why UUIDv7 Is the New Go-To Primary Key for Distributed Databases
macrozheng
macrozheng
Jun 20, 2025 · Backend Development

Why UUIDv7 Outperforms Traditional UUIDs for Database Primary Keys

This article explains the drawbacks of traditional random UUIDs as database primary keys, introduces the time‑ordered UUIDv7 design, shows how its ordered structure improves index performance and storage efficiency, provides Java generation and SQL usage examples, and answers common questions about collisions and clock rollback.

UUIDv7databasejava
0 likes · 9 min read
Why UUIDv7 Outperforms Traditional UUIDs for Database Primary Keys
Python Programming Learning Circle
Python Programming Learning Circle
Jun 5, 2025 · Fundamentals

What’s New in Python 3.14? 7 Game‑Changing Features You Must Know

Python 3.14 brings a collection of major upgrades—t‑strings for safer templating, lazy type‑annotation evaluation, a standardized external debugger API, built‑in Zstandard compression, a smarter REPL, new UUID versions with 40% faster generation, and stricter finally‑block semantics—each aimed at improving developer productivity, security, and runtime performance.

Pythondebugger-apipython-3.14
0 likes · 11 min read
What’s New in Python 3.14? 7 Game‑Changing Features You Must Know
Java Backend Technology
Java Backend Technology
May 16, 2025 · Databases

How to Prevent MySQL Auto‑Increment ID Exhaustion: 6 Proven Strategies

When MySQL auto‑increment IDs approach their limit, this guide explains six practical solutions—including expanding column types, using UUIDs, segmenting ID generation, composite keys, adjusting increment steps, and sharding databases—to ensure scalable, unique identifiers for large‑scale applications.

ID Exhaustionauto_incrementdatabase scaling
0 likes · 7 min read
How to Prevent MySQL Auto‑Increment ID Exhaustion: 6 Proven Strategies
Top Architecture Tech Stack
Top Architecture Tech Stack
May 8, 2025 · Backend Development

Distributed ID Generation: Requirements and Common Implementation Schemes

The article explains why traditional auto‑increment primary keys are unsuitable for distributed systems, outlines the business requirements for a distributed ID (global uniqueness, trend and monotonic increase, security), and reviews several generation approaches such as UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf and Didi TinyID, including their advantages and drawbacks.

distributed-idredissegment mode
0 likes · 14 min read
Distributed ID Generation: Requirements and Common Implementation Schemes
Architect's Guide
Architect's Guide
Apr 25, 2025 · Databases

Solutions for MySQL Auto Increment ID Exhaustion

This article discusses the problem of MySQL auto‑increment ID exhaustion and presents six practical solutions—including changing column type to BIGINT, using UUIDs, segmenting ID generation, composite keys, adjusting auto‑increment steps, and database sharding—to ensure scalability and uniqueness.

Database designID Exhaustionauto_increment
0 likes · 6 min read
Solutions for MySQL Auto Increment ID Exhaustion
Architecture Digest
Architecture Digest
Apr 11, 2025 · Databases

Performance Issues of Using UUID as Primary Key in MySQL and Optimization Strategies

The article explains why using UUIDs as primary keys in MySQL large tables leads to poor index efficiency, slower inserts and queries, and costly index refreshes on updates, and then presents practical optimization techniques such as ordered UUIDs, binary storage, hybrid auto‑increment keys, and table partitioning.

Database designindex performancemysql
0 likes · 7 min read
Performance Issues of Using UUID as Primary Key in MySQL and Optimization Strategies
Architect's Tech Stack
Architect's Tech Stack
Mar 31, 2025 · Databases

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

This article investigates MySQL's recommendation to avoid UUIDs and non‑sequential keys by benchmarking insert performance of auto‑increment, UUID, and random (snowflake) primary keys, analyzing their index structures, drawbacks, and concluding that sequential auto‑increment keys provide the best overall efficiency.

auto_incrementindexingjava
0 likes · 9 min read
Performance Comparison of Auto‑Increment, UUID, and Random Keys in MySQL
Java Backend Technology
Java Backend Technology
Mar 26, 2025 · Databases

Why UUID Primary Keys Slow Down MySQL Inserts: A Performance Deep Dive

This article investigates why MySQL discourages UUID or non‑sequential Snowflake IDs as primary keys, compares auto_increment, UUID, and random‑key tables through SpringBoot‑JdbcTemplate benchmarks, analyzes their index structures, and explains the performance trade‑offs and security considerations.

SpringBootauto_incrementindexing
0 likes · 10 min read
Why UUID Primary Keys Slow Down MySQL Inserts: A Performance Deep Dive
macrozheng
macrozheng
Mar 25, 2025 · Databases

Why Auto‑Increment Beats UUID in MySQL: Performance & Index Insights

This article investigates MySQL’s recommendation against UUIDs, comparing auto‑increment, UUID, and random snowflake keys through insertion speed tests and index structure analysis, revealing why auto‑increment keys outperform others, while also discussing the drawbacks of each approach.

Database designIndex structurePerformance Testing
0 likes · 10 min read
Why Auto‑Increment Beats UUID in MySQL: Performance & Index Insights
Java Architect Essentials
Java Architect Essentials
Mar 24, 2025 · Databases

Why MySQL Discourages UUID as Primary Key: Performance Comparison with Auto‑Increment and Random Keys

This article investigates MySQL's recommendation against using UUIDs or non‑sequential keys as primary keys by creating three tables, benchmarking insert and query speeds with Spring Boot/JdbcTemplate, analyzing index structures, and discussing the trade‑offs of auto‑increment, UUID, and random long keys.

Database designauto_incrementindexing
0 likes · 11 min read
Why MySQL Discourages UUID as Primary Key: Performance Comparison with Auto‑Increment and Random Keys
Java Captain
Java Captain
Mar 22, 2025 · Databases

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

This article investigates MySQL's recommendation against using UUID or random Snowflake IDs as primary keys by creating three tables with different key strategies, running Spring Boot/JDBC performance tests, analyzing index structures, and concluding that auto‑increment keys offer superior insertion efficiency and fewer drawbacks.

Database IndexJDBCSpring Boot
0 likes · 10 min read
Performance Comparison of UUID, Auto‑Increment, and Random Keys in MySQL
Java Web Project
Java Web Project
Mar 19, 2025 · Databases

Why MySQL Auto‑Increment Beats UUID: A Deep Dive into Insertion Performance and Index Structure

This article experimentally compares MySQL auto_increment, UUID, and random Snowflake keys by measuring insert and query speeds, analyzing InnoDB index behavior, and discussing the trade‑offs of each primary‑key strategy, ultimately showing why auto_increment generally outperforms UUID in large‑scale workloads.

InnoDBauto_incrementbenchmark
0 likes · 11 min read
Why MySQL Auto‑Increment Beats UUID: A Deep Dive into Insertion Performance and Index Structure
Java Tech Enthusiast
Java Tech Enthusiast
Mar 13, 2025 · Databases

Performance Comparison of UUID vs Auto-Increment IDs in MySQL

Benchmarking three MySQL tables—auto_increment, UUID, and random long keys—shows that sequential auto_increment inserts are fastest, random keys are slower, and UUIDs dramatically lag due to random I/O and fragmentation, so use auto_increment for most workloads and reserve UUIDs only for required global uniqueness.

JDBCSpringBootauto_increment
0 likes · 10 min read
Performance Comparison of UUID vs Auto-Increment IDs in MySQL
Code Mala Tang
Code Mala Tang
Mar 9, 2025 · Databases

When Should You Use UUIDs in Databases? Pros, Cons, and Better Alternatives

UUIDs offer global uniqueness for distributed systems but can hurt insertion speed and increase storage, especially with random UUIDv4 keys; this article explains UUID basics, performance drawbacks, and evaluates alternatives like UUIDv7, auto‑increment integers, and ULID to help you choose the right identifier for your database.

alternativesdatabaseperformance
0 likes · 9 min read
When Should You Use UUIDs in Databases? Pros, Cons, and Better Alternatives
Top Architect
Top Architect
Jan 15, 2025 · Databases

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

This article investigates why MySQL recommends auto_increment primary keys over UUID or random Snowflake IDs by creating three tables with different key strategies, running Spring‑Boot/JdbcTemplate performance tests, analyzing insertion speed, index structures, and the trade‑offs of each approach.

Index structureauto_incrementmysql
0 likes · 12 min read
Performance Comparison of Auto‑Increment, UUID, and Random Keys in MySQL
Test Development Learning Exchange
Test Development Learning Exchange
Jan 13, 2025 · Backend Development

Building a Python Flask Service for Automatic ID Generation

This guide demonstrates how to build a Python Flask-based RESTful service that generates various types of unique identifiers—including UUIDs, timestamps, Redis counters, Snowflake IDs, and random strings—while covering installation, code implementation, API endpoints, error handling, rate limiting, and extensibility considerations.

APIFlaskID generation
0 likes · 7 min read
Building a Python Flask Service for Automatic ID Generation
Top Architect
Top Architect
Dec 5, 2024 · Databases

Why Not Use UUID as Primary Key in MySQL? Performance Analysis and Comparison with Auto‑Increment IDs

This article examines MySQL's recommendation against UUID primary keys by creating three tables with different key strategies, running large‑scale insert tests using Spring JdbcTemplate, and analyzing the resulting performance, index behavior, and trade‑offs of auto‑increment, UUID, and random keys.

auto_incrementdatabase indexingmysql
0 likes · 12 min read
Why Not Use UUID as Primary Key in MySQL? Performance Analysis and Comparison with Auto‑Increment IDs
dbaplus Community
dbaplus Community
Oct 29, 2024 · Databases

Why UUID v7 Beats UUID v4 as a Clustered Index – Performance Test Results

This article compares UUID v4 and UUID v7 as clustered index keys, explains their structures, lists pros and cons, describes a Docker‑based MySQL experiment using Node.js and Go, presents single‑ and multi‑thread insertion timings, and analyses why the time‑ordered UUID v7 (and serial IDs) outperform random UUID v4.

Clustered IndexDockerGo
0 likes · 14 min read
Why UUID v7 Beats UUID v4 as a Clustered Index – Performance Test Results
Selected Java Interview Questions
Selected Java Interview Questions
Oct 26, 2024 · Databases

Handling MySQL Auto Increment ID Exhaustion: Strategies and Solutions

This article explains why MySQL auto‑increment IDs can run out in large or special‑case tables and presents six practical solutions—including changing the column type to BIGINT, using UUIDs, segmenting IDs, composite keys, adjusting auto‑increment steps, and sharding databases—to ensure scalable and unique primary keys.

ID Exhaustionauto_incrementmysql
0 likes · 6 min read
Handling MySQL Auto Increment ID Exhaustion: Strategies and Solutions
Su San Talks Tech
Su San Talks Tech
Sep 15, 2024 · Backend Development

Mastering Distributed ID Generation: From UUID to Snowflake and Beyond

This article explores common distributed ID generation strategies—including UUID, database auto‑increment, segment allocation, Redis, Zookeeper, Snowflake, and open‑source solutions like Leaf, Tinyid, and Baidu UID‑Generator—detailing their principles, advantages, drawbacks, and implementation examples for high‑performance backend systems.

LeafTinyidZooKeeper
0 likes · 17 min read
Mastering Distributed ID Generation: From UUID to Snowflake and Beyond
Top Architect
Top Architect
Jun 13, 2024 · Databases

Why MySQL Discourages UUIDs and Random IDs: Performance Comparison with Auto‑Increment Primary Keys

This article analyzes MySQL's recommendation to avoid UUID or non‑sequential random primary keys by benchmarking insert performance across three tables—auto_increment, UUID, and random key—explaining the underlying index structures, observed speed differences, and the trade‑offs of each approach.

Database designauto_incrementindexing
0 likes · 12 min read
Why MySQL Discourages UUIDs and Random IDs: Performance Comparison with Auto‑Increment Primary Keys
21CTO
21CTO
Jun 2, 2024 · Databases

How UUIDs Hurt Database Performance and What You Can Do About It

This article explains how using UUIDs as primary keys can degrade insert performance and increase storage requirements, illustrating the impact with a million‑row simulation and offering guidance for better database design in.

primary keystorageuuid
0 likes · 5 min read
How UUIDs Hurt Database Performance and What You Can Do About It
Architect
Architect
May 1, 2024 · Fundamentals

Why ULID Beats UUID: A Deep Dive into Features, Specs, and Python Usage

This article compares UUID and ULID, explains the limitations of UUID versions, details ULID's timestamp‑based, lexicographically sortable design, presents its binary layout and encoding, and shows how to generate and manipulate ULIDs in Python with concrete code examples.

Distributed SystemsPythonSorting
0 likes · 8 min read
Why ULID Beats UUID: A Deep Dive into Features, Specs, and Python Usage
Su San Talks Tech
Su San Talks Tech
Apr 19, 2024 · Backend Development

Distributed Primary Keys in ShardingSphere: Strategies & Custom Implementations

This article explores why distributed primary keys are essential for sharding, compares built‑in ShardingSphere ID generation strategies such as UUID, NanoID, Snowflake, CosId and custom algorithms, details their configuration, performance trade‑offs, and provides code examples for implementing and registering custom key generators.

ShardingSpherecustom algorithmdatabase sharding
0 likes · 17 min read
Distributed Primary Keys in ShardingSphere: Strategies & Custom Implementations
Architecture Digest
Architecture Digest
Apr 12, 2024 · Databases

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

This article analyzes why MySQL recommends auto‑increment primary keys over UUIDs or random snowflake IDs by designing three tables, running insert‑select benchmarks with Spring Boot's JdbcTemplate, presenting the test results, and discussing the underlying index‑structure impacts and trade‑offs.

Database Indexauto_incrementmysql
0 likes · 10 min read
Performance Comparison of Auto‑Increment, UUID, and Random Keys in MySQL
FunTester
FunTester
Apr 7, 2024 · Backend Development

Generating Globally Unique Identifiers (GUID) for Performance Testing: UUID, Distributed Services, Snowflake Algorithm, and Thread‑Local Techniques

This article explains why globally unique identifiers are needed in performance testing, compares several common solutions such as Java UUID, Redis/Zookeeper distributed ID generators, the Snowflake algorithm, and thread‑local or shared counters, and provides complete Java code examples for each approach.

Distributed SystemsGUIDPerformance Testing
0 likes · 13 min read
Generating Globally Unique Identifiers (GUID) for Performance Testing: UUID, Distributed Services, Snowflake Algorithm, and Thread‑Local Techniques
Selected Java Interview Questions
Selected Java Interview Questions
Feb 23, 2024 · Backend Development

Designing an Order Number Generation System in Spring Boot

This article presents several approaches for generating unique, scalable order numbers in Spring Boot, including UUIDs, database sequences or auto‑increment IDs, timestamp‑based strings with random components, and distributed Snowflake IDs, each accompanied by Java code examples and discussion of their advantages and drawbacks.

Spring Bootjavaorder ID
0 likes · 10 min read
Designing an Order Number Generation System in Spring Boot
Senior Tony
Senior Tony
Feb 22, 2024 · Backend Development

Eight Distributed ID Generation Strategies: Pros, Cons, and Implementation Guide

This article reviews eight popular distributed ID generation methods—including UUID, database auto‑increment, Redis INCR, Snowflake, database segment, Meituan Leaf, Didi Tinyid, and Baidu UidGenerator—detailing their principles, code examples, advantages, disadvantages, and practical considerations for choosing the right solution.

LeafTinyiddatabase segment
0 likes · 11 min read
Eight Distributed ID Generation Strategies: Pros, Cons, and Implementation Guide
Sohu Tech Products
Sohu Tech Products
Feb 21, 2024 · Fundamentals

Unlocking iOS Debugging: A Deep Dive into DWARF and dSYM

This article explains the DWARF debugging information format, its role in iOS development, how dSYM files store DWARF data, the structure of compilation units and DIEs, key DW_TAG and DW_AT attributes, UUID matching, and practical dwarfdump commands for symbolication.

DWARFdSYMdebugging
0 likes · 10 min read
Unlocking iOS Debugging: A Deep Dive into DWARF and dSYM
JD Tech
JD Tech
Feb 19, 2024 · Databases

Choosing and Generating Sharding Keys for Database Partitioning

This article explains how to select appropriate sharding keys based on business requirements and data access patterns, describes vertical and horizontal partitioning methods, and presents common techniques such as equal‑value, index, and gene methods along with key generation strategies like auto‑increment, UUID, Snowflake algorithm, and open‑source middleware.

Horizontal PartitionVertical Partitiondatabase
0 likes · 10 min read
Choosing and Generating Sharding Keys for Database Partitioning
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 31, 2024 · Backend Development

Distributed System Unique ID: Characteristics and Implementation Solutions

This article explains the importance of globally unique identifiers in distributed systems, outlines their key characteristics such as global uniqueness, monotonic increase, and security, and compares five implementation approaches—UUID, database auto‑increment, Redis, Zookeeper, and Snowflake—detailing their advantages and drawbacks.

Unique IDuuid
0 likes · 8 min read
Distributed System Unique ID: Characteristics and Implementation Solutions
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 18, 2024 · Backend Development

Understanding Java's UUID.randomUUID() Implementation

This article examines the inner workings of Java's java.util.UUID class, detailing how UUID.randomUUID() generates version‑4 UUIDs using SecureRandom, the bitwise adjustments for version and variant fields, and the constructor logic that assembles the final 128‑bit identifier.

BackendSecureRandomjava
0 likes · 9 min read
Understanding Java's UUID.randomUUID() Implementation
dbaplus Community
dbaplus Community
Jan 7, 2024 · Backend Development

Mastering Snowflake IDs: Java Implementation, Pitfalls & Solutions

This article explains the Snowflake ID algorithm, its 64‑bit structure, provides a complete Java implementation, discusses common issues such as clock rollback and node ID management, and compares Snowflake IDs with UUIDs while suggesting Baidu's UidGenerator as a robust improvement.

Unique IDdistributed-systemsjava
0 likes · 9 min read
Mastering Snowflake IDs: Java Implementation, Pitfalls & Solutions
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 16, 2023 · Backend Development

Common Distributed Unique ID Generation Strategies and Their Implementation

The article reviews five major distributed unique ID generation methods—including UUID, Redis auto‑increment, database auto‑increment, database segment mode, and Snowflake—explains their principles, advantages, drawbacks, and provides practical integration guides and code examples for Java developers.

Leafdatabase segmentdistributed-id
0 likes · 14 min read
Common Distributed Unique ID Generation Strategies and Their Implementation
FunTester
FunTester
Nov 5, 2023 · Backend Development

Why java.util.UUID.randomUUID Can Block Threads and How to Fix It

The article explains how java.util.UUID.randomUUID relies on OS entropy, can block threads when entropy is low, shows a real‑world thread‑dump example, and provides three remedies: upgrading the JDK, installing haveged, or switching to /dev/urandom.

BlockingJDKentropy
0 likes · 5 min read
Why java.util.UUID.randomUUID Can Block Threads and How to Fix It
Liangxu Linux
Liangxu Linux
Oct 5, 2023 · Fundamentals

Why ULID Beats UUID: A Deep Dive into Lexicographically Sortable IDs

This article explains the limitations of UUID, introduces ULID as a time‑and‑randomness based identifier with 1.21×10⁻²⁴ unique values per millisecond, details its specification, binary layout, and shows how to generate and manipulate ULIDs in Python for distributed systems.

Distributed SystemsPythonULID
0 likes · 7 min read
Why ULID Beats UUID: A Deep Dive into Lexicographically Sortable IDs
ITPUB
ITPUB
Sep 20, 2023 · Databases

UUID vs Auto‑Increment IDs in MySQL: Pros, Cons, and When to Choose

This article compares UUID and auto‑increment primary keys in MySQL, explaining how each is generated, their advantages and drawbacks, performance implications, and practical guidance on selecting the right key type for different business scenarios.

Database designauto_incrementmysql
0 likes · 7 min read
UUID vs Auto‑Increment IDs in MySQL: Pros, Cons, and When to Choose
Selected Java Interview Questions
Selected Java Interview Questions
Jul 6, 2023 · Databases

Why MySQL Discourages UUIDs and Non‑Sequential IDs: Performance Comparison with Auto‑Increment Primary Keys

This article analyzes MySQL's recommendation against UUIDs and non‑sequential keys by benchmarking three tables—auto‑increment, UUID, and random snowflake IDs—using a Spring Boot JdbcTemplate test, revealing that sequential primary keys provide superior insert performance and lower index fragmentation.

auto_incrementindexmysql
0 likes · 9 min read
Why MySQL Discourages UUIDs and Non‑Sequential IDs: Performance Comparison with Auto‑Increment Primary Keys
Programmer DD
Programmer DD
May 15, 2023 · Backend Development

Choosing the Right Distributed ID Strategy: UUID, Snowflake, Segment, Redis, and More

This article examines various distributed ID generation techniques—including UUID, database auto‑increment, segment mode, Redis INCR, Snowflake, Meituan Leaf, Baidu UidGenerator, and Didi TinyID—detailing their principles, advantages, drawbacks, and code examples to help developers select the most suitable solution for their systems.

Segmentdistributed-idredis
0 likes · 16 min read
Choosing the Right Distributed ID Strategy: UUID, Snowflake, Segment, Redis, and More
Java High-Performance Architecture
Java High-Performance Architecture
Mar 19, 2023 · Databases

Mastering Distributed ID Generation: From UUID to Snowflake and Beyond

This article explores various distributed ID generation strategies—including UUID, database auto‑increment, segment mode, Redis INCR, Snowflake, Meituan Leaf, Baidu UidGenerator, and Didi TinyID—detailing their principles, advantages, drawbacks, and Java code examples to help developers choose the right solution for high‑scale systems.

distributed-idjavaredis
0 likes · 16 min read
Mastering Distributed ID Generation: From UUID to Snowflake and Beyond
Top Architect
Top Architect
Mar 19, 2023 · Backend Development

Distributed Global Unique ID Generation: Requirements, Common Solutions, and Snowflake Implementation

The article explains why distributed systems need globally unique identifiers, outlines strict generation rules and availability requirements, compares common approaches such as UUID, database auto‑increment and Redis, and provides a detailed overview and Java implementation of Twitter's Snowflake algorithm.

distributed-idredissnowflake
0 likes · 14 min read
Distributed Global Unique ID Generation: Requirements, Common Solutions, and Snowflake Implementation
MaGe Linux Operations
MaGe Linux Operations
Jan 13, 2023 · Fundamentals

Why ULID Beats UUID: A Deep Dive into Unique, Sortable IDs

This article explains what ULID is, why it often outperforms UUID by combining timestamp and randomness for collision‑free, lexicographically sortable identifiers, details its specification, binary layout, encoding, and shows practical Python usage and common application scenarios.

Distributed SystemsULIDunique identifier
0 likes · 8 min read
Why ULID Beats UUID: A Deep Dive into Unique, Sortable IDs
Top Architect
Top Architect
Jan 6, 2023 · Databases

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

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

Snowflake IDauto_incrementindexing
0 likes · 11 min read
Why MySQL Discourages UUID Primary Keys and a Performance Comparison of Auto‑Increment, UUID, and Random Long IDs
Top Architect
Top Architect
Dec 19, 2022 · Backend Development

Distributed ID Generation: Requirements, Schemes, and Implementations

This article explains why distributed ID generation is needed in micro‑service architectures, outlines business requirements such as global uniqueness and monotonicity, and surveys common generation schemes—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID – with code examples and pros/cons.

Backenddistributed-idsnowflake
0 likes · 13 min read
Distributed ID Generation: Requirements, Schemes, and Implementations
Top Architect
Top Architect
Dec 19, 2022 · Databases

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

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

Database Indexmysqlperformance
0 likes · 11 min read
Performance Comparison of Auto‑Increment, UUID, and Random Keys in MySQL
Top Architect
Top Architect
Nov 29, 2022 · Backend Development

Distributed ID Generation Strategies: UUID, Auto‑Increment, Segment Mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, Didi TinyID

This article explains why distributed ID generation is needed, outlines business requirements such as global uniqueness and monotonicity, and compares eight practical schemes—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID—detailing their advantages, disadvantages, and implementation examples.

BackendSegmentdistributed-id
0 likes · 16 min read
Distributed ID Generation Strategies: UUID, Auto‑Increment, Segment Mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, Didi TinyID
Java High-Performance Architecture
Java High-Performance Architecture
Nov 28, 2022 · Backend Development

Mastering Distributed ID Generation: Strategies, Pros, and Code Samples

This article explains why distributed ID generation is essential for modern micro‑service architectures, outlines the key requirements such as global uniqueness and monotonicity, and compares popular solutions like UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID with practical code examples.

BackendID generationdistributed-id
0 likes · 13 min read
Mastering Distributed ID Generation: Strategies, Pros, and Code Samples
Top Architect
Top Architect
Nov 14, 2022 · Databases

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

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

auto_incrementmysqlperformance
0 likes · 13 min read
Performance Comparison of Auto‑Increment ID vs UUID Primary Keys in MySQL
Architect's Tech Stack
Architect's Tech Stack
Oct 20, 2022 · Fundamentals

Understanding ULID: A Better Alternative to UUID

ULID (Universally Unique Lexicographically Sortable Identifier) combines a millisecond-precision timestamp with high-entropy randomness to produce 128‑bit, URL‑safe, lexicographically sortable IDs that avoid UUID’s collision risks, offering advantages such as monotonic ordering, compact Base32 encoding, and suitability for distributed database primary keys.

Distributed SystemsPythonULID
0 likes · 8 min read
Understanding ULID: A Better Alternative to UUID
IT Architects Alliance
IT Architects Alliance
Oct 16, 2022 · Fundamentals

Understanding ULID: Features, Specification, and Python Usage

This article explains what ULID (Universally Unique Lexicographically Sortable Identifier) is, compares it with UUID, outlines its timestamp‑based and random components, describes its Base32 encoding and binary layout, and shows how to generate and manipulate ULIDs in Python using the ulid‑py library.

ULIDdistributed-systemsidentifier
0 likes · 7 min read
Understanding ULID: Features, Specification, and Python Usage
IT Architects Alliance
IT Architects Alliance
Sep 15, 2022 · Databases

Designing Indexes and Primary Keys for Distributed Database Architectures

Effective index and primary key design in distributed database architectures requires using globally unique, ordered identifiers instead of auto‑increment keys, embedding shard information in keys, employing auxiliary index tables, and handling global tables to ensure queries target a single shard, thereby preserving scalability and performance.

distributed databasesglobal tablesindex design
0 likes · 11 min read
Designing Indexes and Primary Keys for Distributed Database Architectures
Java Architect Essentials
Java Architect Essentials
Sep 12, 2022 · Databases

Why MySQL Discourages UUIDs as Primary Keys: Performance Comparison with Auto‑Increment and Random Keys

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

auto_incrementmysqlperformance
0 likes · 10 min read
Why MySQL Discourages UUIDs as Primary Keys: Performance Comparison with Auto‑Increment and Random Keys
Tencent Cloud Developer
Tencent Cloud Developer
Aug 24, 2022 · Backend Development

Go Distributed ID Generation: UUID, ShortUUID, XID, KSUID, ULID, Snowflake, and Segment Modes

The article surveys Go‑based distributed ID generation techniques—from UUID, short‑UUID, XID, KSUID, ULID, and Snowflake to database auto‑increment, Redis, ZooKeeper, and segment/leaf approaches—detailing their characteristics, trade‑offs, implementation snippets, and strategies for ordering, uniqueness, and clock‑rollback handling.

GoSegmentdatabase
0 likes · 12 min read
Go Distributed ID Generation: UUID, ShortUUID, XID, KSUID, ULID, Snowflake, and Segment Modes
Top Architect
Top Architect
Aug 11, 2022 · Databases

Primary Key and Index Design for Distributed Databases

The article explains why auto‑increment primary keys are unsuitable for sharded databases, recommends using globally unique ordered identifiers such as UUIDs or Snowflake IDs, and discusses index design strategies—including index tables, embedding shard keys, and handling global tables—to ensure efficient single‑shard queries.

distributed databasesglobal tablesindex design
0 likes · 10 min read
Primary Key and Index Design for Distributed Databases
Su San Talks Tech
Su San Talks Tech
Aug 11, 2022 · Backend Development

How to Choose the Right Distributed ID Generator for Your System

This article examines common distributed ID generation strategies—including UUID, Snowflake-like algorithms, database auto‑increment, and Redis atomic increment—detailing their requirements, advantages, drawbacks, and suitable scenarios to help engineers select the most appropriate solution for high‑performance, secure systems.

distributed-idredissnowflake
0 likes · 12 min read
How to Choose the Right Distributed ID Generator for Your System
IT Xianyu
IT Xianyu
Jul 12, 2022 · Frontend Development

Understanding NanoID: Features, Advantages, Limitations, and Usage in JavaScript

This article introduces NanoID as a modern alternative to UUID, explains how to install and use it in JavaScript projects, compares performance, size, and security, discusses customization options and limitations, and suggests when to prefer NanoID for future development.

JavaScriptNode.jsUnique IDs
0 likes · 6 min read
Understanding NanoID: Features, Advantages, Limitations, and Usage in JavaScript
Programmer DD
Programmer DD
Jul 8, 2022 · Databases

Why Auto‑Increment Beats UUID in MySQL: Performance Test & Deep Dive

This article investigates MySQL’s recommendation against UUIDs, comparing auto‑increment, UUID, and Snowflake‑style random keys through insertion and query benchmarks, analyzing their index structures, performance impacts, and trade‑offs, and concludes why sequential primary keys generally outperform non‑sequential identifiers.

auto_incrementdatabaseindex
0 likes · 12 min read
Why Auto‑Increment Beats UUID in MySQL: Performance Test & Deep Dive
macrozheng
macrozheng
Jun 24, 2022 · Backend Development

Choosing the Right Distributed ID Generator: UUID, Snowflake, NanoID

This article examines the trade‑offs of common distributed ID generators—UUID, timestamp‑based schemes, Snowflake, and NanoID—highlighting their size, ordering, performance, and security implications to help developers select the most suitable approach for their systems.

Distributed SystemsID generationnanoid
0 likes · 6 min read
Choosing the Right Distributed ID Generator: UUID, Snowflake, NanoID
Top Architect
Top Architect
Apr 30, 2022 · Backend Development

Scaling Strategies, Hardware Expansion, and Distributed ID Generation in Backend Systems

The article explains why capacity expansion is needed, compares whole‑machine and component‑level scaling, introduces the AKF splitting principle, discusses challenges of distributed architectures, and reviews database clustering and distributed ID generation techniques such as UUID and Snowflake.

Backend Architecturedistributed-idelastic scaling
0 likes · 12 min read
Scaling Strategies, Hardware Expansion, and Distributed ID Generation in Backend Systems