This article explains how to use a bitmap to store 6 billion URLs within 1 GB of memory and introduces Bloom filters as a space‑efficient probabilistic structure for deduplication, providing memory calculations, usage scenarios, and Java code examples.
The article explains how Redis’s rich data structures and persistence options enable it to serve not only as a distributed cache but also as a primary store for user profiles, counters, leaderboards, relationships, active‑user tracking, distributed locks, rate limiting, messaging, geospatial queries, and more, while also discussing high‑availability and hot‑cold data challenges.
This article provides a comprehensive overview of the C++ Standard Template Library, detailing the differences between vectors and lists, memory management, iterator validity, container operations, and implementations of various containers such as deque, set, map, and slist, along with code examples.
This article explains Redis’s five core data object types—strings, lists, hashes, sets, and sorted sets—detailing their encoding schemes, underlying memory structures such as SDS, ziplist, linkedlist, hashtable, and skiplist, and how Redis optimizes storage and access performance.
This article provides a comprehensive technical walkthrough of Redis, covering its core concepts, data structures, performance tricks, caching pitfalls, persistence options, high‑availability architectures, distributed locking mechanisms, and consistency strategies, all illustrated with concrete examples and code snippets.
This article introduces Redis as a high‑performance in‑memory NoSQL database, explains its rich data structures, core design that makes it fast, key advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples.
This article introduces Redis as an open‑source, high‑performance in‑memory key‑value store, explains its rich data structures, underlying implementations, performance advantages, common use cases such as caching and messaging, and provides step‑by‑step installation and basic command examples for Ubuntu systems.
The team analyzed Lucene’s disk‑based inverted index and built a custom in‑memory inverted‑index service for Himalaya’s ad engine, encoding terms as 64‑bit keys, supporting real‑time updates and BooleanQuery‑style and custom expression filtering, which cut query latency from ~50 ms to under 5 ms and enabled massive scaling.
Redis is a high-performance, open-source in-memory key-value database offering rich data structures, persistence options, and advanced features like replication, clustering, and pub/sub, making it ideal for caching, counters, message queues, leaderboards, and session storage in demanding, high-concurrency applications.
This article explains key database terminology, traces the history of database technologies, compares relational, NoSQL, NewSQL, OLTP/OLAP, columnar, time‑series and graph databases, and demonstrates practical data‑structure designs such as zipper tables, bit operations, bitmaps, bloom filters, and ring queues for software development.
This article explains why Python lists are essential, how to create them (empty, with integers, strings, mixed types, or nested lists), outlines their key characteristics such as order and mutability, and demonstrates common operations—including indexing, slicing, adding, removing, modifying, and retrieving element indices—through clear code examples.
This article presents three interview‑style algorithm problems—a golden treasure‑box search, an inequality‑set validator with maximum‑difference calculation, and a smallest‑number‑after‑removing‑digits task—each with clear problem statements, constraints, step‑by‑step simulation logic, and full Python code implementations.
This article presents seventeen practical Python techniques—including list manipulation, dictionary handling, string operations, and control‑flow shortcuts—that showcase the language's elegance and help developers write cleaner, more efficient code in everyday projects.
This article presents a curated list of twenty practical Python tricks—including string reversal, title casing, unique element extraction, list multiplication, dictionary merging, timing code execution, and more—each explained with concise descriptions and ready‑to‑run code examples to help developers write cleaner and more efficient Python code.
This article presents a curated collection of practical Python tricks—from handling multiple user inputs and using all/any for condition checks, to swapping variables, detecting palindromes, removing duplicates, finding the most frequent list item, leveraging list comprehensions, *args, enumerate, string joining, dictionary merging, sorting, pretty‑printing, and comparing list‑reversal methods—each illustrated with clear code examples.
The article explains how to store and de‑duplicate 4 billion unsigned integers using a bitmap to reduce memory from 14.9 GB to under 500 MB, introduces the concept and benefits of bitmaps, describes Bloom filters, their principles, advantages, limitations, typical use cases, and provides Java and Redis implementation examples.
This article reviews a C++ interview covering object‑oriented programming basics, STL container behaviors, networking protocols, inter‑process communication mechanisms, memory layout, and common interview questions, providing concise explanations and code examples for each topic.
This article explains how to install and configure Redis, connect to it using Python's redis library, and demonstrates storing and retrieving various data structures—including strings, hashes, lists, sets, and sorted sets—followed by proper disconnection, providing a practical guide for Python developers.
Explore the design and mechanics of Bloom filters, understand their role in preventing cache penetration, learn how to calculate optimal parameters, and see practical Java implementations using Google Guava and Redisson, including code snippets, performance considerations, and strategies for handling deletions.
This article presents a thorough overview of Python algorithm fundamentals, covering sorting, searching, cryptographic techniques, and neural‑network examples, while linking to the open‑source TheAlgorithms/Python repository that provides both theoretical explanations and ready‑to‑run code samples for learners.
To reduce costly database I/O, the article explains how Bloom filters, Counting Bloom filters, and Cuckoo filters work, detailing their bitmap/hash mechanisms, false‑positive behavior, deletion limitations, and practical enhancements such as multi‑hash functions and bucket‑level fingerprints.
This article explains how Bloom filters, their counting variant, and Cuckoo filters work to reduce unnecessary database I/O by using bitmap or fingerprint techniques, discusses their false‑positive and deletion limitations, and presents practical optimizations for high‑performance hash‑based filtering.
This article introduces the basic concepts of graphs, including vertices, edges, directed and undirected types, explains common storage methods such as adjacency matrices and adjacency lists with examples, and demonstrates graph traversal techniques like depth‑first and breadth‑first search using Java code.
This article traces the history of database development from early file systems to relational models, outlines major database categories such as hierarchical, relational, NoSQL, NewSQL, and columnar stores, and explores practical data structure designs like chain tables, bitwise operations, and circular queues for modern software engineering.
This article presents fifteen practical Redis usage patterns—including caching, distributed sessions, locks, global IDs, counters, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow relationships, and ranking—illustrating how each can be implemented with commands and code snippets to build efficient, scalable backend services.
This article presents a collection of practical Python techniques for working with built‑in container types such as lists, tuples, sets, and dictionaries, covering operations like extracting maximum values, counting elements, slicing, copying, mapping, filtering, column extraction, and transposition, all illustrated with clear code examples.
An extensive guide to Redis data structures—including strings, hashes, lists, sets, sorted sets, streams, hyperloglog, geospatial, bitmap, and bitfield—detailing their use cases, underlying encodings, conversion thresholds, and internal implementation details with code examples.
This article provides a comprehensive overview of Redis data types—including strings, hashes, lists, sets, sorted sets, streams, hyperloglog, geospatial indexes, bitmaps, and bitfields—detailing their structures, encoding mechanisms, application scenarios, and underlying implementation details with code examples.
This comprehensive guide explains Redis fundamentals, covering NoSQL basics, the five core data types and their internal storage mechanisms, persistence options (RDB and AOF), replication, Sentinel failover, publish/subscribe patterns, and common cache pitfalls such as penetration, breakdown, and avalanche, providing practical insights for developers and architects.
This article provides a detailed walkthrough of Redis's internal architecture, covering the client module, event‑driven networking, command processing, memory management, persistence strategies, high‑availability features, and the low‑level data structures such as redisServer, redisDb, dict, dictEntry, and redisObject that power its fast key‑value storage.
This article explains the internal structure of Java's ConcurrentHashMap in JDK 1.8, covering its array‑based storage, linked‑list and red‑black tree handling of hash collisions, core concurrency mechanisms, and key performance enhancements such as fine‑grained locking, lock‑free size updates, and multithreaded resizing.
This article introduces Redis Sets as unordered unique string collections, explains their ideal use cases, and provides detailed walkthroughs of creation, query, update, and deletion commands—including SADD, SREM, SISMEMBER, SCARD, SMEMBERS, SSCAN, SINTER, SUNION, and SDIFF—along with underlying encoding mechanisms.
This article explains why Python uses indentation for block grouping, how floating‑point arithmetic works, why strings are immutable, the purpose of the explicit self parameter, the absence of assignment in expressions, and many other design decisions that shape Python's syntax and runtime behavior.
This article provides a comprehensive overview of Java's collection framework, explaining the differences between List, Set, Queue, and Map, detailing their underlying data structures, and offering best practices for safe traversal and modification.
The article explains the fundamentals of tree data structures, compares B, B+, B*, and red‑black trees, and shows how B+ trees reduce disk I/O and improve range query performance, which is why MySQL adopts B+ trees for its indexes.
This tutorial provides a comprehensive introduction to core Python concepts, covering numeric operations, string handling, built‑in functions, common data structures, class and object mechanics, as well as useful utilities such as iteration tools, file I/O and JSON serialization.
This article examines Redis List interview topics, covering FIFO misconceptions, underlying encodings across versions, ZIPLIST compression mechanics, backward traversal, and the time complexities of node count queries for both ZIPLIST and LINKEDLIST implementations.
This article explains Redis's compressed list structures—ZIPLIST and its successor LISTPACK—detailing their layouts, encoding schemes, query and update complexities, and how LISTPACK resolves ZIPLIST's chain‑update performance issues to provide a more memory‑efficient list implementation.
This tutorial presents a thorough overview of essential Python concepts, demonstrating numeric operations, string conversions, built‑in functions, diverse data structures, object‑oriented programming techniques, and useful utilities such as file handling, iteration tools, and JSON serialization, all illustrated with clear code examples.
This article explains Redis's rapid growth from its 2009 inception, outlines its version history and popularity, and details the architectural choices—memory‑first design, efficient data structures, smart encoding, and a single‑threaded I/O multiplexing model—that together give Redis its exceptional performance.
This article provides a comprehensive overview of Redis, covering why it is used as a cache, its single‑threaded efficiency, multithreading in version 6.0, common data structures and their use cases, pipeline advantages, persistence mechanisms, transactions, Bloom filter for massive URL checks, internal data organization, and incremental rehashing.
This article introduces linked lists as a fundamental data structure, compares them with arrays, explains single, doubly, and circular variants, demonstrates insertion, deletion, and boundary handling with dummy nodes, and details two‑pointer techniques for cycle detection and finding the list’s midpoint.
This article introduces a curated collection of Python algorithm resources, covering sorting and searching techniques, cryptographic methods, and neural‑network implementations, while linking to a GitHub repository and offering supplemental visualizations and a free Python learning QR code.
This article explains the evolution of tree-based index structures—from basic binary search trees through AVL and red‑black trees to B‑trees and B+‑trees—highlighting their trade‑offs and why MySQL adopts B+‑trees for efficient disk‑based indexing.
RedisObject serves as a bridge between Redis's external data structures and internal implementations, enabling efficient storage and retrieval of data types like strings, lists, hashes, sets, and sorted sets through a unified object model.
This article explores sixteen practical Redis patterns—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, queues, lotteries, likes, tags, product filtering, follow relationships, and leaderboards—detailing their data types, commands, and code examples for building high‑performance systems.
This article explains how Redis achieves high performance by storing data in memory and using a variety of specialized data structures—such as SDS, quicklist, listpack, hash tables, and skip lists—to implement its key‑value store, covering their designs, trade‑offs, and evolution across Redis versions.
This article introduces essential Python data structures—including strings, lists, tuples, dictionaries, sets, as well as stack and queue implementations—explaining their characteristics, usage, and providing clear code examples to illustrate creation, indexing, slicing, and common operations.
This article explains the internal mechanisms of Java's ConcurrentHashMap, covering its constructors, element insertion via put and putVal, the sizeCtl variable, treeification of bins, counting operations, and the complex multi‑threaded resizing process, with detailed code examples.
Learn how to efficiently store and query massive binary state data—such as user login status and daily sign‑in records—using Redis Bitmap, covering underlying structures, memory advantages, key design, and practical commands like SETBIT, GETBIT, BITCOUNT, BITPOS, and BITOP for real‑world analytics.
This article explains the internal design of Java's ConcurrentHashMap, covering hash table fundamentals, contrasts with HashMap and Hashtable, and details the architectural changes from the segment‑based locking in JDK 1.7 to the node‑based, CAS‑driven structure with tree bins in JDK 1.8.
The article provides a detailed outline of the 2021 Algorithm Training Camp, listing weekly topics such as trees, graphs, dynamic programming, and advanced search, along with corresponding video lessons, assignment files, exam sessions, and supplementary Git & GitHub tutorials.
This comprehensive guide explains what Redis is, its core data structures, typical scenarios such as caching, counters, message queues and leaderboards, installation steps on Linux, configuration options, advanced features like pipelines, Lua scripting, persistence mechanisms, replication, caching strategies, consistency challenges, and distributed locking techniques.
This article provides an in‑depth overview of Redis, covering its single‑threaded architecture, core data structures (String, Hash, List, Set, ZSet), persistence mechanisms (RDB, AOF, hybrid), replication, Sentinel and cluster designs, memory eviction policies, bitmap analytics, skiplist implementation, and strategies for ensuring data consistency.
This article explains cache penetration, introduces Bloom filters as a space‑efficient probabilistic data structure, demonstrates how to implement them with Guava and Redis in Java, and discusses practical usage scenarios and performance considerations.
Redis 6.0 implements several compact data structures—SDS, ziplist, quicklist, hash, set, and ZSet—each optimized for memory efficiency and performance, and this guide explains their definitions, internal layouts, usage scenarios, and key implementation details such as packing attributes, incremental rehashing, and skiplist operations.
This article explains Java's HashMap initial capacity, how the constructor uses the tableSizeFor method to round the requested size up to the next power of two, and why a power‑of‑two capacity is essential for fast index calculation.
This article explains why Vue SSR performance suffers, introduces cache concepts and eviction policies, and walks through a complete, O(1) LRU cache built with JavaScript using a hash map, doubly‑linked list and arrays, complete with code and visual examples.
This article presents a step‑by‑step tutorial for building a console‑based student information management system in Python, covering system design, functional requirements, detailed function implementations for adding, deleting, modifying, searching, and displaying records, and provides the full source code with execution screenshots.
This article explains how hash tables store key‑value pairs as array entries, describes hash collisions when different keys map to the same index, and outlines two common resolution methods—open addressing and chaining—while also providing visual illustrations and practical insights.
This comprehensive guide walks you through essential Python concepts—from absolute values and numeral system conversions to string manipulation, function utilities, data structures, class mechanics, and handy built‑in tools—complete with clear code examples and explanations for each topic.
This article explains the fundamentals of hash tables, how they store key‑value pairs, the nature of hash collisions, and the two primary resolution strategies—open addressing and chaining—illustrated with clear examples and diagrams.
This article explains Redis's superior performance by detailing its six underlying data structures—Simple Dynamic Strings, hash tables, ziplist, quicklist, skiplist, and integer sets—covering their implementations, memory optimizations, collision handling, and lookup complexities, with code examples and diagrams.
This article explains how Redis stores set and sorted‑set objects using two underlying data structures, details the intset and hashtable encodings, describes the upgrade process with concrete examples, and lists the common commands for manipulating these collections.
This article provides an in‑depth technical guide to Redis, covering its single‑threaded model, core data structures (String, Hash, List, Set, ZSet) with practical commands, persistence mechanisms (RDB, AOF, hybrid), master‑slave replication, Sentinel and cluster architectures, cache eviction policies, memory management, progressive rehash, skiplist implementation, bitmap statistics, and consistency challenges when coupling Redis with MySQL.
Redis achieves high performance by storing all data in memory, using compact data structures like SDS, linked lists, hash tables, skip lists and integer sets, running a single‑threaded event loop, and handling thousands of client connections with efficient I/O multiplexing.
This article explains why Redis delivers high query speed by leveraging its in‑memory architecture, custom data structures such as SDS, linked lists, hash tables, skip‑lists, and intsets, a single‑threaded execution model combined with efficient I/O multiplexing, and recent multithreaded I/O enhancements.
This article provides an in‑depth technical guide to Redis, covering its single‑threaded I/O model, core data structures (String, Hash, List, Set, ZSet), persistence options (RDB, AOF, hybrid), master‑slave replication, Sentinel, cluster slot allocation, eviction policies, progressive rehash, skip‑list implementation, and consistency challenges between MySQL and Redis.
This article provides an in‑depth overview of Redis, covering its single‑threaded design, core data structures, persistence mechanisms (RDB, AOF, hybrid), master‑slave replication, Sentinel and Cluster architectures, eviction policies, progressive rehash, bitmap usage for massive analytics, skiplist implementation, and strategies for handling MySQL‑Redis write inconsistencies.
This article provides a comprehensive Python tutorial covering numeric operations, string manipulation, function definitions, data structures, class creation, object introspection, and useful built‑in tools, complete with clear code examples for each concept.
RoaringBitmap improves traditional BitMap by lazily allocating four container types, compressing sparse data, and dynamically switching between array, bitmap, and run containers, enabling fast exact set operations that power big‑data systems such as Kylin, ClickHouse, and B‑Station’s user‑visit and crowd‑package pipelines, dramatically reducing memory use and processing latency.
The article explains why interviewers probe the implementation details of backend components such as Redis, HashMap, and Memcached, illustrates common interview questions, and shows how mastering the underlying data structures, algorithms, and memory‑allocation mechanisms can improve both interview performance and real‑world problem solving.
This article explains why Redis stores set and sorted‑set objects using two different internal encodings, describes the intset and hashtable representations for sets, the skiplist and ziplist representations for sorted sets, shows the upgrade process with code examples, and lists the common commands for manipulating these data structures.
The article explains Redis’s core concepts—including its in‑memory key‑value store, six low‑level data structures, single‑threaded execution, AOF and RDB persistence options, master‑replica replication with Sentinel failover, and horizontal scaling via Cluster’s hash‑slot sharding and rebalancing.
This article walks through recreating the popular ‘Sheep a Sheep’ puzzle game using Godot Engine, detailing the game’s mechanics, three stack patterns, data structures, detection of selectable tiles, level generation, shuffling, mask handling, and inter‑object communication, while sharing code snippets and design insights.
This article explains how Redis stores key‑value pairs, details the internal data structures such as dict, dictEntry and redisObject, and provides practical memory‑saving tricks—including key shortening, encoding choices, object sharing, bitmap usage, hash consolidation, fragmentation handling, and 32‑bit deployment—to dramatically reduce RAM consumption while maintaining performance.
Redis achieves exceptional speed by operating as an in‑memory database, leveraging compact data structures like SDS, linked lists, hash tables, skip lists and ziplists, running a single‑threaded event loop with I/O multiplexing, and employing optimizations such as lazy‑free, progressive rehashing, and multithreaded network I/O.
This article explains the principles, Java implementation, and performance benefits of Bitmap and RoaringBitmap, demonstrating how they dramatically reduce storage costs, enable fast deduplication and set operations, and optimize large‑scale data warehouse queries in real‑world scenarios.
This document lists the complete set of lecture PDFs, videos, and supplemental files for a Java backend development curriculum, covering data structures and algorithms, Spring Framework, JVM fundamentals, concurrency, cloud native concepts, and interview-focused topics across eleven chapters.
This guide explains how to use Redis Bitmap to efficiently store and query massive binary state data—such as user login status and daily sign‑ins—by leveraging GETBIT, SETBIT, BITCOUNT, BITPOS, and BITOP commands, dramatically reducing memory usage for millions of users.
This article explains why Redis’s single‑threaded design achieves high performance, details its five fundamental data types—string, list, set, hash, and sorted set—their internal implementations, and introduces advanced structures such as Geo, Bitmap, and HyperLogLog with practical command examples.
This article introduces essential distributed‑system mechanisms—including Bloom filters, consistent hashing, quorum, leader/follower roles, heartbeats, fencing, write‑ahead logs, segment logs, high‑water marks, leases, gossip protocols, failure detection, CAP/PACELC theorems, hinted handoff, read‑repair, and Merkle trees—to help engineers design scalable and fault‑tolerant services.
Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, hash tables, skip‑lists and zip‑lists, running a single‑threaded event loop with I/O multiplexing, and applying optimisations like lazy‑free, progressive rehashing and optional multi‑threaded I/O for network traffic.
This article explains the concept and operation of Bloom filters, discusses their limitations such as false positives and deletion difficulties, introduces the Counting Bloom filter and Cuckoo filter as improvements, and explores their underlying hash mechanisms, performance trade‑offs, and optimization strategies.
This article explains how Redis internally stores set and sorted‑set objects using intset, hashtable, ziplist, and skiplist encodings, the conditions that trigger each representation, the upgrade process, and the essential Redis commands for manipulating these data structures.
This tutorial explains how to create, initialize, retrieve, update, and delete entries in Python dictionaries using both literal syntax and built‑in functions, demonstrates the use of the get, update, pop, and fromkeys methods, and shows common pitfalls and best‑practice code examples.
This article explains Python's four main composite data types—tuple, list, set, and dictionary—detailing their properties, mutability, typical operations, performance considerations, and appropriate use cases, accompanied by example code illustrating immutability of tuples.
An in‑depth guide to Redis’s core data structures—String, List, Hash, Set, and Sorted Set—detailing their characteristics, common commands, practical examples, and typical application scenarios such as caching, counting, messaging, and ranking, with code snippets and reference links.
This article explains how Redis stores key‑value pairs, dives into the underlying dict, dictEntry and redisObject structures, and presents seven practical memory‑saving tricks—including key shortening, encoding tweaks, object sharing, bitmap usage, hash consolidation, fragmentation cleanup, and 32‑bit deployment—to dramatically reduce RAM consumption while preserving performance.
This article explains Python's four main composite data types—tuple, list, set, and dictionary—detailing their characteristics, typical operations, performance considerations, and appropriate usage scenarios, while providing code examples and practical guidance for selecting the right structure in different programming contexts.
This article explains the concepts of time and space complexity, demonstrates their practical measurement with Python's list and set structures, and compares their lookup speed and memory consumption using concrete code examples and empirical results.
This article provides a comprehensive analysis of Go's map implementation, covering its hash‑table foundation, key type constraints, hash function characteristics, collision resolution strategies, runtime initialization, internal structures like hmap and bmap, and the various operations for creation, access, update, deletion, and resizing.
This article explains the motivation behind using filters to reduce database I/O, introduces Bloom filters and their bitmap implementation, discusses their limitations, then covers Counting Bloom filters and Cuckoo filters—including their hash structures, deletion support, performance trade‑offs, and practical improvements.
This article explains Redis's low‑level data structures—including ziplist, skiplist, intset, quicklist, zipmap and stream—detailing their memory layouts, implementation code, use‑case selection criteria, performance trade‑offs, and configurable parameters that balance speed and space.
The article explains Redis’s internal low‑level structures—ziplist, skiplist, intset, quicklist, zipmap, and stream—detailing their memory‑efficient layouts, operations, use cases, and how they combine (e.g., quicklist merging linked lists with ziplists) to deliver high performance in the in‑memory database.
This article explores Redis’s internal data structures—including simple dynamic strings, linked lists, and dictionaries—detailing their encoding constants, implementation differences across versions, performance advantages, and rehashing mechanisms that enable high‑throughput, memory‑efficient operations.
This article presents a comprehensive collection of practical Redis scenarios—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, recommendation models, and ranking—accompanied by example commands and Java code snippets for each use case.
The article details Redis’s core low‑level data structures—Simple Dynamic Strings (SDS) with length‑aware headers, a custom doubly linked list for O(1) head/tail access, and a hash‑table dictionary employing MurmurHash, incremental rehashing, and packed headers to optimize memory and performance across versions.
This article explains Redis's internal storage mechanisms and presents seven practical optimization techniques—including key‑value compression, small‑collection encoding, object sharing, bitmap usage, hash structuring, memory‑fragment defragmentation, and 32‑bit deployment—to dramatically reduce memory consumption while increasing data capacity.
This article introduces Python's core built‑in sequence types—lists, tuples, dictionaries, and sets—explaining their characteristics, common operations, and performance considerations, and provides numerous interactive code snippets that demonstrate creation, indexing, slicing, modification, searching, sorting, and set algebra.
