The article explains how Redis achieves more than 100,000 queries per second by leveraging in‑memory storage, highly optimized data structures, a single‑threaded core with epoll‑based I/O multiplexing, optional I/O multithreading, and performance tricks such as pipelining and careful key sizing.
Redis can sustain over 100,000 queries per second thanks to four key factors: pure in‑memory storage, highly optimized data structures such as SDS and ziplist, a single‑threaded event loop with epoll‑based I/O multiplexing, and optional multi‑threaded network handling introduced in Redis 6.0.
Redis can sustain over 100,000 queries per second thanks to four key pillars—memory‑first storage, highly optimized data structures like SDS and skip lists, a single‑threaded event loop with epoll multiplexing, and multi‑core I/O threading—each explained with benchmarks, code samples, and real‑world comparisons.
This comprehensive Redis guide covers its role as a core component in large‑scale architectures, explains common use cases, walks through installation and configuration options, details all primary data structures with commands and examples, and explores persistence, transactions, Lua scripting, replication, Sentinel, and cluster modes.
This comprehensive guide outlines a step‑by‑step learning path for Redis, covering foundational commands, core data structures, high‑performance internals, persistence options, clustering, common caching pitfalls, performance tuning, monitoring, source‑code exploration, and recommended resources for becoming a Redis expert.
Redis achieves million‑level concurrency by keeping all data in RAM, using epoll/kqueue for non‑blocking I/O, employing highly optimized data structures with O(1) or O(log N) operations, and evolving from a single‑threaded core to optional multi‑threaded I/O, boosting throughput up to 12×.
This tutorial walks through essential Python data structures, showing how to retrieve a dictionary's length, keys, values, and items, iterate using four different patterns, merge dictionaries with update, and then introduces sets—covering creation, properties, and common operations such as add, update, pop, remove, discard, clear, and iteration—with concrete code examples and their outputs.
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 sixteen practical Redis use cases—from simple caching and distributed sessions to global IDs, rate limiting, bitmaps, shopping carts, timelines, message queues, likes, tags, filtering, follow relationships, and ranking—each illustrated with commands and code snippets for real‑world backend development.
This article explores sixteen practical Redis applications—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow relationships, and ranking—demonstrating how Redis can serve as a versatile data store beyond simple caching.
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 note explains why Java introduces arrays, defines arrays as collections of same‑type variables, demonstrates the limitation of using individual variables for many items, and outlines six key characteristics of Java arrays, including fixed length, zero‑based indexing, and default values.
pyarrow.Schema is the Python representation of an Arrow table schema, describing column names, types, nullability, and other metadata, and it is essential for defining, inspecting, serializing, and interfacing data structures across libraries like Pandas, Polars, and Arrow‑based query engines.
This article explains why multi‑way search trees such as B‑trees, B+‑trees, B*‑trees and R‑trees are crucial for reducing disk I/O in large‑scale storage systems, covering their hardware background, structural definitions, height analysis, insertion and deletion algorithms, and practical examples with code and diagrams.
When a small fraction of requests overwhelms a system, understanding which endpoints, keys, or users cause the bottleneck is crucial; this article explains why traditional full‑count sorting fails at scale, introduces efficient approximate Top‑K algorithms such as fixed‑size min‑heap and Count‑Min Sketch, and provides production‑ready Go implementations with practical usage patterns and performance benchmarks.
This article introduces seven fundamental data structures—arrays, queues, stacks, linked lists, trees, graphs, and hash tables—explaining their concepts, typical use cases, strengths, and limitations to help developers choose the right tool for efficient program design.
This article explains the design, implementation, and practical use of the Linux kernel's intrusive linked‑list data structure, covering its core concepts, list_head definition, common macros, insertion, deletion, traversal, optimization techniques, concurrency control with RCU and memory barriers, and real‑world examples in device drivers and process scheduling.
The article examines Lenovo’s 2023 graduate hiring salaries across cities, roles, and education levels, then shares a recent backend interview experience, detailing questions on deadlocks, networking layers, DNS resolution, TLS handshakes, common data structures, and Java’s ArrayList implementation, offering practical insights and recommendations.
Redis achieves sub‑millisecond response times by storing all data in RAM, using a single‑threaded event loop with I/O multiplexing (epoll/select/poll), and employing highly optimized data structures such as skip lists and hash tables that provide O(1) or O(log N) operations.
Redis delivers millisecond‑level response and millions of operations per second by storing data entirely in memory, using a single‑threaded event‑driven model, efficient I/O multiplexing with epoll, and highly optimized data structures such as strings, hashes, lists, sets and sorted sets.
This article explains why Redis can handle massive concurrent traffic by storing all data in RAM, using a single‑threaded event loop, leveraging Linux epoll for I/O multiplexing, and employing highly optimized in‑memory data structures that keep latency in the microsecond range.
This guide explains Python sets—unordered, mutable collections of unique hashable items—covering their key characteristics, creation methods, set comprehensions, core API for adding, removing, and testing membership, as well as set algebra operations, practical examples, limitations, and a quick reference table.
This guide explores ten practical Redis non‑cache patterns—including distributed locks, message queues, leaderboards, real‑time counters, Bloom filters, session stores, distributed counters, rate limiting, unique ID generation, and delay queues—detailing their data structures, key commands, and typical application scenarios.
This article explains the fundamentals of database indexes, covering what indexes are, their underlying structures such as B‑Tree, B+‑Tree and hash tables, their advantages and drawbacks, and the various index types—including primary, secondary, clustered and non‑clustered—used in MySQL engines.
This article walks through the evolution from binary search trees to balanced trees, B‑trees and finally B+ trees, explaining how MySQL's InnoDB and MyISAM storage engines implement these structures to reduce disk I/O and boost query performance.
This article explains how using a bitmap can reduce the memory needed to store billions of integers from about 15 GB to under 500 MB, describes the bitmap concept, introduces Bloom filters, outlines their principles, advantages, common use cases, and provides Java and Redis code examples for implementation.
This article explores Java's HashMap internals, detailing its bucket array design, hash processing, collision handling, Java 8 treeification, resizing strategy, load factor and threshold calculations, performance optimization tips, common pitfalls, and when to choose alternative map implementations for high‑concurrency or ordered use cases.
Redis achieves million‑level concurrency by storing all data in memory, leveraging ultra‑fast read/write speeds, employing optimized data structures such as strings, hashes, lists, sets and sorted sets, using I/O multiplexing to handle many connections in a single thread, and scaling through master‑slave replication for high availability.
This article presents a comprehensive guide to advanced Python techniques, covering sophisticated syntax, powerful data structures, functional programming, concurrency with threading and asyncio, performance optimization using NumPy, Cython, Numba, and practical debugging and visualization tools, illustrated with clear code examples.
This comprehensive guide compiles essential C/C++ interview questions covering language fundamentals, data structures, algorithms, memory management, OOP principles, templates, and common coding patterns, providing clear explanations, example code, and practical insights to help both fresh graduates and experienced developers confidently tackle technical interviews.
This article explores five sophisticated data structures—B‑Tree, Radix Tree, Rope, Bloom Filter, and Cuckoo Hash—explaining their design, typical use cases, and why they outperform classic structures when handling massive scale, high‑speed lookups, or complex data manipulation.
This comprehensive guide introduces Python's core syntax and concepts—including its history, variables, data types, operators, control structures, functions, built‑in data structures, exception handling, and module usage—providing readers with a solid foundation for effective programming.
This article dives deep into Swift's Dictionary implementation, explaining its underlying hash‑table structure, memory layout, bucket calculation, probing strategies, copy‑on‑write semantics, performance optimizations, and conflict‑resolution techniques, all illustrated with real source code and debugging screenshots.
This article dives deep into Swift's Dictionary implementation, explaining its underlying hash‑table structure, memory layout, variant storage, probing strategies, copy‑on‑write semantics, conflict resolution, load‑factor handling, and automatic resizing, all illustrated with real code and debugger screenshots.
Learn how to efficiently remove duplicates from 4 billion QQ numbers using a memory‑friendly Bitmap approach that fits within a 1 GB limit, including calculations, step‑by‑step implementation, Java code, and a discussion of its advantages and drawbacks.
This article demonstrates how to simulate object‑oriented programming in C by using structs and function pointers, defines a list interface, provides a full implementation with insertion, deletion, traversal, and testing code, and explains why such techniques improve readability and maintainability.
This guide explains Python tuples—immutable ordered collections—covering their definition, creation methods (including packing, unpacking, and single-element tuples), element access, common operations like concatenation, repetition, slicing, membership testing, length retrieval, nesting, and built‑in methods such as count, index, and conversion from lists.
This article explains the Bloom filter data structure, its hash‑based design and false‑positive behavior, then demonstrates practical implementations using Java BitSet, Guava, and Redisson, covering initialization, configuration, usage tips, and performance considerations for Redis bitmap storage.
This comprehensive guide explains what Protocol Buffers are, why they outperform JSON and XML, how to install and configure the library, the supported data types, code generation for multiple languages, practical C++ examples, and typical scenarios such as distributed systems, storage, and network communication.
The article shares a detailed SF interview experience, covering typical Java interview questions such as self‑introduction, challenging projects, learning paths, abstract class vs interface, HashMap vs Hashtable, insertion steps, red‑black and B+ trees, MySQL and Redis indexing choices, large‑table optimization, JVM memory model, and the purpose of the Survivor space.
This article walks through the fundamentals of C++'s std::vector, covering its basic concepts, common use cases, detailed implementation of key operations like push_back, pop_back, and iterators, deep source‑code analysis, and practical interview strategies for hand‑coding the container.
Beyond the hype of counting code lines, this article explores why quality matters and presents a classic interview problem—finding the second‑strongest contestant in a knockout tournament—using a binary‑tree simulation with a concise Java implementation that runs in optimal time.
This article recounts a challenging Pinduoduo C++ interview question to hand‑write std::vector, then thoroughly explains its basic concepts, core interfaces, memory management, iterator behavior, source‑code analysis, and interview strategies, providing code examples and practical tips for mastering this essential container.
This article explains how Python’s GIL affects concurrency, when to use multithreading versus multiprocessing, and provides practical tips on efficient inter‑process communication, iteration, string handling, sorting, file I/O, and leveraging the standard library to dramatically improve script performance.
This article presents a curated collection of nine high‑utility C code snippets for embedded development, covering a circular buffer, custom assertions, bit reversal, fixed‑point arithmetic, endianness conversion, bit masks, timer handling, binary search, and a simple bitset structure, each with concise explanations and ready‑to‑use implementations.
This guide introduces Python's core fundamentals, covering its concise syntax, commenting styles, dynamic variables, primary data types, input/output functions, a full range of operators, control‑flow statements, and essential data structures such as lists, tuples, dictionaries and sets, complete with examples and visual illustrations.
This article introduces Python's core built‑in data structures—lists, sets, dictionaries, and tuples—explaining their characteristics, typical use cases, and providing clear code examples for creation, modification, and access.
This article introduces the binary search tree (BST) data structure, explains its core concepts, provides Python implementations for node definition, search, insert, and delete operations, compares performance, and discusses practical applications and exercises.
This article provides a thorough, English‑language walkthrough of Java 8+ ConcurrentHashMap’s source code, covering its constructor logic, load‑factor handling, CAS‑based insertion, node optimizations, the put method, element‑count updates, multi‑threaded resizing, treeification, and auxiliary operations such as get, remove, and computeIfAbsent.
This article examines the evolution of Java's HashMap from head‑insertion in JDK 1.7 to tail‑insertion in JDK 1.8, explains how the change eliminates circular‑list deadlocks during concurrent resizing, discusses remaining concurrency pitfalls such as red‑black tree conversion, and offers best‑practice solutions like using ConcurrentHashMap and proper initial capacity settings.
Redis 8.0 GA introduces a suite of new data structures—including a Vector Set for AI, native JSON support, and several probabilistic types—enhances the query engine with secondary indexes and full‑text/vector search, delivers significant performance gains, and re‑embraces open source by adding an OSI‑approved AGPLv3 license.
Redis 8.0 GA introduces major performance enhancements, adds AI‑focused vector and probabilistic data structures, expands native JSON support, improves the query engine with secondary indexes, and re‑embraces open source by offering an AGPLv3 licensing option.
Redis 8.0 GA introduces a suite of new data structures, AGPLv3 licensing, multithreaded query execution, horizontal scaling, and significant performance gains, positioning Redis as a more powerful in‑memory database for big‑data, AI, and real‑time applications.
This article traces MySQL’s architectural evolution from single‑node to sharded clusters, explains the fundamentals and classifications of NoSQL databases, and provides a comprehensive guide to Redis—including installation, memory management, and detailed usage of its five core data types with best‑practice considerations.
This comprehensive guide explains Redis's core architecture, the underlying implementation of its various data types, persistence mechanisms (RDB and AOF), high‑availability solutions such as replication, Sentinel and Cluster, as well as performance‑monitoring techniques and common optimization strategies.
This article presents practical Python performance optimization techniques, covering principles such as avoiding premature optimization, reducing global variables, minimizing attribute access, eliminating unnecessary abstractions, avoiding data copying, using efficient string concatenation, leveraging short‑circuit logic, loop optimizations, JIT compilation with Numba, and selecting appropriate data structures.
This article provides an in‑depth exploration of Java’s concurrent collection classes, covering the design and implementation of ConcurrentHashMap, ConcurrentLinkedQueue, and the seven blocking queue variants, complete with code analysis, performance considerations, and practical usage scenarios for high‑throughput multithreaded applications.
In this interview-style article, the interviewer probes a candidate on why Redis is exceptionally fast, covering its in‑memory storage, single‑threaded design, I/O multiplexing, optimized data structures, memory management tricks, and practical performance‑tuning strategies.
The article explains how Protocol Buffers (proto3) encode basic and composite types using varint, zigzag, fixed-size and IEEE‑754 formats, describes tag and length field structures, and presents optimization strategies such as selecting size‑efficient types, flattening nested messages, and delta‑encoding to significantly reduce serialized byte‑stream size.
This article explains Java’s hashCode method, its role in hash-based collections like HashMap and HashSet, how objects are placed in buckets, the necessity of overriding hashCode alongside equals, and how proper implementation improves performance and ensures consistent behavior.
This article presents a curated collection of thirty practical Python mini‑tasks, each accompanied by concise explanations and ready‑to‑run code snippets that illustrate common operations such as duplicate detection, anagram checking, memory usage, dictionary merging, and more, helping beginners quickly master useful programming techniques.
This article introduces Python's four fundamental data structures—list, tuple, set, and dictionary—explaining their characteristics, creation syntax, and typical operations to help readers choose the appropriate structure for different programming scenarios.
This article examines the most frequent Redis performance bottlenecks—including high memory usage, network latency, misconfiguration, poor data‑structure choices, and suboptimal persistence—explains why they occur, and provides concrete optimization techniques, monitoring commands, real‑world case studies, and emerging trends to keep your cache fast and stable.
This article compiles the most frequently asked Redis interview questions, covering fundamentals, data structures, persistence mechanisms, high‑availability features, clustering, performance tuning, and troubleshooting, providing clear explanations and practical guidance to help candidates confidently tackle any Redis interview.
This article introduces Python dictionaries, explains their key characteristics, and provides a comprehensive set of code examples demonstrating creation, access, modification, deletion, iteration, and advanced techniques such as dictionary comprehensions and safe value retrieval.
This article explains how to use Redis as a high‑performance caching layer—covering local and remote caches, support for multiple data structures, expiration and eviction policies, persistence mechanisms like RDB and AOF, a simple TCP protocol, and advanced modules—enabling services to handle tens of thousands of queries per second without overloading MySQL.
This article explains the fundamentals of hash structures, hash functions, and Java collection implementations such as HashMap, LinkedHashMap, and ConcurrentHashMap, covering their design, collision handling, performance characteristics, and how Redis extends these concepts to a distributed environment.
Discover six unexpected Python dictionary features—from insertion-order preservation in Python 3.7+, safe key access with .get(), immutable key requirements, the power of collections.defaultdict, the concise merge operator | in Python 3.9+, to using popitem() for stack-like behavior—each illustrated with clear code examples.
This article explains why Python lists are slow for head insertions and deletions, introduces the deque data structure from the collections module, compares their time complexities, and shows practical scenarios and code examples where deque provides superior performance and thread‑safety.
This article introduces Python's set data structure, explains its unordered, unique, and mutable characteristics, demonstrates how to create sets, and provides eleven practical code examples covering basic definitions, element addition and removal, set operations like union, intersection, difference, subset checks, deduplication, iteration, and conditional filtering.
This article compiles a wide range of Linux C/C++ interview questions covering language fundamentals, data structures, algorithms, operating systems, networking, databases, and general problem‑solving approaches to help candidates assess and improve their technical knowledge.
This article introduces Python lists, explains their core operations such as adding, removing, searching, sorting, and iterating, and provides ten detailed code examples that illustrate common use cases and scenarios for effective list manipulation.
This article provides a comprehensive guide to PHP arrays, covering how to create them with array() or short syntax, initialize numeric arrays with range(), convert variables using compact(), and demonstrates accessing, adding, modifying, deleting, traversing with loops, and using built‑in functions, while also introducing related data structures.
The article explains that programming is fundamentally the combination of algorithms and data structures, breaks algorithms into control and logic, and argues that separating logic, control, and data—along with mastering essential design principles and data structures—is key to writing high‑quality, maintainable code.
Redis stores data directly in memory rather than on disk, leveraging microsecond‑level access, a single‑threaded Reactor event loop with I/O multiplexing, optimized data structures like strings, hashes, lists, sets, and a simple text protocol, all of which combine to deliver exceptionally high performance for high‑frequency read/write workloads.
This article explains practical Python implementations for reversing a linked list using iterative and recursive approaches, merging two or multiple sorted linked lists, handling edge cases such as empty inputs, and includes complete code samples with complexity analysis for each method.
This article demonstrates how to improve the performance of nested for‑loops that match user IDs between two large lists by adding a break statement and by converting the inner list into a hash map, reducing execution time from tens of seconds to a few seconds.
This article explores powerful PHP data structures and algorithms—including binary search, hash tables, linked lists, stacks, queues, and binary trees—demonstrating their implementations, performance optimization strategies, and the modern Laravel Collections approach to efficiently handle large-scale data in web development.
This article explains various Python sorting techniques—including the built‑in sorted() function, the in‑place list.sort() method, key‑based sorting for complex structures, multi‑criteria ordering, and custom comparison via functools.cmp_to_key—providing clear code examples for each approach.
This article explains the purpose, design, and internal data structures of ext4 extents, describes how the B+‑tree indexes extents for efficient mapping of logical to physical blocks, and compares ext4’s extent mechanism with older file‑system addressing methods and other modern file systems.
This article examines core and advanced data structures in PHP and Laravel, demonstrating how arrays, associative and multidimensional arrays, collections, and JSON storage can be leveraged with practical code examples and query‑optimization techniques to build efficient, scalable, and maintainable web applications.
This article explains how MySQL's indexing evolved from simple binary search trees through AVL and red‑black trees to B‑trees and finally B+ trees, highlighting the performance and I/O advantages that make B+ trees the preferred index structure for disk‑based databases.
Redis achieves remarkable speed by storing data entirely in memory, employing a single‑threaded event loop with I/O multiplexing, and using highly optimized in‑memory data structures while balancing durability through efficient persistence mechanisms, all of which combine to minimize latency and maximize throughput.
This article presents a detailed guide to classic sorting, searching, and encryption algorithms, explains their principles and use cases, and provides Python implementation links and visualizations, offering a valuable resource for learners seeking to master fundamental algorithmic techniques.
This article presents a collection of practical Python techniques—including one‑line variable swapping, list, set and dictionary comprehensions, the Counter class for counting, pretty‑printing JSON, inline conditional expressions, list slicing, itertools combinations, and a quirky False‑equals‑True example—each illustrated with concise code snippets and explanations.
The article details Tencent’s updated 15‑month compensation packages for 2025 backend roles, outlines a one‑hour interview covering OS process/thread concepts, sorting algorithms, MySQL storage engines and indexing, Redis data structures, Java collections, and compares RocketMQ with Kafka for reliable messaging.
This guide outlines the core data structures—arrays, 2D arrays, queues, linked lists, stacks, trees, and hash maps—explaining their characteristics, typical use‑case scenarios, and concrete examples to help embedded developers write efficient, scalable code.
This tutorial walks through thirty practical Python dictionary operations—from creating and accessing entries to merging, comprehensions, sorting, and deletion—providing clear code examples and expected outputs to help readers master this versatile data structure.
The article honors the late Tsinghua professor Yan Weimin, highlighting her pioneering role in Chinese computer science, the lasting impact of her co‑authored Data Structures textbook, and the rigorous standards that shaped generations of computing talent.
This article explains why storing daily sign‑in data in a traditional database can cause performance issues at scale and demonstrates how Redis bitmap, a memory‑efficient bit‑level structure, can record and compute continuous user sign‑ins both by date and by user.
The article explains how to store and deduplicate billions of identifiers by using a bitmap to represent presence with a single bit per value, calculates memory requirements, shows Redis bitmap commands, and introduces Bloom filters as an extension with multiple hash functions for efficient large‑scale data handling.
This article demonstrates how replacing a naïve double‑for‑loop that matches two large lists of users with a HashMap lookup dramatically cuts execution time from tens of seconds to a few seconds by reducing the algorithmic complexity from O(n²) to O(n).
This article explains Bloom filters and Cuckoo filters, covering their principles, implementations, and practical applications in database optimization.
This article explains the bitmap (BitVec) data structure, its memory efficiency for handling billions of integers, real‑world applications such as bloom filters and permission flags, and walks through Go’s internal BitVec implementation with concrete code examples and performance insights.
This article explains the treap data structure—its BST and heap properties, random priority balancing, and implementation details—then dives into Go's runtime semaRoot treap, showing step‑by‑step enqueue and dequeue algorithms with code, rotations, and performance reasoning.
Redis’s evolution from linked lists to ziplist, quicklist, and the newer listpack is examined in depth, highlighting their structures, memory‑performance trade‑offs, operational details, and practical guidance for Java developers on choosing the right data structure for different workloads.
This article dissects Go's runtime GPM model and the lock‑free runq data structure, detailing its fields, core operations such as runqput, runqget, runqgrab, and their atomic implementations, while also comparing local and global queues and illustrating the code paths with concrete examples.
This article combines a Huawei campus recruitment overview—including interview timeline, salary grades, and interview process—with extensive technical Q&A covering Java vs C differences, Java features, OOP concepts, common design patterns, Redis and MySQL comparisons, MySQL transaction properties, B‑Tree indexes, list deduplication, stack implementations, and the low‑level workings of the ping command.
This article explains how Redis implements dynamic string expansion using the Simple Dynamic String (SDS) structure, detailing the sdsMakeRoomFor function, its allocation strategy, type handling, and the architectural changes introduced in Redis 7.0.
This article provides a comprehensive overview of essential Python concepts—including decorators, list comprehensions, generators, exception handling, modules, threading, shallow and deep copying, garbage collection, variable arguments, closures, method types, process‑thread differences, relational vs NoSQL databases, array vs linked‑list structures, and the distinction between HTTP and Web Service API testing—illustrated with clear explanations and runnable code examples.
