# data-structures

Published articles for data-structures.

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

## Optimizing OPA performance: From arrays to objects

DevFeed: [Optimizing OPA performance: From arrays to objects](<https://devfeed.tech/articles/optimizing-opa-performance-from-arrays-to-objects-22577.md>)

Original publisher: [Read original article](<https://medium.com/capital-one-tech/optimizing-opa-performance-from-arrays-to-objects-a3c966acdaa5?source=rss----3db3a67cb648---4>)

Author: Capital One Tech

Published: 2026-07-07T14:25:30Z

Content type: tutorial

Language: en

Sources: [Capital One Tech](<https://devfeed.tech/sources/capital-one-tech.md>)

Topics: [opa](<https://devfeed.tech/topics/opa.md>), [Open Policy Agent](<https://devfeed.tech/topics/open-policy-agent.md>), [rego](<https://devfeed.tech/topics/rego.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Algorithms, Complexity](<https://devfeed.tech/topics/algorithms-complexity.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [cloud-native](<https://devfeed.tech/tags/cloud-native.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [opa](<https://devfeed.tech/tags/opa.md>), [open-policy-agent](<https://devfeed.tech/tags/open-policy-agent.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance-tuning](<https://devfeed.tech/tags/performance-tuning.md>), [rego](<https://devfeed.tech/tags/rego.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [software-supply-chain](<https://devfeed.tech/tags/software-supply-chain.md>)

### AI overview

This article explains how to improve Open Policy Agent performance by choosing appropriate data structures for Rego policies. It focuses on replacing nested arrays with keyed objects to avoid inefficient array traversal when evaluating large datasets.

### Source excerpt

Achieve 99% faster Rego policy execution through optimization. Note: This post focuses on one aspect of performance tuning Rego policies and datasets evaluated by OPA-arrays vs. objects. The Rego Style Guide and Regal Rego linter are very helpful resources for learning Rego best practices and avoiding code smells in Rego policies. There is also the OPA performance tuning documentation. In 2018, I started using open policy agent (OPA) as a solution for controlling and preventing unwanted behaviors in our Kubernetes Clusters. OPA, along with Kubernetes Dynamic Admission Control, provided a means to build preventive controls. Since then, I have worked with several PaC solutions. I have always stayed close to the OPA tool set because of how well it supports multiple use cases. OPA is domain agnostic and can be used with virtually any use case, as long as you supply the correct data and policies. To that end, OPA use cases have expanded throughout several technical disciplines, such as cloud-native computing and software supply chain management. OPA performance engineering OPA enables us to unify PaC solutions across multiple use cases and systems, using the same languages and tools. However, there is always room for improvement and performance engineering policies and the execution thereof. In addition, optimizing data that policies evaluate and mutate should be part of our focus when we deliver OPA-based solutions. Recently I was asked to help with OPA performance issues. I made several recommendations, but I overlooked one simple and glaring issue: the poor performing policy was processing a large data set using nested-arrays, instead of the best practice of using keyed-objects. Later, something was bothering me about my interaction and I realized that while I gave decent architectural level advice, I completely missed the best engineering advice. Rego policies and data should be optimized just like other algorithms and relative data, and part of that optimization is

## Recent LLVM hash table improvements

DevFeed: [Recent LLVM hash table improvements](<https://devfeed.tech/articles/recent-llvm-hash-table-improvements-31122.md>)

Original publisher: [Read original article](<https://maskray.me/blog/2026-06-07-recent-llvm-hash-table-improvements>)

Published: 2026-06-07T07:00:00Z

Content type: article

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [hash](<https://devfeed.tech/topics/hash.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [hash](<https://devfeed.tech/tags/hash.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

The article reviews recent improvements to LLVM hash tables, including replacing quadratic probing and tombstone or empty-key sentinels with linear probing, Algorithm R deletion, and bit-array occupancy. It also discusses pointer and iterator invalidation behavior and reports performance improvements in DenseMap.

### Source excerpt

LLVM has several hash tables. They used quadratic probing with in-band sentinel keys (empty, tombstone); recent work has been replacing that with linear probing with tombstone key removed. DenseMap (replacement for std::unordered_map): DenseMapInfo::getEmptyKey() / getTombstoneKey(). DenseSet: implemented using DenseMap compiler-rt/lib/sanitizer_common/sanitizer_dense_map.h ports the implementation for sanitizers. SmallPtrSet (replacement for std::unordered_set<T *>): hard-coded -1 (empty) and -2 (tombstone). StringMap (replacement for std::unordered_map<std::string, V>) StringSet: implemented using StringMap FoldingSet (uniquing/hash-consing container, not a general map) For the open-addressed DenseMap and SmallPtrSet, pointers, references, and iterators are invalidated by insert. StringMap is different: each entry lives in a heap-allocated StringMapEntry<V> node, so entry pointers survive grow. std::unordered_map, being node-based, keeps surviving-element pointers valid across both insert and erase and only invalidates the erased element's own iterator. LLVM code rarely needs that stronger contract -- callers do not hold long-lived references into the container across mutation -- and that gap is what gives pass to relocating erase and bit-array occupancy. Recently, Tombstones have been removed from DenseMap and SmallPtrSet. erase() also invalidates pointers. DenseMap has also retired its empty-key sentinel, leading to significant performance improvements. DenseMap with integer keys (int/unsigned/size_t) had -1/-2 reserved -- a footgun, now fixed. StringMap got Algorithm R deletion too. Its entries are separately heap-allocated, so erase keeps entry pointers valid but invalidates iterators; erase-while-iterating moved to remove_if. FoldingSet dropped chaining for linear probing plus Algorithm R; the intrusive next-in-bucket pointer became a cached 32-bit hash.

## Safe Optimistic Lock Coupling

DevFeed: [Safe Optimistic Lock Coupling](<https://devfeed.tech/articles/safe-optimistic-lock-coupling-25091.md>)

Original publisher: [Read original article](<https://databasearchitects.blogspot.com/2026/04/safe-optimistic-lock-coupling.html>)

Author: Thomas Neumann (noreply@blogger.com)

Published: 2026-04-29T10:22:56Z

Content type: article

Language: en

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

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [race-condition](<https://devfeed.tech/topics/race-condition.md>)

Tags: [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [locking](<https://devfeed.tech/tags/locking.md>), [locks](<https://devfeed.tech/tags/locks.md>), [mutex](<https://devfeed.tech/tags/mutex.md>), [performance](<https://devfeed.tech/tags/performance.md>), [race-condition](<https://devfeed.tech/tags/race-condition.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>), [thread](<https://devfeed.tech/tags/thread.md>), [typesafety](<https://devfeed.tech/tags/typesafety.md>)

### AI overview

The article explains how lock coupling can limit the scalability of concurrent binary-tree lookups because readers contend on locks, especially at the root. It presents Optimistic Lock Coupling, in which readers validate version numbers without writes, and discusses the race-condition risk when values are used before validation.

### Source excerpt

As the number of CPU cores keeps growing, the scalability of concurrent data structures becomes increasingly important. A data structure that works fine on 4 cores can become a bottleneck on 32, not because of algorithmic limitations, but because of how it synchronizes access. We illustrate that with a simple binary tree. Usually these data structures are protected by some kind of lock: struct Node { mutex lock; key_type key; value_type value; Node* left, *right; }; struct Tree { mutex lock; Node* root; }; When searching a value, we can traverse the data structure, lock the parts of the data we are currently touching, and release locks when we are done ("lock coupling"): option<value_type> Tree::lookup(key_type key) { lock.lock_shared(); mutex* currentLock = &lock; Node* iter = root; option<value_type> result; while (iter) { if (key == iter->key) { result = iter->value; break; } Node* next = (key < iter->key) ? iter->left : iter->right; if (next) next->lock.lock_shared(); currentLock->unlock(); currentLock = next ? &next->lock : nullptr; iter = next; } currentLock->unlock(); return result; } While conceptually simple, lock coupling has quite poor performance in practice. The problem is that it creates contention on the locks, in particular for the root node. Every lookup goes through the root node, thus the root node is constantly locked and unlocked. While there is no semantic contention between lookups, as all readers can read the root concurrently, there is physical contention on the lock itself, which limits scalability. This can be seen below, with concurrent lookups in a tree of 100,000 elements, executed on a 16-core / 32-thread 9950X3D. Lookup scalability: no locking vs lock coupling This contention problem can be solved by using Optimistic Lock Coupling, a synchronization technique where readers do not perform any writes. The key idea here is that writers lock as usual, and increase a version number when they are done updating. Readers read the version numb

## The Data Structures Behind Text Editors: Gap Buffers, Piece Tables, Ropes, and CRDTs

DevFeed: [The Data Structures Behind Text Editors: Gap Buffers, Piece Tables, Ropes, and CRDTs](<https://devfeed.tech/articles/the-data-structures-behind-text-editors-gap-buffers-piece-tables-ropes-and-crdts-39655.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2026-04-05_text-editor-data-structures>)

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

Content type: tutorial

Language: en

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

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

Tags: [data-structures](<https://devfeed.tech/tags/data-structures.md>), [delete](<https://devfeed.tech/tags/delete.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [editor](<https://devfeed.tech/tags/editor.md>), [file](<https://devfeed.tech/tags/file.md>), [insert](<https://devfeed.tech/tags/insert.md>), [memory](<https://devfeed.tech/tags/memory.md>), [search](<https://devfeed.tech/tags/search.md>), [syntax-highlighting](<https://devfeed.tech/tags/syntax-highlighting.md>)

### AI overview

This tutorial explains how text editors represent document buffers in memory. It compares gap buffers, piece tables, ropes, and CRDTs, focusing on the trade-offs among insertion, deletion, reading, cursor movement, memory efficiency, latency, and multi-user concurrency.

### Source excerpt

Open a text editor, type a character, and it appears on screen. That single keystroke triggers a surprisingly deep question: how does the editor represent your document in memory so that insertions, deletions, and cursor movements all feel instant, even on a file with millions of lines...

## 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.

## Bloom Filters vs Counting Bloom Filters: When Deletions Kill Performance

DevFeed: [Bloom Filters vs Counting Bloom Filters: When Deletions Kill Performance](<https://devfeed.tech/articles/bloom-filters-vs-counting-bloom-filters-when-deletions-kill-performance-39567.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/15-bloom-filters-deletable-bloom-filters/>)

Author: hello@ankit-rana.com

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

Content type: article

Language: en

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

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [CPU Cache](<https://devfeed.tech/topics/cpu-cache.md>)

Tags: [bloom-filter](<https://devfeed.tech/tags/bloom-filter.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpu-cache](<https://devfeed.tech/tags/cpu-cache.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [false-negative](<https://devfeed.tech/tags/false-negative.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article explains that standard Bloom filters support membership checks but not deletion because clearing shared bits can create false negatives. Counting Bloom filters enable deletion with counters, but their larger memory footprint can push lookups out of CPU cache and increase latency through random memory access.

### Source excerpt

A standard Bloom filter is append-only because bits are shared between items, so clearing a bit for one item can create a false negative for another. Counting Bloom filters fix deletion by replacing each bit with a 4-bit or 8-bit counter, which multiplies the footprint four to eight times, pushes the structure out of L3, and turns each of the k lookups into a roughly 100 ns RAM hit instead of a 10 ns cache hit.

## Cuckoo Filters: Cache-Friendly Membership Checks With Deletions

DevFeed: [Cuckoo Filters: Cache-Friendly Membership Checks With Deletions](<https://devfeed.tech/articles/cuckoo-filters-cache-friendly-membership-checks-with-deletions-39568.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/16-cuckoo-filters-architecture/>)

Author: hello@ankit-rana.com

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

Content type: tutorial

Language: en

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

Topics: [CPU Cache](<https://devfeed.tech/topics/cpu-cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [hash](<https://devfeed.tech/topics/hash.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [cpu-cache](<https://devfeed.tech/tags/cpu-cache.md>), [cuckoo-filter](<https://devfeed.tech/tags/cuckoo-filter.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [false-positive](<https://devfeed.tech/tags/false-positive.md>), [hash](<https://devfeed.tech/tags/hash.md>), [insert](<https://devfeed.tech/tags/insert.md>), [performance](<https://devfeed.tech/tags/performance.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [spatial-locality](<https://devfeed.tech/tags/spatial-locality.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This article explains how Cuckoo filters support deletions while improving CPU cache behavior compared with counting Bloom filters. They check two specific buckets using compact fingerprints, but insertions can fail when kick-out chains exceed their limit, requiring capacity planning or overflow handling.

### Source excerpt

A Cuckoo filter stores a one-to-two byte fingerprint in a hash table and finds it by checking exactly two buckets, the primary index and its XOR-derived alternate, instead of k random bit positions scattered across a large array. That spatial locality is the whole win on real CPUs. The trade-off is a hard edge: when the kick-out chain exceeds its limit, the insert fails outright.

## How MongoDB Stores Data - WiredTiger Pages vs SQLite

DevFeed: [How MongoDB Stores Data - WiredTiger Pages vs SQLite](<https://devfeed.tech/articles/how-mongodb-stores-data-wiredtiger-pages-vs-sqlite-39651.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2026-03-09_mongodb-wiredtiger-vs-sqlite-storage>)

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

Content type: tutorial

Language: en

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

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

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [database](<https://devfeed.tech/tags/database.md>), [memory](<https://devfeed.tech/tags/memory.md>), [mongodb](<https://devfeed.tech/tags/mongodb.md>), [performance](<https://devfeed.tech/tags/performance.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>)

### AI overview

This tutorial explains how MongoDB's WiredTiger storage engine stores collection and index data in variable-size B-trees, then compares that model with SQLite's fixed-page B-tree and overflow-page design. It focuses on how page management, overflow references, reconciliation, and cache pressure can affect query performance.

### Source excerpt

. [MongoDB WiredTiger vs SQLite Storage](mongodb-wiredtiger-vs-sqlite-storage-cover...

## Building an LSM Storage Engine from Scratch in Rust

DevFeed: [Building an LSM Storage Engine from Scratch in Rust](<https://devfeed.tech/articles/building-strata-39414.md>)

Original publisher: [Read original article](<https://n8z.dev/posts/building-strata/>)

Author: Nevin Zheng

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

Content type: opinion

Language: en

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

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

Tags: [code](<https://devfeed.tech/tags/code.md>), [compaction](<https://devfeed.tech/tags/compaction.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [database](<https://devfeed.tech/tags/database.md>), [merge](<https://devfeed.tech/tags/merge.md>), [mvcc](<https://devfeed.tech/tags/mvcc.md>), [rust](<https://devfeed.tech/tags/rust.md>), [storage](<https://devfeed.tech/tags/storage.md>), [storage-engine](<https://devfeed.tech/tags/storage-engine.md>)

### AI overview

A personal engineering account of building an LSM storage engine from scratch in Rust. The author discusses choosing LSM trees, prioritizing correctness and developer experience, versioning keys for possible MVCC exploration, and considering key-value separation to reduce compaction costs.

### Source excerpt

Building my own perfectly imperfect LSM storage engine from scratch in Rust.

## Good technology blogs: a reading list for the holidays

DevFeed: [Good technology blogs: a reading list for the holidays](<https://devfeed.tech/articles/good-technology-blogs-a-reading-list-for-the-holidays-5591.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/tech-blogs>)

Author: Alexey Milovidov

Published: 2025-12-29T00:00:00Z

Content type: article

Language: en

Sources: [ClickHouse Blog](<https://devfeed.tech/sources/clickhouse-blog.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Algorithms, Complexity](<https://devfeed.tech/topics/algorithms-complexity.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Computer science](<https://devfeed.tech/topics/computer-science.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Networks](<https://devfeed.tech/topics/networks.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [databases](<https://devfeed.tech/tags/databases.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [networks](<https://devfeed.tech/tags/networks.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [systems](<https://devfeed.tech/tags/systems.md>), [web-development](<https://devfeed.tech/tags/web-development.md>)

### AI overview

A holiday reading list of favorite technology blogs covering performance optimization, data structures and algorithms, database development, compilers, operating systems, programming languages, computer science, mathematics, hardware, networks, web development, computer graphics, and AI. It highlights authors and libraries connected to high-performance software and ClickHouse, including simdjson, Roaring bitmap, USearch, StringZilla, Hyperscan, Miniselect, LZ4, and zstd.

### Source excerpt

A collection of my favorite technology blogs

## Free interview-preparation challenges for software engineering and front-end developer interviews

DevFeed: [Free interview-preparation challenges for software engineering and front-end developer interviews](<https://devfeed.tech/articles/i-spent-10k-learning-to-pass-tech-interviews-here-s-everything-for-free-32368.md>)

Original publisher: [Read original article](<https://brianjenney.substack.com/p/i-spent-10k-learning-to-pass-tech>)

Author: Brian Jenney

Published: 2025-12-15T20:00:52Z

Content type: article

Language: en

Sources: [Brian Jenney](<https://devfeed.tech/sources/brian-jenney.md>)

Topics: [Learning](<https://devfeed.tech/topics/learning.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Front end](<https://devfeed.tech/topics/frontend.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [advice](<https://devfeed.tech/tags/advice.md>), [coding](<https://devfeed.tech/tags/coding.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [front-end](<https://devfeed.tech/tags/front-end.md>), [learning](<https://devfeed.tech/tags/learning.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

The author describes spending $10,000 on Interview Kickstart after repeated technical interview failures, later reaching final rounds at Google and Meta without receiving offers. They share free interview-preparation challenges covering light data structures and algorithms, front-end development, system design, behavioral interviews, videos, resources and bonus questions.

### Source excerpt

About 5 years ago, I dropped $10,000 on Interview Kickstart (not an endorsement and not NOT an endorsement either) after bombing technical interview after technical interview.

## Why Ruby Is Well Suited for Advent of Code

DevFeed: [Why Ruby Is Well Suited for Advent of Code](<https://devfeed.tech/articles/why-ruby-is-the-best-language-for-advent-of-code-20121.md>)

Original publisher: [Read original article](<https://hashrocket.com/blog/posts/why-ruby-is-the-best-language-for-advent-of-code>)

Author: Tony Yunker

Published: 2025-12-02T14:00:00Z

Content type: opinion

Language: en

Sources: [Hashrocket](<https://devfeed.tech/sources/hashrocket.md>)

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

Tags: [advent-of-code](<https://devfeed.tech/tags/advent-of-code.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [programming](<https://devfeed.tech/tags/programming.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

This opinion article explains why the author prefers Ruby for Advent of Code programming puzzles, highlighting Ruby's flexibility, data structures, standard library, and tooling. It also notes that Ruby's metaprogramming can cause bugs in larger production codebases.

### Source excerpt

It's the most wonderful time of the year - Christmas Advent of Code time! Advent of Code is an Advent Calendar style series of programming puzzles put out each year, starting on December 1st leading up to Christmas. The puzzles are super festive and ramp up in difficulty over the course of the month. Programmers of every level can participate, and in researching some of the more difficult problems you'll probably learn something cool! It's a great way to finish out the year. I've been taking part in Advent of Code since 2019 (I've never completed a full year - and that's ok! You can participate for as long as it's fun and have the time) and have tried solving in multiple different languages - Advent is a great way to learn/skill up in a new language. But Ruby remains my favorite language in which to solve these puzzles. Many of Ruby's strengths - its flexibility, robust standard library, and tooling make it the ideal language for Advent of Code. Flexibility Ruby doesn't enforce any one way of writing code. Want to solve a problem with a procedural script? Go for it! Want to leverage object-oriented programming and send messages between classes? Can do! Want to write in a functional style and map and zip a data structure in one long chain? You can do that too! And you can mix and match paradigms between problems - whatever models each problem best. Ruby's data structures are super flexible as well. In many of the problems, Array and Hash allow you to very quickly model solutions. But if you find a hash isn't quite cutting it and you don't want to upgrade it to a full class, you can use the Data class to create value objects. This will lend you a bit more structure than a hash, and allow you to encapsulate some logic inside it without having to bring in the overhead of a Class. Some of Ruby's flexibility - metaprogramming in particular - can be...unpopular... in larger production codebases. It's the "magic" that can lead to some nasty bugs. But Advent is a great place

## Book early-access discount code

DevFeed: [Book early-access discount code](<https://devfeed.tech/articles/book-early-access-discount-code-38669.md>)

Original publisher: [Read original article](<https://ericlippert.com/2025/11/17/book-early-access-discount-code/>)

Author: ericlippert

Published: 2025-11-17T19:48:52Z

Content type: release

Language: en

Sources: [Eric Lippert](<https://devfeed.tech/sources/eric-lippert.md>)

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

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [book](<https://devfeed.tech/tags/book.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>)

### AI overview

The author announces that Fabulous Adventures In Data Structures And Algorithms is available through Manning's Early Access Program, with six chapters currently published. A 50% discount is available through November 27 using the code MLLippert.

### Source excerpt

Hey everyone, I first want to say a heartfelt thank you so much for the warm comments and supportive feedback I've gotten since I announced that I'm in process of writing Fabulous Adventures In Data Structures And Algorithms. It means ... Continue reading ->

## Scaling HNSWs

DevFeed: [Scaling HNSWs](<https://devfeed.tech/articles/scaling-hnsws-20647.md>)

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

Published: 2025-11-11T12:53:38Z

Content type: article

Language: en

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

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [Low Latency](<https://devfeed.tech/topics/low-latency.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [blog-post](<https://devfeed.tech/tags/blog-post.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [redis](<https://devfeed.tech/tags/redis.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

An advanced blog post about HNSW internals, optimizations, and the challenges of integrating HNSW vector similarity search into Redis while maintaining low latency and high performance. The author also questions whether HNSWs are the final approach for greedy nearest-vector search.

### Source excerpt

I'm taking a few weeks of pause on my HNSWs developments (now working on some other data structure, news soon). At this point, the new type I added to Redis is stable and complete enough, it's the perfect moment to reason about what I learned about HNSWs, and turn it into a blog post. That kind of brain dump that was so common pre-AI era, and now has become, maybe, a bit more rare. Well, after almost one year of thinking and implementing HNSWs and vector similarity stuff, it is time for some writing. However this is not going to be an intro on HNSWs: too many are present already. This is the "extra mile" instead. If you know HNSWs, I want to share with you my more "advanced" findings, especially in the context of making them fast enough to allow for a "Redis" experience: you know, Redis is designed for low latency and high performance, and HNSWs are kinda resistant to that, so there were challenges to expose HNSWs as an abstract data structure. This blog post will be split into several sections. Think of them as pages of the same book, different chapters of the same experience. Oh and, by the way, I already wrote and subsequently lost this blog post :D [long, sad story about MacOS and bad habits - I hadn't lost something like that since the 90s, during blackouts], so here most of the problem will be to recall what I wrote a few days ago and, while I'm at it, to better rephrase what I didn't like very much. ## A few words about the state of HNSW Before digging into the HNSWs internals and optimizations, I want to say a few things about HNSWs. The original paper introducing HNSWs is a great piece of computer science literature, and HNSWs are amazing data structures, but: I don't believe they are the last word for searching, in a greedy way, for nearby vectors according to a distance function. The paper gives the feeling it lacks some "pieces", almost like if the researchers, given six months more, had a lot more to explore and say. For instance, I modified the paper m

## Getting Friendly With CPU Caches

DevFeed: [Getting Friendly With CPU Caches](<https://devfeed.tech/articles/getting-friendly-with-cpu-caches-22223.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2023/07/getting-friendly-with-cpu-caches.html>)

Published: 2025-10-21T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [CPU Cache](<https://devfeed.tech/topics/cpu-cache.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [data](<https://devfeed.tech/tags/data.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [intel](<https://devfeed.tech/tags/intel.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>), [processor](<https://devfeed.tech/tags/processor.md>), [programming](<https://devfeed.tech/tags/programming.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

This tutorial explains how CPU cache behavior and data locality affect application performance. Using a Go case study, it shows that replacing a large embedded array in a user struct with a slice reduced cache misses and improved benchmark performance by more than 40 times.

### Source excerpt

Understanding how your data structures interact with hardware is one of the most powerful ways to improve application performance. This blogpost explores how CPU caches influence speed and how thoughtful struct design in Go can yield massive gains. Through a real-world case study, it shows how replacing a large embedded array with a slice improved performance by more than 40 times by reducing cache misses and improving data locality. Originally published in July 2023, its lessons remain highly relevant today for developers optimizing for memory efficiency and cache-aware programming.

## Atomic Data Modifications for Data Connect

DevFeed: [Atomic Data Modifications for Data Connect](<https://devfeed.tech/articles/atomic-data-modifications-for-data-connect-16600.md>)

Original publisher: [Read original article](<https://firebase.blog/posts/2025/05/dataconnect-atomic-data-modifications>)

Author: Andrea Wu

Published: 2025-05-06T00:00:00Z

Content type: tutorial

Language: en

Sources: [Firebase Blog](<https://devfeed.tech/sources/firebase-blog.md>)

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

Tags: [data-structures](<https://devfeed.tech/tags/data-structures.md>), [database](<https://devfeed.tech/tags/database.md>), [firebase](<https://devfeed.tech/tags/firebase.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [sql-connect](<https://devfeed.tech/tags/sql-connect.md>), [tutorials](<https://devfeed.tech/tags/tutorials.md>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

This Firebase tutorial explains Data Connect's atomic operations for maintaining consistency and preventing race conditions. It covers incrementing and decrementing fields and adding or removing list items, with examples involving banking and todo-list applications.

### Source excerpt

News, tutorials, and updates from the Firebase team.

## Write Barriers

DevFeed: [Write Barriers](<https://devfeed.tech/articles/write-barriers-31811.md>)

Original publisher: [Read original article](<https://patshaughnessy.net/2025/2/18/write-barriers>)

Author: Pat Shaughnessy

Published: 2025-02-18T00:00:00Z

Content type: tutorial

Language: en

Sources: [Pat Shaughnessy](<https://devfeed.tech/sources/pat-shaughnessy.md>)

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

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [beautiful](<https://devfeed.tech/tags/beautiful.md>), [code](<https://devfeed.tech/tags/code.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [updating-ruby-under-a-microscope](<https://devfeed.tech/tags/updating-ruby-under-a-microscope.md>)

### AI overview

This tutorial explains Ruby write barriers in incremental and generational garbage collection. Write barriers detect writes to arrays, hashes, and other data structures that may add objects requiring marking; when triggered, Ruby moves the modified object back onto the mark stack for processing during a later garbage-collection step.

### Source excerpt

I've started working on a new edition of Ruby Under a Microscope that covers Ruby 3.x. I'm working on this in my spare time, so it will take a while. Leave a comment or drop me a line and I'll email you when it's finished. Ruby's garbage col

## Integrating Snapshotter with a memory datastore in Golang

DevFeed: [Integrating Snapshotter with a memory datastore in Golang](<https://devfeed.tech/articles/integrating-snapshotter-with-a-memory-datastore-in-golang-39634.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2025-02-16_Integrating-Snapshotter-with-a-memory-datastore-in-Golang>)

Published: 2025-02-16T00: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>), [copy](<https://devfeed.tech/topics/copy.md>), [data](<https://devfeed.tech/topics/data.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [copy](<https://devfeed.tech/tags/copy.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [interface](<https://devfeed.tech/tags/interface.md>), [iteration](<https://devfeed.tech/tags/iteration.md>), [object](<https://devfeed.tech/tags/object.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

A practical guide to integrating copy-on-write snapshotting with an in-memory datastore in Go. It describes goals for concurrent snapshots and restore operations, outlines how snapshot state is tracked across stores and shards, and discusses possible latency and memory impacts for reads and writes.

### Source excerpt

. [Integrating a Snapshotter with a Go Memory Datastore](integrating-snapshotter-with-a-memory-datastore-in-golang-cover...

## 5 Non-LLM Software Trends To Be Excited About

DevFeed: [5 Non-LLM Software Trends To Be Excited About](<https://devfeed.tech/articles/5-non-llm-software-trends-to-be-excited-about-39081.md>)

Original publisher: [Read original article](<https://read.engineerscodex.com/p/5-non-llm-software-trends-to-be-excited>)

Author: Engineer's Codex

Published: 2024-11-12T07:31:23Z

Content type: opinion

Language: en

Sources: [Engineer's Codex](<https://devfeed.tech/sources/engineer-s-codex.md>)

Topics: [Local-First](<https://devfeed.tech/topics/local-first.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [client](<https://devfeed.tech/topics/client.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>)

Tags: [client](<https://devfeed.tech/tags/client.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [latency](<https://devfeed.tech/tags/latency.md>), [local-first](<https://devfeed.tech/tags/local-first.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

An opinion article highlights local-first software and related conflict-resolution techniques as software engineering trends outside the focus on LLMs. It explains how local storage and processing can improve latency, user experience, and resilience, and introduces CRDTs as a deterministic way to merge replicated data.

### Source excerpt

Innovations outside the AI spotlight

## 11 Data Structures Every Developer Should Know

DevFeed: [11 Data Structures Every Developer Should Know](<https://devfeed.tech/articles/11-data-structures-every-developer-should-know-17733.md>)

Original publisher: [Read original article](<https://blog.amigoscode.com/p/11-data-structures-every-developer>)

Author: Nelson Djalo

Published: 2024-10-24T16:06:22Z

Content type: tutorial

Language: en

Sources: [Amigoscode Newsletter](<https://devfeed.tech/sources/amigoscode-newsletter.md>)

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

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [developer](<https://devfeed.tech/tags/developer.md>), [fifo](<https://devfeed.tech/tags/fifo.md>), [graph](<https://devfeed.tech/tags/graph.md>), [programming](<https://devfeed.tech/tags/programming.md>), [queue](<https://devfeed.tech/tags/queue.md>)

### AI overview

A tutorial introducing 11 data structures relevant to software development, coding interviews, algorithm efficiency, and system design. It explains arrays, 2D arrays, queues, stacks, and graphs, including their properties and practical use cases.

### Source excerpt

Master These 11 Data Structures to Excel in Programming and System Design

## IS-IS Labs: Explore IS-IS Data Structures

DevFeed: [IS-IS Labs: Explore IS-IS Data Structures](<https://devfeed.tech/articles/is-is-labs-explore-is-is-data-structures-11083.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/10/isis-labs-explore-data-structures/>)

Published: 2024-10-10T06:04:00Z

Content type: tutorial

Language: en

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

Topics: [IS-IS](<https://devfeed.tech/topics/is-is.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [networking](<https://devfeed.tech/topics/networking.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>)

Tags: [data-structures](<https://devfeed.tech/tags/data-structures.md>), [ipv4](<https://devfeed.tech/tags/ipv4.md>), [is-is](<https://devfeed.tech/tags/is-is.md>), [netlab](<https://devfeed.tech/tags/netlab.md>), [network](<https://devfeed.tech/tags/network.md>), [routing](<https://devfeed.tech/tags/routing.md>)

### AI overview

This tutorial introduces an exercise in the IS-IS labs series that examines the data structures IS-IS creates to represent a network after configuring IS-IS routing for IPv4.

### Source excerpt

In the first exercise in the IS-IS labs series, you configured IS-IS routing for IPv4. Before moving on to more complex topics, let's explore the data structures IS-IS created to represent your network.

## Fundamental Skills for Software Engineers

DevFeed: [Fundamental Skills for Software Engineers](<https://devfeed.tech/articles/up-your-game-fundamental-skills-for-software-engineers-33306.md>)

Original publisher: [Read original article](<https://ruslanspivak.com/bb02/>)

Author: Ruslan Spivak

Published: 2024-07-31T17:04:00Z

Content type: article

Language: en

Sources: [Ruslan Spivak](<https://devfeed.tech/sources/ruslan-spivak.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [math](<https://devfeed.tech/topics/math.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blog](<https://devfeed.tech/tags/blog.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [fundamentals](<https://devfeed.tech/tags/fundamentals.md>), [math](<https://devfeed.tech/tags/math.md>), [programming](<https://devfeed.tech/tags/programming.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

The article argues that software engineers should build durable fundamentals because technologies and frameworks change quickly. It recommends focusing on programming languages, software design and architecture, data structures and algorithms, operating systems, networking, databases, distributed systems, mathematics, and soft skills.

### Source excerpt

"Fundamentals are the foundation of excellence. Without a strong base, you cannot reach your full potential." - John Wooden Hey there! Let's talk fundamentals today. Why are they important? John Wooden's quote sums it up nicely, but let's unpack it a bit more: Strong foundation: A solid grasp ...

## Good programmers worry about data structures and their relationships

DevFeed: [Good programmers worry about data structures and their relationships](<https://devfeed.tech/articles/good-programmers-worry-about-data-structures-and-their-relationships-39086.md>)

Original publisher: [Read original article](<https://read.engineerscodex.com/p/good-programmers-worry-about-data>)

Author: Engineer's Codex

Published: 2024-07-08T00:52:15Z

Content type: opinion

Language: en

Sources: [Engineer's Codex](<https://devfeed.tech/sources/engineer-s-codex.md>)

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

Tags: [code](<https://devfeed.tech/tags/code.md>), [data](<https://devfeed.tech/tags/data.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [git](<https://devfeed.tech/tags/git.md>), [programming](<https://devfeed.tech/tags/programming.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

The article argues that software design should begin with data structures and their relationships because a well-designed data model can make code easier to design, maintain, understand, and verify. It uses Git-related remarks attributed to Linus Torvalds and an example where restructuring data replaced a 500-line function with a 50-line function.

### Source excerpt

Wisdom from Linus Torvalds, the creator of Git and Linux

## Data Structures Explained: Arrays vs. Linked Lists for Efficient Coding

DevFeed: [Data Structures Explained: Arrays vs. Linked Lists for Efficient Coding](<https://devfeed.tech/articles/data-structures-explained-arrays-vs-linked-lists-for-efficient-coding-28415.md>)

Original publisher: [Read original article](<https://banes.dev/data-structures-explained-arrays-vs-linked-lists-for-efficient-coding/>)

Author: admin

Published: 2024-05-04T09:06:06Z

Content type: tutorial

Language: en

Sources: [Posts on Chris Banes](<https://devfeed.tech/sources/posts-on-chris-banes.md>)

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

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [coding](<https://devfeed.tech/tags/coding.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>), [vs](<https://devfeed.tech/tags/vs.md>)

### AI overview

This tutorial explains arrays and linked lists as fundamental data structures. It compares their organization, access speed, size flexibility, and suitability for adding or removing items, with a Python code example for linked lists.

### Source excerpt

Storing data is more than just putting things in boxes. Are you ready to learn the secrets of super-efficient data organization? Data structures and algorithms are like the superpowers of programming. They help computers store, find, and change information in the smartest ways possible. If you're new to coding, learning about basic data structures is [...]

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