The hottest Concurrency Substack posts right now

And their main takeaways
Category
Top Technology Topics

iOS System Design interviews in 2026

Jacob’s Tech Tavern • 6122 implied HN points • 03 Mar 26
đź•ą Technology Concurrency
  1. Use a simple, reusable framework (scoping, functional and non‑functional requirements, data model, API design, high‑level design, drill‑downs) to structure every system design answer.
  2. Prioritize data flow and architecture over UI framework debates; fully understand and scope the problem before drawing or choosing implementation details.
  3. Practice with real worked examples and focused prep notes so you can confidently handle common iOS system design prompts and make your study time efficient.

The 1-hour Swift Concurrency course

Jacob’s Tech Tavern • 5904 implied HN points • 08 Jul 25
đź•ą Technology Concurrency
  1. Swift concurrency is important to understand for effective development in modern iOS programming. Knowing how it works helps you make better decisions when writing code.
  2. The course focuses on two main areas: the reasons behind Swift concurrency and the available tools to use. Understanding when to use each tool is key to solving problems efficiently.
  3. Having a strong grasp of Swift concurrency allows you to predict how your code will behave in different situations. This makes you a more skilled and intuitive developer.

The Synchronization Framework in Swift 6

Jacob’s Tech Tavern • 3936 implied HN points • 30 Dec 24
đź•ą Technology Concurrency
  1. Swift 6 introduced a new Synchronization framework that includes features like Mutex and Atomics. These help manage how different parts of a program can work together safely.
  2. The new concurrency tools are based on a concept called generic ownership, which is new for Swift 6. This means they have better performance and flexibility.
  3. The article also compares these new low-level features to high-level ones like Actors to see how they perform. This can help developers choose the right tool for their needs.

Advanced Swift Concurrency

Jacob’s Tech Tavern • 2624 implied HN points • 12 Nov 24
đź•ą Technology Concurrency
  1. Swift Concurrency is a modern way to handle tasks in Swift, making it easier and more powerful compared to earlier methods like GCD. It's designed for simplicity and efficiency.
  2. Important concepts in Swift Concurrency include Task properties like priority, cancellation, and timeout settings. Understanding these helps developers manage their applications better.
  3. Using Task effectively allows developers to create more responsive and dynamic apps. It’s great to explore real-life examples to grasp how to implement these advanced features.

What I Learned This Week #6

Eventually Consistent • 59 implied HN points • 01 Jul 24
đź•ą Technology Concurrency
  1. Data partitioning helps manage query loads by distributing large datasets across multiple disks and processors. Considerations include rebalancing for even distribution, distributed query execution, and dealing with hot spots.
  2. Partitioning secondary indexes can be done locally or globally, with tradeoffs between keeping related data together versus faster lookups for certain queries. Routing queries in distributed systems may use coordination services or gossip protocols for efficiency.
  3. Transactions provide a way to manage concurrency and software failures by ensuring operations either fully succeed or fully fail. AWS Lambda uses worker models for task execution and Rust Atomics for memory ordering control across threads.
Get a weekly roundup of the best Substack posts, by hacker news affinity:

Comprehension of Concurrency is a Lifelong Journey

Push to Prod • 19 implied HN points • 23 Jul 24
đź•ą Technology Concurrency
  1. Understanding concurrency is a long-term process that requires ongoing learning. It's normal to feel confused, but every experience adds to your knowledge.
  2. It's important to be open about your knowledge gaps. Accepting that you don't know everything helps you grow and learn from others.
  3. Mistakes and misunderstandings are part of the journey. Embracing these moments can lead to valuable insights and a deeper comprehension.

What I Learned This Week #2

Eventually Consistent • 39 implied HN points • 02 Jun 24
đź•ą Technology Concurrency
  1. Transaction latency is crucial in datacenters, affected by shared resource contention that causes waiting, the main performance bottleneck.
  2. Coroutines provide concurrency without synchronization complexity, unlike threads which need careful synchronization for shared data access to avoid conflicts.
  3. Each thread maintains its own call stack, recording function calls and variables, enabling independent execution and function history maintenance.

