# Parallelism

Published articles for Parallelism.

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 We Built Automated Capacity Testing for Kafka Consumers

DevFeed: [How We Built Automated Capacity Testing for Kafka Consumers](<https://devfeed.tech/articles/how-we-built-automated-capacity-testing-for-kafka-consumers-23723.md>)

Original publisher: [Read original article](<https://medium.com/booking-com-development/how-we-built-automated-capacity-testing-for-kafka-consumers-1853623bce78?source=rss----1c36c35f9c76---4>)

Author: Kaan Karakaya

Published: 2026-09-14T09:46:34Z

Content type: tutorial

Language: en

Sources: [Booking.com Development - Medium](<https://devfeed.tech/sources/booking-com-development-medium.md>)

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [HTTP](<https://devfeed.tech/topics/http.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [health-checks](<https://devfeed.tech/tags/health-checks.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [load](<https://devfeed.tech/tags/load.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [partition](<https://devfeed.tech/tags/partition.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [scale](<https://devfeed.tech/tags/scale.md>), [site-reliability-engineer](<https://devfeed.tech/tags/site-reliability-engineer.md>), [sre](<https://devfeed.tech/tags/sre.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This article describes Booking.com's extension of an existing capacity-testing platform for Kafka consumers. It explains how changing partition assignment can provide a controlled, measurable way to test consumer throughput and whether remaining consumers can absorb reassigned work after an instance or failure domain disappears.

### Source excerpt

Photo by GuerrillaBuzz on Unsplash Kafka makes it easy to distribute work across consumer instances. It is much harder to prove, safely and repeatedly, how those instances behave when the distribution changes and one of them has to carry more than its usual share. For teams that run Kafka at scale, this is a practical reliability question: how much load can a consumer instance actually handle? We had automated capacity testing for HTTP services, but Kafka consumers were still tested with manual drills. Those drills could tell us something, but they were disruptive, difficult to reproduce, and risky precisely when the system was close to its limit. We wanted a controlled way to answer three questions: What is the maximum sustainable throughput of a consumer instance? If an instance or failure domain disappears, can the remaining consumers absorb the reassigned work? Are we overprovisioning resources because we do not know the real limit? The result was an extension to our capacity-testing platform that turns Kafka partition assignment into a safe, measurable load-control mechanism. Why HTTP capacity testing did not translate Our existing platform was designed for request-response services behind a load balancer. A scheduled test selects one instance, routes an increasing share of traffic to it, runs health checks after each step, and records the highest ratio the instance can sustain. After the test, traffic returns to its normal distribution and the result is reported to the service owner. Kafka has no equivalent traffic knob. Consumers pull records, and the unit of parallelism is the partition. Within a consumer group, each partition is owned by one consumer at a time. If a topic has 12 partitions and four equally loaded instances, each instance owns about three. When one instance disappears, a rebalance gives the survivors more partitions -- and the extra work arrives as a step change, not as a smooth increase from a load balancer. The key translation: for an HTTP

## Where Kafka Fits in Modern Systems

DevFeed: [Where Kafka Fits in Modern Systems](<https://devfeed.tech/articles/where-kafka-fits-in-modern-systems-18029.md>)

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

Author: Nikki Siapno

Published: 2026-08-25T12:02:09Z

Content type: tutorial

Language: en

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

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [Event-Streaming](<https://devfeed.tech/topics/event-streaming.md>), [systems](<https://devfeed.tech/topics/systems.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [consumer](<https://devfeed.tech/tags/consumer.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [durability](<https://devfeed.tech/tags/durability.md>), [event-streaming](<https://devfeed.tech/tags/event-streaming.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [partition](<https://devfeed.tech/tags/partition.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This article explains when Apache Kafka is appropriate for distributed systems. It presents Kafka as a durable event log whose replayability, consumer fan-out, and partition-based parallelism support real-time data pipelines and shared event-driven architectures, while warning that Kafka can add unnecessary operational complexity for simpler asynchronous workflows.

### Source excerpt

When should you actually use Kafka? And when is it just unnecessary complexity?

## Coroutine Essentials

DevFeed: [Coroutine Essentials](<https://devfeed.tech/articles/coroutine-essentials-25051.md>)

Original publisher: [Read original article](<https://typealias.com/start/kotlin-coroutines/>)

Author: author@typealias.com (Dave Leeds)

Published: 2026-08-21T00: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: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [async](<https://devfeed.tech/tags/async.md>), [cancellation](<https://devfeed.tech/tags/cancellation.md>), [coding](<https://devfeed.tech/tags/coding.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [deferred](<https://devfeed.tech/tags/deferred.md>), [dispatcher](<https://devfeed.tech/tags/dispatcher.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [job](<https://devfeed.tech/tags/job.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [launch](<https://devfeed.tech/tags/launch.md>), [learn-to-program](<https://devfeed.tech/tags/learn-to-program.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [programming](<https://devfeed.tech/tags/programming.md>), [runblocking](<https://devfeed.tech/tags/runblocking.md>), [software](<https://devfeed.tech/tags/software.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [suspend-function](<https://devfeed.tech/tags/suspend-function.md>), [withcontext](<https://devfeed.tech/tags/withcontext.md>), [yield](<https://devfeed.tech/tags/yield.md>)

### AI overview

This tutorial introduces essential Kotlin coroutine concepts for performing multiple tasks concurrently, such as making network calls while updating a screen. It aims to provide a foundation for day-to-day coding and more advanced coroutine concepts.

### Source excerpt

When you're on hold during a phone call, you might also check your email. While brewing coffee, you might also cook breakfast. And while driving a car, you might listen to a podcast. In the same way, sometimes it's helpful for the software that we write to do more than one thing at a time. For example, it could make two or three network calls at one time--all while updating the screen to show the progress of each call.

## The Orchestrator's Tax

DevFeed: [The Orchestrator's Tax](<https://devfeed.tech/articles/the-orchestrator-s-tax-4422.md>)

Original publisher: [Read original article](<https://martinfowler.com/articles/orchestrator-tax.html>)

Author: Martin Fowler (martin@martinfowler.com)

Published: 2026-07-28T13:10:00Z

Content type: article

Language: en

Sources: [Martin Fowler](<https://devfeed.tech/sources/martin-fowler.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [incident](<https://devfeed.tech/topics/incident.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [delegation](<https://devfeed.tech/tags/delegation.md>), [incident](<https://devfeed.tech/tags/incident.md>), [memory](<https://devfeed.tech/tags/memory.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Rahul Garg argues that the main cost of subagents in long-running multi-agent work is not necessarily execution time or parallelism, but the orchestrator's limited working memory. Drawing on an exploratory Claude Code session involving four subagents, the article examines delegation, context overhead, and the need for explicit delegation rules.

### Source excerpt

Subagents get justified by time saved and parallel execution, but Rahul Garg explains that's not what matters most. Every token in the orchestrator's context is competing for its attention, and the real value of a subagent is what it keeps out of that context. Subagents should be treated as a tool for protecting the orchestrator's working memory, offloading reasoning it doesn't need to hold onto. Doing this well means giving the orchestrator explicit ground rules for when and how to delegate. more...

## How Lawmatics Cut CI Compute Cost by 39.3% and Shortened Pipeline Time by 15.8%

DevFeed: [How Lawmatics Cut CI Compute Cost by 39.3% and Shortened Pipeline Time by 15.8%](<https://devfeed.tech/articles/how-lawmatics-cut-ci-compute-cost-by-39-3-and-shortened-pipeline-time-by-15-8-20424.md>)

Original publisher: [Read original article](<https://semaphore.io/blog/how-lawmatics-cut-ci-compute-cost-and-shortened-pipeline-time>)

Author: Christian Gómez Alonso

Published: 2026-07-27T15:23:37Z

Content type: article

Language: en

Sources: [Semaphore Engineering](<https://devfeed.tech/sources/semaphore-engineering.md>)

Topics: [ci](<https://devfeed.tech/topics/ci.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [browser](<https://devfeed.tech/topics/browser.md>)

Tags: [browser](<https://devfeed.tech/tags/browser.md>), [ci](<https://devfeed.tech/tags/ci.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [compute](<https://devfeed.tech/tags/compute.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

This case study describes how Lawmatics optimized its CI pipeline by changing the machine class used for parallel browser end-to-end tests while initially preserving parallelism. The reported result was a 39.3% reduction in average application compute cost per pipeline and a 15.8% reduction in active pipeline duration.

### Source excerpt

CI optimization is easiest to reason about when the problem is concrete: one pipeline, one critical path, and one cost model. Lawmatics reached out to us with that kind of problem. Their application pipeline was already parallelized and already using a sensible CI structure. The remaining question was whether the most expensive part of the [...] The post How Lawmatics Cut CI Compute Cost by 39.3% and Shortened Pipeline Time by 15.8% appeared first on Semaphore.

## How the Gradle Team Adopted Isolated Projects

DevFeed: [How the Gradle Team Adopted Isolated Projects](<https://devfeed.tech/articles/how-the-gradle-team-adopted-isolated-projects-24658.md>)

Original publisher: [Read original article](<https://blog.gradle.org/isolated-projects-in-gradle-team>)

Author: Alex Semin

Published: 2026-07-22T04:00:00Z

Content type: article

Language: en

Sources: [The Gradle Blog](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Dependency management](<https://devfeed.tech/topics/dependency-management.md>), [ci](<https://devfeed.tech/topics/ci.md>), [ide](<https://devfeed.tech/topics/ide.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [ci](<https://devfeed.tech/tags/ci.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [dependency-management](<https://devfeed.tech/tags/dependency-management.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [ide](<https://devfeed.tech/tags/ide.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

The Gradle team describes adopting the experimental Isolated Projects feature in its own build. The article explains that Isolated Projects runs project configuration in parallel to improve scalability and performance, and outlines migration prerequisites, diagnostics, convention plugins, dependency management, and Shared Build Services.

### Source excerpt

Isolated Projects is an experimental feature aimed at improving Gradle scalability and performance. It speeds up builds by running project configuration in parallel, which benefits practically every workflow, from CI builds to IDE sync. We want the feature to offer an excellent user experience, so we made it a goal to adopt Isolated Projects in our own build, even though it is still in active development. This lets us find and smooth out the rough spots early, though secretly, we were also looking forward to the productivity boost for our own team. With Isolated Projects, more build logic runs concurrently. To keep builds reliable under that parallelism, the feature introduces additional constraints, and adopting it means migrating your build to address the violations of those constraints. Migrating our build Isolated Projects builds directly on top of the Configuration Cache, so making the build Configuration Cache compatible is a prerequisite. Fortunately for us, we've been enjoying fast inner developer loops for many years now, so that box was already checked. The general approach to migrating against new constraints is to start with the simplest workflows, such as running the help task, and address the violations. Then proceed to more complex workflows, such as IDE sync or CI. Running in Diagnostics mode helps you see all violations at once in a single HTML report, and the guide describes the recommended migration path. For the Gradle build, we followed a similar path. What helped us the most and made the migration much smoother is following the best practices, especially the best practice of having convention plugins: each project applies the build logic it needs, and no project has to reach in and mutate another's state directly. We've leaned heavily on sharing artifacts between projects only via dependency management, which is inherently compatible with Isolated Projects by making each project define its "outputs", on which other projects can depend. For more

## Npb: Nixpkgs PR build diff CLI inspired by nixpkgs-review

DevFeed: [Npb: Nixpkgs PR build diff CLI inspired by nixpkgs-review](<https://devfeed.tech/articles/npb-nixpkgs-pr-build-diff-cli-inspired-by-nixpkgs-review-31361.md>)

Original publisher: [Read original article](<https://discourse.nixos.org/t/npb-nixpkgs-pr-build-diff-cli-inspired-by-nixpkgs-review/79106>)

Author: samestep

Published: 2026-07-21T21:09:29Z

Content type: article

Language: en

Sources: [Announcements - NixOS Discourse](<https://devfeed.tech/sources/announcements-nixos-discourse.md>)

Topics: [Nix](<https://devfeed.tech/topics/nix.md>), [Development](<https://devfeed.tech/topics/development.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>)

Tags: [announcements](<https://devfeed.tech/tags/announcements.md>), [caching](<https://devfeed.tech/tags/caching.md>), [cli](<https://devfeed.tech/tags/cli.md>), [memory](<https://devfeed.tech/tags/memory.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [text](<https://devfeed.tech/tags/text.md>)

### AI overview

A developer introduces npb, a Nixpkgs pull-request build outcome diff CLI inspired by nixpkgs-review. It compares build results before and after a change, and adds features including passthru.test inclusion, cached failures, lower memory usage, parallel Nix evaluations, reproducible report commands, and progress indicators.

### Source excerpt

Hello! While reviewing Nixpkgs PRs written by myself and others, I've found it difficult to keep track of which build failures were preexisting and which are regressions introduced by the PR itself. So I built a tool called npb which produces reports that are similar to nixpkgs-review, but show both before and after, instead of just after. github.com GitHub - samestep/npb: Nixpkgs build outcome diff CLI Nixpkgs build outcome diff CLI While building this, I also included some other features I had found myself wanting previously, such as: automatically including passthru.tests caching build failures in a local database reducing memory usage of Nix evaluations speeding up Nix evaluations via parallelism giving each report a command that reproduces the same report providing progress indicators during long-running operations I hope you find it useful! Disclosure, quoting the project's README: The development of this project was AI-assisted. There is no AI-generated text in this README, npb --help, or npb's generated reports. 7 posts - 4 participants Read full topic

## Releasing Execution Contexts

DevFeed: [Releasing Execution Contexts](<https://devfeed.tech/articles/releasing-execution-contexts-22337.md>)

Original publisher: [Read original article](<https://crystal-lang.org/2026/07/12/releasing-execution-contexts/>)

Author: Julien Portalier

Published: 2026-07-12T00:00:00Z

Content type: release

Language: en

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

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

Tags: [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [main-thread](<https://devfeed.tech/tags/main-thread.md>), [multithreading](<https://devfeed.tech/tags/multithreading.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [threads](<https://devfeed.tech/tags/threads.md>)

### AI overview

Crystal is introducing Execution Contexts, an interface for orchestrating fibers across one or more threads. The article describes concurrent and parallel contexts, configurable parallelism, and execution across CPU cores while preserving a single-threaded default.

### Source excerpt

Two and a half years ago, with the invaluable support from 84codes, we re-examined the multithreading model inherited from Crystal 0.28 (preview MT).

## Using OxCaml to implement type-safe reference counting between OCaml and Python

DevFeed: [Using OxCaml to implement type-safe reference counting between OCaml and Python](<https://devfeed.tech/articles/using-oxcaml-to-implement-type-safe-reference-counting-between-ocaml-and-python-20199.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/oxcaml-typesafe-reference-counting-python/>)

Author: Nicolas Trangez

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

Content type: tutorial

Language: en

Sources: [Jane Street](<https://devfeed.tech/sources/jane-street.md>)

Topics: [OCaml](<https://devfeed.tech/topics/ocaml.md>), [Python](<https://devfeed.tech/topics/python.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Data analysis](<https://devfeed.tech/topics/data-analysis.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [gc](<https://devfeed.tech/tags/gc.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [ocaml](<https://devfeed.tech/tags/ocaml.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

Jane Street describes using OxCaml extensions to implement type-safe reference counting between OCaml and Python. The approach addresses delayed deallocation when objects cross the language boundary, including for large data frames and scarce resources such as GPU memory.

### Source excerpt

Jane Street is known for being an OCaml shop, but for years now Python has been our second major programming language, acting as the primary tool for data analysis and (especially importantly these days) machine learning. Most of our traders and researchers think and write in Python, even as the majority of our infrastructure is written in OCaml.

## Achieving Fast Inner Dev Loops with Gradle: Configuration Cache and Beyond

DevFeed: [Achieving Fast Inner Dev Loops with Gradle: Configuration Cache and Beyond](<https://devfeed.tech/articles/achieving-fast-inner-dev-loops-with-gradle-configuration-cache-and-beyond-24617.md>)

Original publisher: [Read original article](<https://blog.gradle.org/fast-inner-dev-loops-with-gradle>)

Author: Alex Semin

Published: 2026-05-20T04:00:00Z

Content type: article

Language: en

Sources: [The Gradle Blog](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [code productivity](<https://devfeed.tech/topics/code-productivity.md>), [build performance](<https://devfeed.tech/topics/build-performance.md>), [build times](<https://devfeed.tech/topics/build-times.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [context](<https://devfeed.tech/tags/context.md>), [developer-productivity](<https://devfeed.tech/tags/developer-productivity.md>), [flow](<https://devfeed.tech/tags/flow.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [kotlinconf](<https://devfeed.tech/tags/kotlinconf.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [productivity](<https://devfeed.tech/tags/productivity.md>)

### AI overview

This article explains how Gradle is working to accelerate inner developer loops. It describes the shift from execution time to configuration time as the main build bottleneck in large codebases, while highlighting configuration cache, incremental builds, build cache, and parallelism as approaches to reduce waiting and preserve developer flow.

### Source excerpt

How many engineers in your organization have to sit idle for 10 or more minutes just to rebuild the app locally after a small change? If you're an engineering leader, build engineer, or part of a developer productivity team, you're not alone in facing this challenge. Building complex software is inherently demanding, but the time your developers spend waiting has a profound impact beyond just the literal minutes lost. It fundamentally disrupts their psychological flow. "There are like these time scales of psychological flow, right? So if something takes longer than a minute, you already start planning for it... you suffer from context switch as well. If it's 1 second, that's where we want to be right in that seamless state of flow. And if it's less than one second, then you feel it's like magic... productive developers are happy developers." -- Rodrigo Oliveira When developers have to wait, their attention drifts, and the cost of context switching destroys their momentum. Our goal as enablers of developer productivity should be to eliminate this friction, bringing that feedback loop as close as possible to the "magical one second". In a recent presentation at KotlinConf 2025, Gradle engineers Rodrigo Oliveira and Alex Semin detailed how Gradle Build Tool is evolving to keep developers in that productive, happy "flow state". By tackling the most significant bottlenecks in modern software builds, Gradle is paving the way for incredibly fast inner developer loops. If you prefer to watch the presentation recording, you can find it here. The shifting bottleneck: From execution to configuration On every invocation, Gradle goes through three distinct phases: initialization, configuration, and execution. Historically, when we optimized Gradle builds, we focused almost exclusively on the execution phase. This is when the majority of work expected by a developer happens: production sources compilation, test execution, etc. For years, execution was the longest phase. We tackled thi

## Workflow-as-code: orchestration in pure code

DevFeed: [Workflow-as-code: orchestration in pure code](<https://devfeed.tech/articles/workflow-as-code-orchestration-in-pure-code-30721.md>)

Original publisher: [Read original article](<https://www.windmill.dev/blog/launch-week-workflow-as-code>)

Author: Ruben Fiszel

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

Content type: release

Language: en

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

Topics: [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Code](<https://devfeed.tech/topics/code.md>), [Python](<https://devfeed.tech/topics/python.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Error Handling](<https://devfeed.tech/topics/error-handling.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [editor](<https://devfeed.tech/tags/editor.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [execution](<https://devfeed.tech/tags/execution.md>), [launch-week](<https://devfeed.tech/tags/launch-week.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [python](<https://devfeed.tech/tags/python.md>), [releases](<https://devfeed.tech/tags/releases.md>), [typescript](<https://devfeed.tech/tags/typescript.md>), [version-control](<https://devfeed.tech/tags/version-control.md>), [workflow](<https://devfeed.tech/tags/workflow.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

Windmill introduces workflow-as-code, allowing complex workflows to be defined in TypeScript or Python. The system uses checkpointing and replay, runs tasks as separate jobs, supports parallelism and fault tolerance, and releases workers while workflows wait.

### Source excerpt

Introducing workflow-as-code: define complex workflows in TypeScript or Python with checkpointing, parallelism, and fault tolerance built in.

## How Apollo Built an AI-Powered Style Guide Reviewer for Documentation

DevFeed: [How Apollo Built an AI-Powered Style Guide Reviewer for Documentation](<https://devfeed.tech/articles/how-we-taught-an-ai-to-nitpick-docs-23393.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/how-we-taught-an-ai-to-nitpick-docs>)

Author: Daniel Abdelsamed

Published: 2026-03-16T12:33:22Z

Content type: article

Language: en

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

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [AI Development](<https://devfeed.tech/topics/ai-development.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [caching](<https://devfeed.tech/tags/caching.md>), [cost](<https://devfeed.tech/tags/cost.md>), [docs](<https://devfeed.tech/tags/docs.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [github](<https://devfeed.tech/tags/github.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

Apollo's documentation team built an AI-powered style guide reviewer that applies documentation rules contextually and reports findings to authors in GitHub. The article explains how restructuring the style guide, integrating the review into the existing workflow, and optimizing speed and cost made it practical to run on every commit.

### Source excerpt

Learn how Apollo's docs team built an AI-powered style guide reviewer that runs on every commit -- and the three things that made it actually work: restructuring the style guide as a pattern library, integrating results directly into GitHub, and optimizing for speed and cost with caching, line-level review, and parallelism.

## How Agoda Load Balanced Kafka

DevFeed: [How Agoda Load Balanced Kafka](<https://devfeed.tech/articles/how-agoda-load-balanced-kafka-34677.md>)

Original publisher: [Read original article](<https://newsletter.systemdesigncodex.com/p/how-agoda-load-balanced-kafka>)

Author: Saurabh Dashora

Published: 2026-03-10T08:01:37Z

Content type: article

Language: en

Sources: [System Design Codex](<https://devfeed.tech/sources/system-design-codex.md>)

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [data-processing](<https://devfeed.tech/topics/data-processing.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [data-centers](<https://devfeed.tech/tags/data-centers.md>), [data-processing](<https://devfeed.tech/tags/data-processing.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [partitioning](<https://devfeed.tech/tags/partitioning.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>)

### AI overview

A deep dive into how Agoda uses Kafka to process large volumes of real-time supplier price updates. It explains the distributor, processor, and Kafka components, then examines how partitions, partitioners, and consumer assignors support parallel processing and expose challenges when workloads and consumer capabilities are uneven.

### Source excerpt

Deep Dive

## RCCLX: Innovating GPU Communications on AMD Platforms

DevFeed: [RCCLX: Innovating GPU Communications on AMD Platforms](<https://devfeed.tech/articles/rcclx-innovating-gpu-communications-on-amd-platforms-30493.md>)

Original publisher: [Read original article](<https://engineering.fb.com/2026/02/24/data-center-engineering/rrcclx-innovating-gpu-communications-amd-platforms-meta/>)

Author: Sudharssun Subramanian; Subodh Iyengar; Cen Zhao; Srinath Bayareddy; James Hongyi Zeng

Published: 2026-02-24T21:30:54Z

Content type: article

Language: en

Sources: [Meta AI Research](<https://devfeed.tech/sources/meta-ai-research.md>)

Topics: [GPU](<https://devfeed.tech/topics/gpu.md>), [Meta](<https://devfeed.tech/topics/meta.md>), [communications](<https://devfeed.tech/topics/communications.md>), [AI Models](<https://devfeed.tech/topics/ai-models.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Inference](<https://devfeed.tech/topics/inference.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Transformer](<https://devfeed.tech/topics/transformer.md>)

Tags: [accelerate](<https://devfeed.tech/tags/accelerate.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-models](<https://devfeed.tech/tags/ai-models.md>), [ai-research](<https://devfeed.tech/tags/ai-research.md>), [communications](<https://devfeed.tech/tags/communications.md>), [data-center-engineering](<https://devfeed.tech/tags/data-center-engineering.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [inference](<https://devfeed.tech/tags/inference.md>), [large-language-model](<https://devfeed.tech/tags/large-language-model.md>), [latency](<https://devfeed.tech/tags/latency.md>), [layer](<https://devfeed.tech/tags/layer.md>), [meta](<https://devfeed.tech/tags/meta.md>), [ml-applications](<https://devfeed.tech/tags/ml-applications.md>), [networking-traffic](<https://devfeed.tech/tags/networking-traffic.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>)

### AI overview

Meta describes the initial open-source release of RCCLX, an enhanced version of RCCL for AMD platforms integrated with Torchcomms. The article presents Direct Data Access algorithms and Low Precision Collectives, including approaches intended to reduce communication latency during large language model inference.

### Source excerpt

We are open-sourcing the initial version of RCCLX - an enhanced version of RCCL that we developed and tested on Meta's internal workloads. RCCLX is fully integrated with Torchcomms and aims to empower researchers and developers to accelerate innovation, regardless of their chosen backend. Communication patterns for AI models are constantly evolving, as are hardware [...] Read More... The post RCCLX: Innovating GPU Communications on AMD Platforms appeared first on Engineering at Meta.

## Gastown, and where software is going

DevFeed: [Gastown, and where software is going](<https://devfeed.tech/articles/gastown-and-where-software-is-going-13057.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/gastown-and-where-software-is-going>)

Published: 2026-01-20T00:00:00Z

Content type: opinion

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Development](<https://devfeed.tech/topics/development.md>), [AI Development](<https://devfeed.tech/topics/ai-development.md>), [Terminal](<https://devfeed.tech/topics/terminal.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-based-programming](<https://devfeed.tech/tags/agent-based-programming.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-gastown](<https://devfeed.tech/tags/claude-gastown.md>), [gastown](<https://devfeed.tech/tags/gastown.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [terminal](<https://devfeed.tech/tags/terminal.md>), [ux](<https://devfeed.tech/tags/ux.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

An opinion article examining Gastown as a prototype for agent-driven software work. It highlights terminal-based coordination, distributed tasks, worktree isolation, and the importance of CI, guardrails, and shared truth, while noting that the system remains unreliable in practice.

### Source excerpt

Gastown hints at the future of software: agent-driven workflows where CI, guardrails, and shared truth matter more than writing code faster.

## The Hidden Cost of Convenience: Rethinking Old ORM Patterns for Scale

DevFeed: [The Hidden Cost of Convenience: Rethinking Old ORM Patterns for Scale](<https://devfeed.tech/articles/the-hidden-cost-of-convenience-rethinking-old-orm-patterns-for-scale-20459.md>)

Original publisher: [Read original article](<https://eng.wealthfront.com/2025/12/08/the-hidden-cost-of-convenience-rethinking-old-orm-patterns-for-scale/>)

Author: Andrew Houts

Published: 2025-12-08T22:06:50Z

Content type: article

Language: en

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

Topics: [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [Code](<https://devfeed.tech/topics/code.md>), [data](<https://devfeed.tech/topics/data.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [dashboards](<https://devfeed.tech/topics/dashboards.md>), [Database](<https://devfeed.tech/topics/database.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [code](<https://devfeed.tech/tags/code.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [flame-graph](<https://devfeed.tech/tags/flame-graph.md>), [orm](<https://devfeed.tech/tags/orm.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [sql](<https://devfeed.tech/tags/sql.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [wealthfront-engineering](<https://devfeed.tech/tags/wealthfront-engineering.md>)

### AI overview

Wealthfront examines performance problems in an aging portfolio balance calculation system whose overnight batch processing scaled poorly as client growth and assets under management increased. The article describes profiling the job with command-line and sampling-profiler tools, using collected data and flame graphs to investigate where runtime was spent.

### Source excerpt

Ever been here before? Stuck with a job that needs to be continually revisited because its performance gets worse with every passing day, and each attempt at improving said performance yields diminishing returns? This is the situation we found ourselves in with the portfolio balance calculation system--the code responsible for aggregating data from multiple sources... Read more

## How Zed Improved Project Search Performance in Release 214.4

DevFeed: [How Zed Improved Project Search Performance in Release 214.4](<https://devfeed.tech/articles/nerd-sniped-project-search-13517.md>)

Original publisher: [Read original article](<https://zed.dev/blog/nerd-sniped-project-search>)

Author: Piotr Osiewicz

Published: 2025-11-26T00:00:00Z

Content type: article

Language: en

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

Topics: [Code](<https://devfeed.tech/topics/code.md>), [vs-code](<https://devfeed.tech/topics/vs-code.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [files](<https://devfeed.tech/tags/files.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [project](<https://devfeed.tech/tags/project.md>), [search](<https://devfeed.tech/tags/search.md>), [vs-code](<https://devfeed.tech/tags/vs-code.md>)

### AI overview

This article explains why Zed's project search was slow and describes the performance improvements released in Zed 214.4. It covers filesystem scanning, in-memory buffers, settings and .gitignore handling, and parallel execution.

### Source excerpt

Why was it slow, and why is it still slow?

## Scaling LLM Inference: Innovations in Tensor Parallelism, Context Parallelism, and Expert Parallelism

DevFeed: [Scaling LLM Inference: Innovations in Tensor Parallelism, Context Parallelism, and Expert Parallelism](<https://devfeed.tech/articles/scaling-llm-inference-innovations-in-tensor-parallelism-context-parallelism-and-expert-parallelism-30492.md>)

Original publisher: [Read original article](<https://engineering.fb.com/2025/10/17/ai-research/scaling-llm-inference-innovations-tensor-parallelism-context-parallelism-expert-parallelism/>)

Author: Cen Zhao; Xiaodong Wang; Jianyu Huang

Published: 2025-10-17T16:00:50Z

Content type: article

Language: en

Sources: [Meta AI Research](<https://devfeed.tech/sources/meta-ai-research.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [AI Inference](<https://devfeed.tech/topics/ai-inference.md>), [Inference Performance](<https://devfeed.tech/topics/inference-performance.md>), [LLM Techniques](<https://devfeed.tech/topics/llm-techniques.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [sharding](<https://devfeed.tech/topics/sharding.md>), [long-context](<https://devfeed.tech/topics/long-context.md>)

Tags: [ai-research](<https://devfeed.tech/tags/ai-research.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [inference](<https://devfeed.tech/tags/inference.md>), [kv-cache](<https://devfeed.tech/tags/kv-cache.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [latency](<https://devfeed.tech/tags/latency.md>), [llms](<https://devfeed.tech/tags/llms.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [sharding](<https://devfeed.tech/tags/sharding.md>)

### AI overview

Meta describes three forms of parallelism--tensor, context, and expert parallelism--for scaling large language model inference across GPUs. The article explains how prefill and decoding differ computationally and how these techniques target resource efficiency, throughput, and latency.

### Source excerpt

At Meta, we are constantly pushing the boundaries of LLM inference systems to power applications such as the Meta AI App. We're sharing how we developed and implemented advanced parallelism techniques to optimize key performance metrics related to resource efficiency, throughput, and latency. The rapid evolution of large language models (LLMs) has ushered in a [...] Read More... The post Scaling LLM Inference: Innovations in Tensor Parallelism, Context Parallelism, and Expert Parallelism appeared first on Engineering at Meta.

## ClickHouse Release 25.8

DevFeed: [ClickHouse Release 25.8](<https://devfeed.tech/articles/clickhouse-release-25-8-5129.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/clickhouse-release-25-08>)

Author: ClickHouse

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

Content type: release

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [parquet](<https://devfeed.tech/topics/parquet.md>), [Flight](<https://devfeed.tech/topics/flight.md>), [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>)

Tags: [apache-arrow](<https://devfeed.tech/tags/apache-arrow.md>), [bug](<https://devfeed.tech/tags/bug.md>), [bug-fixes](<https://devfeed.tech/tags/bug-fixes.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [data](<https://devfeed.tech/tags/data.md>), [data-lake](<https://devfeed.tech/tags/data-lake.md>), [features](<https://devfeed.tech/tags/features.md>), [files](<https://devfeed.tech/tags/files.md>), [format](<https://devfeed.tech/tags/format.md>), [integration](<https://devfeed.tech/tags/integration.md>), [new-features](<https://devfeed.tech/tags/new-features.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [parquet](<https://devfeed.tech/tags/parquet.md>), [partitioning](<https://devfeed.tech/tags/partitioning.md>), [performance](<https://devfeed.tech/tags/performance.md>), [release](<https://devfeed.tech/tags/release.md>), [storage](<https://devfeed.tech/tags/storage.md>), [streaming](<https://devfeed.tech/tags/streaming.md>)

### AI overview

ClickHouse 25.8 introduces 45 new features, 47 performance optimizations, and 119 bug fixes. Highlights include a faster experimental native Parquet reader, Data Lake improvements, Hive-style partitioned writes, initial PromQL support, and Arrow Flight integration.

### Source excerpt

ClickHouse 25.8 is available. In this post, you will learn about new features, including a new Parquet reader and Arrow Flight integration.

## Using Clojure channels to increase throughput

DevFeed: [Using Clojure channels to increase throughput](<https://devfeed.tech/articles/using-clojure-channels-to-increase-throughput-30521.md>)

Original publisher: [Read original article](<https://medium.com/helpshift-engineering/using-clojure-channels-to-increase-throughput-c051cc7f9893?source=rss----3229f31ca4f4---4>)

Author: Abhinav Dubey

Published: 2025-05-28T10:07:12Z

Content type: tutorial

Language: en

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

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Kafka](<https://devfeed.tech/topics/kafka.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [async](<https://devfeed.tech/topics/async.md>), [Grafana](<https://devfeed.tech/topics/grafana.md>)

Tags: [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [channel](<https://devfeed.tech/tags/channel.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [core-async](<https://devfeed.tech/tags/core-async.md>), [grafana](<https://devfeed.tech/tags/grafana.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [multithreading](<https://devfeed.tech/tags/multithreading.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>)

### AI overview

This tutorial explains how to increase throughput in a Clojure-based Kafka consumer by using core.async channels and multiple worker threads. It compares a single-threaded baseline with configurations using three and ten workers, reporting shorter processing times for 1,000 events in the described benchmark.

### Source excerpt

When building systems that process large volumes of messages synchronously, performance bottlenecks can quickly become a challenge specially with single-threaded designs. In this post, we'll look at how leveraging worker threads in a Clojure-based Kafka consumer can significantly boost throughput & reduce total processing time. Using simple concurrency primitives, it's possible to achieve parallelism & scale gracefully, all while keeping the codebase clean & maintainable. We'll start with a baseline, introduce worker threads using Clojure's core.async & measure the impact. Setup & Context Kafka & Zookeeper For observability: Grafana Kafka producer: A simple script that sends messages to a Kafka topic at a configurable rate (messages per minute) for a fixed duration. After each event is pushed, a counter metric is emitted Kafka consumer: A simple script that listens to a topic & consumes messages & simulates processing time finding square-root of a number (henceforth, assume that it takes ~1 second to find the square root) . A counter metric is emitted after processing each message The Baseline: Single-Threaded Consumer If each message takes t seconds to process & there are n messages, total processing time becomes n x t seconds. This provides a clean baseline to evaluate the impact of using channel moving forward. Adding workers with core.asyncValues are conveyed on queue-like channels. By default channels require producer and consumer to rendezvous for the transfer of a value through the channel https://clojuredocs.org/clojure.core.async To improve throughput, we introduce parallelism using Clojure's core.async channels. Messages from Kafka are fed into a channel, & multiple worker threads read from this channel to process messages concurrently Here, we used >!! (blocking put) & <!! (blocking take) to communicate via channels & future to execute the business-logic on a separate thread Who gets blocked & when : The thread putting message into the channel will get bl

## Scheduling In Go : Part III - Concurrency

DevFeed: [Scheduling In Go : Part III - Concurrency](<https://devfeed.tech/articles/scheduling-in-go-part-iii-concurrency-22142.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2018/12/scheduling-in-go-part3.html>)

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

Content type: tutorial

Language: en

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

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [IO](<https://devfeed.tech/topics/io.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blog](<https://devfeed.tech/tags/blog.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [io](<https://devfeed.tech/tags/io.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [technical](<https://devfeed.tech/tags/technical.md>)

### AI overview

This third post in a series about the Go scheduler explains concurrency as out-of-order execution and distinguishes it from parallelism. It discusses how CPU-bound and I/O-bound workloads affect the decision to use concurrency, using practical examples and benchmarks to show that parallelism can improve CPU-bound performance while concurrency alone can benefit I/O-bound work.

### Source excerpt

Although originally written in 2018, the following concepts remain essential for developers working with concurrency. This blogpost focuses on concurrency, distinguishing it from parallelism by defining it as "out of order" execution. It emphasizes the importance of understanding workload types--CPU bound (e.g., summing, sorting) and IO bound (e.g., file reading)--to assess when concurrency is appropriate. Through practical examples and benchmarks, it shows that parallelism boosts performance for CPU bound tasks, while concurrency alone benefits IO bound workloads. The post underscores that identifying workload type is key to applying concurrency effectively without added complexity.

## Parallelism with Android SQLite

DevFeed: [Parallelism with Android SQLite](<https://devfeed.tech/articles/parallelism-with-android-sqlite-25628.md>)

Original publisher: [Read original article](<https://blog.p-y.wtf/parallelism-with-android-sqlite>)

Author: Pierre-Yves Ricau

Published: 2025-02-05T05:35:36Z

Content type: tutorial

Language: en

Sources: [Py's blog](<https://devfeed.tech/sources/py-s-blog.md>)

Topics: [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Android](<https://devfeed.tech/topics/android.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [io](<https://devfeed.tech/tags/io.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>)

### AI overview

This article explains how Android SQLite's default single-connection behavior causes parallel queries on the same database to block one another. It examines how excessive query parallelism can consume coroutine dispatcher threads and delay unrelated I/O tasks, then discusses using separate dispatchers for blocking database work.

### Source excerpt

The SQLDelight documentation provides this example: val players: Flow> = playerQueries.selectAll() .asFlow() .mapToList(Dispatchers.IO) This looks reasonable, right? In the Square Point Of Sale application, we recently ...

## Fearless Concurrency Ep.3: Managing Threaded Programs and Data Races in Rust

DevFeed: [Fearless Concurrency Ep.3: Managing Threaded Programs and Data Races in Rust](<https://devfeed.tech/articles/fearless-concurrency-ep-3-managing-threaded-programs-and-data-races-in-rust-22260.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/10/fearless-concurrency-ep3-optimize-rust-code-with-scoped-threads-&-rayon.html>)

Published: 2024-10-10T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Library](<https://devfeed.tech/topics/library.md>)

Tags: [advanced-rust-threading](<https://devfeed.tech/tags/advanced-rust-threading.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [efficient-parallelism-in-rust](<https://devfeed.tech/tags/efficient-parallelism-in-rust.md>), [optimize-rust-code](<https://devfeed.tech/tags/optimize-rust-code.md>), [parallel-processing-in-rust](<https://devfeed.tech/tags/parallel-processing-in-rust.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [performance-optimization-rust](<https://devfeed.tech/tags/performance-optimization-rust.md>), [pitfalls](<https://devfeed.tech/tags/pitfalls.md>), [rayon-library-rust](<https://devfeed.tech/tags/rayon-library-rust.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-concurrency-best-practices](<https://devfeed.tech/tags/rust-concurrency-best-practices.md>), [rust-concurrency-tutorial](<https://devfeed.tech/tags/rust-concurrency-tutorial.md>), [rust-parallel-computing](<https://devfeed.tech/tags/rust-parallel-computing.md>), [rust-scientific-computing-with-threads](<https://devfeed.tech/tags/rust-scientific-computing-with-threads.md>), [rust-scoped-threads-vs-std-thread](<https://devfeed.tech/tags/rust-scoped-threads-vs-std-thread.md>), [rust-threading-strategies](<https://devfeed.tech/tags/rust-threading-strategies.md>), [rust-work-stealing-with-rayon](<https://devfeed.tech/tags/rust-work-stealing-with-rayon.md>), [safe-concurrency-in-rust](<https://devfeed.tech/tags/safe-concurrency-in-rust.md>), [safety](<https://devfeed.tech/tags/safety.md>), [scoped-threads-in-rust](<https://devfeed.tech/tags/scoped-threads-in-rust.md>), [series](<https://devfeed.tech/tags/series.md>), [techniques](<https://devfeed.tech/tags/techniques.md>), [threading](<https://devfeed.tech/tags/threading.md>), [threads](<https://devfeed.tech/tags/threads.md>)

### AI overview

Episode 3 of the Fearless Concurrency series explains scoped threads and the Rayon library in Rust. It compares standard threads, scoped threads, and Rayon, covering safe shared-data access, parallel processing of datasets, CPU workload distribution, and the risk of over-parallelization.

### Source excerpt

Introduction: Welcome to Episode 3 of the Fearless Concurrency series! In this episode, Herbert explores advanced threading techniques in Rust, focusing on scoped threads and the Rayon library to help developers build more efficient and parallelized applications. This episode is packed with practical insights on when and how to use different threading models to optimize performance and handle complex workloads. Scoped Threads: Ensuring safe access to shared data with guaranteed lifetimes for concurrent threads.

## Revisiting HPX

DevFeed: [Revisiting HPX](<https://devfeed.tech/articles/revisiting-hpx-25138.md>)

Original publisher: [Read original article](<https://blog.brakmic.com/revisiting-hpx/>)

Author: brakmic

Published: 2024-09-23T09:53:03Z

Content type: tutorial

Language: en

Sources: [Harris Brakmic - Coding](<https://devfeed.tech/sources/harris-brakmic-coding.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Testing](<https://devfeed.tech/topics/testing.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [coding](<https://devfeed.tech/tags/coding.md>), [cpp](<https://devfeed.tech/tags/cpp.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-computing](<https://devfeed.tech/tags/distributed-computing.md>), [examples](<https://devfeed.tech/tags/examples.md>), [framework](<https://devfeed.tech/tags/framework.md>), [hpx](<https://devfeed.tech/tags/hpx.md>), [installation](<https://devfeed.tech/tags/installation.md>), [macos](<https://devfeed.tech/tags/macos.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [programming](<https://devfeed.tech/tags/programming.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This hands-on article revisits HPX, a runtime system for asynchronous, parallel, and distributed computing. It covers installation on macOS, configuration, compilation, and testing, and discusses HPX features including task-based parallelism and components.

### Source excerpt

This article explores the powerful parallelization and distributed computing capabilities of the HPX framework. Starting with installation on macOS, it walks through configuring, compiling, and testing HPX on a modest machine, highlighting key features like asynchronous programming, task-based parallelism, and HPX components. Whether new to HPX or looking for practical examples, this guide offers a hands-on approach to understanding and utilizing HPX in real-world scenarios.

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