This article demonstrates how to encapsulate common RedisTemplate operations—such as deleting single or multiple keys, setting expiration, checking existence, and performing String and Hash CRUD actions—by providing concrete Java code examples and step‑by‑step method implementations.
This article explains how to access the Redis CLI on Linux, connect to remote servers, and provides detailed examples of common commands for each of Redis's five data types—String, List, Set, Sorted Set, and Hash—highlighting key syntax and usage patterns.
This guide explains how to achieve pagination and multi‑condition fuzzy queries in Redis by leveraging ZSet for ordered paging and Hash with HSCAN for pattern matching, detailing command usage, combination strategies, and performance optimizations such as temporary set expiration and data freshness handling.
This article explains when to store user objects in Redis as a JSON‑encoded String or as a field‑level Hash, comparing memory usage, atomic updates, network overhead, concurrency safety, scalability, and provides practical tips for large keys, hot keys, and Redis threading.
The article compares storing user objects in Redis using plain SET with JSON versus using HASH fields, providing code demos, benchmark results, memory and concurrency analysis, and practical guidelines on when to choose each approach for optimal performance and safety.
This article explains how to achieve conditional queries and pagination in Redis using Sorted Sets and Hashes, outlines the implementation steps for pagination, fuzzy multi‑condition search, their combination, and discusses performance optimizations such as expiration and real‑time data handling.
This guide presents a comprehensive overview of Redis core data structures—String, List, Set, Sorted Set, and Hash—detailing their most common commands, practical code examples, and typical application scenarios such as counters, distributed sessions, locks, ranking lists, and shopping‑cart storage.
This article explains how to use Redis Sorted Sets for efficient pagination, leverages Hashes and HSCAN for multi‑condition fuzzy queries, and combines both techniques with performance‑optimizing strategies such as expiration and real‑time updates.
This article explains why newly deployed front‑end pages often still display old content due to browser, Nginx, or CDN caching, and provides a three‑step method—including proper cache‑control headers, hash‑named assets, and version‑based fallback—to ensure users always see the latest version.
This article explains how to use Redis Sorted Sets and Hashes to achieve efficient pagination, fuzzy multi‑condition queries, and their combination, while also discussing performance‑optimisation strategies such as temporary ZSet expiration and data‑freshness handling, before concluding with a brief promotional segment.
This article explains the fundamentals of database indexes, covering their purpose, underlying structures such as hash tables, B‑Tree and B+‑Tree, the advantages and drawbacks, and the various index types in MySQL including clustered, non‑clustered, primary, secondary, unique, prefix, and full‑text indexes.
This tutorial explains why encryption matters in Android reverse engineering, distinguishes standard and custom algorithms, lists common hash, symmetric, and asymmetric methods, and provides complete Java code examples for Hex, Base64, MD5, SHA‑1, MAC, DES, 3DES, AES, and RSA, all runnable in Android Studio.
This article explains three Redis-based methods—Hash, Bitmap, and HyperLogLog—for tracking website user visits, detailing how each structure works, their implementation steps, memory and accuracy trade‑offs, and guidance on choosing the best approach for different traffic scenarios.
The article explains why large keys, oversized values, massive key counts, and huge Bitmaps or Bloom filters degrade Redis performance and provides practical splitting techniques—using multiple keys, hashes, bucketed hashing, and bitmap partitioning—to reduce memory pressure and improve response times.
The article explains hash algorithm fundamentals, compares common hashes, presents extensive Go benchmark results across multiple data sizes, highlights the superior performance of Go's maphash (memhash) implementation, and shows how to access it via linkname and assembly details.
This guide explains PostgreSQL table partitioning, covering its definition, benefits, drawbacks, the three partition types (RANGE, LIST, HASH), step‑by‑step SQL commands for creating partitions, indexes, and managing them, and concludes with practical recommendations for effective use.
This article explains how to implement pagination, multi‑condition fuzzy search, and their combination using Redis Sorted Sets and Hashes, discusses performance optimizations and expiration strategies, and also contains promotional material for ChatGPT services and a community offering.
By leveraging Redis sorted sets for ordered pagination and hash fields with HSCAN for multi‑condition fuzzy matching, the article shows how to build a cached query pipeline that creates temporary ZSets keyed by pattern, supports efficient page retrieval, and uses expirations and refresh strategies to balance freshness and performance.
This article explains how the frontend can upload files to the backend using base64 or binary Blob transmission, introduces key JavaScript objects such as files, Blob, FormData, and FileReader, and provides practical code examples for validation, preview, chunked uploading, progress tracking, and resumable uploads with hash verification.
The article explains software supply chain security by describing how source code becomes artifacts, the role of hashes and digital signatures, and how frameworks like SLSA and Sigstore provide attestations and trusted signing to ensure provenance and protect against tampering.
This article explains how to efficiently detect changes in complex Kubernetes Operator objects by comparing current and desired states using methods such as reflect.DeepEqual, hash‑based comparison, JSON Patch generation, deep copying, and custom comparison functions, and offers best‑practice guidance for reliable controller implementations.
This article explains Redis's five basic data types—String, List, Hash, Set, and Sorted Set—detailing their typical use cases, common commands, and providing concrete CLI examples that demonstrate how to manipulate each type.
This article explains how to use Redis' Sorted Set and Hash structures to achieve efficient pagination, multi‑condition fuzzy queries, and their combination, while also discussing performance optimizations such as expiration handling and data synchronization strategies.
This article explains how to achieve conditional fuzzy queries and pagination in Redis by leveraging Sorted Sets and Hashes, detailing command usage, data modeling, combination strategies, and performance optimizations such as expiration and real‑time updates.
This article explains how to use Redis Sorted Sets for efficient pagination, leverages Hashes and HSCAN for multi‑condition fuzzy searches, and combines both techniques with optimization strategies such as temporary ZSet expiration and real‑time update handling to build a practical caching‑layer query solution.
The incident showed that Redis hashes encoded as ziplist incur O(N) HEXISTS latency, causing high CPU on hot keys, while hashtable‑encoded hashes remain O(1); adjusting hash‑max‑ziplist settings or redesigning hot‑key patterns can convert to faster, though more memory‑hungry, hashtable encoding.
This article explains how to use Redis Sorted Sets and Hashes to achieve pagination, fuzzy multi‑condition queries, and their combination, while also discussing performance optimizations such as expiration and update strategies for generated ZSet collections.
This article explains how to achieve efficient pagination and multi‑condition fuzzy searches in Redis by leveraging Sorted Sets for ordered paging, Hashes with HSCAN for pattern matching, and combining both techniques with caching and expiration strategies to optimize performance.
This article explains how to implement efficient pagination and multi‑condition fuzzy queries in Redis using Sorted Sets and Hashes, outlines the underlying commands, discusses combining both techniques, and offers optimization strategies such as expiration handling to maintain cache performance.
This article explains the inner workings of Redis Hashes, covering the dict and listpack storage mechanisms, memory‑optimizing conditions, rehashing strategies, and the underlying C structures that enable fast O(1) field lookups and efficient memory usage.
This article introduces Redis HSET, covering its definition, suitable use cases, common commands for creating, reading, updating, and deleting hash fields, as well as the underlying encoding mechanisms (ziplist vs hashtable) and best practices, including the deprecation of HMSET.
The article explains how to improve slow iOS list pages by using prefetch and preload techniques, caching network responses, handling new‑user scenarios, and implementing a hash‑based cache‑validation system to minimize unnecessary reloads and boost rendering performance.
This article explains the inner workings of Git by detailing what occurs during initialization, adding files, committing changes, managing branches, and interacting with remote repositories, covering the .git directory structure, objects, SHA‑1 hashing, the index, HEAD, refs, and push operations.
This article examines why a MySQL InnoDB table with a unique index can still store duplicate rows—especially when indexed columns contain NULL values or when logical deletion is used—and presents several practical strategies such as adjusting delete status, adding timestamp or auxiliary ID fields, using hash columns, and leveraging proper bulk‑insert techniques to enforce uniqueness effectively.
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.
The article explains how space‑efficient probabilistic structures such as BloomFilter and Count‑min Sketch enable large‑scale data deduplication, join pruning, real‑time idempotent filtering, and approximate top‑K analytics by trading modest accuracy loss for dramatically reduced storage and faster computation.
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 tutorial explains why learning encryption algorithms is essential for Android reverse engineering, distinguishes standard and non‑standard algorithms, and provides complete Java code examples for Hex/Base64 encoding, message‑digest (MD5, SHA‑1, MAC), symmetric ciphers (DES, 3DES, AES) and asymmetric RSA, all runnable in an Android Studio project.
This article explains how to use Redis data structures—Set, Hash, Bitmap, and HyperLogLog—along with Redisson in Java to efficiently count unique page visitors (UV) in high‑traffic mobile internet scenarios, comparing memory usage, precision, and scalability.
This article examines short‑URL system design, comparing hash‑based, MySQL, and Redis storage strategies, and proposes an optimized solution using auto‑increment IDs with high‑base (62) encoding and lightweight encryption to reduce storage and improve lookup performance.
This article explains how to handle the massive‑data problem of intersecting two files containing billions of URLs by using hash‑based divide‑and‑conquer techniques, file partitioning, and in‑memory hash lookups to achieve scalable performance beyond naive O(m·n) approaches.
This article reviews MySQL horizontal partitioning, explains five partitioning strategies (HASH, RANGE, KEY, LIST, COMPOSITE), demonstrates how to create and test partitioned tables, compares performance with and without indexes, and covers partition management operations such as adding, dropping, and rebuilding partitions.
The ezmlm_hash() function calculates the hash of an email address for storing EZMLM mailing‑list entries in a MySQL database, describing its parameter, return value, and providing a complete PHP usage example.
This article explains three Redis-based techniques—Hash, Bitset, and HyperLogLog—for efficiently counting daily page visits, detailing command usage, memory trade‑offs, and accuracy considerations, helping backend engineers implement scalable visitor statistics in high‑traffic environments like large e‑commerce platforms.
The hash_update_file() function reads a file and feeds its contents into an existing hash context, optionally using a stream context, returning true on success or false on failure, and is useful for generating file hashes in PHP applications.
hash_update() is a PHP function that appends a string of data to an active hash computation context created by hash_init(), takes a resource context and a string data as parameters, and returns TRUE upon successful update of the hash digest.
The article explains PHP's hash_init function, detailing its purpose to initialize an incremental hashing context, describing its parameters (algorithm name, options, key), return value, and provides a complete example demonstrating how to compute an MD5 hash using hash_update and hash_final.
The hash_final() function completes an incremental hash operation in PHP, returning either a raw binary digest or a lowercase hexadecimal string based on the raw_output flag, with usage illustrated through a complete example.
The article explains PHP’s hash_copy() function, detailing its purpose of duplicating a hash context, the required $context parameter, the returned resource, and provides a complete example with code and expected output for demonstration.
The PHP function hash_algos() returns an indexed array of all supported hash algorithm names, allowing developers to retrieve the available algorithms for cryptographic operations; the documentation includes its signature, return description, a usage example, and a sample output listing algorithms such as md5, sha1, and crc32.
This article explains PHP's hash() function, detailing its purpose, supported algorithms, parameter usage, optional raw output, and provides a clear code example with expected hexadecimal result for generating cryptographic message digests.
This article explores three surprising Python quirks: how numeric keys like 5 and 5.0 collide in dictionaries, why a return statement in a finally block overrides earlier returns, and how object identity and hash values can behave unexpectedly, revealing the language’s underlying mechanics.
This article introduces the OneSM3 PHP library for the SM3 cryptographic hash, provides Composer installation steps, usage examples for string and file signing, and presents performance benchmark results comparing it with OpenSSL and another PHP SM3 implementation.
This article explains the design and implementation details of Redis's Simple Dynamic String (SDS) and the underlying structures of its core collections—List, Set, Sorted Set (Zset), and Hash—covering their memory layouts, advantages, and the conditions that trigger different internal representations.
This article explains the principles of hash tables, how hash functions are used for data sharding in distributed databases such as DBLE, compares hash‑modulo and consistent‑hash approaches, and discusses their advantages, limitations, and practical configuration tips.
The article explains three Redis-based techniques—Hash, Bitset, and HyperLogLog—for counting daily page visits on high‑traffic sites, detailing command usage, memory trade‑offs, and the pros and cons of each method.
This article provides a clear, beginner‑friendly explanation of blockchain technology, covering its nature as a decentralized distributed database, the structure of blocks and hashes, the mining process with difficulty adjustment, and how forks are resolved, while highlighting its advantages and limitations.
This guide explains how to use Laravel's Hash facade to securely hash passwords with Bcrypt or Argon2, configure hashing drivers, adjust algorithm parameters, and verify or rehash passwords using methods such as make, check, and needsRehash.
This article explains the brute‑force (BF) substring search algorithm, demonstrates its step‑by‑step operation with examples, then introduces a simple hash‑based sliding‑window method (a basic Rabin‑Karp approach), provides Java code, and shows how to compute and update hashes efficiently to locate a pattern in a main string.
This article explains why Python dictionary keys with numeric values can overwrite each other, how a return statement inside a try block is overridden by a return in a finally block, and why object identity (is) and hash values behave as they do, illustrating each point with code examples.
This article explains blockchain fundamentals, describing its structure as a decentralized distributed database, the composition of blocks, hash functions, the mining process, Bitcoin’s application, and the technology’s key advantages and drawbacks, providing a concise beginner’s overview.
This article explains three Redis‑based techniques—using hash tables, bitsets, and the HyperLogLog probabilistic algorithm—to accurately count daily page views, detailing the required commands, implementation steps, advantages, and limitations for high‑traffic sites.
This article explains how to dramatically reduce Redis memory consumption—by up to 90%—through converting long string keys to integers, leveraging zipList‑encoded hashes, and distributing millions of key‑value pairs across many hash buckets while maintaining query performance.
This article explains the concept of hash functions and hash tables, illustrates how they map data to array indices, discusses collision resolution methods, and details Redis's internal dictionary implementation, including zipmap optimization, operation complexities, and practical usage differences between hashes and sets.
This article explains how to leverage the hash fragment of an H5 URL to enable seamless, non‑refreshing data exchange between a Mini Program and H5 pages, covering the problem, solution, implementation details, code examples, pitfalls, and best‑practice tips.
This article provides a clear, beginner‑friendly explanation of blockchain as a decentralized distributed database, covering its essential structure, hash‑based immutability, mining difficulty, fork resolution, and why its practical use cases remain limited.
After initially implementing table sharding, we later added database sharding, sharing a detailed retrospective that covers when to partition tables, various sharding strategies (range, hash, range+hash), migration challenges, business compatibility, and final archiving practices, illustrated with diagrams and practical tips.
This article introduces Redis as an open‑source in‑memory store, outlines its core data structures—strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and geospatial indexes—and provides concrete command examples, application scenarios, and best‑practice guidelines for effective usage.
This article presents a hybrid sharding approach that combines range partitioning to assign ID ranges to groups and hash modulo on the total number of tables to achieve uniform data distribution while avoiding hotspots and eliminating the need for data migration during scaling.
This article introduces the concept of load balancing as a key high‑availability technique, explains five common strategies—round robin, weighted round robin, least connections, fastest response, and hash—provides code examples, compares their pros and cons, and outlines health‑check methods to ensure reliable service.
This article introduces the most frequently used encryption techniques in frontend development—including Base64 encoding, hash functions, salting, slow hash algorithms, key‑hashing, XOR, symmetric and asymmetric encryption, digital signatures, and practical CryptoJS usage—explaining their principles, appropriate scenarios, and providing ready‑to‑use code examples.
This comprehensive guide explores essential strategies for handling massive datasets, covering hash-based structures, bucket partitioning, heap and quicksort techniques, trie trees, Bloom filters, external sorting, and MapReduce, and demonstrates how to efficiently solve common interview problems such as top‑K queries and duplicate removal.
This article explores practical algorithms for sorting, de‑duplicating, and extracting top‑K records from massive data sets, covering bitmap techniques, external sorting, hash‑based counting, min‑heap selection, divide‑and‑conquer, Bloom filters, and distributed processing strategies.
This article demystifies blockchain by explaining its fundamental structure of linked blocks, how hashes ensure integrity, the differences between public and private blockchains, and illustrates smart contract use cases such as automated rent payments, providing clear examples and visual diagrams for beginners.
This tutorial explains blockchain as a special distributed database, covering its core concepts such as block structure, hash immutability, mining difficulty, dynamic difficulty adjustment, and chain forks, while highlighting its advantages, limitations, and typical use cases like cryptocurrencies.
This article explains how blockchain technology underpins Bitcoin, covering basic concepts such as distributed ledgers, cryptographic hash functions, digital signatures, hash pointers, Merkle trees, and the structure of Bitcoin's blockchain, while also highlighting broader applications and future considerations.
This article provides a clear, beginner‑friendly explanation of blockchain, covering its nature as a decentralized database, the role of blocks and hashes, mining mechanics, difficulty adjustment, and how forks are resolved, while highlighting both strengths and limitations of the technology.
This article provides a clear, beginner‑friendly explanation of blockchain technology, covering its nature as a decentralized database, block structure, hashing, mining difficulty, dynamic adjustment, forks, and practical limitations, while illustrating concepts with diagrams and real‑world examples.
This article breaks down the anatomy of a Bitcoin block, detailing its header, identifier, transaction list, and the Merkle tree construction with JavaScript code examples to illustrate how hashes are combined into a root hash.
This article explains load‑balancing concepts and demonstrates Java implementations of several algorithms—including Round Robin, Random, source‑IP hash, weighted round robin, weighted random, and least‑connections—while discussing their advantages, drawbacks, and concurrency considerations.
This article explains the concept of load balancing and provides Java implementations of several common algorithms—including Round Robin, Random, Source‑IP Hash, Weighted Round Robin, Weighted Random, and a discussion of Least Connections—highlighting their principles, advantages, drawbacks, and concurrency considerations.
This article introduces Redis's five core data structures—String, List, Set, Hash, and Sorted Set—detailing their characteristics, common commands, additional operations, and typical use cases, providing a comprehensive guide for developers working with Redis.
This article introduces Node.js's built‑in crypto module, explaining how to perform one‑way hashing with SHA‑256, create HMACs for stronger integrity checks, and use symmetric cipher/decipher for encrypting and decrypting data, complete with practical code snippets.
Redis’s hash‑max‑ziplist‑entries and hash‑max‑ziplist‑value settings control when hash tables switch to compressed ziplist storage, and by segmenting data into 1,000‑item hash tables, Instagram reduced memory usage from ~20 GB to about 5 GB, dramatically improving efficiency.
This article explains PHP's various encryption methods, covering one-way hash functions like MD5 and SHA1, symmetric algorithms, the rarely used crypt() function, and detailed implementations of asymmetric encryption with OpenSSL, including key generation, encryption, decryption, and practical code examples.
This guide outlines the five primary Nginx load‑balancing methods—Round Robin, Least Connections, Least Time (header or last_byte), IP Hash, and generic Hash—explaining how each algorithm works and showing the corresponding upstream configuration syntax for assigning server weights and parameters.
