# Sequences

Published articles for Sequences.

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

## More whimsical OEIS sequences

DevFeed: [More whimsical OEIS sequences](<https://devfeed.tech/articles/more-whimsical-oeis-sequences-40522.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/shortform/2026-05-22-1528/>)

Published: 2026-05-22T22:28:34Z

Content type: opinion

Language: en

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

Topics: [Sequences](<https://devfeed.tech/topics/sequences.md>)

Tags: [depths-of-oeis](<https://devfeed.tech/tags/depths-of-oeis.md>), [doom](<https://devfeed.tech/tags/doom.md>), [oeis](<https://devfeed.tech/tags/oeis.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [shortform](<https://devfeed.tech/tags/shortform.md>), [xkcd](<https://devfeed.tech/tags/xkcd.md>)

### AI overview

An informal survey of whimsical OEIS sequences, including sequences inspired by XKCD, non-reduced fractions, hexadecimal patterns, James Bond primes, random tables, and references to the number 666.

### Source excerpt

Here are some more whimsical OEIS sequences I came across. XKCD 2016 joked that "OEIS keeps rejecting my submissions," including one that gives "Integers in increasing order of width when printed in Helvetica." Well, two days after that comic was published (2018-07-09), Hugo Pfoertner published A316600, with a very precise definition. Then he did Arial. Randall Munroe missed a huge opportunity to commit to his bit and actually try to submit some of his sequences before publishing the comic.

## Abandoned Cart Recovery for SaaS: Tactics That Recover 15% of Lost Revenue

DevFeed: [Abandoned Cart Recovery for SaaS: Tactics That Recover 15% of Lost Revenue](<https://devfeed.tech/articles/abandoned-cart-recovery-for-saas-tactics-that-recover-15-of-lost-revenue-9509.md>)

Original publisher: [Read original article](<https://dodopayments.com/blogs/abandoned-cart-recovery-saas/>)

Author: Ayush Agarwal

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

Content type: tutorial

Language: en

Sources: [Dodo Payments Blog](<https://devfeed.tech/sources/dodo-payments-blog.md>)

Topics: [Software as a service](<https://devfeed.tech/topics/saas.md>)

Tags: [checkout](<https://devfeed.tech/tags/checkout.md>), [conversion](<https://devfeed.tech/tags/conversion.md>), [conversion-optimization](<https://devfeed.tech/tags/conversion-optimization.md>), [email](<https://devfeed.tech/tags/email.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [retention](<https://devfeed.tech/tags/retention.md>), [saas](<https://devfeed.tech/tags/saas.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

A guide to recovering abandoned SaaS signups and incomplete purchases through funnel instrumentation, targeted follow-up sequences, and abandonment-specific recovery flows.

### Source excerpt

How SaaS companies recover abandoned signups and incomplete purchases. Email sequences, exit-intent flows, and the recovery patterns that actually convert.

## Unusual uses of OEIS sequences on GitHub

DevFeed: [Unusual uses of OEIS sequences on GitHub](<https://devfeed.tech/articles/unusual-uses-of-oeis-sequences-on-github-40521.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/shortform/2026-04-13-0700/>)

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

Content type: opinion

Language: en

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

Topics: [Sequences](<https://devfeed.tech/topics/sequences.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [depths-of-oeis](<https://devfeed.tech/tags/depths-of-oeis.md>), [github](<https://devfeed.tech/tags/github.md>), [oeis](<https://devfeed.tech/tags/oeis.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [shortform](<https://devfeed.tech/tags/shortform.md>)

### AI overview

The article surveys unusual uses of OEIS sequences in open-source software on GitHub. It describes their use in the Mercury and Ziffers live-coding music frameworks, the Plato e-reader's pen-size options, and the GC Wizard geocaching app.

### Source excerpt

I went hunting for references to the OEIS in open source code, and found some weird ones. There are not one, but two live-coding music frameworks that use OEIS sequences as a source for "anything that can be sequenced" in music. I'm guessing that's used for choosing pseudorandom melodies, interesting rhythyms, or how to overlap tracks in different ways. The first project is called mercury, which is advertised as having "an extensive library of algorithms to generate or transform numbersequences that can modulate parameters.

## The OEIS meta sequence and subway stations

DevFeed: [The OEIS meta sequence and subway stations](<https://devfeed.tech/articles/the-oeis-meta-sequence-and-subway-stations-40520.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/shortform/2026-04-09-0556/>)

Published: 2026-04-09T13:55:17Z

Content type: opinion

Language: en

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

Topics: [Sequences](<https://devfeed.tech/topics/sequences.md>), [math](<https://devfeed.tech/topics/math.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [depths-of-oeis](<https://devfeed.tech/tags/depths-of-oeis.md>), [new-york-city](<https://devfeed.tech/tags/new-york-city.md>), [numberphile](<https://devfeed.tech/tags/numberphile.md>), [oeis](<https://devfeed.tech/tags/oeis.md>), [quirk](<https://devfeed.tech/tags/quirk.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [shortform](<https://devfeed.tech/tags/shortform.md>), [train](<https://devfeed.tech/tags/train.md>)

### AI overview

This commentary examines OEIS sequence A051070, whose nth term is the nth entry of sequence A_n, or -1 when that sequence lacks enough terms. It highlights unusually large or unknown values, subway-stop sequences included in the OEIS, and self-referential questions involving A051070 and A102288.

### Source excerpt

A051070 is a sequence about OEIS sequences. a(n) is the n-th term in sequence A_n (or -1 if A_n doesn't have enough terms). So the first term in A051070 is 1 because A000001 is the number of groups of order n, and that sequence has 1 as its entry in index 1. A000002 is the Kolakoski sequence (what? For another time) and has value 2 in entry 2. The sequence continues: 1, 2, 1, 0, 2, 3, 0, 7, 8, 4, 63, 1, 316, ...

## Why Your Staging Database Never Matches Production

DevFeed: [Why Your Staging Database Never Matches Production](<https://devfeed.tech/articles/why-your-staging-database-never-matches-production-5866.md>)

Original publisher: [Read original article](<https://neon.com/blog/why-your-staging-database-never-matches-production>)

Author: Carlota Soto

Published: 2025-12-12T19:28:15Z

Content type: article

Language: en

Sources: [Blog -- Neon Docs](<https://devfeed.tech/sources/blog-neon-docs.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Development](<https://devfeed.tech/topics/development.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [development](<https://devfeed.tech/tags/development.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [product](<https://devfeed.tech/tags/product.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The article explains why staging databases continually diverge from production. Data, schema, and transformation drift arise because the environments are independent and production continues changing while staging is refreshed, restored, tested, and modified at different times. It illustrates the problem with PostgreSQL sequences, where test-created staging users can receive IDs that production later assigns to real customers.

### Source excerpt

Back when hashtags were a thing, you could search Twitter and find #NoStaging, a community dedicated to banishing the concept of staging from the development world. In the eyes of the #NoStagers, staging was costly, confusing, and corruptible. And they were/are entirely correct....

## Waiting for PostgreSQL 19 - Sequence synchronization in logical replication.

DevFeed: [Waiting for PostgreSQL 19 - Sequence synchronization in logical replication.](<https://devfeed.tech/articles/waiting-for-postgresql-19-sequence-synchronization-in-logical-replication-33669.md>)

Original publisher: [Read original article](<https://www.depesz.com/2025/11/11/waiting-for-postgresql-19-sequence-synchronization-in-logical-replication/>)

Author: depesz

Published: 2025-11-11T12:24:23Z

Content type: tutorial

Language: en

Sources: [select \* from depesz;](<https://devfeed.tech/sources/select-from-depesz.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [logical](<https://devfeed.tech/tags/logical.md>), [pg19](<https://devfeed.tech/tags/pg19.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [psql](<https://devfeed.tech/tags/psql.md>), [publications](<https://devfeed.tech/tags/publications.md>), [replication](<https://devfeed.tech/tags/replication.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>), [upgrade](<https://devfeed.tech/tags/upgrade.md>), [upgrades](<https://devfeed.tech/tags/upgrades.md>), [waiting](<https://devfeed.tech/tags/waiting.md>)

### AI overview

This article demonstrates PostgreSQL 19's planned sequence synchronization for logical replication. It sets up source and destination databases, tests sequence synchronization, finds that resynchronization must be manually invoked, and reports that synchronizing 10,000 sequences took about one second in the author's test.

### Source excerpt

First, on 9th of October 2025, Amit Kapila committed patch: Add "ALL SEQUENCES" support to publications. This patch adds support for the ALL SEQUENCES clause in publications, enabling synchronization/replication of all sequences that is useful for upgrades. Publications can now include all sequences via FOR ALL SEQUENCES. psql enhancements: \d shows publications for ... Continue reading "Waiting for PostgreSQL 19 - Sequence synchronization in logical replication."

## Gophercon Latam 2025 - Serving TUIs over SSH using Go ✨

DevFeed: [Gophercon Latam 2025 - Serving TUIs over SSH using Go ✨](<https://devfeed.tech/articles/gophercon-latam-2025-serving-tuis-over-ssh-using-go-37743.md>)

Original publisher: [Read original article](<https://carlosbecker.com/posts/gophercon-latam-2025/>)

Author: Carlos Alexandro Becker

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

Content type: article

Language: en

Sources: [Carlos Becker](<https://devfeed.tech/sources/carlos-becker.md>)

Topics: [ssh](<https://devfeed.tech/topics/ssh.md>), [Go](<https://devfeed.tech/topics/go.md>), [Text-based user interface](<https://devfeed.tech/topics/tui.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [ansi](<https://devfeed.tech/tags/ansi.md>), [build](<https://devfeed.tech/tags/build.md>), [code](<https://devfeed.tech/tags/code.md>), [event](<https://devfeed.tech/tags/event.md>), [go](<https://devfeed.tech/tags/go.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [interviews](<https://devfeed.tech/tags/interviews.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [photos](<https://devfeed.tech/tags/photos.md>), [repository](<https://devfeed.tech/tags/repository.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [serve](<https://devfeed.tech/tags/serve.md>), [ssh](<https://devfeed.tech/tags/ssh.md>), [talk](<https://devfeed.tech/tags/talk.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

A recap of a Gophercon Latam 2025 talk covering terminal history, ANSI escape sequences, SSH, and how to build and serve a text-based user interface using Bubble Tea and Wish.

### Source excerpt

My talk at Gophercon Latam 2025, showing a brief history of terminals, an introduction to ANSI escape sequences, a briefer introduction to SSH, and finally, how to build and serve a TUI using Bubble Tea and Wish.

## jOOQ 3.20 released with ClickHouse, Databricks, and much more DuckDB support, new modules, Oracle type hierarchies, more spatial support, decfloat and synonym support, hidden columns, Scala 3, Kotlin 2, and much more

DevFeed: [jOOQ 3.20 released with ClickHouse, Databricks, and much more DuckDB support, new modules, Oracle type hierarchies, more spatial support, decfloat and synonym support, hidden columns, Scala 3, Kotlin 2, and much more](<https://devfeed.tech/articles/jooq-3-20-released-with-clickhouse-databricks-and-much-more-duckdb-support-new-modules-oracle-type-hierarchies-more-spatial-support-decfloat-and-synonym-support-hidden-co-28953.md>)

Original publisher: [Read original article](<https://blog.jooq.org/jooq-3-20-released-with-clickhouse-databricks-and-much-more-duckdb-support-new-modules-oracle-type-hierarchies-more-spatial-support-decfloat-and-synonym-support-hidden-columns-scala-3-kotlin/>)

Author: lukaseder

Published: 2025-02-20T10:27:54Z

Content type: release

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [databricks](<https://devfeed.tech/topics/databricks.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Oracle Database](<https://devfeed.tech/topics/oracle-database.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Scala](<https://devfeed.tech/topics/scala.md>), [reactive](<https://devfeed.tech/topics/reactive.md>), [jpa](<https://devfeed.tech/topics/jpa.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [databricks](<https://devfeed.tech/tags/databricks.md>), [decfloat](<https://devfeed.tech/tags/decfloat.md>), [dirty-tracking](<https://devfeed.tech/tags/dirty-tracking.md>), [dml-join](<https://devfeed.tech/tags/dml-join.md>), [duckdb](<https://devfeed.tech/tags/duckdb.md>), [hidden-columns](<https://devfeed.tech/tags/hidden-columns.md>), [jdk-21](<https://devfeed.tech/tags/jdk-21.md>), [jooq](<https://devfeed.tech/tags/jooq.md>), [jooq-3-20](<https://devfeed.tech/tags/jooq-3-20.md>), [jooq-development](<https://devfeed.tech/tags/jooq-development.md>), [jpa](<https://devfeed.tech/tags/jpa.md>), [json](<https://devfeed.tech/tags/json.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-2](<https://devfeed.tech/tags/kotlin-2.md>), [merge](<https://devfeed.tech/tags/merge.md>), [modules](<https://devfeed.tech/tags/modules.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [oracle-plsql-types](<https://devfeed.tech/tags/oracle-plsql-types.md>), [r2dbc](<https://devfeed.tech/tags/r2dbc.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [scala](<https://devfeed.tech/tags/scala.md>), [scala-3](<https://devfeed.tech/tags/scala-3.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [spatial](<https://devfeed.tech/tags/spatial.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

jOOQ 3.20 introduces experimental ClickHouse and Databricks SQL dialects, improves DuckDB support, adds new integration modules, and expands support for Oracle type hierarchies, spatial features, decfloat, synonyms, hidden columns, Scala 3, and Kotlin 2.

### Source excerpt

New dialects: jOOQ 3.20 ships with 2 new experimental dialects: ClickHouse is a fast-moving SQL dialect with a historic vendor-specific syntax that is gradually migrated to a more standards compliant alternative, which is why our support is still experimental. A lot of behaviours differ from what one would expect elsewhere, including NULL handling, which is ... Continue reading jOOQ 3.20 released with ClickHouse, Databricks, and much more DuckDB support, new modules, Oracle type hierarchies, more spatial support, decfloat and synonym support, hidden columns, Scala 3, Kotlin 2, and much more ->

## Effective Kotlin Item 54: Prefer Sequences for big collections with more than one processing step

DevFeed: [Effective Kotlin Item 54: Prefer Sequences for big collections with more than one processing step](<https://devfeed.tech/articles/effective-kotlin-item-54-prefer-sequences-for-big-collections-with-more-than-one-processing-step-39290.md>)

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

Published: 2021-09-20T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Sequences](<https://devfeed.tech/topics/sequences.md>), [Collections](<https://devfeed.tech/topics/collections.md>), [.NET](<https://devfeed.tech/topics/net.md>)

Tags: [collections](<https://devfeed.tech/tags/collections.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [lazy](<https://devfeed.tech/tags/lazy.md>), [order-of-operations](<https://devfeed.tech/tags/order-of-operations.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This article explains the difference between Kotlin collection and sequence processing. Sequences are lazy: intermediate operations build a processing chain, and calculations occur during terminal operations. The article discusses their element-by-element ordering, reduced processing work, support for infinite sequences, and avoidance of intermediate collections.

### Source excerpt

What the difference between list and sequence processing is, and when each should be preferred.

## Exploring a new Postgres database

DevFeed: [Exploring a new Postgres database](<https://devfeed.tech/articles/exploring-a-new-postgres-database-41225.md>)

Original publisher: [Read original article](<https://www.craigkerstiens.com/2020/11/14/Exploring-a-new-Postgres-database/>)

Author: Map

Published: 2020-11-14T19:30:56Z

Content type: tutorial

Language: en

Sources: [Craig Kerstiens](<https://devfeed.tech/sources/craig-kerstiens.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [file](<https://devfeed.tech/topics/file.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>), [Heroku](<https://devfeed.tech/topics/heroku.md>)

Tags: [cli](<https://devfeed.tech/tags/cli.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [databases](<https://devfeed.tech/tags/databases.md>), [file](<https://devfeed.tech/tags/file.md>), [heroku](<https://devfeed.tech/tags/heroku.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [psql](<https://devfeed.tech/tags/psql.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

A practical guide to exploring an unfamiliar Postgres database using the psql command-line client. It covers configuring psql defaults, inspecting database objects and tables, examining data, formatting output, and working with JSONB.

### Source excerpt

At past jobs I'd estimate we had 100 different production apps that in some way were powering key production systems. Sure some were backend/internal apps while others key production apps such as the dashboard itself. At other companies we had a smaller handful of Heroku apps that powered our cloud service, about 5-10 in total. Even just working with those internal apps it's a number of things to keep context on. But when it comes to interacting with something you don't know getting a lay of the land quickly is key. In helping a customer optimize and tune, or even just understand what is going on in their app an understanding of the data model is key. As I just started a few months back at Crunchy Data I found myself digging into a lot of new systems and quickly trying to ramp up and get a feel for them. Over the past 10 years I've pretty well codified my steps to getting a feel for a new database. While I'm not a DBA and a small portion of my job is spent inside a database being able to quickly navigate one saves me hours each month and days out of the year. I'm sure my process isn't perfect, but hopefully it helps other when navigating a new Postgres database for the first time. First the tooling For any new database my go to tool is psql. The built-in Postgres CLI is going to be the quickest thing for me to navigate around. If you use a CLI for anything else then this should be your preference here as well. I'm also going to have a psqlrc file setup that has some good defaults. My go to defaults in my psqlrc are: -- Automatically format output based on result length and screen \x auto -- Prettier nulls \pset null '#' -- Save history based on database name \set HISTFILE ~/.psql_history- :DBNAME -- Turn on automatic query timing \timing Getting a feel for the tables The first thing I'm going to do is just table a look at which objects exist within the database with \d. This will spit out a mix of tables, views, sequences all within your database. A cleaner version

## Restart ID sequences in Postgres on Truncation

DevFeed: [Restart ID sequences in Postgres on Truncation](<https://devfeed.tech/articles/restart-id-sequences-in-postgres-on-truncation-28329.md>)

Original publisher: [Read original article](<http://fuzzyblog.io/blog/sql/2020/03/13/restart-id-sequences-in-postgres-on-truncation.html>)

Author: Fuzzygroup

Published: 2020-03-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Scott Johnson](<https://devfeed.tech/sources/scott-johnson.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Rails](<https://devfeed.tech/topics/rails.md>)

Tags: [activerecord](<https://devfeed.tech/tags/activerecord.md>), [csv](<https://devfeed.tech/tags/csv.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [id](<https://devfeed.tech/tags/id.md>), [identifier](<https://devfeed.tech/tags/identifier.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [rails](<https://devfeed.tech/tags/rails.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

A tutorial on resetting PostgreSQL ID sequences when truncating tables, including a Rails implementation using ActiveRecord. Resetting sequences keeps identifiers consistent when rebuilding data from the same CSV files in development and production.

### Source excerpt

Note: This is from a real world thing that I'm about to release. Like a lot of database apps in the world, mine generally tend to use auto incrementing ids for object identifiers. An object identifier is a value in a system which uniquely identifies something. Let's say you have a url like this: http://localhost:3169/locations?country_id=91 What that is saying, under the hood, is "Get the data from the locations store and give me the object with id value 91". The thing that I'm currently building is populated with a bunch of data which is coming from CSV files that I'm loading from the Internet and I need to wipe the data in the system every time it rebuilds. Now when I say location store, I mean, in this case, a locations table in a Postgres database. When you wipe the contents of a table in Postgres you end up with the next object in the table getting the last ID value plus 1. The secret is to add this snippet to your truncation routine: RESTART IDENTITY or in full: TRUNCATE states RESTART IDENTITY And in Rails I have this implemented on all my core classes as: def self.truncate ActiveRecord::Base.connection.execute("TRUNCATE states RESTART IDENTITY") end Since this is a def self., think of it as a C style static thing. By defining it this way, I can simply call it as State.truncate to eliminate all data in my states store (ok its is a table but it could be more complex) and restart my ID sequences. And in cases it wasn't clear exactly why you want this, since I'm processing the same data files in Production as in Development, my bookmarks become consistent allowing easier debugging.

## When to Use Sequences

DevFeed: [When to Use Sequences](<https://devfeed.tech/articles/when-to-use-sequences-25045.md>)

Original publisher: [Read original article](<https://typealias.com/guides/when-to-use-sequences/>)

Author: author@typealias.com (Dave Leeds)

Published: 2019-09-16T00:00:00Z

Content type: tutorial

Language: en

Sources: [Dave Leeds on Kotlin - typealias.com](<https://devfeed.tech/sources/dave-leeds-on-kotlin-typealias-com.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Streams](<https://devfeed.tech/topics/streams.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [collections](<https://devfeed.tech/tags/collections.md>), [guide](<https://devfeed.tech/tags/guide.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [series](<https://devfeed.tech/tags/series.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [stateless](<https://devfeed.tech/tags/stateless.md>), [streams](<https://devfeed.tech/tags/streams.md>)

### AI overview

A tutorial comparing Kotlin sequences with normal collections and Java streams. It explains performance trade-offs, including how operation-chain length and intermediate collections can affect efficiency, while emphasizing that benchmarks with realistic data are needed for specific code.

### Source excerpt

One of the most common questions I get about Kotlin's sequences is this: "When should I use sequences, and when should I use normal collections?" That's the question we're going to answer in this third and final article in this series! We're going to look at the trade-offs of each, including the main things that affect their performance. Then, we'll look at how Kotlin's sequences stack up against Java streams, a similar concept.

## Inside Sequences: Create Your Own Sequence Operations

DevFeed: [Inside Sequences: Create Your Own Sequence Operations](<https://devfeed.tech/articles/inside-sequences-create-your-own-sequence-operations-25038.md>)

Original publisher: [Read original article](<https://typealias.com/guides/inside-kotlin-sequences/>)

Author: author@typealias.com (Dave Leeds)

Published: 2019-07-23T05:00:00Z

Content type: tutorial

Language: en

Sources: [Dave Leeds on Kotlin - typealias.com](<https://devfeed.tech/sources/dave-leeds-on-kotlin-typealias-com.md>)

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

Tags: [article](<https://devfeed.tech/tags/article.md>), [collection-operations](<https://devfeed.tech/tags/collection-operations.md>), [collections](<https://devfeed.tech/tags/collections.md>), [data](<https://devfeed.tech/tags/data.md>), [guide](<https://devfeed.tech/tags/guide.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [iterable](<https://devfeed.tech/tags/iterable.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [programming](<https://devfeed.tech/tags/programming.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [terminal](<https://devfeed.tech/tags/terminal.md>)

### AI overview

A tutorial that examines how Kotlin sequences process collection elements and explains their relationship to iterables and iterators. It also demonstrates how to create a custom sequence class and use it in an operation chain.

### Source excerpt

Sequences are a fantastic way to process collections of data in a way that can perform better than the standard collection operations, as we saw in the previous article, Kotlin Sequences: An Illustrated Guide. Today, we're going even deeper! We're going to look under the hood - inside Kotlin sequences - in order to understand how they work like never before! In fact, by the end of this article, we'll even create our very own Sequence class and plug it into an operation chain!

## pg\_hexedit now supports GiST, GIN, and hash indexes

DevFeed: [pg\_hexedit now supports GiST, GIN, and hash indexes](<https://devfeed.tech/articles/pg-hexedit-now-supports-gist-gin-and-hash-indexes-33659.md>)

Original publisher: [Read original article](<https://pgeoghegan.blogspot.com/2017/12/pghexedit-now-supports-gist-gin-and.html>)

Author: Peter Geoghegan (noreply@blogger.com)

Published: 2017-12-15T20:29:00Z

Content type: release

Language: en

Sources: [Peter Geoghegan's blog](<https://devfeed.tech/sources/peter-geoghegan-s-blog.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [hash](<https://devfeed.tech/topics/hash.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>)

Tags: [experimental](<https://devfeed.tech/tags/experimental.md>), [hash](<https://devfeed.tech/tags/hash.md>), [index](<https://devfeed.tech/tags/index.md>), [indexes](<https://devfeed.tech/tags/indexes.md>), [internals](<https://devfeed.tech/tags/internals.md>), [nbtree](<https://devfeed.tech/tags/nbtree.md>), [pg-hexedit](<https://devfeed.tech/tags/pg-hexedit.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

An update to the experimental pg_hexedit toolkit adds annotations for GiST, GIN, and hash indexes, as well as sequences, when inspecting raw PostgreSQL relation files. The author plans to add BRIN and SP-GiST support later.

### Source excerpt

I've added several enhancements to pg_hexedit, the experimental hex editor toolkit that allows you to open up raw PostgreSQL relation files with useful tags and annotations about the state and purpose of each field. The tool now supports annotations for GiST, GIN, and hash indexes, as well as sequences. GIN "posting tree" leaf page. Compressed TIDs are in orange. It wasn't very time consuming to add these enhancements, because most index access methods share the same basic approach to page layout. I plan to add support for the two remaining index access methods (BRIN and SP-GiST) early in the new year. My hope is that this will spur interest in the internals of PostgreSQL index access methods (PDF link), and how they deal with index tuples and space management (PDF link). Hat tip to Pat Shaughnessy, who just today wrote a great blog post on the internals of GiST. The fact that he has done such a thorough job of explaining how GiST works to a wider audience is encouraging.

## Java 9 Flow API: ordered merge

DevFeed: [Java 9 Flow API: ordered merge](<https://devfeed.tech/articles/java-9-flow-api-ordered-merge-24810.md>)

Original publisher: [Read original article](<https://akarnokd.blogspot.com/2017/09/java-9-flow-api-ordered-merge.html>)

Author: David Karnok (noreply@blogger.com)

Published: 2017-09-11T14:46:00Z

Content type: tutorial

Language: en

Sources: [Akarnokd - Advanced RxJava](<https://devfeed.tech/sources/akarnokd-advanced-rxjava.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Java 9](<https://devfeed.tech/topics/java-9.md>), [API](<https://devfeed.tech/topics/api.md>)

Tags: [backpressure](<https://devfeed.tech/tags/backpressure.md>), [batching](<https://devfeed.tech/tags/batching.md>), [flow](<https://devfeed.tech/tags/flow.md>), [flow-api](<https://devfeed.tech/tags/flow-api.md>), [java](<https://devfeed.tech/tags/java.md>), [java-9](<https://devfeed.tech/tags/java-9.md>), [merge](<https://devfeed.tech/tags/merge.md>), [ordered-merge](<https://devfeed.tech/tags/ordered-merge.md>), [queue](<https://devfeed.tech/tags/queue.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [rxjava](<https://devfeed.tech/tags/rxjava.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [stream](<https://devfeed.tech/tags/stream.md>)

### AI overview

This article explains why zip() and flatMap() are unsuitable for merging multiple ordered event sequences while preserving order. It presents an orderedMerge() operator that selects the smallest or largest available item, requires a fixed number of source sequences, and discusses how unordered sources produce priority-queue-like output. It also introduces prefetching, queues, coordination, batching, and stable-prefetch backpressure for an inner consumer implementation.

### Source excerpt

Introduction Sometimes, one has several ordered sequences of events and would like to merge them into one single flow. Since one element from a sequence should come before another element in another sequence, we need a way to keep comparing elements with each other from different sequences. Unfortunately, zip() doesn't work because it takes a row of available items and item #2 from sequence #2 may come before item #1 from stream #3. Plus, if one stream is shorter than the others, the end sequence stops. Similarly, flatMap() doesn't work because it takes the next item from any inner source sequence the moment it is available without any ordering considerations at that point. At least it emits all items from all sources (provided there are no errors of course). Therefore, we need something between the two operators: one that collects up a row of items from the sources, decides which is the smallest/largest of them based on some comparison logic and only emits that. It then awaits a fresh item from that specific source (or completion) and repeats the picking of the smallest/largest item as long as there are requests for it. Such operator, let's call it orderedMerge(), has an implication about the number of its inner source sequences: it has to be fixed. The reason for it is that it has to pick the smallest/largest of the available items in order for the output to be in order. If there is still a source missing, it can't know for sure the others are smaller/larger that any of the upcoming item from that missing source will produce. The second implication is, what happens if the sources themselves are not ordered? The logic presented in this post still works, but the end output won't be totally ordered. It will act like some priority queue instead: picking important items first before turning to less important ones. The inner consumer Operators handling multiple sources often need a way to prefetch item from these sources and give out them on demand to some joining logic

## What is special about Nim?

DevFeed: [What is special about Nim?](<https://devfeed.tech/articles/what-is-special-about-nim-30843.md>)

Original publisher: [Read original article](<https://hookrace.net/blog/what-is-special-about-nim/>)

Published: 2014-12-31T23:00:00Z

Content type: tutorial

Language: en

Sources: [Dennis Felsing](<https://devfeed.tech/sources/dennis-felsing.md>)

Topics: [Nim](<https://devfeed.tech/topics/nim.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>)

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [build](<https://devfeed.tech/tags/build.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [import](<https://devfeed.tech/tags/import.md>), [metaprogramming](<https://devfeed.tech/tags/metaprogramming.md>), [nim](<https://devfeed.tech/tags/nim.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [run](<https://devfeed.tech/tags/run.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>), [xor](<https://devfeed.tech/tags/xor.md>)

### AI overview

An introductory article that demonstrates Nim through runnable examples, compile-time execution, CRC32 table generation, templates, macros, and language extension techniques.

### Source excerpt

Russian Translation by frol, Chinese Translation by JiyinYiyong, Japanese Translation by Mutsuha Asada The Nim programming language is exciting. While the official tutorial is great, it slowly introduces you to the language. Instead I want to quickly show what you can do with Nim that would be more difficult or impossible in other languages. I discovered Nim in my quest to find the right tools to write a game, HookRace, the successor of my current DDNet game/mod of Teeworlds. Since I'm busy with other projects for now, this blog is now officially about Nim instead, until I find time to continue developing the game. Easy to get running Ok, this part is not exciting yet, but I invite you to follow along with the post: for i in 0..10: echo "Hello World"[0..i] If you want to do so, get the Nim compiler. Save this code as hello.nim, compile it with nim c hello and finally run the binary with ./hello. To immediately compile and run, use nim -r c hello. To use an optimized release build instead of a debug build use nim -d:release c hello. With all of these settings you will see the following output: H He Hel Hell Hello Hello Hello W Hello Wo Hello Wor Hello Worl Hello World Run regular code at compile time To implement an efficient CRC32 procedure you need a lookup table. You could compute it at runtime or write it into your code as a magic array. Clearly we don't want any magic numbers in our code, so we'll do it at runtime (for now): import unsigned, strutils type CRC32* = uint32 const initCRC32* = CRC32(-1) proc createCRCTable(): array[256, CRC32] = for i in 0..255: var rem = CRC32(i) for j in 0..7: if (rem and 1) > 0: rem = (rem shr 1) xor CRC32(0xedb88320) else: rem = rem shr 1 result[i] = rem # Table created at runtime var crc32table = createCRCTable() proc crc32(s): CRC32 = result = initCRC32 for c in s: result = (result shr 8) xor crc32table[(result and 0xff) xor ord(c)] result = not result # String conversion proc $, automatically called by echo proc `$`(c: CRC32)

## English Letter Frequency Counts: Mayzner Revisited or ETAOIN SRHLDCU

DevFeed: [English Letter Frequency Counts: Mayzner Revisited or ETAOIN SRHLDCU](<https://devfeed.tech/articles/english-letter-frequency-counts-mayzner-revisited-or-etaoin-srhldcu-40576.md>)

Original publisher: [Read original article](<http://norvig.com/mayzner.html>)

Published: 2013-01-04T00:00:00Z

Content type: article

Language: en

Sources: [Peter Norvig](<https://devfeed.tech/sources/peter-norvig.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [datasets](<https://devfeed.tech/topics/datasets.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>), [Google](<https://devfeed.tech/topics/google.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [data](<https://devfeed.tech/tags/data.md>), [google](<https://devfeed.tech/tags/google.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

This article revisits Mark Mayzner's 1960s study of English letter and letter-sequence frequencies. It analyzes Google Books Ngrams data, with counts organized by word length, letter position, and n-gram length, using a much larger dataset than the original sample.

### Source excerpt

An analysis of frequency counts for letters and letter sequences (n-grams), with counts broken out by length of word and poition in word, as well as by length of ngram. A re-implementation of the work done by Mark Mayzner in the 1960s -- but this time with 30 million times more data.

## Reset Counter

DevFeed: [Reset Counter](<https://devfeed.tech/articles/reset-counter-34477.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2012/10/reset-counter/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2012-10-05T07:44:00Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [blog](<https://devfeed.tech/tags/blog.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [query](<https://devfeed.tech/tags/query.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [window-functions](<https://devfeed.tech/tags/window-functions.md>)

### AI overview

A technical walkthrough for calculating the logical value of an ever-increasing counter that periodically resets. It models timestamped measurements and uses PostgreSQL window functions to identify counter wraparounds and retain the relevant values.

### Source excerpt

I've been given a nice puzzle that I think is a good blog article opportunity, as it involves some thinking and window functions.

## Complete Sequences and Magic Tricks

DevFeed: [Complete Sequences and Magic Tricks](<https://devfeed.tech/articles/complete-sequences-and-magic-tricks-40288.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/10/02/complete-sequences-and-magic-tricks/>)

Published: 2012-10-02T11:28:16Z

Content type: tutorial

Language: en

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

Topics: [Sequences](<https://devfeed.tech/topics/sequences.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [code](<https://devfeed.tech/tags/code.md>), [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [greedy-algorithm](<https://devfeed.tech/tags/greedy-algorithm.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [numberphile](<https://devfeed.tech/tags/numberphile.md>), [primes](<https://devfeed.tech/tags/primes.md>), [programming](<https://devfeed.tech/tags/programming.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

This tutorial explains complete integer sequences through a card trick inspired by a Numberphile video. It presents a greedy algorithm that generates the cards and selects the smallest representation of each number, then shows how to implement the method in JavaScript.

### Source excerpt

Numberphile posted a video today describing a neat trick based on complete sequences: The mathematics here is pretty simple, but I noticed at the end of the video that Dr. Grime was constructing the cards by hand, when really this is a job for a computer program. I thought it would be a nice warmup exercise (and a treat to all of the Numberphile viewers) to write a program to construct the cards for any complete sequence.

## Dynamic Time Warping for Sequence Comparison

DevFeed: [Dynamic Time Warping for Sequence Comparison](<https://devfeed.tech/articles/dynamic-time-warping-for-sequence-comparison-40281.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/07/25/dynamic-time-warping/>)

Published: 2012-07-25T20:11:39Z

Content type: tutorial

Language: en

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

Topics: [Sequences](<https://devfeed.tech/topics/sequences.md>), [Python](<https://devfeed.tech/topics/python.md>), [coding](<https://devfeed.tech/topics/coding.md>), [math](<https://devfeed.tech/topics/math.md>)

Tags: [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [function](<https://devfeed.tech/tags/function.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [math](<https://devfeed.tech/tags/math.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [min](<https://devfeed.tech/tags/min.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [range](<https://devfeed.tech/tags/range.md>), [return](<https://devfeed.tech/tags/return.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

This tutorial explains dynamic time warping for comparing sequences of different lengths when their features may occur at different times or rates. It presents a Python implementation using a cost matrix and dynamic programming, with a local numeric distance based on absolute difference.

### Source excerpt

Problem: Write a program that compares two sequences of differing lengths for similarity. Solution: (In Python) import math def dynamicTimeWarp(seqA, seqB, d = lambda x,y: abs(x-y)): # create the cost matrix numRows, numCols = len(seqA), len(seqB) cost = [[0 for _ in range(numCols)] for _ in range(numRows)] # initialize the first row and column cost[0][0] = d(seqA[0], seqB[0]) for i in xrange(1, numRows): cost[i][0] = cost[i-1][0] + d(seqA[i], seqB[0]) for j in xrange(1, numCols): cost[0][j] = cost[0][j-1] + d(seqA[0], seqB[j]) # fill in the rest of the matrix for i in xrange(1, numRows): for j in xrange(1, numCols): choices = cost[i-1][j], cost[i][j-1], cost[i-1][j-1] cost[i][j] = min(choices) + d(seqA[i], seqB[j]) for row in cost: for entry in row: print "%03d" % entry, print "" return cost[-1][-1] Discussion: Comparing sequences of numbers can be tricky business.

## Concurrent Sequencing

DevFeed: [Concurrent Sequencing](<https://devfeed.tech/articles/concurrent-sequencing-30639.md>)

Original publisher: [Read original article](<http://bad-concurrency.blogspot.com/2011/12/concurrent-sequencing_31.html>)

Author: Michael Barker (noreply@blogger.com)

Published: 2011-12-31T10:37:00Z

Content type: article

Language: en

Sources: [Bad Concurrency](<https://devfeed.tech/sources/bad-concurrency.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Java](<https://devfeed.tech/topics/java.md>), [cpu](<https://devfeed.tech/topics/cpu.md>)

Tags: [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [event](<https://devfeed.tech/tags/event.md>), [java](<https://devfeed.tech/tags/java.md>), [process](<https://devfeed.tech/tags/process.md>), [processors](<https://devfeed.tech/tags/processors.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

The article examines poor Disruptor performance under heavy contention when there are fewer available processor cores than busy threads. It attributes the problem to a busy-spin publishing loop that can starve the thread updating the cursor, and discusses Java and processor-level constraints affecting possible solutions.

### Source excerpt

A few weeks ago one of the users of the Disruptor posted some worrying benchmarks: ThreePublisherToOneProcessorSequencedThroughputTest run 0: BlockingQueue=645,161 Disruptor=1,772 ops/sec run 1: BlockingQueue=1,250,000 Disruptor=20,000,000 ops/sec run 2: BlockingQueue=1,250,000 Disruptor=56 ops/sec It appears under heavy contention with fewer available cores than busy threads the Disruptor can perform terribly. After a bit of investigation I managed to isolate the problem. One of the most complex parts of the Disruptor is the multi-threaded claim strategy. It is the only place in the Disruptor where - out of necessity - we break the single-writer principal. The approach that we used was very simple. Each thread claims a slot in the ring buffer using AtomicLong.incrementAndGet(). This ensures that each claim will return a unique sequential value. The complexity arrives when the multiple threads try to publish their sequence. We require that all events placed in the ring buffer must be made available to event processors in a strictly sequential order. To ensure this behaviour we have a method called serialisePublishing(). Our simple implementation would have the thread that is publishing busy spin until the last published sequence (the cursor) is one less the value being published. This works because each sequence published is unique and strictly ascending. For example if one thread wants to publish the value 8, it will spin until the cursor value reaches 7. Because no other thread will be trying publish value 8 it can make progress and ensuring the sequential publishing behaviour in the process. However, this busy spin loop causes problems when there are more threads than cores. The threads that need wait for the prior sequences to be published can starve out the thread that should be updating the cursor. This leads to the unpredictable results shown above. We need a better solution. In an ideal world there would be a Java API that would compile down to the Intel MON

## Coding Challenge: The Luhny Bin

DevFeed: [Coding Challenge: The Luhny Bin](<https://devfeed.tech/articles/coding-challenge-the-luhny-bin-15580.md>)

Original publisher: [Read original article](<https://developer.squareup.com/blog/coding-challenge-the-luhny-bin>)

Author: Square Engineering

Published: 2011-11-14T17:00:00Z

Content type: article

Language: en

Sources: [Square Corner Blog RSS Feed](<https://devfeed.tech/sources/square-corner-blog-rss-feed.md>)

Topics: [Code Challenge](<https://devfeed.tech/topics/code-challenge.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [coding](<https://devfeed.tech/topics/coding.md>), [ASCII](<https://devfeed.tech/topics/ascii.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Streams](<https://devfeed.tech/topics/streams.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [ascii](<https://devfeed.tech/tags/ascii.md>), [coding](<https://devfeed.tech/tags/coding.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [github](<https://devfeed.tech/tags/github.md>), [logs](<https://devfeed.tech/tags/logs.md>), [numbers](<https://devfeed.tech/tags/numbers.md>), [sequences](<https://devfeed.tech/tags/sequences.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

This coding challenge asks readers to write a command-line program that reads ASCII text, identifies digit sequences resembling credit card numbers using the Luhn checksum, masks every digit in qualifying sequences with X characters, and writes the filtered text to standard output. The challenge includes requirements for 14- to 16-digit numbers, separators, and overlapping matches.

### Source excerpt

Do you have what it takes to escape the Luhny Bin?

## Brute-force String Generation in C

DevFeed: [Brute-force String Generation in C](<https://devfeed.tech/articles/brute-force-string-generation-in-c-40659.md>)

Original publisher: [Read original article](<https://radek.io/posts/brute-force-string-generation-in-c/>)

Published: 2011-08-03T00:00:00Z

Content type: tutorial

Language: en

Sources: [Radek Pazdera](<https://devfeed.tech/sources/radek-pazdera.md>)

Topics: [C](<https://devfeed.tech/topics/c.md>), [Sequences](<https://devfeed.tech/topics/sequences.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Code](<https://devfeed.tech/topics/code.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [c](<https://devfeed.tech/tags/c.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [language](<https://devfeed.tech/tags/language.md>), [python](<https://devfeed.tech/tags/python.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

The article presents a C implementation for generating string sequences used in brute-force attacks. It emphasizes speed and efficient generation of input combinations, contrasting the C implementation with earlier Python examples.

### Source excerpt

Simple and fast way of generating string sequences in C.

## Finding orphaned sequences

DevFeed: [Finding orphaned sequences](<https://devfeed.tech/articles/finding-orphaned-sequences-34363.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2010/03/finding-orphaned-sequences/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2010-03-17T12:35:00Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [Sequences](<https://devfeed.tech/topics/sequences.md>), [Database](<https://devfeed.tech/topics/database.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [query](<https://devfeed.tech/tags/query.md>), [sequences](<https://devfeed.tech/tags/sequences.md>)

### AI overview

The article presents a query for finding database sequences that are not used as default values in any table columns.

### Source excerpt

This time we're having a database where sequences were used, but not systematically as a default value of a given column. It's mainly an historic bad idea, but you know the usual excuse with bad ideas and bad code: the first 6 months it's experimental, after that it's historic. *Not talking about genome orphaned sequences here, though* Still, here's a query for 8.4 that will allow you to list those sequences you have that are not used as a default value in any of your tables:

[Next page](<https://devfeed.tech/tags/sequences.md?cursor=WyIyMDEwLTAzLTE3VDEyOjM1OjAwKzAwOjAwIiwgImE4OGY3NDgyLThhYjUtNDkwYS1iNzllLThlYjkxZjRlZjM1NiJd>)