The article walks through the evolution of Redis leaderboard architectures, covering why ZSets are used, handling same‑score ordering, seasonal resets, access patterns, synchronous vs asynchronous updates, big‑key and hot‑key issues, sharding with buckets, and data durability strategies.
Redis 8.0 consolidates many previously external modules—JSON, time‑series, vector search, probabilistic data structures, and more—into a single package, and this article walks through 16 concrete scenarios ranging from field‑level cache expiration to AI‑ready vector similarity search, showing exact commands and when to prefer each feature.
This article walks through sixteen common Redis scenarios—including caching hot data, sharing state across services, implementing distributed locks, generating global IDs, counting events, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tagging, product filtering, and leaderboards—each illustrated with concrete commands and code snippets.
This guide walks Java backend developers through Redis’s eight core scenarios—caching, distributed locks, rate limiting, session sharing, leaderboards, counters, message and delay queues, bitmap statistics, and geolocation—providing complete code, diagrams, and production‑grade best practices.
Redis offers far more than simple key‑value caching; by leveraging its rich data structures—strings, hashes, lists, sets, sorted sets, bitmaps, HyperLogLog, GEO, and streams—developers can implement distributed locks, rate limiting, leaderboards, session storage, counters, geolocation, delayed queues, messaging, bloom filters, and more, all with concise commands.
This article presents a comprehensive guide to 16 practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, queues, lotteries, likes, product tagging, filtering, social graphs, and leaderboards—complete with command examples, code snippets, and visual illustrations to help developers implement these patterns efficiently.
This article presents a comprehensive guide to 16 practical Redis use cases—including caching, distributed locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow‑recommendation models, and ranking—complete with code snippets and data‑structure examples.
This guide walks through ten classic Redis scenarios—caching, session storage, rate limiting, leaderboards, message queues, Pub/Sub, real‑time analytics, distributed locks, geospatial queries, and shopping carts—providing Go code examples, best‑practice tips, and performance considerations for each pattern.
This article breaks down the interview‑level system design of a WeChat‑style step leaderboard that must support over a billion users, handling massive write spikes, low‑latency friend ranking queries, storage scaling, and relationship complexity with a three‑part architecture using MQ, Redis, and MySQL.
This article surveys the most popular large‑language‑model leaderboards—including lmarena, Artificial Analysis, SuperCLUE, and llm‑stats—detailing their evaluation methods, coverage areas, URLs, and practical usage tips, while warning readers that rankings are only a reference and real‑world performance may vary.
This article walks through the end‑to‑end design of a leaderboard that must serve over 100 million users with 100 k queries per second, covering requirement clarification, real‑time and accuracy challenges, technology selection such as Redis ZSet, multi‑layer architecture, sharding, caching, monitoring, and practical implementation tips to achieve low latency, high consistency, and cost‑effective scalability.
This tutorial walks through why Redis is essential for Go services, how to choose and install the go‑redis client, and provides step‑by‑step code for connections, common commands, cache‑aside, distributed locks, leaderboards, and lightweight queues, followed by performance tuning and best‑practice recommendations.
Designing a real‑time step leaderboard for billions of users requires tackling massive write spikes, fast friend‑based queries, scalable storage, and high availability; this guide outlines a three‑step architecture using asynchronous message queues, Redis ZSETs, and MySQL sharding to meet those challenges.
This article explores how to build a scalable, high‑performance leaderboard for hundreds of millions of users by comparing traditional database ORDER BY approaches with Redis sorted sets, addressing challenges such as hot keys, memory pressure, persistence risks, and presenting a divide‑and‑conquer implementation strategy.
This article examines six different leaderboard implementation strategies—from simple database sorting and cache‑plus‑scheduled tasks to Redis sorted sets, sharded Redis clusters, pre‑computed layered caches, and real‑time stream processing with Flink—detailing their suitable scenarios, advantages, disadvantages, and architectural diagrams to help engineers choose the most appropriate solution.
This article analyzes how to build a real‑time, billion‑user leaderboard for a game like Honor of Kings, explaining why traditional ORDER BY queries fail, why Redis sorted sets excel, and detailing sharding, hot‑key mitigation, memory optimization, and fault‑tolerant implementation techniques.
This article analyzes the essential requirements of massive‑scale game leaderboards, explains how Redis sorted sets and hash tables provide fast ranking and lookup, and presents a multi‑layered architecture—including hot‑key sharding, dynamic partitioning, tiered storage, read/write separation, pipeline batching, and hybrid persistence—to achieve real‑time, billion‑user performance.
This article explains how to design a scalable leaderboard using Redis Zset for moderate traffic and a sharded‑key plus local cache architecture for ultra‑high concurrency, detailing synchronization strategies, data flow, and practical implementation steps.
This article explains how to design ranking systems for games and social apps, compares database sorting and client‑side approaches, and provides step‑by‑step Java code for implementing Redis‑based counters, leaderboards, performance optimizations, and real‑world use cases.
Discover ten practical Redis scenarios—from counting page visits and caching category trees to implementing distributed locks, leaderboards, rate limiting, bitmap analytics, message queues, and global ID generation—each illustrated with concise code snippets and best‑practice tips for robust backend development.
This article presents sixteen practical Redis use cases—including caching, distributed locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow relationships, and leaderboards—each explained with data types, commands, and code examples.
This article explores ten practical Redis scenarios—from counting page visits and caching category trees to implementing distributed locks, leaderboards, rate limiting, bitmap statistics, cache acceleration, message queues, and global ID generation—providing code snippets and best‑practice tips for each use case.
Redis Sorted Sets, powered by skip lists, provide O(log n) operations for ranking and range queries; this article explains their internal structure, core commands, and demonstrates how to implement a real‑time leaderboard in Spring Boot using Redis, complete with configuration, entity design, and service methods.
This article explores five common Redis applications—caching, session storage, distributed locking, rate limiting, and leaderboards—explaining how each leverages Redis’s in‑memory speed, atomic commands, and data structures to improve performance, scalability, and reliability of modern web services.
This article explains Redis Sorted Set’s underlying implementation using skiplist and listpack, compares their storage strategies, and demonstrates how to build a real‑time game leaderboard with practical command examples and score calculations.
This article explains the Redis Sorted Set data type, its underlying storage mechanisms (listpack and skiplist + dict), the internal structures and algorithms, and demonstrates how to build a real‑time game leaderboard using ZADD, ZRANGE and ZREVRANK commands.
This article outlines sixteen practical Redis usage scenarios—including caching, distributed sessions, locks, ID generation, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow relationships, and leaderboards—explaining each concept and providing example code snippets for implementation.
This article presents sixteen practical Redis use‑cases—including caching, distributed locks, global IDs, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow/recommendation models and leaderboards—each explained with concise descriptions and ready‑to‑run code snippets.
The article analyzes the shortcomings of current click‑through‑rate benchmarks, explains why leaderboards are valuable, and proposes concrete criteria—including online evaluation, sequential test data, leakage prevention, and read‑only submissions—to build a more realistic and robust CTR benchmarking platform.
This article introduces a collection of practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking—explaining their data types, commands, and sample code.
This article explains how to design and implement a real-time ranking system for a mobile tank game using Redis sorted sets, covering leaderboard categories, composite scoring formulas, dynamic updates, data retrieval with pipelines, and provides a complete PHP class example.
The 58 City AI Algorithm Competition, now in its second edition, has attracted over 200 teams from more than 50 universities and 30 internal groups, with daily leaderboard updates, a baseline MMoE model scoring 0.7294, and a GitHub repository for participants.
This article explains how to build a real‑time game leaderboard using Redis sorted sets, covering ranking categories, composite scoring formulas, dynamic updates, efficient data retrieval with pipelines, and provides a complete PHP class implementation.
This article explains how to implement a real‑time ranking system for a mobile tank game using Redis sorted sets, covering ranking categories, composite scoring formulas, dynamic updates, efficient data retrieval with pipelines, and a complete PHP class example.
This article explains how to build a real‑time, dual‑dimension leaderboard for a mobile tank game using Redis Sorted Sets, covering ranking types, composite score calculations, dynamic updates, efficient data retrieval with pipelines, and a complete PHP implementation.
This article walks through designing a ranking system for interview scenarios, comparing MySQL and Redis implementations, covering sorted‑set operations, handling daily, weekly, and multi‑day leaderboards, scaling to billions of users, and addressing practical considerations beyond pure API usage.
This article introduces Redis as an in‑memory key‑value database, explains its five core data structures, and outlines typical scenarios such as caching hot data, counters, queues, bit‑maps for massive datasets, latest‑list feeds, and leaderboards, providing practical guidance for developers.
By adopting Tencent Cloud Serverless functions, the developers of the mini‑game “LeXiang Garden” eliminated the need for a dedicated backend, directly accessed WeChat authentication, stored tokens, and implemented global leaderboards with just two cloud functions, dramatically lowering the barrier to mini‑game creation.
Redis, a powerful in‑memory data store, offers versatile capabilities beyond simple key‑value storage, and this article explores five common real‑world scenarios—full‑page caching, leaderboards, session storage, queues, and pub/sub—demonstrating how to leverage its rich data structures for faster, more reliable applications.
