Swift 6.2 Tip! All SwiftUI Views are now implicitly @MainActor isolated.
Got a warning using a View property inside a @Sendable closure? That's because it might run on a background thread.
The fix: Explicitly capture a copy of the property 
Verwaltet von:
#concurrency
2 Beiträge2 Beteiligte0 Beiträge heute
Fortgeführter Thread
If you care about Rust and concurrency, you’ll want to see this.
https://eurorust.eu/talks/deadlock-detection/?utm_source=mastodon&utm_medium=social&utm_campaign=25-06-26-speaker-horacio-scaffino
#RustLang #Concurrency #RustTools
2/3
EuroRustEuroRust 2025 – October 9 & 10, Paris & onlineEuroRust is a 2 day conference for the European Rust community – October 9 & 10, 2025 – in Paris & online
I am playing with #libstdexec, I used a static thread pool and bulk. The problem is that the workload is not uniform. For some inputs, there is next to no work to be done.
When this happens, the mechanism inside the scheduler is dominating my profiling.
What I really want is something like adaptive workload splitting.
Any ideas? #cpp #cplusplus #programming #concurrency
Now @oughtputs speaking at @brightonruby about #Concurrency in #Rails.
TIL nothing works as you would expect:
https://www.cybertec-postgresql.com/en/select-for-update-considered-harmful-postgresql/
CYBERTEC PostgreSQL | Services & Support · SELECT FOR UPDATE considered harmful in PostgreSQLThis article tells you why SELECT FOR UPDATE is almost always the wrong lock and that you should use SELECT FOR NO KEY UPDATE instead.
Concurrency Concept: Say you have two threads trying to access the same bytes.
Instead of a lock, both threads can reserve a specific time interval, in which they are allowed to access the memory area. So the access timeline would look something like this (t1 and t2 being the timeframe's the respective threads can access it): t1 | t2 | t1 | t2 | ...
"The best way to approach concurrency is to master the fundamentals" #scala #concurrency https://lukastymo.com/posts/022-concurrency-basic-synchronization/
On the Way to Another Dawn · [Scala] Fundamental Concurrency Problems and SolutionsThe best way to approach concurrency is to master the fundamentals. Below is a small collection of foundational concurrency problems with practical solutions using Scala and Cats Effect.
Conclusion In this post, we explore four fundamental concurrency problems and their idiomatic solutions using Scala and Cats Effect, but which could be generalized to any programming language with concurrency support.
After reading this post, you should be able to:
Mutex for synchronizing access to shared resources Semaphore for limiting the number of concurrent tasks CyclicBarrier for synchronizing tasks at a common point CountDownLatch for waiting for a signal before proceeding with tasks Problem 1: Counter Updated in Parallel (Mutex) ❌ The Problem Suppose we have a simple counter that is incremented by 1000 tasks running in parallel. Without synchronization, we get incorrect results.
Antwortete im Thread
@noboilerplate THIS!
I think a lot of people inadvertently assume async #RustLang is so different from sync Rust, because the way it is - when in fact it's because of the (most popular) async runtime they're using.
We should look way more into alternative #async runtimes to #Tokio, e.g. smol:
https://floss.social/@janriemer/111669258656959538
#Smol allows you to use non-'static Futures by using a local executor:
https://floss.social/@janriemer/111669668856899636
It looks a lot more like "normal" #Rust.
FLOSS.socialJan :rust: :ferris: (@janriemer@floss.social)Yay! @notgull@hachyderm.io is working on `smol` integration with #axum! :awesome:
https://github.com/notgull/smol-axum
The smol #async runtime:
https://github.com/smol-rs/smol
#Tokio is not the end-all-be-all runtime. You should keep looking at alternatives and what unique features they can offer. ✨
Don't be blinded by "if it is the most popular, it must be the best" fallacy.
#Rust #RustLang #RustAsync #AsyncRust
Paging #Swift #Concurrency experts! Is there any way to leverage KVO to synchronously update a property in one class in response to a change in another?
Note that both `MyClass` and `AVPlayer` are `@MainActor`, so I think this should be a safe thing to want to do... I just don't know how to do it!
cc @mattiem
EDIT: is this a good use case for `MainActor.assumeIsolated`?
Faster Python: Concurrency in async/await and threading: https://blog.jetbrains.com/pycharm/2025/06/concurrency-in-async-await-and-threading/
The JetBrains BlogFaster Python: Concurrency in async/await and threading | The PyCharm BlogWant to write faster Python code? Discover the difference between `async/await` and `threading` and how concurrency works in Python with real-world examples.
The Concurrency Trap: How an Atomic Counter Stalled a Pipeline
https://www.conviva.com/platform/the-concurrency-trap-how-an-atomic-counter-stalled-a-pipeline/
Conviva · The Concurrency Trap: How An Atomic Counter Stalled A Pipeline - ConvivaDiscover how a single atomic counter caused a major slowdown in Conviva's high-scale streaming analytics platform. This post unpacks the concurrency pitfalls behind a mysterious latency spike and offers lessons for Rust developers working with DAGs, actor models, and shared state.
Faster Python: Concurrency in async/await and threading
#Pycharm #Howtos #Tutorials #Webdevelopment #Concurrency #Python
https://blog.jetbrains.com/pycharm/2025/06/concurrency-in-async-await-and-threading/
The JetBrains BlogFaster Python: Concurrency in async/await and threading | The PyCharm BlogWant to write faster Python code? Discover the difference between `async/await` and `threading` and how concurrency works in Python with real-world examples.
Fray: A Controlled Concurrency Testing Framework for the JVM
GitHubGitHub - cmu-pasta/fray: A controlled concurrency testing framework for the JVMA controlled concurrency testing framework for the JVM - cmu-pasta/fray
One day I need to learn wtf this @ sendable stuff is that Xcode whines about nowadays. It seems to be something that should be simple that has gone through a concurrent swiftification and instantly become hard to understand and impossible to implement correctly. Everything about concurrency in Swift feels unnecessarily complicated and cursed. Or maybe I’m just too dumb for for this? Very plausible.
Zasper is an IDE designed to support massive concurrency compared with JupyterLab https://github.com/zasper-io/zasper #productivity #kernels #concurrency
parking_lot: ffffffffffffffff…, https://fly.io/blog/parking-lot-ffffffffffffffff/.
Excellent article from the Fly.io team about a locking bug they encountered in their codebase, and how it has resulted in a bug fix in parking_lot. Well written.
Kudos to the engineers involved.
Flyparking_lot: ffffffffffffffff...Gnarliest Rust proxy bug yet.
Antwortete im Thread
@drmorr I really feel these guys should give papaya a try: https://github.com/ibraheemdev/papaya
It is exactly designed for use cases such as these, where you have incredibly high read contention, and you don’t want to have deadlocks at all.
It’s a relatively young library, so I can understand they may want to do very careful testing, but an API that cannot deadlock is absolutely worth it IMO.
GitHubGitHub - ibraheemdev/papaya: A fast and ergonomic concurrent hashmap for read-heavy workloads.A fast and ergonomic concurrent hashmap for read-heavy workloads. - ibraheemdev/papaya
In this article, we'll explore how actors work, how they differ from classes, and how to use them to protect the app's state from race conditions.
#Swift #Programming #Concurrency #Actors #iOS #macOS
https://tanaschita.com/swift-actors-basics/