Rust: future cannot be sent between threads safely

Art’s Substack • 39 implied HN points • 24 May 24
đź•ą Technology Concurrency
  1. In Rust, sending futures between threads safely can lead to compilation errors. This can happen when sharing mutable data across threads that must be protected with a Mutex.
  2. The issue with sending futures between threads safely is due to the fact that futures in Rust are required to implement the 'Send' trait. Problems arise when trying to hold a MutexGuard across an await, causing the future not to be Send.
  3. To resolve issues related to sending futures between threads safely in Rust, one solution is to explicitly introduce a scope to handle locking and unlocking of the MutexGuard around the await, ensuring that the future is 'Send'.

The Concurrency Ambition

Money in Transit • 39 implied HN points • 21 Aug 23
đź•ą Technology Concurrency
  1. Software now needs to handle multiple tasks at once due to hardware limitations
  2. Old programming languages may not be efficient for handling concurrency
  3. Async programming allows tasks to take turns, making it easier to handle concurrency

The devil is old

Wednesday Wisdom • 113 implied HN points • 21 Feb 24
đź•ą Technology Concurrency
  1. Experience and age often bring wisdom, knowledge, and a unique perspective.
  2. In technology, while tools and capabilities have evolved, fundamental principles like people dynamics, math, and physics remain constant.
  3. Despite advancements, people still struggle with basic math, concurrent programming, and effective communication in group settings.

⛷️Slalom: Designing a runtime for AI-generated code

Slalom dev blog • 8 HN points • 10 Feb 24
đź•ą Technology Concurrency
  1. The development of a custom runtime is crucial for safely running AI-generated code, focusing on simplicity and user control.
  2. Key features like pausing processes, green threads with backtracking, syntactic continuations, and fair resource management are essential for efficient operation.
  3. Building a reliable runtime for AI-generated code involves creating APIs that prevent potential user errors, allowing for undoable actions and permission-seeking processes.

Advanced async testing: Unstructured concurrency

Jacob’s Tech Tavern • 3 HN points • 01 Aug 23
đź•ą Technology Concurrency
  1. Unstructured concurrency introduces a different approach to handling asynchronous code compared to structured concurrency like async/await.
  2. When dealing with unstructured concurrency like Tasks, testing can become challenging and may require using XCTestExpectation to handle closure-based asynchronous operations.
  3. To overcome testing challenges with unstructured concurrency, leverage mocks, the defer keyword, and XCTestExpectation to ensure precise test execution.

Advanced Swift Actors: Re-entrancy & Interleaving

Jacob’s Tech Tavern • 2 HN points • 10 Oct 23
đź•ą Technology Concurrency
  1. Understanding Swift actors is crucial for managing re-entrancy and interleaving in your code.
  2. Building an optimal authentication service involves utilizing Swift actors to minimize duplicate work and network overhead.
  3. Swift concurrency model utilizes cooperative threading, executors, and actors to create an illusion of single-threadedness and prevent data races.

Combine, async/await, and Unit Testing

Jacob’s Tech Tavern • 0 implied HN points • 22 Aug 23
đź•ą Technology Concurrency
  1. Combine and async/await can be used together to write robust and maintainable software with modern language features.
  2. Testing @ObservableObject view models, Combine publishers in async methods, and Combine publishers converted to AsyncSequence are key in achieving unit test mastery.
  3. Understanding the interoperation between Combine and async/await is a powerful skill for writing unit tests and marrying the two concurrency approaches.

What's a distributed system?

Brick by Brick • 0 implied HN points • 05 Mar 24
đź•ą Technology Concurrency
  1. A distributed system is a collection of components on multiple computers that appear as a single, unified system to users. They are commonly used in database and file systems.
  2. Key characteristics of distributed systems include concurrency, scalability, fault tolerance, and decentralization, enabling efficient operation across multiple machines.
  3. In distributed systems, concepts like fault tolerance, recovery & durability, the CAP theorem, and quorums & consensus are crucial for maintaining reliability, consistency, and coordination among nodes.