Tokio: Macros
A guide to using Tokio's `join!` and `select!` macros for concurrent and parallel async operations in Rust.
A guide to using Tokio's `join!` and `select!` macros for concurrent and parallel async operations in Rust.
A guide to using Tokio channels for sharing data between async tasks in Rust, covering MPSC, broadcast, and watch patterns.
A Swift developer details unexpected crashes in Swift 6 due to @unchecked Sendable and implicit actor isolation, offering solutions for concurrency-safe logging.
Explores methods for implementing background task processing and concurrency in Starlette-based web applications like FastAPI to avoid blocking on LLM API calls.
Explores challenges and solutions for testing asynchronous Swift code, focusing on avoiding random failures due to concurrency issues in Swift 6.
Explains single-threaded execution in Swift and its importance for UI responsiveness, as a foundation for concurrency ahead of Swift 6.
Explains why micro-benchmarks are often misleading for performance optimization and advocates for real-world profiling instead.
Explores techniques for implementing idempotent 'get or create' operations in PostgreSQL, covering race conditions, concurrency, and constraint handling.
Swift 6 introduces an opt-in compiler mode to detect and prevent data race conditions at compile time, enhancing concurrent programming safety.
Final reflections on a 30-part series about building an image processing application using the SObjectizer actor framework in C++.
A guide to selecting dispatchers in the SObjectizer actor model framework for C++, focusing on strategies for binding agents to threads.
Explores SObjectizer's mutable messages feature in C++ for efficient actor model communication, preventing unnecessary data copying.
Explains how the Swift compiler uses a syntax check to automatically apply @MainActor isolation to closures passed to DispatchQueue.main.async.
Explores performance analysis in the SObjectizer actor framework, focusing on throughput, latency, and factors like service time and waiting time.
Explores new lock statement patterns in .NET 9, comparing the new Lock class with traditional Monitor-based locking and showing performance benchmarks.
Introduces performance metrics and considerations for message-passing applications using the actor model, focusing on SObjectizer and C++.
Explains a subtle async/await problem with List.ForEach in .NET and provides a solution using a custom ForEachAsync extension method.
A Java programming challenge to process one billion rows of temperature data, focusing on performance optimization and modern Java features.
Introduces the new System.Threading.Lock type in .NET 9, a dedicated lock type that aims to be more explicit and potentially faster than using a plain object with the lock keyword.
Introduces MemoizR, a .NET library for declarative structured concurrency and dynamic lazy memoization, inspired by frontend patterns.