# Deadlock

A concurrency condition in which two or more threads or processes wait indefinitely for resources held by one another.

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

## A C++ Exception Handler Retries Without Releasing Deadlock Resources

DevFeed: [A C++ Exception Handler Retries Without Releasing Deadlock Resources](<https://devfeed.tech/articles/codesod-lock-em-dead-28511.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/lock-em-dead>)

Author: Remy Porter

Published: 2026-08-26T06:30:00Z

Content type: opinion

Language: en

Sources: [The Daily WTF](<https://devfeed.tech/sources/the-daily-wtf.md>)

Topics: [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Exception](<https://devfeed.tech/topics/exception.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code](<https://devfeed.tech/tags/code.md>), [codesod](<https://devfeed.tech/tags/codesod.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [exception](<https://devfeed.tech/tags/exception.md>)

### AI overview

The article examines a C++ exception handler that retries after detecting a deadlock. It explains that the retry mechanism appears to jump back to the start of the block without releasing resources, so it can leave the deadlock unresolved and potentially add more deadlocks.

### Source excerpt

Kevin sends us an exception handler from C++. Let's see if we can spot what's going wrong: catch (Exception::Deadlock) { retry; } When we catch a deadlock happening, we retry. That's not a keyword in C++, and looking at how it's used, it has to be some kind of macro, and I suspect that the macro is hiding a goto underneath it. The real problem, though, is that we suspect we're in a deadlock situation. That means this thread is waiting on a resource held by another thread which is waiting for a resource held by this thread. Neither train may continue until the other has passed. So this retry only works if it releases the resource held by this thread (letting the deadlocking thread proceed). But does it? Not according ot Kevin. The code already had a pile of deadlocks in it, so they brought in a highly paid consultant to try and fix them by reordering access and tracing where mutexes were causing issues. This retry just jumps back up to the top of the block, without releasing any resources. It "seems the consultant wanted to add some deadlocks of their own," Kevin says. [Advertisement] BuildMaster allows you to create a self-service release management platform that allows different teams to manage their applications. Explore how!

## Week Ending August 02, 2026

DevFeed: [Week Ending August 02, 2026](<https://devfeed.tech/articles/week-ending-august-02-2026-17665.md>)

Original publisher: [Read original article](<https://lwkd.info/2026/20260806>)

Published: 2026-08-06T23:45:00Z

Content type: news

Language: en

Sources: [Last Week in Kubernetes Development](<https://devfeed.tech/sources/last-week-in-kubernetes-development.md>)

Topics: [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [bug](<https://devfeed.tech/topics/bug.md>), [releases](<https://devfeed.tech/topics/releases.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [developer](<https://devfeed.tech/tags/developer.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [news](<https://devfeed.tech/tags/news.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

The Kubernetes community roundup covers a Steering Committee candidate Q&A, social media documentation, KCD Around the World, upcoming documentation and release milestones, and fixes for kubelet CPU allocation and StatefulSet reconciliation issues.

### Source excerpt

Developer News

## Deadlocks and downtime

DevFeed: [Deadlocks and downtime](<https://devfeed.tech/articles/deadlocks-and-downtime-2323.md>)

Original publisher: [Read original article](<https://planetscale.com/blog/deadlocks-and-downtime>)

Author: Simeon Griggs

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

Content type: tutorial

Language: en

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

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [errors](<https://devfeed.tech/tags/errors.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [learn](<https://devfeed.tech/tags/learn.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [reduce](<https://devfeed.tech/tags/reduce.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

This article explains how Postgres deadlocks arise when concurrent transactions hold locks that each other needs, and how those deadlocks can escalate into database downtime. It examines the effects of high query volume and immediate retry loops, then recommends consistent row-update ordering, smaller transactions, and late locking to reduce the risk.

### Source excerpt

Deadlocks happen when transactions block each other. Learn how they escalate into downtime, how to reduce them through better queries and retry logic, and how Traffic Control can protect your database from your application.

## How Shopify Uses MySQL for Oversell Protection at Scale

DevFeed: [How Shopify Uses MySQL for Oversell Protection at Scale](<https://devfeed.tech/articles/shopify-said-mysql-redis-18132.md>)

Original publisher: [Read original article](<https://hungrymindsdev.substack.com/p/shopify-said-mysql-redis>)

Author: Alexandre Zajac

Published: 2026-06-22T15:30:09Z

Content type: article

Language: en

Sources: [Hungry Minds](<https://devfeed.tech/sources/hungry-minds.md>)

Topics: [MySQL](<https://devfeed.tech/topics/mysql.md>), [Database](<https://devfeed.tech/topics/database.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [concurrent](<https://devfeed.tech/tags/concurrent.md>), [database](<https://devfeed.tech/tags/database.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [redis](<https://devfeed.tech/tags/redis.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The article describes Shopify's inventory oversell protection challenge and implementation techniques centered on MySQL, including bounded row pools, composite primary keys, READ COMMITTED isolation, consistent lock ordering, and shadow-mode migration from Redis. It emphasizes concurrency, ACID guarantees, and production-scale reservation handling.

### Source excerpt

PLUS: SpaceX buys Cursor for $60B 💰, AWS Blocks framework launch ⚡, Terminal optimization tips 👨💻

## Monitor SLAs and scale ClickHouse Cloud with clickhousectl and agents

DevFeed: [Monitor SLAs and scale ClickHouse Cloud with clickhousectl and agents](<https://devfeed.tech/articles/monitor-slas-and-scale-clickhouse-cloud-with-clickhousectl-and-agents-5427.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/monitor-and-scale-clickhouse-cloud-with-clickhousectl>)

Author: Al Brown

Published: 2026-06-05T14:58:29Z

Content type: tutorial

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [monitor](<https://devfeed.tech/topics/monitor.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [dashboards](<https://devfeed.tech/topics/dashboards.md>), [Front end](<https://devfeed.tech/topics/frontend.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [guide](<https://devfeed.tech/tags/guide.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [monitor](<https://devfeed.tech/tags/monitor.md>), [resource](<https://devfeed.tech/tags/resource.md>), [scale](<https://devfeed.tech/tags/scale.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

This guide shows how to monitor per-workload SLAs in ClickHouse Cloud, investigate latency breaches, scale infrastructure, and delegate remediation to an agent.

### Source excerpt

Tag queries to track per-workload SLAs, then use clickhousectl to investigate breaches and scale ClickHouse Cloud, with an agent to remediate.

## Diagnosing a Deadlock in Trino's Hudi Connector That Stalled Blinkit's Inventory Pipeline

DevFeed: [Diagnosing a Deadlock in Trino's Hudi Connector That Stalled Blinkit's Inventory Pipeline](<https://devfeed.tech/articles/how-a-deadlock-froze-blinkit-s-supply-chain-20085.md>)

Original publisher: [Read original article](<https://lambda.blinkit.com/how-a-deadlock-froze-blinkits-supply-chain-4b7c4d6d4a3f?source=rss----42df4a1e8725---4>)

Author: Ratul Dawar

Published: 2026-05-29T09:26:27Z

Content type: article

Language: en

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

Topics: [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>)

Tags: [apache-hudi](<https://devfeed.tech/tags/apache-hudi.md>), [big-data](<https://devfeed.tech/tags/big-data.md>), [blinkit](<https://devfeed.tech/tags/blinkit.md>), [bug](<https://devfeed.tech/tags/bug.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [s3](<https://devfeed.tech/tags/s3.md>), [thread](<https://devfeed.tech/tags/thread.md>), [trino](<https://devfeed.tech/tags/trino.md>), [trinos](<https://devfeed.tech/tags/trinos.md>), [yield](<https://devfeed.tech/tags/yield.md>)

### AI overview

Blinkit describes how a deadlock in Trino's Hudi connector stalled inventory replenishment queries without errors or resource saturation. The issue involved one thread pool handling both file-split production and signalling; the reported fix used cooperative scheduling and was contributed upstream.

### Source excerpt

A silent deadlock in our query engine was stalling inventory replenishment jobs with no error, no crash -- just infinite waiting. This is the story of how we found it, traced it to an open-source bug, and fixed it upstream. TL;DRTrino's Hudi connector used a single thread pool for both producing file splits and signalling when there was room for more. Under load, every thread ended up waiting for a signal that had no thread left to run it. The fix was to switch the producer side to a cooperative scheduling pattern: yield the thread when the buffer is full, and resume when space opens. Our inventory replenishment pipeline was frozen. CPU was idle. Memory was fine. There were no errors anywhere. Queries just... stopped moving. The first signal was a long queue on one of our analytics clusters. Queries were piling up. Inventory replenishment jobs -- the jobs that decide how much stock every warehouse and store needs to hold -- were delayed. Blinkit's supply chain was being impacted. Dashboards were turning amber, but nothing was crashing. That was the unsettling part. Investigation: Resources Doing Nothing The affected cluster runs analytical workloads on Trino, reading data stored in Apache Hudi tables on S3. The natural first instinct in a queue build-up is to look at resource saturation -- a CPU spike, memory pressure, network bottleneck. There was none of that. The cluster was sitting largely idle, with CPU barely above baseline and heap usage well within limits. Every new query touching a Hudi table joined the queue and stayed there indefinitely. Queries that were already mid-execution completed fine. Only freshly submitted ones were affected. And crucially, there were no errors. No timeouts, no exceptions in the logs -- just silence and a growing backlog. A thread dump -- a snapshot of what every thread in the process is doing right now -- was our next move. It showed dozens of producer threads all stuck in the same parked state, waiting on the exact same internal signal.

## Database Locking Mechanisms

DevFeed: [Database Locking Mechanisms](<https://devfeed.tech/articles/database-locking-mechanisms-34675.md>)

Original publisher: [Read original article](<https://newsletter.systemdesigncodex.com/p/database-locking-mechanisms>)

Author: Saurabh Dashora

Published: 2026-05-19T06:27:39Z

Content type: tutorial

Language: en

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

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Object-relational mapping](<https://devfeed.tech/topics/orm.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [hibernate](<https://devfeed.tech/tags/hibernate.md>), [locking](<https://devfeed.tech/tags/locking.md>), [locks](<https://devfeed.tech/tags/locks.md>), [optimistic-locking](<https://devfeed.tech/tags/optimistic-locking.md>), [sql](<https://devfeed.tech/tags/sql.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

This tutorial compares pessimistic and optimistic locking for maintaining data consistency in multi-user applications. Pessimistic locking acquires locks before updates, while optimistic locking detects conflicts at commit time using version numbers or timestamps. The article explains their trade-offs in concurrency, performance, deadlocks, and consistency, and outlines suitable use cases.

### Source excerpt

Pessimistic vs Optimistic

## GNU/Hurd developments and fixes in Q1 2026

DevFeed: [GNU/Hurd developments and fixes in Q1 2026](<https://devfeed.tech/articles/2026-q1-32749.md>)

Original publisher: [Read original article](<http://www.gnu.org/software/hurd/news/2026-q1.html>)

Published: 2026-03-02T06:07:00Z

Content type: news

Language: en

Sources: [GNU Hurd](<https://devfeed.tech/sources/gnu-hurd.md>)

Topics: [GNU/Hurd](<https://devfeed.tech/topics/gnu-hurd.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [kernels](<https://devfeed.tech/topics/kernels.md>), [Debian](<https://devfeed.tech/topics/debian.md>), [bug](<https://devfeed.tech/topics/bug.md>), [C](<https://devfeed.tech/topics/c.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [qemu](<https://devfeed.tech/topics/qemu.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [bug](<https://devfeed.tech/tags/bug.md>), [c](<https://devfeed.tech/tags/c.md>), [claude](<https://devfeed.tech/tags/claude.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [debian](<https://devfeed.tech/tags/debian.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [gnu-hurd](<https://devfeed.tech/tags/gnu-hurd.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [linux](<https://devfeed.tech/tags/linux.md>), [qemu](<https://devfeed.tech/tags/qemu.md>)

### AI overview

A Q1 2026 GNU/Hurd project update reports debugging and fixes across SMP, threading, filesystem, IPC, networking, and related components, along with wiki documentation and hardware-installation guidance.

### Source excerpt

Hello! Welcome to a new qoth. This qoth covers new and interesting GNU/Hurd developments in Q1 of 2026! Details. Brent W. Baccala debugged some x86_64 SMP issues with a Claude AI bot. The bot did not contribute any code. It just found some incorrect code that Damien then fixed. It did get some things wrong, but it was incredibly helpful pointing out several problems. You can read its report here. Joshua Branson tweaked the hurd wiki. The most helpful addition is this page, which documents how to flash a working qemu hurd image directly to an HDD or SSD. This is a really easy way to install the Hurd on real hardware! Buy a supported machine from this page and give it a shot! Consider this another reminder that the Hurd project could use more documentation writers. It's an easy way to contribute. As a fun fact, Joshua wrote this qoth on the Hurd running on a T420 with 12 GB of RAM! Running Debian GNU/Hurd on bare metal these days is largely fairly stable. Emacs, i3, netsurf, and luakit all work just fine and most of the Debian package archive compiles without issue on the Hurd. Etienne Brateau fixed a compilation error. He also provided a simple test program that exposed a rather serious threading bug, which Samuel promptly fixed. This is a good reminder that writing simple C test programs that successfully run on Linux, but fail on the Hurd can have a large impact. Gianluca Cannata worked on our httpfs translator. Diego Nieto Cid added a daemon-wait option for console-client. This can help users with slow machines avoid a broken Hurd console. He also fixed a rumpdisk compilation issue. Mike Kelley fixed a deadlock in SMP enabled GNU Mach kernels. He also fixed a page fault in amd64 SMP kernels. He fixed another deadlock in the alarm () function. He fixed a panic when running large builds without the mach-defpager. He also fixed some of our signal related code. He worked with Samuel to investigate an odd bug. Their detailed investigation uncovered and lead to a fix in

## How to Prevent the DB from Becoming a Bottleneck

DevFeed: [How to Prevent the DB from Becoming a Bottleneck](<https://devfeed.tech/articles/how-to-prevent-the-db-from-becoming-a-bottleneck-34683.md>)

Original publisher: [Read original article](<https://newsletter.systemdesigncodex.com/p/how-to-prevent-the-db-from-becoming>)

Author: Saurabh Dashora

Published: 2026-02-24T08:15:03Z

Content type: tutorial

Language: en

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

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [MongoDB](<https://devfeed.tech/topics/mongodb.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [latency](<https://devfeed.tech/tags/latency.md>), [locking](<https://devfeed.tech/tags/locking.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This tutorial explains how databases can become application performance bottlenecks even when application code is optimized. It covers diagnosing slow queries with profiling and logs, monitoring execution time and latency, and understanding how locking and deadlocks can affect concurrent transactions.

### Source excerpt

Tips and Strategies

## Introducing: Postgres Best Practices

DevFeed: [Introducing: Postgres Best Practices](<https://devfeed.tech/articles/introducing-postgres-best-practices-496.md>)

Original publisher: [Read original article](<https://supabase.com/blog/postgres-best-practices-for-ai-agents>)

Author: Pedro Rodrigues

Published: 2026-01-21T07:00:00Z

Content type: release

Language: en

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

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [cursor](<https://devfeed.tech/topics/cursor.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>)

Tags: [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [postgres](<https://devfeed.tech/tags/postgres.md>)

### AI overview

Supabase releases Agent Skills that give AI coding agents Postgres best-practice rules for producing correct, high-quality code.

### Source excerpt

We are releasing Agent Skills for Postgres Best Practices to help AI coding agents write high quality, correct Postgres code.

## Corrosion

DevFeed: [Corrosion](<https://devfeed.tech/articles/corrosion-1692.md>)

Original publisher: [Read original article](<https://fly.io/blog/corrosion/>)

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

Content type: article

Language: en

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

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Network](<https://devfeed.tech/topics/network.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [fly](<https://devfeed.tech/topics/fly.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>)

Tags: [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [distributed-system](<https://devfeed.tech/tags/distributed-system.md>), [docker](<https://devfeed.tech/tags/docker.md>), [docker-containers](<https://devfeed.tech/tags/docker-containers.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [networking](<https://devfeed.tech/tags/networking.md>), [outage](<https://devfeed.tech/tags/outage.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [routing](<https://devfeed.tech/tags/routing.md>), [rust](<https://devfeed.tech/tags/rust.md>), [servers](<https://devfeed.tech/tags/servers.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>)

### AI overview

This article introduces Corrosion, Fly.io's open-source distributed state synchronization and service discovery system. It explains how Fly.io propagates workload and routing state across globally distributed servers and edge proxies, and recounts a severe outage caused by a Rust concurrency bug that triggered a contagious deadlock. The article also describes Fly.io's decentralized orchestration model, in which individual servers are authoritative for their workloads instead of relying on a centralized database.

### Source excerpt

Fly.io transmogrifies Docker containers into Fly Machines: micro-VMs running on our own hardware all over the world. The hardest part of running this platform isn't managing the servers, and it isn't operating the network; it's gluing those two things together. Several times a second, as customer CI/CD pipelines tear up or bring down Fly Machines, our state synchronization system blasts updates across our internal mesh, so that edge proxies from Tokyo to Amsterdam can keep the accurate routing table that allows them to route requests for applications to the nearest customer instances. On September 1, 2024, at 3:30PM EST, a new Fly Machine came up with a new "virtual service" configuration option a developer had just shipped. Within a few seconds every proxy in our fleet had locked up hard. It was the worst outage we've experienced: a period during which no end-user requests could reach our customer apps at all. Distributed systems are blast amplifiers. By propagating data across a network, they also propagate bugs in the systems that depend on that data. In the case of Corrosion, our state distribution system, those bugs propagate quickly. The proxy code that handled that Corrosion update had succumbed to a notorious Rust concurrency footgun: an if let expression over an RWLock assumed (reasonably, but incorrectly) in its else branch that the lock had been released. Instant and virulently contagious deadlock. A lesson we've learned the hard way: never trust a distributed system without an interesting failure story. If a distributed system hasn't ruined a weekend or kept you up overnight, you don't understand it yet. Which is why that's how we're introducing Corrosion, an unconventional service discovery system we built for our platform and open sourced. Our Face-Seeking Rake State synchronization is the hardest problem in running a platform like ours. So why build a risky new distributed system for it? Because no matter what we try, that rake is waiting for our foot

## Trip report: Node.js collaboration summit (2025 Paris)

DevFeed: [Trip report: Node.js collaboration summit (2025 Paris)](<https://devfeed.tech/articles/trip-report-node-js-collaboration-summit-2025-paris-2438.md>)

Original publisher: [Read original article](<https://nodejs.org/en/blog/events/collab-summit-2025-paris>)

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

Content type: article

Language: en

Sources: [Node.js Blog](<https://devfeed.tech/sources/node-js-blog.md>)

Topics: [Node.js](<https://devfeed.tech/topics/node-js.md>), [ci](<https://devfeed.tech/topics/ci.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [wasm](<https://devfeed.tech/topics/wasm.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [browsers](<https://devfeed.tech/topics/browsers.md>)

Tags: [browsers](<https://devfeed.tech/tags/browsers.md>), [ci](<https://devfeed.tech/tags/ci.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [wasm](<https://devfeed.tech/tags/wasm.md>)

### AI overview

A trip report on the 2025 Node.js collaboration summit in Paris, covering CI infrastructure reliability, experimental WASM modules, browser coordination, V8 Oilpan integration, memory safety, garbage collection, mentorship, and contributor experience.

### Source excerpt

Node.js® is a free, open-source, cross-platform JavaScript runtime environment that lets developers create servers, web apps, command line tools and scripts.

## Debugging deadlocks in Postgres

DevFeed: [Debugging deadlocks in Postgres](<https://devfeed.tech/articles/debugging-deadlocks-in-postgres-11751.md>)

Original publisher: [Read original article](<https://incident.io/blog/debugging-deadlocks-in-postgres>)

Author: Louis Heath

Published: 2025-02-04T21:37:00Z

Content type: tutorial

Language: en

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

Topics: [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [backend-development](<https://devfeed.tech/topics/backend-development.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [backend-development](<https://devfeed.tech/tags/backend-development.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [database](<https://devfeed.tech/tags/database.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [incident](<https://devfeed.tech/tags/incident.md>), [incident-channel](<https://devfeed.tech/tags/incident-channel.md>), [incident-management](<https://devfeed.tech/tags/incident-management.md>), [incident-response](<https://devfeed.tech/tags/incident-response.md>), [locks](<https://devfeed.tech/tags/locks.md>), [outage](<https://devfeed.tech/tags/outage.md>), [post-mortem](<https://devfeed.tech/tags/post-mortem.md>), [slack-incident](<https://devfeed.tech/tags/slack-incident.md>), [sync](<https://devfeed.tech/tags/sync.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

This article explains how deadlocks arise in Postgres when concurrent processes hold locks that each other needs. It recommends redesigning transactions to acquire locks in a consistent order and discusses alternative approaches that reduce parallelism and may increase lock timeouts.

### Source excerpt

Deadlocks are a natural hurdle in backend development, but with a bit of digging and careful design they can be identified and resolved.

## MVCC and serializability in HyPer

DevFeed: [MVCC and serializability in HyPer](<https://devfeed.tech/articles/mvcc-and-serializability-in-hyper-39630.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2024-11-06_MVCC-and-serializability-in-HyPer-564430884c9a>)

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

Content type: article

Language: en

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

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [locking](<https://devfeed.tech/topics/locking.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [processing](<https://devfeed.tech/topics/processing.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [database](<https://devfeed.tech/tags/database.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [locking](<https://devfeed.tech/tags/locking.md>), [mvcc](<https://devfeed.tech/tags/mvcc.md>), [processing](<https://devfeed.tech/tags/processing.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

This article explains Multi-Version Concurrency Control (MVCC), contrasts it with Two-Phase Locking, and introduces MVCC patterns and techniques used in HyPer. It discusses locking phases, deadlocks, cascading rollbacks, and concurrency limitations.

### Source excerpt

. [MVCC and Serializability in HyPer](mvcc-and-serializability-in-hyper-cover...

## Fearless Concurrency Ep.4: Understanding Mutexes and Thread Safety in Rust

DevFeed: [Fearless Concurrency Ep.4: Understanding Mutexes and Thread Safety in Rust](<https://devfeed.tech/articles/fearless-concurrency-ep-4-understanding-mutexes-and-thread-safety-in-rust-22261.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/10/fearless-concurrency-ep4-understanding-mutexes-and-thread-safety-in-rust.html>)

Published: 2024-10-25T00: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>), [Rust](<https://devfeed.tech/topics/rust.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>)

Tags: [avoiding-race-conditions-in-rust](<https://devfeed.tech/tags/avoiding-race-conditions-in-rust.md>), [code](<https://devfeed.tech/tags/code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-and-memory-management-in-rust](<https://devfeed.tech/tags/concurrency-and-memory-management-in-rust.md>), [concurrency-in-rust](<https://devfeed.tech/tags/concurrency-in-rust.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [managing-shared-data-in-rust](<https://devfeed.tech/tags/managing-shared-data-in-rust.md>), [mutex](<https://devfeed.tech/tags/mutex.md>), [mutex-and-drop-trait-in-rust](<https://devfeed.tech/tags/mutex-and-drop-trait-in-rust.md>), [mutexes-in-rust](<https://devfeed.tech/tags/mutexes-in-rust.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-concurrency-best-practices](<https://devfeed.tech/tags/rust-concurrency-best-practices.md>), [rust-concurrency-guide](<https://devfeed.tech/tags/rust-concurrency-guide.md>), [rust-drop-trait-in-concurrency](<https://devfeed.tech/tags/rust-drop-trait-in-concurrency.md>), [rust-multithreading-tutorial](<https://devfeed.tech/tags/rust-multithreading-tutorial.md>), [rust-mutex-example](<https://devfeed.tech/tags/rust-mutex-example.md>), [rust-mutex-vs-lock](<https://devfeed.tech/tags/rust-mutex-vs-lock.md>), [rust-ownership-and-borrowing-in-concurrency](<https://devfeed.tech/tags/rust-ownership-and-borrowing-in-concurrency.md>), [rust-thread-safety](<https://devfeed.tech/tags/rust-thread-safety.md>), [rust-thread-safety-without-garbage-collection](<https://devfeed.tech/tags/rust-thread-safety-without-garbage-collection.md>), [safety](<https://devfeed.tech/tags/safety.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>), [thread](<https://devfeed.tech/tags/thread.md>), [thread-synchronization-in-rust](<https://devfeed.tech/tags/thread-synchronization-in-rust.md>), [understanding-poisoned-mutexes-in-rust](<https://devfeed.tech/tags/understanding-poisoned-mutexes-in-rust.md>)

### AI overview

This episode explains how Rust's ownership and borrowing rules support thread-safe multithreaded programming. It covers sharing data with mutexes, mutual exclusion, automatic lock cleanup, poisoned mutexes, and how Rust helps prevent data races, undefined behavior, and some deadlock issues.

### Source excerpt

Introduction: Welcome to Episode 4 of Fearless Concurrency in Rust! In this episode, we explore how Rust's ownership and borrowing rules impact multithreaded programming, focusing on the complexities of managing memory in a concurrent environment. We'll break down how Rust's strict borrowing and ownership model ensures safety and prevents common pitfalls like data races and undefined behavior, making it an ideal choice for building reliable multithreaded applications. Thread Safety and Ownership: Managing variables across threads using Rust's ownership rules.

## How to deadlock Tokio application in Rust with just a single mutex

DevFeed: [How to deadlock Tokio application in Rust with just a single mutex](<https://devfeed.tech/articles/how-to-deadlock-tokio-application-in-rust-with-just-a-single-mutex-5965.md>)

Original publisher: [Read original article](<https://turso.tech/blog/how-to-deadlock-tokio-application-in-rust-with-just-a-single-mutex>)

Author: Piotr Jastrzebski

Published: 2024-09-02T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Tokio](<https://devfeed.tech/topics/tokio.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>)

Tags: [concurrent-programming](<https://devfeed.tech/tags/concurrent-programming.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [rust](<https://devfeed.tech/tags/rust.md>), [tokio](<https://devfeed.tech/tags/tokio.md>), [turso](<https://devfeed.tech/tags/turso.md>)

### AI overview

A Tokio-based Rust program deadlocks when a synchronous task holds a std::sync::Mutex while blocking on a future. The article recommends tokio::sync::Mutex for this asynchronous scenario and cautions against premature optimization.

### Source excerpt

Battlefield story of how we managed to deadlock Tokio program with just a single mutex

## Mitigating Deadlocks in high concurrency environments

DevFeed: [Mitigating Deadlocks in high concurrency environments](<https://devfeed.tech/articles/mitigating-deadlocks-in-high-concurrency-environments-1494.md>)

Original publisher: [Read original article](<https://shopify.engineering/mitigating-deadlocks-in-high-concurrency-environments>)

Author: Elson Oliveira

Published: 2024-08-14T16:31:20Z

Content type: article

Language: en

Sources: [Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering.md>), [Shopify Engineering - Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering-shopify-engineering.md>)

Topics: [Deadlock](<https://devfeed.tech/topics/deadlock.md>)

Tags: [batch](<https://devfeed.tech/tags/batch.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [data](<https://devfeed.tech/tags/data.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [performance](<https://devfeed.tech/tags/performance.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

The article explains how concurrent MySQL upserts can create gap-lock overlaps and deadlocks, and proposes composite primary keys to better align storage with update patterns.

### Source excerpt

The problem In order to guarantee data integrity, MySQL requires locks prior to updating existing records. If multiple processes update data in the same table in parallel, deadlocks can occur depending on how the data is stored in disk and managed by MySQL. That can happen even if the different processes target different records. This blog post explores the problem of deadlocks in MySQL while updating data, and illustrates how composite primary keys can effectively mitigate this issue.

## Keycloak 23.0.4 released

DevFeed: [Keycloak 23.0.4 released](<https://devfeed.tech/articles/keycloak-23-0-4-released-31631.md>)

Original publisher: [Read original article](<https://www.keycloak.org/2024/01/keycloak-2304-released>)

Author: Keycloak Team

Published: 2024-01-08T00:00:00Z

Content type: release

Language: en

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

Topics: [Keycloak](<https://devfeed.tech/topics/keycloak.md>), [WebAuthn](<https://devfeed.tech/topics/webauthn.md>), [OpenID connect (OIDC)](<https://devfeed.tech/topics/oidc.md>), [Cross-origin resource sharing (CORS)](<https://devfeed.tech/topics/cors.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [passwords](<https://devfeed.tech/topics/passwords.md>)

Tags: [cors](<https://devfeed.tech/tags/cors.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [idm](<https://devfeed.tech/tags/idm.md>), [kerberos](<https://devfeed.tech/tags/kerberos.md>), [keycloak](<https://devfeed.tech/tags/keycloak.md>), [keycloak-release](<https://devfeed.tech/tags/keycloak-release.md>), [ldap](<https://devfeed.tech/tags/ldap.md>), [migration-guide](<https://devfeed.tech/tags/migration-guide.md>), [oidc](<https://devfeed.tech/tags/oidc.md>), [openid-connect](<https://devfeed.tech/tags/openid-connect.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [password](<https://devfeed.tech/tags/password.md>), [release](<https://devfeed.tech/tags/release.md>), [saml](<https://devfeed.tech/tags/saml.md>), [sso](<https://devfeed.tech/tags/sso.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Keycloak 23.0.4 was released on January 8, 2024. The release provides download and upgrade guidance and lists resolved issues affecting WebAuthn tests, remote session preloading, offline sessions, password visibility styling, administrative APIs, CORS, user-profile scopes, CI label parsing, OIDC logout tokens, and Catalan HTML email links.

### Source excerpt

To download the release go to Keycloak downloads. Upgrading Before upgrading refer to the migration guide for a complete list of changes. All resolved issues Bugs #9693 PubKeySignRegisterTest failures in WebAuthn tests testsuite #24508 Deadlock when pre-loading remote sessions from external Infinispan storage #24763 Remove sign out action for offline sessions admin/ui #25016 Make password visibility css classes configurable for themes login/ui #25096 Meaning of briefRepresentation query parameter is inverted in GroupResource.getSubGroups admin/api #25111 RealmAdminResource.getGroupByPathGroup does not work with space in path parameter admin/api #25120 CORS issue in 'openid-connect/certs' endpoint oidc #25475 User Profile: If required roles ("user") and reqired scopes are set, the required scopes have no effect user-profile #25633 Parsing of labels issue IDs doesn't work with colons and the "fixes" keyword ci #25753 Backchannel logout token is missing the "exp" claim oidc #25878 HTML emails in Catalan don't contain links translations

## Dynamic Table Partitioning in Postgres

DevFeed: [Dynamic Table Partitioning in Postgres](<https://devfeed.tech/articles/dynamic-table-partitioning-in-postgres-500.md>)

Original publisher: [Read original article](<https://supabase.com/blog/postgres-dynamic-table-partitioning>)

Author: Michel Pelletier

Published: 2023-10-03T07:00:00Z

Content type: tutorial

Language: en

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

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

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [data](<https://devfeed.tech/tags/data.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [learn](<https://devfeed.tech/tags/learn.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [scale](<https://devfeed.tech/tags/scale.md>)

### AI overview

This article explains how dynamic table partitioning can help scale a large Postgres table in place. Using a customer example with 500 million chat messages, it describes how growing indexes, aging data, unrelated rows, vacuuming, and data movement can degrade query performance and complicate migration without downtime.

### Source excerpt

Learn how to scale large postgres tables in place and increase query performance.

## A linter I really recommend you to use if you're doing SQL in Golang

DevFeed: [A linter I really recommend you to use if you're doing SQL in Golang](<https://devfeed.tech/articles/a-linter-i-really-recommend-you-to-use-if-you-re-doing-sql-in-golang-5876.md>)

Original publisher: [Read original article](<https://turso.tech/blog/a-linter-i-really-recommend-you-to-use-if-youre-doing-sql-in-golang-ab9fcf5b561f>)

Author: Piotr Jastrzebski

Published: 2023-08-10T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [SQL](<https://devfeed.tech/topics/sql.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [ci](<https://devfeed.tech/topics/ci.md>), [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>)

Tags: [also](<https://devfeed.tech/tags/also.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code](<https://devfeed.tech/tags/code.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [golang](<https://devfeed.tech/tags/golang.md>), [sql](<https://devfeed.tech/tags/sql.md>), [turso](<https://devfeed.tech/tags/turso.md>)

### AI overview

This final article in a series about resource leaks in SQL databases with Golang explains how to use the sqlclosecheck linter to detect database resources that are not closed. It demonstrates local usage and integration with GitHub Actions and golangci-lint so the check can run automatically.

### Source excerpt

This is a final article of my mini series about the topic of leaking resources when using SQL databases in Golang. The whole series consists of three parts

## How to get your database access code deadlocked in Golang

DevFeed: [How to get your database access code deadlocked in Golang](<https://devfeed.tech/articles/how-to-get-your-database-access-code-deadlocked-in-golang-5968.md>)

Original publisher: [Read original article](<https://turso.tech/blog/how-to-get-your-database-access-code-deadlocked-in-golang-f31ec98c3833>)

Author: Piotr Jastrzebski

Published: 2023-07-27T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [database](<https://devfeed.tech/tags/database.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [golang](<https://devfeed.tech/tags/golang.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [turso](<https://devfeed.tech/tags/turso.md>)

### AI overview

A Go database/sql deadlock can occur when an error exits a row-processing loop before the rows are closed. The article explains that explicitly closing rows releases a reader lock so a deferred writer-lock operation can proceed.

### Source excerpt

Unlike C++ or Rust, Golang is supposed to be a programmer friendly language. Most of the time it does a great job in increasing developer productivity by being a relatively easy programming language...

## What's New in Apache Pulsar 2.7.5

DevFeed: [What's New in Apache Pulsar 2.7.5](<https://devfeed.tech/articles/what-s-new-in-apache-pulsar-2-7-5-12730.md>)

Original publisher: [Read original article](<https://pulsar.apache.org/blog/2022/09/09/Apache-Pulsar-2-7-5/>)

Author: Jason918, momo-jun

Published: 2022-09-09T00:00:00Z

Content type: release

Language: en

Sources: [Apache Pulsar Blog](<https://devfeed.tech/sources/apache-pulsar-blog.md>)

Topics: [Apache Pulsar](<https://devfeed.tech/topics/pulsar.md>), [releases](<https://devfeed.tech/topics/releases.md>), [bug](<https://devfeed.tech/topics/bug.md>), [Release notes](<https://devfeed.tech/topics/release-notes.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>)

Tags: [apache](<https://devfeed.tech/tags/apache.md>), [api](<https://devfeed.tech/tags/api.md>), [bug-fixes](<https://devfeed.tech/tags/bug-fixes.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

Apache Pulsar 2.7.5 is the final 2.7.x release, featuring critical fixes for message and data loss, broker deadlocks, connection leaks, proxy failures, and compaction behavior.

### Source excerpt

The Apache Pulsar community releases version 2.7.5! 23 contributors provided improvements and bug fixes that delivered 89 commits. Thanks for all your contributions.

## Transactional Memory and Tech Hype Waves

DevFeed: [Transactional Memory and Tech Hype Waves](<https://devfeed.tech/articles/transactional-memory-and-tech-hype-waves-35213.md>)

Original publisher: [Read original article](<https://blog.jessfraz.com/post/transactional-memory-and-tech-hype-waves/>)

Published: 2019-08-14T15:09:26Z

Content type: opinion

Language: en

Sources: [Jessie Frazelle](<https://devfeed.tech/sources/jessie-frazelle.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Database](<https://devfeed.tech/topics/database.md>), [intel](<https://devfeed.tech/topics/intel.md>)

Tags: [attacks](<https://devfeed.tech/tags/attacks.md>), [database](<https://devfeed.tech/tags/database.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [intel](<https://devfeed.tech/tags/intel.md>), [side-channel](<https://devfeed.tech/tags/side-channel.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>)

### AI overview

The article explains transactional memory, including Intel's Transactional Synchronization Extensions (TSX), as a way to avoid deadlocks while potentially introducing livelocks. It compares transactional memory with database transactions and discusses speculative outcomes, TSX abort handlers, and possible side-channel security concerns.

### Source excerpt

At lunch today I learned about Transactional Synchronization Extensions (TSX) which is an implementation of transactional memory. The conversation started as a rant about why transactional memory is bad but then it evolved into how this concept even came to be and how it even got implemented if it's such a terrible idea. What is transactional memory? First let's start by going over what transactional memory is. You might be familiar with a deadlock. A deadlock occurs when a process or thread is waiting for a specific resource, which is also waiting on a different resource that is being held by another waiting process. You can think of this as P1 needs R1 and has R2, while in turn P2 needs R2 and has R1. That is a deadlock. Transactional memory removes the possibility of getting a deadlock and replaces it with what is known as a livelock. A livelock happens when processes are constantly changing with regard to one another but neither of them move forward or progress in anyway. Imagine you are walking down the street while another person is heading towards you. You move to the right to avoid running into them as they also move in that direction to avoid running into you. You both then move to the other side so as to not run into each other. This repeats over and over again with no progress forward since both people are moving in the same direction. That is a livelock. With transactional memory you no longer have deadlocks but livelocks. Why is this? Well, transactional memory works very similarly to database transactions. A transaction is a group of operations that can execute and commit changes as long as there are no conflicts. If there is a conflict, it will start from state zero and try to run again until there are no conflicts. Therefore, until there is a successful commit of a run, the outcome of any operation is speculative. Intel's implementation of TSX behaves in such a way that when a transaction aborts due to a hardware exception, it does not fire typical e

## Friday Q&A 2017-10-27: Locks, Thread Safety, and Swift: 2017 Edition

DevFeed: [Friday Q&A 2017-10-27: Locks, Thread Safety, and Swift: 2017 Edition](<https://devfeed.tech/articles/friday-q-a-2017-10-27-locks-thread-safety-and-swift-2017-edition-30624.md>)

Original publisher: [Read original article](<http://www.mikeash.com/pyblog/friday-qa-2017-10-27-locks-thread-safety-and-swift-2017-edition.html>)

Author: Mike Ash

Published: 2017-10-27T11:28:00Z

Content type: article

Language: en

Sources: [Mike Ash](<https://devfeed.tech/sources/mike-ash.md>)

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Objective-C](<https://devfeed.tech/topics/objective-c.md>)

Tags: [concurrent](<https://devfeed.tech/tags/concurrent.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [locks](<https://devfeed.tech/tags/locks.md>), [mutex](<https://devfeed.tech/tags/mutex.md>), [objective-c](<https://devfeed.tech/tags/objective-c.md>), [safety](<https://devfeed.tech/tags/safety.md>), [swift](<https://devfeed.tech/tags/swift.md>), [thread](<https://devfeed.tech/tags/thread.md>), [threading](<https://devfeed.tech/tags/threading.md>), [threads](<https://devfeed.tech/tags/threads.md>)

### AI overview

An updated guide to locks and thread safety in Swift, covering mutex types, their behavior, and related Apple and Objective-C synchronization facilities.

### Source excerpt

Back in the dark ages of Swift 1, I wrote an article about locks and thread safety in Swift. The march of time has made it fairly obsolete, and reader Seth Willits suggested I update it for the modern age, so here it is! (Read More)

[Next page](<https://devfeed.tech/topics/deadlock.md?cursor=WyIyMDE3LTEwLTI3VDExOjI4OjAwKzAwOjAwIiwgIjAyODY4YzZjLTc5OTItNDgwOS1iYzZlLTYyOTlkMDgxNTQ0NiJd>)