# Skiplists

Skiplists are randomized linked-list data structures that implement sets and lists with expected logarithmic-time operations.

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

## How to Use Stacks and Queues in JavaScript

DevFeed: [How to Use Stacks and Queues in JavaScript](<https://devfeed.tech/articles/how-to-use-stacks-and-queues-in-javascript-87925.md>)

Original publisher: [Read original article](<https://jsdev.space/howto/stacks-and-queues/>)

Author: anton liberant

Published: 2026-08-25T00:00:00Z

Content type: tutorial

Language: en

Sources: [JavaScript Development](<https://devfeed.tech/sources/javascript-development.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Skiplists](<https://devfeed.tech/topics/skiplists.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [fifo](<https://devfeed.tech/tags/fifo.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lifo](<https://devfeed.tech/tags/lifo.md>), [queues](<https://devfeed.tech/tags/queues.md>)

### AI overview

This tutorial explains stack and queue behavior in JavaScript, showing how LIFO and FIFO determine which item is processed next. It demonstrates array-based implementations, including an indexed queue that avoids repeatedly shifting remaining elements, and describes uses such as task processing, function calls, and breadth-first search.

### Source excerpt

Learn how stacks and queues work in JavaScript, when to use LIFO and FIFO, and how to implement both data structures with practical examples.

## Howto Find the Start of a Cycle in a Linked List

DevFeed: [Howto Find the Start of a Cycle in a Linked List](<https://devfeed.tech/articles/howto-find-the-start-of-a-cycle-in-a-linked-list-87918.md>)

Original publisher: [Read original article](<https://jsdev.space/howto/linked-list-cycle-start/>)

Author: anton liberant

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

Content type: tutorial

Language: en

Sources: [JavaScript Development](<https://devfeed.tech/sources/javascript-development.md>)

Topics: [Skiplists](<https://devfeed.tech/topics/skiplists.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [coding](<https://devfeed.tech/tags/coding.md>), [data](<https://devfeed.tech/tags/data.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [linked-list](<https://devfeed.tech/tags/linked-list.md>), [manipulation](<https://devfeed.tech/tags/manipulation.md>), [return](<https://devfeed.tech/tags/return.md>)

### AI overview

This tutorial explains Floyd's fast and slow pointer algorithm for detecting a cycle in a singly linked list and locating its entry point. It presents the meeting-point reasoning, a JavaScript implementation, a hash set alternative, and their time and space tradeoffs.

### Source excerpt

Learn how Floyd's Fast and Slow Pointer algorithm detects cycles and finds the exact starting node of a loop in O(n) time and O(1) space.

## Databases are Spreadsheets

DevFeed: [Databases are Spreadsheets](<https://devfeed.tech/articles/databases-are-spreadsheets-81338.md>)

Original publisher: [Read original article](<https://stack.convex.dev/databases-are-spreadsheets>)

Author: Stack

Published: 2024-04-16T16:00:00Z

Content type: tutorial

Language: en

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

Topics: [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [search-engines](<https://devfeed.tech/topics/search-engines.md>), [NoSQL](<https://devfeed.tech/topics/nosql.md>), [Skiplists](<https://devfeed.tech/topics/skiplists.md>)

Tags: [b-tree](<https://devfeed.tech/tags/b-tree.md>), [binary-search](<https://devfeed.tech/tags/binary-search.md>), [database-indexes](<https://devfeed.tech/tags/database-indexes.md>), [databases](<https://devfeed.tech/tags/databases.md>), [full-text-search](<https://devfeed.tech/tags/full-text-search.md>), [linear-scan](<https://devfeed.tech/tags/linear-scan.md>), [perspectives](<https://devfeed.tech/tags/perspectives.md>)

### AI overview

The article explains database indexes through a spreadsheet analogy, showing how sorted indexes support efficient queries and how index design depends on query patterns and product needs. It discusses tradeoffs such as write overhead and storage, and contrasts indexed queries with scans or filtering.

### Source excerpt

I want to share my mental model of databases: - Databases are just big spreadsheets - An index is just a view of the spreadsheet sorted by one or more columns - Binary search over a sorted list is faster than a linear scan (for large lists)

## Queries that scale

DevFeed: [Queries that scale](<https://devfeed.tech/articles/queries-that-scale-81428.md>)

Original publisher: [Read original article](<https://stack.convex.dev/queries-that-scale>)

Author: Stack

Published: 2024-02-13T20:00:52Z

Content type: tutorial

Language: en

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

Topics: [Rockset](<https://devfeed.tech/topics/rockset.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Skiplists](<https://devfeed.tech/topics/skiplists.md>)

Tags: [batching](<https://devfeed.tech/tags/batching.md>), [caching](<https://devfeed.tech/tags/caching.md>), [database](<https://devfeed.tech/tags/database.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [queries](<https://devfeed.tech/tags/queries.md>), [scaling](<https://devfeed.tech/tags/scaling.md>)

### AI overview

The article explains how to keep Convex database queries efficient as an app grows. It covers indexing to avoid full table scans, limiting or paginating results, and reducing unnecessary cache invalidation by separating frequently updated data and batching online status updates. It also cautions against optimizing before an app has meaningful user growth.

### Source excerpt

As your app grows from tens to hundreds to thousands of users, there are some techniques that will keep your database queries snappy and efficient. I've put together a short list of the most common techniques used by teams scaling on Convex.

## In defense of linked lists

DevFeed: [In defense of linked lists](<https://devfeed.tech/articles/in-defense-of-linked-lists-20629.md>)

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

Author: Antirez

Published: 2022-11-04T18:46:29Z

Content type: opinion

Language: en

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

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

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [cache](<https://devfeed.tech/tags/cache.md>), [coding](<https://devfeed.tech/tags/coding.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [educational](<https://devfeed.tech/tags/educational.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [insert](<https://devfeed.tech/tags/insert.md>), [interviews](<https://devfeed.tech/tags/interviews.md>), [linked-list](<https://devfeed.tech/tags/linked-list.md>), [node](<https://devfeed.tech/tags/node.md>), [order](<https://devfeed.tech/tags/order.md>), [pointers](<https://devfeed.tech/tags/pointers.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [rust](<https://devfeed.tech/tags/rust.md>), [skip-list](<https://devfeed.tech/tags/skip-list.md>), [space](<https://devfeed.tech/tags/space.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The author argues that linked lists have value beyond coding interviews: they teach how constant-time additions and linear traversal make time and order tradeoffs tangible. Lists can be augmented with backward or "far" pointers, or multiple items per node, to create structures with different properties. Their constant-time split and join can support practical designs: the author cites Redis combining a threaded operation's output buffer with a real client's buffer, and the Linux kernel's embedded-list macros. The text also presents linked lists as useful for incremental ordering and movement, and simple to implement from memory.

### Source excerpt

A few days ago, on Twitter (oh, dear Twitter: whatever happens I'll be there as long as possible - if you care about people that put a lot of energy in creating it, think twice before leaving the platform). So, on Twitter, I was talking about a very bad implementation of linked lists written in Rust. From the tone of certain replies, I got the feeling that many people think linked lists are like a joke. A trivial data structure that is only good for coding interviews, otherwise totally useless. In a word: the bubble sort of data structures. I disagree, so I thought of writing this blog post full of all the things I love about linked lists. So, get ready to read a sentimental post about a data structure, and don't tell I didn't warn you. Linked lists are educational. When your teacher, or the page of a book, or anything that exposes you for the first time to linked lists shows you this little circle with an arrow pointing to another circle, something immense happens in your mind. Similar to what happens when you understand recursion for the first time. You get what data structures made of links truly are: the triviality of a single node that becomes a lot more powerful and complex once it references another one. Linked lists show the new programmer fundamental things about space and time in computation: how it is possible to add elements in a constant time, and how order is fundamentally costly, because if you want to insert an element "in place" you have to go from one node to the other. You immediately start thinking of ways to speed up the process (preparing you for the next things), and at the same time you understand, deeply, what O(1) and O(N) really mean. Linked lists are augmentable. Add a pointer to the previous element, and now it is possible to go both sides. Add "far" pointers from time to time, and you have a skip list with completely different properties. Change every node to hold multiple items and your linked list becomes unrolled, providing very diff

## Programming book recommendations and anti-recommendations

DevFeed: [Programming book recommendations and anti-recommendations](<https://devfeed.tech/articles/programming-book-recommendations-and-anti-recommendations-77739.md>)

Original publisher: [Read original article](<https://danluu.com/programming-books/>)

Published: 2016-10-16T08:06:34Z

Content type: article

Language: en

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

Topics: [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>), [Skiplists](<https://devfeed.tech/topics/skiplists.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [algorithms-and-data-structures](<https://devfeed.tech/tags/algorithms-and-data-structures.md>), [book](<https://devfeed.tech/tags/book.md>), [coding](<https://devfeed.tech/tags/coding.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [divide-and-conquer](<https://devfeed.tech/tags/divide-and-conquer.md>), [people](<https://devfeed.tech/tags/people.md>), [programmers](<https://devfeed.tech/tags/programmers.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

The author challenges universal "must-read" lists and recommends books by subject, explaining what readers may gain and which books suit different learning goals. Coverage includes algorithms, data structures, complexity, operating systems, concurrency, computer architecture, and other areas relevant to programming. The author also points out gaps in the list, including programming languages and networking.

### Source excerpt

There are a lot of "12 CS books every programmer must read" lists floating around out there. That's nonsense. The field is too broad for almost any topic to be required reading for all programmers, and even if a topic is that important, people's learning preferences differ too much for any book on that topic to be the best book on the topic for all people. This is a list of topics and books where I've read the book, am familiar enough with the topic to say what you might get out of learning more about the topic, and have read other books and can say why you'd want to read one book over another. Algorithms / Data Structures / Complexity Why should you care? Well, there's the pragmatic argument: even if you never use this stuff in your job, most of the best paying companies will quiz you on this stuff in interviews. On the non-bullshit side of things, I find algorithms to be useful in the same way I find math to be useful. The probability of any particular algorithm being useful for any particular problem is low, but having a general picture of what kinds of problems are solved problems, what kinds of problems are intractable, and when approximations will be effective, is often useful. McDowell; Cracking the Coding Interview Some problems and solutions, with explanations, matching the level of questions you see in entry-level interviews at Google, Facebook, Microsoft, etc. I usually recommend this book to people who want to pass interviews but not really learn about algorithms. It has just enough to get by, but doesn't really teach you the why behind anything. If you want to actually learn about algorithms and data structures, see below. Dasgupta, Papadimitriou, and Vazirani; Algorithms Everything about this book seems perfect to me. It breaks up algorithms into classes (e.g., divide and conquer or greedy), and teaches you how to recognize what kind of algorithm should be used to solve a particular problem. It has a good selection of topics for an intro book, it's the

## Regaining Lost Knowledge

DevFeed: [Regaining Lost Knowledge](<https://devfeed.tech/articles/regaining-lost-knowledge-21695.md>)

Original publisher: [Read original article](<https://rhettinger.wordpress.com/2010/02/06/lost-knowledge/>)

Author: rhettinger

Published: 2010-02-06T23:28:30Z

Content type: article

Language: en

Sources: [Raymond Hettinger](<https://devfeed.tech/sources/raymond-hettinger.md>)

Topics: [Running Median](<https://devfeed.tech/topics/running-median.md>), [Skiplists](<https://devfeed.tech/topics/skiplists.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [lost-knowledge](<https://devfeed.tech/tags/lost-knowledge.md>), [median](<https://devfeed.tech/tags/median.md>), [python](<https://devfeed.tech/tags/python.md>), [running-median](<https://devfeed.tech/tags/running-median.md>), [skiplists](<https://devfeed.tech/tags/skiplists.md>), [sliding-window](<https://devfeed.tech/tags/sliding-window.md>), [wikipedia](<https://devfeed.tech/tags/wikipedia.md>)

### AI overview

The excerpt presents an indexable skiplist as a portable O(log n)-time approach to maintaining a running median in a sliding window. Earlier replies based on the median's small movement and a QuickSelect recipe were described as unusably slow for large windows; a published method offered O(√n), while a tree-based solution offered O(log n) but was messy to implement and depended on the blist extension for a ready implementation. Adding link widths to a skiplist made median indexing logarithmic, according to the author, and the resulting approach scales to large windows and is portable across languages. The excerpt claims this application had not previously been presented, while acknowledging the passage is truncated.

### Source excerpt

Rediscovery of Indexable Skiplists in the solution of the Running Median problem.