# concurrently

Published articles for concurrently.

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

## Waiting for PostgreSQL 19 - Add CONCURRENTLY option to REPACK

DevFeed: [Waiting for PostgreSQL 19 - Add CONCURRENTLY option to REPACK](<https://devfeed.tech/articles/waiting-for-postgresql-19-add-concurrently-option-to-repack-33689.md>)

Original publisher: [Read original article](<https://www.depesz.com/2026/04/21/waiting-for-postgresql-19-add-concurrently-option-to-repack/>)

Author: depesz

Published: 2026-04-21T10:40:14Z

Content type: opinion

Language: en

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

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

Tags: [bloat](<https://devfeed.tech/tags/bloat.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [pg19](<https://devfeed.tech/tags/pg19.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [repack](<https://devfeed.tech/tags/repack.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>), [vacuum](<https://devfeed.tech/tags/vacuum.md>), [waiting](<https://devfeed.tech/tags/waiting.md>)

### AI overview

The article tests PostgreSQL 19's proposed CONCURRENTLY option for REPACK on a table with 200 million rows. The test found that the table shrank as expected, while inserts experienced a visible but limited slowdown during repacking.

### Source excerpt

On 6th of April 2026, Álvaro Herrera committed patch: Add CONCURRENTLY option to REPACK When this flag is specified, REPACK no longer acquires access-exclusive lock while the new copy of the table is being created; instead, it creates the initial copy under share-update-exclusive lock only (same as vacuum, etc), and it follows an MVCC ... Continue reading "Waiting for PostgreSQL 19 - Add CONCURRENTLY option to REPACK"

## Node.js script to run multiple commands in parallel

DevFeed: [Node.js script to run multiple commands in parallel](<https://devfeed.tech/articles/node-js-script-to-run-multiple-commands-in-parallel-37322.md>)

Original publisher: [Read original article](<https://muffinman.io/blog/node-script-to-run-multiple-commands-in-parallel/>)

Author: Stanko

Published: 2024-06-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Stanko Tadić](<https://devfeed.tech/sources/stanko-tadic.md>)

Topics: [Node.js](<https://devfeed.tech/topics/node-js.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Scripting](<https://devfeed.tech/topics/scripting.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>)

Tags: [bash](<https://devfeed.tech/tags/bash.md>), [commands](<https://devfeed.tech/tags/commands.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [script](<https://devfeed.tech/tags/script.md>)

### AI overview

This tutorial presents a small Node.js script for running multiple commands in parallel. It explains the requirements, including stopping all commands when one fails and prefixing each command's output with color-coded names, and shows how to use and implement the script.

### Source excerpt

If you encountered a case where you wanted to run multiple commands in parallel, the usual suggestion is to use the shell's & operator to send commands to the background. This approach kind of works, but it has its quirks. I often ended up with a process hanging in the background, multiple outputs being mangled, or the output of some commands completely missing. Bash scripting wizards can probably solve all of these issues, but I turned to JavaScript, as it is the language I know best. If you're eager to see the code, feel free to jump to it. Why not an existing library? # In my professional projects, I would probably just use concurrently. However, this time I decided to write a poor man's version of it. Although simple and basic, it covers my specific use case. It was mostly for learning purposes, but sometimes I create things from scratch for fun or to avoid installing a large library for a tiny piece of it. My requirements # Run multiple commands in parallel. Terminate all of the commands if any of them fail. Prefix each command's output with its color-codedIn the finished version, I added an option to disable colors, as I know some people really don't like colors in their terminals name. I also decided to keep it simple: No CLI version to avoid parsing the arguments. Name (prefix) should be a mandatory input. Usage # To use the script, you need to import it and pass the list of your commands (along with their names) to it. Like this: import { Runner } from './runner.js'; const tasks = [ { name: 'sass', command: 'npm run sass' }, { name: 'build', command: 'npm run build' }, ]; new Runner(tasks); This is how the script looks in action: Source code # Here is the complete script: import { spawn } from 'child_process'; export class Runner { tasks = []; exiting = false; colors = [ '\x1b[33m', // yellow '\x1b[34m', // blue '\x1b[35m', // magenta '\x1b[36m', // cyan ]; /** * Create a new runner. * @param {Object[]} tasks - List of tasks to run in parallel. * @param {st

## How does suspension work in Kotlin coroutines?

DevFeed: [How does suspension work in Kotlin coroutines?](<https://devfeed.tech/articles/how-does-suspension-work-in-kotlin-coroutines-39239.md>)

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

Published: 2021-07-28T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [suspend](<https://devfeed.tech/tags/suspend.md>), [thread](<https://devfeed.tech/tags/thread.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This tutorial explains how suspension works in Kotlin coroutines. It contrasts coroutine suspension with thread blocking, describes how suspended coroutines retain their state while using fewer resources, and introduces suspending functions and their role in suspending coroutines.

### Source excerpt

A deep explanation of how suspension works in Kotlin Coroutines.

## Avoid naming a constraint directly when using ON CONFLICT DO UPDATE

DevFeed: [Avoid naming a constraint directly when using ON CONFLICT DO UPDATE](<https://devfeed.tech/articles/avoid-naming-a-constraint-directly-when-using-on-conflict-do-update-33652.md>)

Original publisher: [Read original article](<https://pgeoghegan.blogspot.com/2015/10/avoid-naming-constraint-directly-when.html>)

Author: Peter Geoghegan (noreply@blogger.com)

Published: 2015-10-02T18:36:00Z

Content type: article

Language: en

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

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [syntax](<https://devfeed.tech/topics/syntax.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [concurrently](<https://devfeed.tech/tags/concurrently.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [indexes](<https://devfeed.tech/tags/indexes.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

The article explains PostgreSQL 9.5's UPSERT syntax and recommends using unique index inference with ON CONFLICT DO UPDATE instead of naming a constraint directly. It describes how inference selects arbiter indexes and handles variations such as column ordering, partial-index predicates, and multiple equivalent unique indexes.

### Source excerpt

PostgreSQL 9.5 will have support for a feature that is popularly known as "UPSERT" - the ability to either insert or update a row according to whether an existing row with the same key exists. If such a row already exists, the implementation should update it. If not, a new row should be inserted. This is supported by way of a new high level syntax (a clause that extends the INSERT statement) that more or less relieves the application developer from having to give any thought to race conditions. This common operation for client applications is set to become far simpler and far less error-prone than legacy ad-hoc approaches to UPSERT involving subtransactions. When we worked on UPSERT, many edge-cases were carefully considered. A technique called "unique index inference" allows DML statement authors to be very explicit about what condition they want to take the alternative (UPDATE or NOTHING) path on. That alternative path can only be taken in the event of a would-be duplicate violation in an "arbiter" unique index (for the DO NOTHING variant, a would-be exclusion violation is also a possible reason to take the alternative NOTHING path). The ability to write UPSERT statements explicitly and safely while also having lots of flexibility is an important differentiator for PostgreSQL's UPSERT in my view. As the 9.5 INSERT documentation explains, the inference syntax contains one or more column_name_index (columns) and/or expression_index expressions (expressions), and perhaps an optional index_predicate (for partial unique indexes, which are technically not constraints at all). This is internally used to figure out which of any available unique indexes ought to be considered as an arbiter of taking the alternative path. If none can be found, the optimizer raises an error. The inference syntax is very flexible, and very tolerant of variations in column ordering, whether or not a partial unique index predicate is satisfied, and several other things. It can infer multiple un

## I wrote Antigen in Go: Antibody

DevFeed: [I wrote Antigen in Go: Antibody](<https://devfeed.tech/articles/i-wrote-antigen-in-go-antibody-37733.md>)

Original publisher: [Read original article](<https://carlosbecker.com/posts/go-antibody/>)

Author: Carlos Alexandro Becker

Published: 2015-06-06T00:00:00Z

Content type: opinion

Language: en

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

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Erlang](<https://devfeed.tech/topics/erlang.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [erlang](<https://devfeed.tech/tags/erlang.md>), [execution](<https://devfeed.tech/tags/execution.md>), [go](<https://devfeed.tech/tags/go.md>), [language](<https://devfeed.tech/tags/language.md>), [learning](<https://devfeed.tech/tags/learning.md>), [post](<https://devfeed.tech/tags/post.md>), [thoughts](<https://devfeed.tech/tags/thoughts.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

A personal account of learning Go while building Antibody, a reimplementation of Antigen. The article discusses Go's syntax, built-in formatting and error checks, and its concurrency features for processing plugin bundles.

### Source excerpt

Learning Go was in my TODO list for a while, and finally I did something about it. This post contains some thoughts about it...

## Bulk Replication

DevFeed: [Bulk Replication](<https://devfeed.tech/articles/bulk-replication-34498.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2013/03/bulk-replication/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2013-03-18T13:54:00Z

Content type: tutorial

Language: en

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

Topics: [Replication](<https://devfeed.tech/topics/replication.md>), [data](<https://devfeed.tech/topics/data.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [batch](<https://devfeed.tech/tags/batch.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [delete](<https://devfeed.tech/tags/delete.md>), [handler](<https://devfeed.tech/tags/handler.md>), [insert](<https://devfeed.tech/tags/insert.md>), [network](<https://devfeed.tech/tags/network.md>), [replication](<https://devfeed.tech/tags/replication.md>)

### AI overview

This article explains how batch update techniques can be applied to trigger-based data replication with SkyTools and londiste. It describes using londiste handlers to process batches of replication events, including bulk-loading methods for inserting, updating, and deleting data.

### Source excerpt

In the previous article here we talked about how to properly update more than one row at a time, under the title Batch Update. We did consider performances, including network round trips, and did look at the behavior of our results when used concurrently. A case where we want to apply the previous article approach is when replicating data with a trigger based solution, such as SkyTools and londiste. Well, maybe not in all cases, we need to have a amount of UPDATE trafic worthy of setting up the solution. As soon as we know we're getting to replay important enough batches of events, though, certainly using the batch update tricks makes sense.

## My experience with django-mptt

DevFeed: [My experience with django-mptt](<https://devfeed.tech/articles/my-experience-with-django-mptt-35435.md>)

Original publisher: [Read original article](<https://darkcoding.net/software/my-experience-with-django-mptt/>)

Author: Graham King

Published: 2011-04-29T23:57:41Z

Content type: opinion

Language: en

Sources: [Graham King](<https://devfeed.tech/sources/graham-king.md>)

Topics: [Django](<https://devfeed.tech/topics/django.md>), [Maintainability](<https://devfeed.tech/topics/maintainability.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Processes](<https://devfeed.tech/topics/processes.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>)

Tags: [concurrently](<https://devfeed.tech/tags/concurrently.md>), [database](<https://devfeed.tech/tags/database.md>), [django](<https://devfeed.tech/tags/django.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [processes](<https://devfeed.tech/tags/processes.md>), [python](<https://devfeed.tech/tags/python.md>), [software](<https://devfeed.tech/tags/software.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

The author shares experience maintaining two Django projects that used django-mptt, a toolkit for adding tree structures to Django models. The article argues that django-mptt's automation can obscure behavior and increase complexity, and recommends starting with a self-referential foreign key and adding mptt only when its performance benefits justify the maintainability cost. It also discusses using raw SQL for bulk imports, avoiding concurrent object creation that can cause deadlocks, and rebuilding trees afterward.

### Source excerpt

"Navigating the forest of django-mptt: A cautionary tale"