The article explains fundamental concepts of encryption and decryption, compares symmetric (AES, DES) and asymmetric (RSA, SM2) methods, describes hash functions (SHA256, MD5, SM3) and their proper use with salting, outlines hybrid RSA‑AES schemes, HTTPS workflow, and common pitfalls such as misuse of Base64.
The paper introduces EMCES, a method that injects episodic memory into controllable diffusion models and uses a hash‑based state representation to generate high‑value synthetic samples, dramatically improving sample efficiency and downstream reinforcement‑learning performance while cutting storage and time costs.
Go’s 2025 addition of the generic Hasher[T] interface to hash/maphash standardizes safe hashing by embedding a random seed throughout recursive calls, resolves previous design flaws, and provides clear guidelines for custom hashers, comparable types, and practical applications such as Bloom filters, all while ensuring performance and correctness.
The article explains how Prompt Caching leverages vLLM's PagedAttention and block‑level hashing to reuse KV cache across identical prefixes, dramatically cutting LLM inference latency and cost, and provides concrete engineering tips for maximizing cache hit rates.
This guide explains why password hashing is essential in modern web applications, introduces PHP's password_hash function, demonstrates its usage with clear code examples, and highlights automatic salting and verification with password_verify to protect user credentials.
This guide explains why password hashing is crucial for protecting user credentials, introduces PHP's password_hash and password_verify functions, provides a complete code example, and highlights automatic salting and verification best practices for robust password security.
This guide explains how to implement symmetric (AES‑CBC, AES‑GCM) and asymmetric (RSA) encryption as well as hashing in Go, providing clear explanations and complete, runnable code samples for each technique.
This article explores three Python quirks: how dictionary keys with equal numeric values overwrite each other due to hashing and equality rules, why a return statement inside a try block is superseded by a return in the finally clause, and how object identity and id values behave, including hash collisions and memory reuse.
Explore the seven most commonly used encryption algorithms—including MD5, SHA families, HMAC, AES, DES/3DES, RSA, and DSA—detailing their principles, Java implementations, performance, and practical security guidelines, while highlighting real-world attack scenarios and best‑practice recommendations for robust information protection.
This article explains how PHP's password_hash function can securely hash passwords, automatically handle salting, and be verified with password_verify, providing code examples and best practices for protecting user credentials in web applications.
This article explains how to improve website password security in PHP by using modern hash functions, adding random salts, employing built‑in password hashing APIs, enforcing strong password policies, scheduling regular password changes, and implementing measures to prevent brute‑force attacks.
This article presents concise Python examples for a wide range of encryption and encoding methods—including MD5, SHA‑256, Base64, AES, RSA, HMAC‑SHA256, Fernet, PBKDF2, Blowfish, and XOR—explaining their usage scenarios and highlighting the importance of selecting appropriate cryptographic techniques for security.
This article explains a divide‑and‑conquer method that splits massive search‑log files, uses multithreaded hashing to count keyword frequencies, and applies a min‑heap to efficiently retrieve the top‑100 most frequent search terms for SEO and recommendation tasks.
This article explains how PHP's password_hash function creates cryptographically strong, salted password hashes, demonstrates its usage with example code, and shows how to verify passwords securely using password_verify, emphasizing best practices for backend security.
The article recounts how the author built a billion‑scale AI image‑asset library by replacing a week‑long import with a clustered‑table, sharded pipeline, MD5‑based unique keys, a custom DataWorks task scheduler, and multi‑engine query layers, sharing practical engineering practices learned through successive iterations.
This article explains how to generate an MD5 hash for a string in Java with the java.security.MessageDigest class, provides a complete example program, details each step of the MD5 algorithm, and describes the core methods and internal workings of MessageDigest for cryptographic hashing.
This article compares Bloom filters and Cuckoo filters, explaining their underlying hash‑based mechanisms, performance characteristics, false‑positive behavior, support for deletions, and suitable use cases to help developers select the appropriate probabilistic data structure for their applications.
This article explains what password salting is, why it is essential for protecting stored passwords against rainbow‑table and brute‑force attacks, outlines step‑by‑step how to generate, apply, and verify salted hashes, and lists additional best practices for enhancing overall credential security.
This article walks through the most commonly used Google Guava packages, demonstrating how to handle strings, collections, primitives, I/O, and various utility classes with concise code snippets and practical tips to boost Java development productivity.
This article explains why bit manipulation is a staple technique in computer science, detailing performance gains, state flag encoding, mask operations, data compression, cryptography, image processing, hash structures, binary counting, and algorithm design, with practical Go examples.
This article explains how to securely hash passwords in PHP using the password_hash function, demonstrates code examples, describes verification with password_verify, and highlights automatic salting and best practices for protecting user credentials.
This article explains how to securely hash passwords in PHP using the password_hash function, demonstrates code examples for hashing and verifying passwords, discusses automatic salting, and highlights best practices for protecting user credentials.
This article explores the benefits of short URLs, explains their redirection mechanics, compares hash‑based and auto‑increment generation methods, and presents a high‑throughput architecture using OpenResty, Redis, and MySQL to handle massive traffic while ensuring reliability and scalability.
This article presents a comprehensive API encryption scheme that combines symmetric and asymmetric cryptography, hashing, and digital signatures, explains HTTPS fundamentals, details WeChat Pay encryption, outlines key exchange and data protection processes, provides Java code examples, and analyzes security, anti‑tampering, anti‑replay, and performance considerations.
This article introduces several widely used PHP encryption algorithms—including MD5, SHA family, AES, RSA, and Base64 encoding—explaining their functions, security considerations, and PHP functions for implementation, while also mentioning additional algorithms like DES, RC4, and Blowfish for specific use cases.
Websites cannot reveal original passwords because they store only salted, one‑way hashes, not the plaintext, making recovery impossible; therefore, when users forget their credentials, the secure approach is to verify identity and issue a password reset rather than expose any stored data.
This article explains how to securely hash passwords in PHP using the password_hash function, describes the underlying hash concept, provides example code for hashing and verifying passwords, and highlights PHP's automatic salting and best practices for protecting user credentials.
While both vectorization and hashing are essential for handling large datasets, this article examines whether vector embeddings can match the deterministic consistency of hash functions, comparing their collision handling, data structure design implications, and suitability for retrieval and machine‑learning tasks.
This article explains how to efficiently upload large files (e.g., 1.5 GB) from the browser by calculating a file hash with spark‑md5, checking server status for instant or resumable uploads, slicing the file into chunks, uploading them concurrently, and finally merging the chunks, while also offering optimization tips such as using Web Workers and adjusting chunk size.
This article explains how to enhance website password security in PHP by using hash functions, adding salts, employing password_hash and password_verify, enforcing strong password policies, scheduling regular password changes, and implementing measures against brute‑force attacks.
This article presents practical Python examples for enhancing network security, covering symmetric and asymmetric encryption, hash functions, password hashing, SSL/TLS communication, SQL injection prevention, XSS mitigation, CSRF protection, and secure password storage to safeguard data and privacy.
The article explains why Java's String class is immutable, highlighting performance gains from constant‑pool caching, security advantages for sensitive data, thread‑safety without synchronization, and hash‑code caching that speeds up hash‑based collections in Java applications.
This article explains Python's comparison and hash magic methods with ten practical code snippets, covering equality, inequality, ordering, hash calculation, total_ordering simplification, custom object sorting, and using objects as dictionary keys, set elements, and memoization caches.
This article introduces the five most widely used encryption algorithms—MD5, SHA‑256, DES, AES, and RSA—explaining their principles, strengths, weaknesses, and providing complete Java code examples for hashing, symmetric, and asymmetric encryption, along with practical usage scenarios such as password storage and HTTPS.
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 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 explains the main PHP encryption techniques—including one‑way hash functions like MD5 and SHA1, reversible encodings such as URL‑encode and Base64, and secure password hashing APIs—providing code examples and usage notes for each method.
This article compares common database sharding strategies—range sharding, mapping tables, ID modulo, hash‑based sharding, and consistent hashing—explaining their implementation complexity, data distribution characteristics, scalability concerns, and practical trade‑offs with code examples.
This article explains core data sharding concepts and models—including hash‑based, range‑based, and consistent hashing—detailing their mappings, routing strategies, scalability considerations, and practical implementation examples for handling massive datasets in distributed systems.
The article explains how to select and implement routing keys for database sharding in an order platform, covering time‑based and business‑related keys, user and merchant scenarios, hash‑modulo strategies for single and multi‑database environments, and the overall data flow.
Facing a challenge of managing roughly one million server-side images and 180 client images, the TOOSIMPLE team built a high-performance backend using fingerprinting, parallel processing, mmap-SSE2 acceleration, and sparsemap indexing, achieving sub-second response times while ensuring correct ordered display.
Efficient Target Attention (ETA) introduces a low‑cost hash‑based attention operator that enables end‑to‑end modeling of ultra‑long user behavior sequences for CTR prediction, achieving significant online CTR, GMV, and QPS improvements in Alibaba’s Taobao feed recommendation system.
This article introduces the essential concept of load balancing in distributed systems and provides a detailed overview of five fundamental algorithms—Round Robin, Weighted Round Robin, Random, Least Connections, and Source IP Hash—explaining their mechanisms and suitable scenarios.
This article explains why large‑scale systems need data partitioning beyond replication, defines partitions and sharding, compares key‑range and hash‑based partitioning methods, discusses load‑balancing and hotspot avoidance, and shows how replication works together with partitioning to improve scalability.
This article examines why passwords are often insecure, explains how they should be stored using hash algorithms and salts, outlines common password‑weaknesses and system vulnerabilities, and introduces FIDO/WebAuthn as a modern, password‑less authentication solution.
This article introduces fundamental cryptography concepts, explaining how symmetric and asymmetric encryption work, the role of key exchange, the purpose and properties of hashing algorithms, and how digital signatures combine encryption and hashing to ensure data authenticity and integrity.
This article explains the concepts, advantages, and limitations of Bloom filters, Counting Bloom filters, and Cuckoo filters, illustrating how they reduce unnecessary I/O in backend systems and offering practical improvements such as multi‑hash functions and bucket designs to enhance space and time efficiency.
This article explains the motivation behind using probabilistic filters to reduce I/O, describes how Bloom filters, Counting Bloom filters, and Cuckoo filters work, analyzes their false‑positive and deletion problems, and presents practical optimizations such as multiple hash functions and multi‑slot buckets.
This article explains how Bloom filters, counting Bloom filters, and Cuckoo filters work, their advantages and limitations, and how they can be used to reduce unnecessary database I/O by efficiently testing element membership before querying the database.
This article explains why using only file name and size to detect duplicate uploads is unreliable, demonstrates how to compute reliable file checksums in Java, and shows through experiments that identical content yields identical hashes regardless of name or type, providing a robust deduplication solution.
This article introduces Bloom filters—a space‑efficient probabilistic data structure—for fast set membership testing, explains their underlying hash‑based mechanism, showcases Java implementation with Google Guava, and demonstrates their application in scenarios such as cache‑penetration protection.
The article explains how Bloom filters, Counting Bloom filters, and Cuckoo filters work, their hash‑based bitmap mechanisms, advantages and limitations such as false positives and deletion issues, and presents practical improvements and hash functions for efficient cache and database query optimization.
The article explains the principles, advantages, and limitations of Bloom filters, introduces Counting Bloom filters as an enhanced version, and then details Cuckoo filters and Cuckoo hashing, including their algorithms, performance trade‑offs, and practical improvements for reducing unnecessary I/O operations.
This article explains a memory‑efficient, divide‑and‑conquer approach using hash partitioning and HashSet intersection to identify shared URLs between two massive 5‑billion‑record files while limited to just 4 GB of RAM.
This article explains the benefits of short URLs and presents a comprehensive, interview‑friendly design for a high‑performance short‑link service, covering redirect mechanics, hash‑based and auto‑increment generation methods, database schema, collision handling, and an OpenResty‑based architecture for massive concurrency.
This article demystifies cryptography by explaining fundamental concepts, tracing its history from ancient substitution ciphers to modern symmetric and asymmetric algorithms, and providing complete Java code examples for DES, AES, RSA, signing, verification, and hashing techniques.
This article explains fundamental cryptography concepts, traces the evolution from ancient substitution ciphers to modern symmetric and asymmetric algorithms, and provides complete Java code examples for DES, AES, RSA, digital signatures, and hash functions such as MD5 and SHA.
The article explains the PHP function hash_update_stream(), detailing its signature, parameters (context, handle, length), return value, and provides a complete example that reads data from a temporary file stream, updates an MD5 hash context, and outputs the resulting hash.
This article examines the challenges of storing massive DMP data in Redis, analyzes memory fragmentation, key‑size issues, and latency constraints, and presents practical strategies such as TTL eviction, bucket‑hashing, custom key compression, and fragmentation‑reduction techniques to enable scalable, real‑time querying.
The article uses a historical story to illustrate basic hash‑based partitioning, its shortcomings when nodes change, and then introduces consistent hashing, hash rings, and virtual nodes as solutions for balanced load distribution and minimal data migration in distributed systems.
This article explains why transmitting passwords over plain HTTP is unsafe, introduces HTTPS and its TLS encryption process, compares symmetric and asymmetric encryption methods, and recommends secure password storage techniques such as salted hashing and BCrypt to protect against rainbow‑table and brute‑force attacks.
This article explains the concept of password salting, its security benefits, and provides a complete Java implementation using MD5, including salt generation, hashing with and without salt, storing salt within the hash, and verification procedures for registration and login.
This article presents ten big‑data interview problems, each describing a scenario such as finding the most frequent IP, top‑K queries, word frequency counting under memory limits, and techniques like hashing, bitmap, trie, heap, and external sorting to solve them efficiently.
This article summarizes a range of practical methods—including Bloom filters, hashing, bit‑maps, heaps, bucket partitioning, database indexes, inverted indexes, external sorting, trie trees, and MapReduce—that are commonly used to handle, deduplicate, and query extremely large data volumes in big‑data applications.
This article reviews common image similarity detection techniques—including hash-based methods (aHash, pHash, dHash), histogram comparison, feature matching with ORB and SIFT/SURF, bag‑of‑words with K‑Means, and CNN‑based VGG16 features—detailing their algorithms, Python implementations, performance characteristics, and practical considerations.
Storing passwords in plaintext is insecure; instead, use cryptographic hash functions with proper salting, avoid simple encryption like AES, understand rainbow table attacks, and adopt modern password‑hash algorithms such as Argon2, Bcrypt or Scrypt to protect user credentials against modern threats.
This article explains the fundamentals of hash functions, outlines the key characteristics of a good hash algorithm, and dives deep into consistent hashing—its background, mechanism, desirable properties, fault tolerance, scalability, and the use of virtual nodes to solve data skew in distributed systems.
This article introduces various cryptographic primitives—including MD, SHA, MAC, and digital signature algorithms such as RSA, DSA, and ECDSA—explains their usage and security considerations, and provides complete .NET Core code examples using the BouncyCastle library for implementation.
This article explains how hashing transforms data lookup from linear or logarithmic time to constant O(1) time by using hash functions and hash tables, illustrates the concept with a simple modulo‑based example, and discusses load factor and collision issues.
This article explores the design of a high‑performance short‑link system, covering its benefits, redirection mechanics, hash‑based and auto‑increment generation methods, database schema, Bloom filter optimization, and a scalable OpenResty‑based architecture for handling massive traffic.
This article explains the internal architecture of Java's ThreadLocal, including its ThreadLocalMap implementation, the purpose of the special hash code 0x61c88647, collision handling strategies, proper usage patterns in web applications, and precautions for avoiding memory leaks in thread pools.
This article provides a comprehensive walkthrough of using Go's crypto library for hashing, symmetric and asymmetric encryption, certificate generation, and TLS/HTTPS server and client implementation, illustrating how these techniques are applied in kubeadm to simplify Kubernetes cluster security.
This article reviews advanced SQL optimization techniques—including using indexes to avoid sorting, reasons an optimizer may skip indexes, hash‑based access methods, and parallel query execution—while summarizing a four‑part series on DBMS‑agnostic performance tuning.
This article summarizes a variety of practical methods—including Bloom filters, hashing, bit‑maps, heaps, bucket partitioning, database indexes, inverted indexes, external sorting, tries, and MapReduce—that can be used to efficiently handle and analyze extremely large data volumes in real‑world scenarios.
The article discusses an interview scenario where a candidate must determine the most frequent integer among billions of values using only a few gigabytes of memory, exploring hash tables, file partitioning, and hashing strategies to handle massive data sets efficiently.
This article explains the fundamentals of AB testing, outlines the iterative workflow, shares best‑practice guidelines, compares single‑layer and multi‑layer experiment frameworks, and details the technical implementation—including SDK design, hashing algorithms, data denoising, and statistical evaluation methods.
This article explains how JD's ZRobot leverages alliance‑chain blockchain to address leasing business challenges such as breach disputes by providing real‑time, immutable evidence, legal endorsement, and secure data storage, while outlining the broader regulatory and industry context in China.
The article presents three Ant Financial research papers featured at KDD 2018—one on graph‑learning fraud detection for return‑freight insurance, another introducing the adaptive GeniePath graph neural network, and a third describing a distributed collaborative hashing system for large‑scale recommendation—highlighting their methodologies, experimental results, and practical impact on Ant Financial’s services.
This article explains Python's hashlib module, demonstrates basic MD5 hashing, shows how to compute file checksums, and discusses secure password storage with salting techniques, providing complete code examples for each use case.
This article explores the evolution of indexing from classic hash tables and B‑Trees to learned index structures, explaining hash functions, collision handling, machine‑learning fundamentals, and the promise and limits of using ML models to improve memory efficiency and query performance.
This article explains how passwords should be encrypted during transmission using symmetric and asymmetric methods such as RSA, why HTTPS is essential, how services like GitHub and Baidu handle login security, and best practices for securely storing passwords with hashing, salting, and strong algorithms like BCrypt and PBKDF2.
Blockchain relies on three fundamental technologies—SHA‑256 hashing, public‑key cryptography, and proof‑of‑work consensus—each ensuring data integrity, secure identity verification, and decentralized block creation, with detailed examples illustrating hash collisions, transaction signing, and nonce‑driven mining challenges.
This article explains the default implementations of Java's Object.equals() and Object.hashCode(), the required contracts for overriding them, demonstrates their behavior in the String class, and provides practical guidelines and example code for correctly overriding these methods in custom classes.
This article examines common password‑storage techniques, explains why plain‑text, symmetric encryption, and simple hashes are insecure, and demonstrates how modern algorithms like PBKDF2, bcrypt, and scrypt, together with proper salting and iteration, can effectively protect user credentials against large‑scale cracking attacks.
This article explains MD5's fast but insecure hashing, demonstrates its use for file verification and password storage in Node.js, and shows how adding random salts dramatically improves password protection while also introducing MD5 collision concepts.
This article introduces Python's cryptographic capabilities, covering built‑in hashing with hashlib, key derivation with pbkdf2_hmac, and practical examples using third‑party libraries PyCryptodome and cryptography to perform MD5/SHA hashing, DES and RSA encryption/decryption, and secure file handling.
This article explains common user password storage methods, compares their security characteristics, and details various cracking approaches—including hash collisions, rainbow tables, and advanced algorithms like PBKDF2, bcrypt, and scrypt—while emphasizing the importance of strong encryption to mitigate data breach risks.
This article demystifies the common belief that cache‑plus‑hash alone solves high‑concurrency challenges, explores essential techniques such as static resource serving, read‑write separation, advanced caching, hash‑based sharding, and especially the design trade‑offs of various Trie‑based data structures for search‑suggestion services, and offers practical optimization steps.
All‑flash storage arrays increasingly rely on deduplication combined with compression to extend SSD lifespan, and this article explains the underlying block‑level workflow, hash‑based fingerprinting, and key implementation differences among vendors such as EMC Xtremio, Pure Storage, and HP 3PAR.
This article explains data deduplication technology, its definition, various classification schemes based on execution time, block size, granularity, and location, and compares it with data compression, highlighting how both techniques can be combined to maximize storage savings.
The article explains why storing plaintext passwords is insecure, describes one‑way hashing, the danger of rainbow tables, how salting and strong hash functions protect credentials, warns against multiple hashing, and outlines practical strategies—including HTTPS and server‑side salts—to secure user authentication.
MySQL’s Query Cache stores the results of SELECT statements by hashing the query, keeping the result set in memory, and invalidating cached entries whenever related tables change, allowing identical queries to be served instantly without re‑execution.
This article explores several under‑used yet useful Google Guava utilities—including unsigned primitive types, 128‑bit MurmurHash, InternetDomainName parsing, class‑path reflection, and CharMatcher string handling—providing code examples and explanations of how they can improve Java development efficiency.
This article examines common pitfalls in password storage—from storing plaintext or reversible encryption to basic hashing, salted hashing, and advanced key‑derivation functions—explaining why each approach can be vulnerable and recommending robust methods like PBKDF2, bcrypt, and scrypt.
