# hashing

Hashing is the process of applying a mathematical or cryptographic hash algorithm to data to produce a representative numeric value or hash digest.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Nix 2.35.0 released

DevFeed: [Nix 2.35.0 released](<https://devfeed.tech/articles/nix-2-35-0-released-31355.md>)

Original publisher: [Read original article](<https://discourse.nixos.org/t/nix-2-35-0-released/78914>)

Author: lisanna

Published: 2026-07-13T20:36:40Z

Content type: release

Language: en

Sources: [Announcements - NixOS Discourse](<https://devfeed.tech/sources/announcements-nixos-discourse.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [releases](<https://devfeed.tech/topics/releases.md>), [content addressed store](<https://devfeed.tech/topics/content-addressed-store.md>), [Security](<https://devfeed.tech/topics/security.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [integrity](<https://devfeed.tech/topics/integrity.md>)

Tags: [bugfixes](<https://devfeed.tech/tags/bugfixes.md>), [content-addressed-store](<https://devfeed.tech/tags/content-addressed-store.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [new-features](<https://devfeed.tech/tags/new-features.md>), [nix-releases](<https://devfeed.tech/tags/nix-releases.md>), [releases](<https://devfeed.tech/tags/releases.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

Nix 2.35.0 is released with new features, bug fixes, performance improvements, and a security fix for recursive-nix. A highlighted change makes source copying to the Nix store more lazy, reducing unnecessary work for typical flake evaluations while preserving the evaluator's existing behavior.

### Source excerpt

On behalf of the Nix team, I am pleased to finally announce the release of Nix 2.35.0. This release contains a good number of new features, bugfixes, and performance improvements, and is available at releases.nixos.org. This release also fixes a security issue with recursive-nix: https://github.com/NixOS/nix/security/advisories/GHSA-6h4g-g5j9-fm5f Release Notes Highlights Sources are copied to the store more lazily #3121 #15711 #15920 Historically, flakes source trees have been eagerly fetched to and evaluated from the Nix store to ensure deterministic and hermetic evaluation, even if the resulting store object is not used as a derivation input. This made the implementation simpler, yet made flakes unusable in large repositories and performed unnecessary writes to the store on each change to the source tree. Since Nix 2.32, all I/O (excluding path: and hg+:-style inputs) for reading sources during evaluation has been funneled to their original filesystem location (or to the ~/.cache/nix/tarball-cache-v2 bare git repository for tarball-based inputs). However, the source tree was still fetched to the store - primarily for computing the resulting content-addressed store path. In most cases, (such as importing the nixpkgs package set) this is not necessary. Touching (and hashing the NAR serialisation of) the whole source tree is unavoidable, since: In case of flake inputs, narHash integrity must be checked eagerly. The outPath attribute of a flake must be known in advance, and for backwards compatibility must be a content-addressed store path string with constant string context representing the flake source tree. Even within the constraints imposed by backwards compatibility requirements, there are several improvements that are achievable. To reduce the number of copies performed, Nix now hashes the input without copying first, assuming that the .outPath will not end up in a derivation attribute and thus would never have to be actually fetched to the store. This comes a

## Coding Challenge #120 - md5sum

DevFeed: [Coding Challenge #120 - md5sum](<https://devfeed.tech/articles/coding-challenge-120-md5sum-29196.md>)

Original publisher: [Read original article](<https://codingchallenges.substack.com/p/coding-challenge-120-md5sum>)

Author: John Crickett

Published: 2026-05-16T08:16:11Z

Content type: tutorial

Language: en

Sources: [Coding Challenges](<https://devfeed.tech/sources/coding-challenges.md>)

Topics: [Code Challenge](<https://devfeed.tech/topics/code-challenge.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [integrity](<https://devfeed.tech/topics/integrity.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [security](<https://devfeed.tech/tags/security.md>), [support](<https://devfeed.tech/tags/support.md>)

### AI overview

A coding challenge guides readers through building an md5sum command-line utility. One track uses a standard or third-party library for hashing, while another implements MD5 from scratch using RFC 1321, covering file handling, check mode, message padding, the Merkle-Damgård construction, and the compression function.

### Source excerpt

This challenge is to build your own md5sum.

## Understanding Gradient Noise with WebGL2 and GLSL

DevFeed: [Understanding Gradient Noise with WebGL2 and GLSL](<https://devfeed.tech/articles/sharing-everything-i-could-understand-about-gradient-noise-26116.md>)

Original publisher: [Read original article](<http://blog.pkh.me/p/42-sharing-everything-i-could-understand-about-gradient-noise.html>)

Published: 2025-06-06T14:45:38Z

Content type: tutorial

Language: en

Sources: [The Last Static Blog RSS](<https://devfeed.tech/sources/the-last-static-blog-rss.md>)

Topics: [glsl](<https://devfeed.tech/topics/glsl.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Code](<https://devfeed.tech/topics/code.md>), [hashing](<https://devfeed.tech/topics/hashing.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [function](<https://devfeed.tech/tags/function.md>), [glsl](<https://devfeed.tech/tags/glsl.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [math](<https://devfeed.tech/tags/math.md>), [performance](<https://devfeed.tech/tags/performance.md>), [procedural](<https://devfeed.tech/tags/procedural.md>), [prog](<https://devfeed.tech/tags/prog.md>)

### AI overview

This tutorial explains gradient noise, beginning with its one-dimensional form and progressing through higher dimensions and complexity. It uses a GPU-oriented approach with WebGL2 and GLSL, including deterministic coordinate-based pseudo-random values and hashing considerations.

### Source excerpt

You've most likely heard about gradient noise through the name Perlin noise, which refers to one particular implementation with various CPU optimizations. Because it's an incredible tool for creative work, it's used virtually everywhere: visual effects, video games, procedural mathematical art, etc. While getting it right can sometimes be subtle, a "broken" implementation can still look good or interesting. After all, "it looks fine, and I'm an artist". In order to gain a deeper and more meaningful understanding we will start studying the 1D version (a case often omitted in the literature), then slowly climb our way up in dimensions and complexity. We'll also work from a GPU perspective rather than a CPU-based one, hence all code snippets and visuals here are implemented in WebGL2/GLSL (hopefully without being too heavy on performance). They should run on most modern devices; let me know if you run into issues. Before we begin, credit where it's due: most of the material here are nothing new. This article is the result of weeks of studying and experimenting with the maths from Inigo Quilez's incredible pages and other scattered resources over the Internet. But as rich and valuable these resources are, they sometimes move quickly over the details, assuming they're obvious. This post is an attempt to fill those gaps. A welcoming wavy 1D gradient noise signal Hashing function and pseudo-random values At the most elementary level, we need a deterministic coordinate based pseudo-random system. More specifically, for any given integer coordinate we need a random value, and as uniformly distributed as possible. Something like: \begin{aligned} h(-3) &= -0.006124 \\ h(-2) &= -0.996686 \\ h(-1) &= 0.200864 \\ h(0) &= -1.000000 \\ h(1) &= 0.053313 \\ h(2) &= -0.893312 \\ h(3) &= 0.854923 \\ \text{...} \end{aligned} Perlin's implementation relies on a permutation table, which is convenient when working on the CPU, but more awkward for a shader. On the GPU, most people rely on v

## A Curious Case of Mistaken Identity: How Lambdas Break Data Class Hashing

DevFeed: [A Curious Case of Mistaken Identity: How Lambdas Break Data Class Hashing](<https://devfeed.tech/articles/a-curious-case-of-mistaken-identity-how-lambdas-break-data-class-hashing-27333.md>)

Original publisher: [Read original article](<https://blog.mmckenna.me/a-curious-case-of-mistaken-identity>)

Author: Matt McKenna

Published: 2024-11-14T21:44:31Z

Content type: tutorial

Language: en

Sources: [Matt McKenna](<https://devfeed.tech/sources/matt-mckenna.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [hash](<https://devfeed.tech/topics/hash.md>), [consistency](<https://devfeed.tech/topics/consistency.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [class](<https://devfeed.tech/tags/class.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [hashcode](<https://devfeed.tech/tags/hashcode.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>)

### AI overview

This Kotlin article explains why data class instances containing lambdas may compare as unequal and produce different hash-based behavior. Each lambda instance has a distinct identity, so the article recommends excluding the callback from equality and hashCode calculations, while noting the resulting maintenance cost.

### Source excerpt

Introduction: The Scene of the Crime It was a dark and stormy night. My hands were flying across the keys when suddenly the codebase began to exhibit strange behavior. Hashes, which once returned the same values for identical objects, suddenly became...

## Comparison between Redis and DragonflyDB's data stores

DevFeed: [Comparison between Redis and DragonflyDB's data stores](<https://devfeed.tech/articles/comparison-between-redis-and-dragonflydb-s-data-stores-39629.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2024-08-27_Comparison-between-Redis-and-DragonflyDB-s-data-stores-e9ecba1ef84c>)

Published: 2024-08-27T00:00:00Z

Content type: article

Language: en

Sources: [Gaurav Sarma's Blog](<https://devfeed.tech/sources/gaurav-sarma-s-blog.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [data](<https://devfeed.tech/topics/data.md>), [hashing](<https://devfeed.tech/topics/hashing.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clustering](<https://devfeed.tech/tags/clustering.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [hash](<https://devfeed.tech/tags/hash.md>), [memory](<https://devfeed.tech/tags/memory.md>), [redis](<https://devfeed.tech/tags/redis.md>), [single-threaded](<https://devfeed.tech/tags/single-threaded.md>), [vs](<https://devfeed.tech/tags/vs.md>)

### AI overview

This article compares how Redis and DragonflyDB store data in memory. It explains Redis's single-threaded architecture and DragonflyDB's multithreaded, shared-nothing design, then introduces separate chaining, open addressing, and extendible hashing.

### Source excerpt

. [Redis vs DragonflyDB Data Store Comparison](redis-vs-dragonflydbs-data-stores-cover...

## Optimising Stripped Locks using Golang arrays

DevFeed: [Optimising Stripped Locks using Golang arrays](<https://devfeed.tech/articles/optimising-stripped-locks-using-golang-arrays-39628.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2024-08-14_Optimising-Stripped-Locks-using-Golang-arrays-34b45ef4e975>)

Published: 2024-08-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [Gaurav Sarma's Blog](<https://devfeed.tech/sources/gaurav-sarma-s-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [hashing](<https://devfeed.tech/topics/hashing.md>)

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [golang](<https://devfeed.tech/tags/golang.md>)

### AI overview

This tutorial explains replacing a global datastore lock with striped locks mapped to buckets by hashing keys. It outlines the bucket and locking approach and begins a benchmark comparing Go maps and arrays for key-fetch performance at different sizes.

### Source excerpt

. [Optimising Striped Locks with Go Arrays](optimising-stripped-locks-using-golang-arrays-cover...

## A case for password hashing with delegation

DevFeed: [A case for password hashing with delegation](<https://devfeed.tech/articles/a-case-for-password-hashing-with-delegation-29179.md>)

Original publisher: [Read original article](<https://www.latacora.com/blog/2023/12/22/case-for-password-hashing/>)

Published: 2023-12-22T15:18:16Z

Content type: article

Language: en

Sources: [Latacora](<https://devfeed.tech/sources/latacora.md>)

Topics: [passwords](<https://devfeed.tech/topics/passwords.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [Security](<https://devfeed.tech/topics/security.md>), [Encryption](<https://devfeed.tech/topics/encryption.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>)

Tags: [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [password](<https://devfeed.tech/tags/password.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This article explains password-based key derivation functions and examines delegated password hashing, in which computation is offloaded to an untrusted server. It discusses how delegation could increase the work factor for systems constrained by weaker devices, with particular attention to encryption-key derivation in end-to-end encrypted backup systems.

### Source excerpt

When people talk about PBKDFs (Password Based Key Derivation Functions), this is usually either in the context of secure password storage, or in the context of how to derive cryptographic keys from potentially low-entropy passwords. The Password Hashing Competition (PHC, 2013-2015) was an open competition to derive new password hashing algorithms, resulting in Argon2 hash as its winner. Apart from achieving general hash security, many of the candidates focused on achieving resistance to parallel attacks on available hardware such as GPUs.

## Consistent hashing algorithm

DevFeed: [Consistent hashing algorithm](<https://devfeed.tech/articles/consistent-hashing-algorithm-27905.md>)

Original publisher: [Read original article](<http://highscalability.com/blog/2023/2/22/consistent-hashing-algorithm.html>)

Author: NK

Published: 2023-02-22T16:39:15Z

Content type: tutorial

Language: en

Sources: [High Scalability](<https://devfeed.tech/sources/high-scalability.md>), [High Scalability](<https://devfeed.tech/sources/high-scalability-2.md>)

Topics: [hashing](<https://devfeed.tech/topics/hashing.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Software](<https://devfeed.tech/topics/software.md>), [Availability](<https://devfeed.tech/topics/availability.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [availability](<https://devfeed.tech/tags/availability.md>), [cache](<https://devfeed.tech/tags/cache.md>), [consistent-hashing](<https://devfeed.tech/tags/consistent-hashing.md>), [distributed-system](<https://devfeed.tech/tags/distributed-system.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [hotspot](<https://devfeed.tech/tags/hotspot.md>), [load-balancing](<https://devfeed.tech/tags/load-balancing.md>), [low-latency](<https://devfeed.tech/tags/low-latency.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [sharding](<https://devfeed.tech/tags/sharding.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

A tutorial explaining consistent hashing: nodes and data keys are mapped onto a virtual hash ring, and clockwise traversal assigns data to nodes. It discusses terminology, cache-server scaling requirements, hotspot reduction, dynamic load, replication, availability, and latency.

### Source excerpt

This is a guest article by NK. You can view the original article Consistent hashing explained on systemdesign.one website. How does consistent hashing work? At a high level, consistent hashing performs the following operations: The output of the hash function is placed on a virtual ring structure (known as the hash ring) The hashed IP addresses of the nodes are used to assign a position for the nodes on the hash ring The key of a data object is hashed using the same hash function to find the position of the key on the hash ring The hash ring is traversed in the clockwise direction starting from the position of the key until a node is found The data object is stored or retrieved from the node that was found Terminology

## 7 Best Practices for Certificate-Based Authentication

DevFeed: [7 Best Practices for Certificate-Based Authentication](<https://devfeed.tech/articles/7-best-practices-for-certificate-based-authentication-29600.md>)

Original publisher: [Read original article](<https://goteleport.com/blog/certificate-authentication-best-practices/>)

Author: sakshyam.shah@goteleport.com (Sakshyam Shah)

Published: 2022-06-15T00:00:00Z

Content type: tutorial

Language: en

Sources: [Teleport](<https://devfeed.tech/sources/teleport.md>)

Topics: [Authentication](<https://devfeed.tech/topics/authentication.md>), [certificates](<https://devfeed.tech/topics/certificates.md>), [Security](<https://devfeed.tech/topics/security.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [hashing](<https://devfeed.tech/topics/hashing.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [certificates](<https://devfeed.tech/tags/certificates.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [hash](<https://devfeed.tech/tags/hash.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [openssl](<https://devfeed.tech/tags/openssl.md>), [security](<https://devfeed.tech/tags/security.md>), [security-best-practices](<https://devfeed.tech/tags/security-best-practices.md>)

### AI overview

This article explains certificate-based authentication security best practices for developers and administrators, with a focus on infrastructure access. It discusses risks including forged certificates, stolen-certificate reuse, compromised certificate authorities, weak verification, and hash collisions, and recommends established cryptographic algorithms, modules, and libraries.

### Source excerpt

We explain security best practices for both developers and administrators of certificate-based authentication, focusing on infrastructure access.

## Group Actions and Hashing Unordered Multisets

DevFeed: [Group Actions and Hashing Unordered Multisets](<https://devfeed.tech/articles/group-actions-and-hashing-unordered-multisets-40449.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2021/10/14/group-actions-and-hashing-unordered-multisets/>)

Published: 2021-10-14T08:00:00Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [hashing](<https://devfeed.tech/topics/hashing.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [abelian-groups](<https://devfeed.tech/tags/abelian-groups.md>), [group-actions](<https://devfeed.tech/tags/group-actions.md>), [group-theory](<https://devfeed.tech/tags/group-theory.md>), [groups](<https://devfeed.tech/tags/groups.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [multiset](<https://devfeed.tech/tags/multiset.md>), [multisets](<https://devfeed.tech/tags/multisets.md>), [practical](<https://devfeed.tech/tags/practical.md>), [programming](<https://devfeed.tech/tags/programming.md>), [xor](<https://devfeed.tech/tags/xor.md>)

### AI overview

The article introduces a result by Kevin Ventullo that applies group actions to hash functions for unordered sets and multisets. It explains why incremental, order-independent hashing is useful and describes collision-related weaknesses of addition and XOR approaches.

### Source excerpt

I learned of a neat result due to Kevin Ventullo that uses group actions to study the structure of hash functions for unordered sets and multisets. This piqued my interest because a while back a colleague asked me if I could think of any applications of "pure" group theory to practical computer programming that were not cryptographic in nature. He meant, not including rings, fields, or vector spaces whose definitions happen to be groups when you forget the extra structure.

## Searching for RH Counterexamples -- Scaling Up

DevFeed: [Searching for RH Counterexamples -- Scaling Up](<https://devfeed.tech/articles/searching-for-rh-counterexamples-scaling-up-40444.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2021/02/16/searching-for-rh-counterexamples-scaling-up/>)

Published: 2021-02-16T09:00:00Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [scaling](<https://devfeed.tech/topics/scaling.md>), [sha256](<https://devfeed.tech/topics/sha256.md>), [hash](<https://devfeed.tech/topics/hash.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [disk-space](<https://devfeed.tech/tags/disk-space.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [programming](<https://devfeed.tech/tags/programming.md>), [refactor](<https://devfeed.tech/tags/refactor.md>), [riemann-hypothesis](<https://devfeed.tech/tags/riemann-hypothesis.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [sha256](<https://devfeed.tech/tags/sha256.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

This article describes scaling a search for counterexamples to the Riemann Hypothesis. It focuses on reducing storage by keeping deterministic SHA-256 summaries instead of every witness value and refactoring the application into a worker architecture.

### Source excerpt

We're ironically searching for counterexamples to the Riemann Hypothesis. Setting up Pytest Adding a Database Search Strategies Unbounded integers Deploying with Docker Performance Profiling Last time we made the audacious choice to remove primary keys from the RiemannDivisorSums table for performance reasons. To help with that, we will do two things in this post Reduce the storage footprint of the whole application (it was 60 GiB when it crashed, and we got up to 84 prime factors).

## ReactOS Website Migrated to New Login System and Upgraded Components

DevFeed: [ReactOS Website Migrated to New Login System and Upgraded Components](<https://devfeed.tech/articles/website-upgraded-33256.md>)

Original publisher: [Read original article](<https://reactos.org/project-news/website-upgraded/>)

Published: 2018-07-04T00:00:00Z

Content type: release

Language: en

Sources: [Front Page on ReactOS Website](<https://devfeed.tech/sources/front-page-on-reactos-website.md>)

Topics: [ReactOS](<https://devfeed.tech/topics/reactos.md>), [Website](<https://devfeed.tech/topics/website.md>), [passwords](<https://devfeed.tech/topics/passwords.md>), [Database](<https://devfeed.tech/topics/database.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [Credential theft](<https://devfeed.tech/topics/credential-theft.md>), [jira](<https://devfeed.tech/topics/jira.md>)

Tags: [account](<https://devfeed.tech/tags/account.md>), [change](<https://devfeed.tech/tags/change.md>), [credential-theft](<https://devfeed.tech/tags/credential-theft.md>), [database](<https://devfeed.tech/tags/database.md>), [free](<https://devfeed.tech/tags/free.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [jira](<https://devfeed.tech/tags/jira.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [os](<https://devfeed.tech/tags/os.md>), [password](<https://devfeed.tech/tags/password.md>), [react](<https://devfeed.tech/tags/react.md>), [reactos](<https://devfeed.tech/tags/reactos.md>), [service](<https://devfeed.tech/tags/service.md>), [website](<https://devfeed.tech/tags/website.md>), [win32](<https://devfeed.tech/tags/win32.md>), [winapi](<https://devfeed.tech/tags/winapi.md>)

### AI overview

The ReactOS Website was migrated to a new login system, its components were upgraded, and its user database was moved and cleaned of unused accounts. The article advises users to change their passwords and notes that some newer accounts may require a password reset.

### Source excerpt

Today, the ReactOS Website has been migrated to a new Login system and all components have been upgraded to their latest versions. In the course of that, the user database has also been moved and cleaned from accounts that have never been used. Such large migrations hardly go without issues, so if you notice anything wrong, please report a bug in our JIRA bugtracker. You are also advised to change your password in the Self-Service, even if it's just to the same one.

## The False Allure of Hashing for Anonymization

DevFeed: [The False Allure of Hashing for Anonymization](<https://devfeed.tech/articles/the-false-allure-of-hashing-for-anonymization-29671.md>)

Original publisher: [Read original article](<https://goteleport.com/blog/hashing-for-anonymization/>)

Author: info@goteleport.com (Kevin Nisbet)

Published: 2018-04-30T00:00:00Z

Content type: article

Language: en

Sources: [Teleport](<https://devfeed.tech/sources/teleport.md>)

Topics: [hashing](<https://devfeed.tech/topics/hashing.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Security, Privacy and Abuse Prevention](<https://devfeed.tech/topics/security-privacy-and-abuse-prevention.md>), [data](<https://devfeed.tech/topics/data.md>), [sha256](<https://devfeed.tech/topics/sha256.md>)

Tags: [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [data](<https://devfeed.tech/tags/data.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [sha256](<https://devfeed.tech/tags/sha256.md>)

### AI overview

The article explains why cryptographic hashing, including SHA-256, does not by itself make personal data anonymous. Hashes of predictable values such as usernames and email addresses can be tested against guesses and identified.

### Source excerpt

Why using cryptographic hashes doesn't make data anonymous.

## Hashing to Estimate the Size of a Stream

DevFeed: [Hashing to Estimate the Size of a Stream](<https://devfeed.tech/articles/hashing-to-estimate-the-size-of-a-stream-40394.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2016/01/04/hashing-to-estimate-the-size-of-a-stream/>)

Published: 2016-01-04T09:00:37Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [hashing](<https://devfeed.tech/topics/hashing.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [data](<https://devfeed.tech/topics/data.md>), [Python](<https://devfeed.tech/topics/python.md>), [parallel](<https://devfeed.tech/topics/parallel.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [approximation-algorithms](<https://devfeed.tech/tags/approximation-algorithms.md>), [data](<https://devfeed.tech/tags/data.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [sublinear-algorithms](<https://devfeed.tech/tags/sublinear-algorithms.md>)

### AI overview

This article explains how random hash functions can estimate the number of distinct items in a data stream that is too large to fit in memory. It presents a Python implementation using minimum hash values and parallel hashes to reduce variance, and states approximation guarantees for the estimate.

### Source excerpt

Problem: Estimate the number of distinct items in a data stream that is too large to fit in memory. Solution: (in python) import random def randomHash(modulus): a, b = random.randint(0,modulus-1), random.randint(0,modulus-1) def f(x): return (a*x + b) % modulus return f def average(L): return sum(L) / len(L) def numDistinctElements(stream, numParallelHashes=10): modulus = 2**20 hashes = [randomHash(modulus) for _ in range(numParallelHashes)] minima = [modulus] * numParallelHashes currentEstimate = 0 for i in stream: hashValues = [h(i) for h in hashes] for i, newValue in enumerate(hashValues): if newValue < minima[i]: minima[i] = newValue currentEstimate = modulus / average(minima) yield currentEstimate Discussion: The technique used here is to use random hash functions.

## Password Authentication/Authorization for Clojure

DevFeed: [Password Authentication/Authorization for Clojure](<https://devfeed.tech/articles/password-authentication-authorization-for-clojure-32097.md>)

Original publisher: [Read original article](<https://adambard.com/blog/buddy-password-auth-example/>)

Published: 2015-12-17T00:00:00Z

Content type: tutorial

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [passwords](<https://devfeed.tech/topics/passwords.md>), [Authorization](<https://devfeed.tech/topics/authorization.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [database](<https://devfeed.tech/tags/database.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [password](<https://devfeed.tech/tags/password.md>)

### AI overview

A tutorial showing how to add session-based password authentication to a Clojure application using the Buddy authentication library. It uses an in-memory store for user data and demonstrates password hashing, login, logout, and middleware-related session handling.

### Source excerpt

In my previous post, I gave a quick overview of how the Buddy auth library for Clojure. Today, I'll give a more fleshed-out example of how to use it to add session-based password authentication to an app.

## Counting hash collisions with the birthday paradox

DevFeed: [Counting hash collisions with the birthday paradox](<https://devfeed.tech/articles/counting-hash-collisions-with-the-birthday-paradox-35234.md>)

Original publisher: [Read original article](<http://matt.might.net/articles/counting-hash-collisions/>)

Published: 2015-07-17T03:33:41Z

Content type: tutorial

Language: en

Sources: [Matt Might](<https://devfeed.tech/sources/matt-might.md>)

Topics: [hash](<https://devfeed.tech/topics/hash.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [function](<https://devfeed.tech/topics/function.md>), [Network](<https://devfeed.tech/topics/network.md>)

Tags: [hash](<https://devfeed.tech/tags/hash.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [technical](<https://devfeed.tech/tags/technical.md>)

### AI overview

This technical note derives a closed-form formula for the expected number of hash collisions among n values when a uniform hash function has a range of D possible outputs. It explains the connection to the birthday paradox and clarifies that the formula counts sequential matching events rather than unique hits or collision pairings.

### Source excerpt

The birthday paradox observes that in a room of 23 people, the odds that at least two people share a birthday is 50% The same logic that drives matching birthdays also drives the probability that one can find collisions with a hash function. In other words, if you have a uniform hashing function that outputs a value between 1 and 365 for any input, the probability that two hashes would collide in a set of 23 values is also 50% Another useful calculation is the expected number of collisions for a sequence of \(n\) values when the range of the hash function contains \(D\) hashes. The closed form solution is: \[ n - D + D \left( \frac{D-1}{D} \right)^n \] There are a few places online that have this (or an equivalent) closed form solution listed, but I couldn't find anywhere that included the derivation of this form, so I've rederived it and posted it here as a technical note. (My present interest in this calculation comes from the number of matches that will happen in a patient-matching network that attempts to match patients having the same disease, assuming the are \(D\) total diseases possible and \(n\) patients in the network.) Read below for the derivation in terms of generalized birthdays. Click here to read the rest of the article

## 3 Wrong Ways to Store a Password

DevFeed: [3 Wrong Ways to Store a Password](<https://devfeed.tech/articles/3-wrong-ways-to-store-a-password-32089.md>)

Original publisher: [Read original article](<https://adambard.com/blog/3-wrong-ways-to-store-a-password/>)

Published: 2013-07-11T00:00:00Z

Content type: tutorial

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [passwords](<https://devfeed.tech/topics/passwords.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [hashing](<https://devfeed.tech/topics/hashing.md>), [PHP](<https://devfeed.tech/topics/php.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [database](<https://devfeed.tech/tags/database.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [password](<https://devfeed.tech/tags/password.md>), [passwords](<https://devfeed.tech/tags/passwords.md>), [php](<https://devfeed.tech/tags/php.md>), [salt](<https://devfeed.tech/tags/salt.md>), [sha256](<https://devfeed.tech/tags/sha256.md>), [web-development](<https://devfeed.tech/tags/web-development.md>)

### AI overview

This tutorial explains common unsafe password-storage approaches, including plaintext storage, unsalted hashing, and fast hashing with a salt. It describes how database compromise, dictionary attacks, and rainbow tables can expose passwords, and introduces safer password-storage practices without fully detailing them in the supplied excerpts.

### Source excerpt

Sooner or later, in the field of Web Development, you're going to need to store someone's password. This is easy to get wrong, but easy to get right, too. Today, let's take a tour of the wrong ways, and then find out how to do it the (current) right way. Plaintext Alice just learned PHP, and are making an app with user authentication. Her database stores an email and password in a table called users.