# data structure

Published articles for data structure.

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

## OpenVDB Introduces SIMD Framework With Some 2~4x Performance Improvements

DevFeed: [OpenVDB Introduces SIMD Framework With Some 2~4x Performance Improvements](<https://devfeed.tech/articles/openvdb-introduces-simd-framework-with-some-2-4x-performance-improvements-31411.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/OpenVDB-SIMD--Framework>)

Author: Michael Larabel

Published: 2026-09-16T10:05:23Z

Content type: news

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [x86](<https://devfeed.tech/topics/x86.md>), [releases](<https://devfeed.tech/topics/releases.md>), [cudnn](<https://devfeed.tech/topics/cudnn.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [avx](<https://devfeed.tech/tags/avx.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [data](<https://devfeed.tech/tags/data.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [github](<https://devfeed.tech/tags/github.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [performance](<https://devfeed.tech/tags/performance.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [release](<https://devfeed.tech/tags/release.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

OpenVDB 13.1 introduces a SIMD framework using Agner Fog's VectorClass Library for explicit x86 vectorization up to AVX-512. Adapted point transfer algorithms reportedly achieve 2x to 4x performance improvements on modern AVX-512 x86_64 CPUs. The release also includes NanoVDB CUDA resource-management and kernel improvements, plus updates to vdb_tool.

### Source excerpt

OpenVDB is the sparse volume data structure and tooling library maintained by the Academy Software Foundation. OpenVDB in turn is used by various CGI software for dealing with sparse volumetric data such as Houdini, RenderMan, and Cinema 4D to the open-source Blender. It's even won an Academy Award for technical achievement while now in 2026 it's finally establishing a SIMD framework for better leveraging modern x86 ISA capabilities...

## Python sets and dictionaries can have quadratic-time performance

DevFeed: [Python sets and dictionaries can have quadratic-time performance](<https://devfeed.tech/articles/python-sets-and-dictionaries-can-have-quadratic-time-performance-29426.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/09/03/python-sets-and-dictionaries-can-have-quadratic-time-performance/>)

Author: Daniel Lemire

Published: 2026-09-03T14:01:45Z

Content type: article

Language: en

Sources: [Daniel Lemire](<https://devfeed.tech/sources/daniel-lemire.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [hash](<https://devfeed.tech/topics/hash.md>), [CPU Cache](<https://devfeed.tech/topics/cpu-cache.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [cpu-cache](<https://devfeed.tech/tags/cpu-cache.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [hash](<https://devfeed.tech/tags/hash.md>), [performance](<https://devfeed.tech/tags/performance.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

The article explains why Python sets and dictionaries are not formally constant-time in all cases. Hash collisions can make insertions and membership checks take quadratic time, while growing data structures can also incur reallocation and slower memory access as they exceed CPU cache capacity.

### Source excerpt

In Python, the dict data structure is the conventional key-value structure. E.g., you might store a list of names as keys and have their phone numbers as values. Valentin Ignatev wrote this amusing post on X: It is indeed widely believed that, in the strict sense, the dict data structure and its companion, the set ... Continue reading Python sets and dictionaries can have quadratic-time performance

## 8 Redis Use Cases Engineers Should Know

DevFeed: [8 Redis Use Cases Engineers Should Know](<https://devfeed.tech/articles/8-redis-use-cases-engineers-should-know-18036.md>)

Original publisher: [Read original article](<https://blog.levelupcoding.com/p/redis-use-cases-engineers-should-know>)

Author: Nikki Siapno

Published: 2026-09-01T12:54:52Z

Content type: tutorial

Language: en

Sources: [Level Up Coding System Design Newsletter](<https://devfeed.tech/sources/level-up-coding-system-design-newsletter.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Server](<https://devfeed.tech/topics/server.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [caching](<https://devfeed.tech/tags/caching.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [redis](<https://devfeed.tech/tags/redis.md>), [server](<https://devfeed.tech/tags/server.md>), [use-cases](<https://devfeed.tech/tags/use-cases.md>)

### AI overview

This article explains that Redis is more than a caching system. It describes how Redis data structures support real-time application patterns such as counters, sessions, queues, leaderboards, rate limiting, coordination, event logs, notifications, and expiring state.

### Source excerpt

Most engineers know Redis for caching. But that's only the beginning...

## Go 1.27 will make some allocations cheaper

DevFeed: [Go 1.27 will make some allocations cheaper](<https://devfeed.tech/articles/go-1-27-will-make-some-allocations-cheaper-29422.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/08/15/go-1-27-will-make-some-allocations-cheaper/>)

Author: Daniel Lemire

Published: 2026-08-15T20:59:19Z

Content type: article

Language: en

Sources: [Daniel Lemire](<https://devfeed.tech/sources/daniel-lemire.md>)

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

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [go](<https://devfeed.tech/tags/go.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>)

### AI overview

The article explains Go's stack and heap allocations, including how escaping values, slices, and dynamic data structures can cause heap allocations. It notes that Go 1.27 is intended to make some heap allocations cheaper, while the supplied excerpt does not specify the implementation details.

### Source excerpt

Like most programming languages, Go has both stack allocations, whose lifetime is limited to the current function, and dynamic (or heap) allocations. The name stack comes from the fact that the memory management is somewhat trivial. There is typically one stack per thread (or goroutine in Go). When a function needs memory, it simply appends ... Continue reading Go 1.27 will make some allocations cheaper

## Keleusma Research Spike: What It Costs to Compile a Data Structure Whose Shape Is Already Decided

DevFeed: [Keleusma Research Spike: What It Costs to Compile a Data Structure Whose Shape Is Already Decided](<https://devfeed.tech/articles/keleusma-research-spike-what-it-costs-to-compile-a-data-structure-whose-shape-is-already-decided-39755.md>)

Original publisher: [Read original article](<https://sgeos.github.io/engineering/compilers/verification/2026/08/09/cost_of_compiling_aggregates.html>)

Author: Brendan Sechter

Published: 2026-08-09T09:00:00Z

Content type: article

Language: en

Sources: [Brendan A R Sechter's Development Blog](<https://devfeed.tech/sources/brendan-a-r-sechter-s-development-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>)

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [research](<https://devfeed.tech/tags/research.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

This case study examines the cost of compiling aggregate data types in the Keleusma compiler backend. Measurements of 331 aggregate operations found that most reduce to constant offsets and typed loads, challenging an estimate based on the feature's general name rather than its actual instances.

### Source excerpt

The largest remaining item in a compiler backend was estimated at a quarter's work. Measured, it is pointer arithmetic over compile-time constants, and two of the three representation forms it was supposed to need account for two operations in the entire corpus. The item is aggregate data types, meaning structs, tuples, arrays and enumerations. It blocks 34.5 percent of the corpus, more than every other unimplemented feature combined, and it had never been scoped because everyone knew it was large. Everyone was reasoning from the wrong artefact. Aggregates are large in a compiler that must decide their layout. This compiler decided it already, in an earlier pass, and bakes the answer into the instruction stream. What reaches the backend is not a type system. It is a byte offset and a scalar kind. The measurement that establishes this took twenty minutes to write and two and a half seconds to run. It reports that of 331 aggregate operations in the corpus, 300 are a constant offset and a typed load, 2 need anything resembling a value representation, and 0 use the general mechanism the instruction set still carries. This article reports that, and reports why the author's own recommendation to run it deserves more scepticism than the result. What this is a case study of The setting is compiler backend scoping and the project is Keleusma, whose backend is described in the first, second and third articles of this series. No compiler background is required. The general shape is estimating the cost of a feature from its name rather than from its instances. "Aggregate data types" names something with a large literature, a hard general case, and a well-known set of representation decisions. None of that is evidence about the work in front of you, and the gap between the category and the instance is where the estimate went wrong. The transferable question is what remains once a decision has already been made upstream. The answer is often mechanical, and the mechanical residue

## How fast is C++26's std::hive?

DevFeed: [How fast is C++26's std::hive?](<https://devfeed.tech/articles/how-fast-is-c-26-s-std-hive-29419.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/08/02/how-fast-is-c26s-stdhive/>)

Author: Daniel Lemire

Published: 2026-08-02T17:00:10Z

Content type: article

Language: en

Sources: [Daniel Lemire](<https://devfeed.tech/sources/daniel-lemire.md>)

Topics: [container](<https://devfeed.tech/topics/container.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [intel](<https://devfeed.tech/topics/intel.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [container](<https://devfeed.tech/tags/container.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [intel](<https://devfeed.tech/tags/intel.md>), [processor](<https://devfeed.tech/tags/processor.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

The article benchmarks a C++26 std::hive implementation against vector, list, and another container. In the reported tests, hive insertion costs about twice as much as vector insertion, while iteration is about eight times slower than vector and no faster than linked-list iteration.

### Source excerpt

C++26 adds a new container to the standard library: std::hive. It is meant to occupy the ground between std::vector and std::list. Like a vector, it keeps its elements in contiguous blocks of memory, so scanning it does not require you to chase a pointer for every element. Like a list, it never moves an element ... Continue reading How fast is C++26's std::hive?

## How much do amd64 microarchitecture levels help in Go?

DevFeed: [How much do amd64 microarchitecture levels help in Go?](<https://devfeed.tech/articles/how-much-do-amd64-microarchitecture-levels-help-in-go-29410.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/06/06/how-much-do-amd64-microarchitecture-levels-help-in-go/>)

Author: Daniel Lemire

Published: 2026-06-06T20:25:19Z

Content type: article

Language: en

Sources: [Daniel Lemire](<https://devfeed.tech/sources/daniel-lemire.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [intel](<https://devfeed.tech/topics/intel.md>)

Tags: [avx](<https://devfeed.tech/tags/avx.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [go](<https://devfeed.tech/tags/go.md>), [intel](<https://devfeed.tech/tags/intel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>)

### AI overview

This article examines how amd64 microarchitecture levels affect Go program performance. It explains the instruction-set levels and reports a benchmark methodology using the Roaring Bitmaps library on an Intel Xeon Gold 6548N with Go 1.26.2 and Roaring v2.18.2. The supplied text does not include the benchmark results.

### Source excerpt

Our 64-bit Intel and AMD processors have evolved over decades. When you compile a Go program for a 64-bit Intel or AMD processor, the compiler targets, by default, a nearly 20-year-old instruction set. The binary that comes out runs on essentially any x64 chip, but it also leaves on the table every instruction that was ... Continue reading How much do amd64 microarchitecture levels help in Go?

## The importance of benchmarks

DevFeed: [The importance of benchmarks](<https://devfeed.tech/articles/the-importance-of-benchmarks-33535.md>)

Original publisher: [Read original article](<https://www.aha.io/engineering/articles/the-importance-of-benchmarks>)

Published: 2026-04-13T00:00:00Z

Content type: article

Language: en

Sources: [Aha! Engineering Blog](<https://devfeed.tech/sources/aha-engineering-blog.md>)

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [performance](<https://devfeed.tech/tags/performance.md>), [structure](<https://devfeed.tech/tags/structure.md>)

### AI overview

The Aha! Develop team investigated a sprint report that took 15 minutes to load and nearly froze the browser. The investigation traced the problem to inefficient progress parsing and data structures that duplicated days without events, producing a more than 100-fold performance increase after changes.

### Source excerpt

Late last year, the Aha! Develop team added support for team line-level reporting. During a team demo in the run-up to the release, we discovered one of our internal sprint reports was taking 15 minutes to load, almost freezing the browser in the p

## CPU Caches and Spatial Locality: Why an Array is 3x Faster Than a Linked List for the Exact Same Big-O Complexity

DevFeed: [CPU Caches and Spatial Locality: Why an Array is 3x Faster Than a Linked List for the Exact Same Big-O Complexity](<https://devfeed.tech/articles/cpu-caches-and-spatial-locality-why-an-array-is-3x-faster-than-a-linked-list-for-the-exact-same-big-o-complexity-39570.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/18-cpu-caches-spatial-locality/>)

Author: hello@ankit-rana.com

Published: 2026-03-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [cpu](<https://devfeed.tech/topics/cpu.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>)

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpu-caches](<https://devfeed.tech/tags/cpu-caches.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [memory-hierarchy](<https://devfeed.tech/tags/memory-hierarchy.md>), [performance](<https://devfeed.tech/tags/performance.md>), [spatial-locality](<https://devfeed.tech/tags/spatial-locality.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This article explains why arrays can outperform linked lists despite both having O(N) traversal complexity. Sequential array access benefits from cache lines, spatial locality, and hardware prefetching, while scattered linked-list nodes cause pointer chasing and more cache misses. The supplied summary reports an approximate threefold performance difference.

### Source excerpt

Arrays and linked lists are both O(N) to traverse, but an array can run about three times faster because CPUs fetch 64-byte cache lines, not individual values. Sequential array access turns the next several iterations into cache hits at roughly 1 ns and lets the hardware prefetcher work ahead. Linked list nodes scattered across the heap defeat the prefetcher, so each dereference risks a 100 ns trip to RAM.

## SQLite Overflow Pages - When Your Rows Don't Fit

DevFeed: [SQLite Overflow Pages - When Your Rows Don't Fit](<https://devfeed.tech/articles/sqlite-overflow-pages-when-your-rows-don-t-fit-39648.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2026-03-06_sqlite-overflow-pages>)

Published: 2026-03-06T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>)

Tags: [b-tree](<https://devfeed.tech/tags/b-tree.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [database](<https://devfeed.tech/tags/database.md>), [performance](<https://devfeed.tech/tags/performance.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>)

### AI overview

This tutorial explains how SQLite stores rows in fixed-size pages and uses overflow-page chains when a row does not fit within a single page. It describes how those chains are reconstructed during reads and why large rows can significantly increase query costs.

### Source excerpt

. [SQLite Overflow Pages](sqlite-overflow-pages-cover...

## Weak AVL Tree

DevFeed: [Weak AVL Tree](<https://devfeed.tech/articles/weak-avl-tree-31118.md>)

Original publisher: [Read original article](<https://maskray.me/blog/2025-12-14-weak-avl-tree>)

Published: 2025-12-14T08:00:00Z

Content type: tutorial

Language: en

Sources: [MaskRay](<https://devfeed.tech/sources/maskray.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [root](<https://devfeed.tech/tags/root.md>), [rotation](<https://devfeed.tech/tags/rotation.md>), [rules](<https://devfeed.tech/tags/rules.md>)

### AI overview

This article introduces weak AVL trees as a rank-based balanced binary search tree and compares their balancing behavior with AVL and red-black trees. It describes rank differences, insertion cases, rotation bounds, and an implementation detail for encoding ranks, while noting that deletion is not yet described.

### Source excerpt

tl;dr: Weak AVL trees are replacements for AVL trees and red-black trees. The 2014 paper

## Volume Grids in Geometry Nodes

DevFeed: [Volume Grids in Geometry Nodes](<https://devfeed.tech/articles/volume-grids-in-geometry-nodes-19182.md>)

Original publisher: [Read original article](<https://code.blender.org/2025/10/volume-grids-in-geometry-nodes/>)

Author: Hans Goudey

Published: 2025-10-07T20:29:49Z

Content type: release

Language: en

Sources: [Blender](<https://devfeed.tech/sources/blender.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Library](<https://devfeed.tech/topics/library.md>), [signed distance functions](<https://devfeed.tech/topics/signed-distance-functions.md>)

Tags: [3d](<https://devfeed.tech/tags/3d.md>), [blender](<https://devfeed.tech/tags/blender.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [general-development](<https://devfeed.tech/tags/general-development.md>), [geometry-nodes](<https://devfeed.tech/tags/geometry-nodes.md>), [library](<https://devfeed.tech/tags/library.md>), [sdf](<https://devfeed.tech/tags/sdf.md>), [volume](<https://devfeed.tech/tags/volume.md>)

### AI overview

Blender 5.0 expands Geometry Nodes support for volumetric data with a new volume grid data type. Grids can store float, vector, and other primitive values, be modified with math nodes, and be viewed or attached to geometry.

### Source excerpt

In Blender 5.0, Geometry Nodes support for volumetric data will be significantly better.

## Vector Sets are part of Redis

DevFeed: [Vector Sets are part of Redis](<https://devfeed.tech/articles/vector-sets-are-part-of-redis-20640.md>)

Original publisher: [Read original article](<http://antirez.com/news/149>)

Published: 2025-04-03T18:01:20Z

Content type: article

Language: en

Sources: [Antirez](<https://devfeed.tech/sources/antirez.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [API](<https://devfeed.tech/topics/api.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [design](<https://devfeed.tech/tags/design.md>), [modularity](<https://devfeed.tech/tags/modularity.md>), [module](<https://devfeed.tech/tags/module.md>), [native](<https://devfeed.tech/tags/native.md>), [redis](<https://devfeed.tech/tags/redis.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

The article announces that Vector Sets have been merged into Redis. It describes them as a new Set-like data type that stores vectors, supports vector-similarity queries, and will be available as a native data type in Redis 8 while retaining modular internal boundaries. The feature is still in beta.

### Source excerpt

Yesterday we finally merged vector sets into Redis, here you can find the README that explains in detail what you get: https://github.com/redis/redis/blob/unstable/modules/vector-sets/README.md The goal of the new data structure is, in short, to create a new "Set alike" data type, similar to Sorted Sets, where instead of having a scalar as a score, you have a vector, and you can add and remove elements the Redis way, without caring about anything except the properties of the abstract data structure Redis implements, ask for elements similar to a given query vector (or a vector associated to some element already in the set), and so forth. But more about that later, a bit of background, first: From the path of the README itself, you can see the implementation is into "modules", but actually, Vector Sets are not a module, it's a part of the Redis core, the thing is that I started developing them as a module, and later I suggested that the implementation should still use the modules API, in order to promote modularity of the internals of Redis, in order to have both the advantages: every Redis instance starting from Redis 8 will have Vector Sets as a native data type, and there are clear boundaries between the core and the implementation ## The first new main data type of Redis after... some time I think that the latest big data structure of Redis were Streams, also developed by me. I resigned, returned, forks happened in the meantime, and it still it looks like the burden to introduce a new data type in Redis is mine :D I must say: I'm ok with that, because as much as I like programming, I also like design, a lot, and I had a feeling, that vectors, and vector similarity, are conceptually very simple, so they deserved a very simple API. And that was what I tried to do. Vector Sets are still a beta feature but I can tell you something, I can guarantee you can learn the API in 3 minutes. I decided that a fundamental requirement for implementing vector similarity was to also

## Subverting control with weak references

DevFeed: [Subverting control with weak references](<https://devfeed.tech/articles/subverting-control-with-weak-references-28094.md>)

Original publisher: [Read original article](<https://jlongster.com/subverting-control-weak-refs>)

Author: James Long

Published: 2025-02-24T12:00:00Z

Content type: tutorial

Language: en

Sources: [James Long](<https://devfeed.tech/sources/james-long.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Memory Leaks](<https://devfeed.tech/topics/memory-leaks.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-leaks](<https://devfeed.tech/tags/memory-leaks.md>), [reference](<https://devfeed.tech/tags/reference.md>)

### AI overview

This JavaScript article explains weak references, WeakRef, and WeakMap. It describes how weak references interact with garbage collection and how WeakMap can avoid retaining objects and causing memory leaks.

### Source excerpt

Weak references are neat. The best language features unlock different kinds of abstractions, and weak references do exactly that. Let me show you why. In JavaScript we have two APIs to work with weak references: WeakMap and WeakRef. (Before I wrote this article I thought WeakRef was only a proposal, but it turns out most browsers have already implemented it) One of the more common use cases uses WeakMap. This data structure keeps a weak reference to the keys in the map, and a strong reference between the keys and values. I guess I should explain what a "weak reference" is: usually if you have a reference to an object in a variable, it stops the garbage collector from deleting it (which makes sense). It'd be weird if suddenly your variable pointed to nothing right? A "weak reference" doesn't stop the object from being garbage collected. Usually languages' semantics don't allow a variable to change in the middle of execution however: // this doesn't exist, but what if we could create a weak reference like this? let weak trans = new Transaction(); // do a bunch of things... // error! trans is... nothing? it got garbage collected trans.transfer(); ^3d7637 Wouldn't it be weird if trans changed in the middle of execution? If that was possible all bets would be off for everything in the entire program because these weak references could be passed anywhere. Instead, APIs for weak references force you to call a function to get the value. The WeakRef class has a deref method to get the object. const ref = new WeakRef(obj) // get the object ref.deref() // do a bunch of things... ref.deref() ^ae238d In the above example, if nothing has a reference to obj, it'll eventually get garbage collected. That means deref might return obj the first time, but the second time it might return undefined. Let's get back to WeakMap which is the more common usage of weak references. (Direct weak references have a lot of weird behaviors and they should be considered very low-level.) A WeakMap has

## Group Similar Links in netlab Topologies

DevFeed: [Group Similar Links in netlab Topologies](<https://devfeed.tech/articles/group-similar-links-in-netlab-topologies-11137.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2025/02/netlab-link-dictionary/>)

Published: 2025-02-06T07:39:00Z

Content type: tutorial

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [netlab](<https://devfeed.tech/tags/netlab.md>), [structure](<https://devfeed.tech/tags/structure.md>), [troubleshooting](<https://devfeed.tech/tags/troubleshooting.md>)

### AI overview

The article explains how to use a dictionary of links in netlab topologies to group links with common functionality and make topology errors easier to locate. It describes nested dictionaries and how netlab preserves dictionary keys during topology transformation for troubleshooting.

### Source excerpt

In the Concise Link Descriptions blog post, I described various data formats that you could use to concisely list nodes attached to a link. Today, we'll focus on a mechanism that helps you spot errors in your topology: a dictionary of links. Imagine you have a large topology with dozens of links, and you get an error saying, "there is this problem with links[17]". It must be great fun counting the links to find which one triggered the error, right? Read more ...

## Rope Optimizations, Part 1

DevFeed: [Rope Optimizations, Part 1](<https://devfeed.tech/articles/rope-optimizations-part-1-13575.md>)

Original publisher: [Read original article](<https://zed.dev/blog/zed-decoded-rope-optimizations-part-1>)

Author: Thorsten Ball, Antonio Scandurra

Published: 2024-11-18T00:00:00Z

Content type: article

Language: en

Sources: [Zed Industries - Blog](<https://devfeed.tech/sources/zed-industries-blog.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [code](<https://devfeed.tech/tags/code.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [pairing](<https://devfeed.tech/tags/pairing.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This Zed Decoded article explains performance optimizations to Zed's Rope data structure, including faster point translation and a further optimization for indexing tabs. It also introduces a companion video of the pairing session.

### Source excerpt

In this episode of Zed Decoded, Thorsten and Antonio walk through the performance optimizations Antonio when working on Zed's Rope data structure before they then pair on adding more optimizations

## How Canva Scaled Their Search to Handle 1M+ Searches Per Minute

DevFeed: [How Canva Scaled Their Search to Handle 1M+ Searches Per Minute](<https://devfeed.tech/articles/how-canva-scaled-their-search-to-handle-1m-searches-per-minute-17968.md>)

Original publisher: [Read original article](<https://newsletter.betterstack.com/p/how-canva-scaled-their-search-to>)

Author: Richard Oliver Bray

Published: 2024-10-23T13:01:58Z

Content type: article

Language: en

Sources: [Hacking Scale by Better Stack](<https://devfeed.tech/sources/hacking-scale-by-better-stack.md>)

Topics: [Web](<https://devfeed.tech/topics/web.md>), [Database](<https://devfeed.tech/topics/database.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Library](<https://devfeed.tech/topics/library.md>), [Code](<https://devfeed.tech/topics/code.md>), [A/B Testing](<https://devfeed.tech/topics/a-b-testing.md>)

Tags: [a-b-testing](<https://devfeed.tech/tags/a-b-testing.md>), [code](<https://devfeed.tech/tags/code.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [database](<https://devfeed.tech/tags/database.md>), [library](<https://devfeed.tech/tags/library.md>), [search](<https://devfeed.tech/tags/search.md>), [software](<https://devfeed.tech/tags/software.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

The article describes Canva's search system, which supports searches across templates, media, fonts, and audio at very high request volumes. It explains that separate servers and search indexes created duplicated code and complicated updates and testing, and introduces search indexes as a way to make text retrieval faster.

### Source excerpt

Canva massively leveled-up their search by stripping away duplicated processes

## B-trees Require Fewer Comparisons Than Balanced Binary Search Trees

DevFeed: [B-trees Require Fewer Comparisons Than Balanced Binary Search Trees](<https://devfeed.tech/articles/b-trees-require-fewer-comparisons-than-balanced-binary-search-trees-25085.md>)

Original publisher: [Read original article](<https://databasearchitects.blogspot.com/2024/06/b-trees-require-fewer-comparisons-than.html>)

Author: Viktor Leis (noreply@blogger.com)

Published: 2024-06-06T13:59:00Z

Content type: article

Language: en

Sources: [Database Architects](<https://devfeed.tech/sources/database-architects.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [comparisons](<https://devfeed.tech/tags/comparisons.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [structure](<https://devfeed.tech/tags/structure.md>), [theory](<https://devfeed.tech/tags/theory.md>)

### AI overview

The article compares B-trees with balanced binary search trees by analyzing the number of comparisons required for lookup operations. It explains that as the B-tree degree increases, the comparison bound approaches the lower bound, and for degree k>=8, B-trees are guaranteed to use fewer comparisons than AVL trees.

### Source excerpt

Due to better access locality, B-trees are faster than binary search trees in practice -- but are they also better in theory? To answer this question, let's look at the number of comparisons required for a search operation. Assuming we store n elements in a binary search tree, the lower bound for the number of comparisons is log2 n in the worst case. However, this is only achievable for a perfectly balanced tree. Maintaining such a tree's perfect balance during insert/delete operations requires O(n) time in the worst case. Balanced binary search trees, therefore, leave some slack in terms of how balanced they are and have slightly worse bounds. For example, it is well known that an AVL tree guarantees at most 1.44 log2 n comparisons, and a Red-Black tree guarantees 2 log2 n comparisons. In other words, AVL trees require at most 1.44 times the minimum number of comparisons, and Red-Black trees require up to twice the minimum. How many comparisons does a B-tree need? In B-trees with degree k, each node (except the root) has between k and 2k children. For k=2, a B-tree is essentially the same data structure as a Red-Black tree and therefore provides the same guarantee of 2 log2 n comparisons. So how about larger, more realistic values of k? To analyze the general case, we start with a B-tree that has the highest possible height for n elements. The height is maximal when each node has only k children (for simplicity, this analysis ignores the special case of underfull root nodes). This implies that the worst-case height of a B-tree is logk n. During a lookup, one has to perform a binary search that takes log2 k comparisons in each of the logk n nodes. So in total, we have log2 k * logk n = log2 n comparisons. This actually matches the best case, and to construct the worst case, we have to modify the tree somewhat. On one (and only one) arbitrary path from the root to a single leaf node, we increase the number of children from k to 2k. In this situation, the tree height

## Kafka 101

DevFeed: [Kafka 101](<https://devfeed.tech/articles/kafka-101-33612.md>)

Original publisher: [Read original article](<https://highscalability.com/untitled-2/>)

Author: ByteByteGo

Published: 2024-05-09T18:55:21Z

Content type: tutorial

Language: en

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

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>)

Tags: [apache-kafka](<https://devfeed.tech/tags/apache-kafka.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [persistence](<https://devfeed.tech/tags/persistence.md>), [real-time-data-streaming](<https://devfeed.tech/tags/real-time-data-streaming.md>)

### AI overview

This introductory article explains Apache Kafka's origins, distributed streaming architecture, and use as a central platform for coordinating data among services and downstream systems. It also describes Kafka's log-based storage model, including immutability, ordered records, concurrent reads, and optimization for high-throughput, cost-efficient HDD storage.

### Source excerpt

This is a guest article by Stanislav Kozlovski, an Apache Kafka Committer. If you would like to connect with Stanislav, you can do so on Twitter and LinkedIn. Originally developed in LinkedIn during 2011, Apache Kafka is one of the most popular open-source Apache projects out

## Readability of Optimized Kotlin Code

DevFeed: [Readability of Optimized Kotlin Code](<https://devfeed.tech/articles/readability-of-optimized-kotlin-code-25605.md>)

Original publisher: [Read original article](<https://www.romainguy.dev/posts/2024/readability-of-optimized-kotlin-code/>)

Author: Romain Guy

Published: 2024-05-03T00:00:00Z

Content type: article

Language: en

Sources: [Posts on Romain Guy](<https://devfeed.tech/sources/posts-on-romain-guy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [API](<https://devfeed.tech/topics/api.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [api](<https://devfeed.tech/tags/api.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [code](<https://devfeed.tech/tags/code.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [developer](<https://devfeed.tech/tags/developer.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This article explains how Kotlin can keep low-level, micro-optimized code readable while preserving efficiency. It demonstrates a type-safe 8x8 grid encoded as a bitfield, using value classes and operator overloading for optimized rectangle and cell operations.

### Source excerpt

Leland and I were recently discussing how to best implement a new data structure to speed up a specific aspect of Jetpack Compose. He came up with a great idea, and nerd sniped me in the process. The problem was to efficiently encode the occupancy of an 8x8 grid represented as a Long (each bit representing a cell in the grid). After coming up with the bit twiddling code that quickly "rasterizes" a rectangle into the grid as a bitfield, I found myself thinking about how incredibly helpful Kotlin can be at making low-level/micro-optimized code easy to read1 for users of an API.

## Rope & SumTree

DevFeed: [Rope & SumTree](<https://devfeed.tech/articles/rope-sumtree-13576.md>)

Original publisher: [Read original article](<https://zed.dev/blog/zed-decoded-rope-sumtree>)

Author: Thorsten Ball, Nathan Sobo, Antonio Scandurra, Max Brunsfeld

Published: 2024-04-23T00:00:00Z

Content type: article

Language: en

Sources: [Zed Industries - Blog](<https://devfeed.tech/sources/zed-industries-blog.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [memory](<https://devfeed.tech/tags/memory.md>)

### AI overview

This Zed Decoded article examines how Zed represents and edits text in memory using its Rope and SumTree data structures. It explains why strings can be inefficient for editing large files and discusses how Zed's implementation works.

### Source excerpt

In this episode of Zed Decoded, Thorsten asks the founders -- Nathan, Max, Antonio -- about the data structures at the heart of Zed: Rope and SumTree.

## Effective Kotlin Item 60: Use appropriate collection types

DevFeed: [Effective Kotlin Item 60: Use appropriate collection types](<https://devfeed.tech/articles/effective-kotlin-item-60-use-appropriate-collection-types-39273.md>)

Original publisher: [Read original article](<https://kt.academy/article/ek-collection-types>)

Published: 2023-12-04T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Collections](<https://devfeed.tech/topics/collections.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [optimize](<https://devfeed.tech/topics/optimize.md>)

Tags: [collections](<https://devfeed.tech/tags/collections.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [thread](<https://devfeed.tech/tags/thread.md>), [time-complexity](<https://devfeed.tech/tags/time-complexity.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This Kotlin article explains the contracts and implementation considerations of lists, sets, and maps. It focuses on how underlying data structures, mutability, thread safety, and array-based list growth affect collection performance and operation time complexity.

### Source excerpt

Using non-standard collection types to improve performance in Kotlin.

## Slices Package: Binary Search

DevFeed: [Slices Package: Binary Search](<https://devfeed.tech/articles/slices-package-binary-search-22224.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2023/08/golang-slices-binary-search.html>)

Published: 2023-08-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [code](<https://devfeed.tech/tags/code.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

A tutorial on using the experimental Go slices package for binary search. It explains binary search on sorted slices, its O(log N) average time complexity, and the package APIs for searches with and without a custom comparison function.

### Source excerpt

Series Here are all the posts in this series about the slices package. Binary Search Clip, Clone, and Compact Compare Contains, Delete, and Equal Introduction Go's most important data structure is the slice and it was designed from the beginning to be mechanically sympathetic with the hardware. To learn more about that, check out Bill Kennedy's Ultimate Go video. Thanks to the introduction of generics in Go 1.18, the language team has been experimenting with a new package called slices. This package provides an API that provides various functions that are useful when working with slices.

## Covariant Nothing Object

DevFeed: [Covariant Nothing Object](<https://devfeed.tech/articles/covariant-nothing-object-39199.md>)

Original publisher: [Read original article](<https://kt.academy/article/ak-covariant-nothing-object>)

Published: 2023-02-13T00:15:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [sealed class](<https://devfeed.tech/topics/sealed-class.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Library](<https://devfeed.tech/topics/library.md>)

Tags: [data-structure](<https://devfeed.tech/tags/data-structure.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [object](<https://devfeed.tech/tags/object.md>), [sealed-class](<https://devfeed.tech/tags/sealed-class.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>), [type-parameter](<https://devfeed.tech/tags/type-parameter.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This Kotlin developer article describes the "Covariant Nothing Object" pattern: using a covariant generic type with Nothing so a singleton object can represent an empty value across compatible types. It relates the pattern to immutable linked lists, Kotlin's standard library, generic messages, and scheduled tasks.

### Source excerpt

The pattern we are all using, but no-one talks about it.

[Next page](<https://devfeed.tech/tags/data-structure.md?cursor=WyIyMDIzLTAyLTEzVDAwOjE1OjAwKzAwOjAwIiwgIjFlODc3MjNjLTY0MjAtNGUyYi05OGRiLTk1ZWFkMjg1NGExYyJd>)