# Structured concurrency

Published articles for Structured concurrency.

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

## Java 27 Delivers Post-Quantum Cryptography, Future Language Innovation, Helidon 27, JavaFX 27

DevFeed: [Java 27 Delivers Post-Quantum Cryptography, Future Language Innovation, Helidon 27, JavaFX 27](<https://devfeed.tech/articles/java-27-delivers-post-quantum-cryptography-future-language-innovation-helidon-27-javafx-27-30909.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/09/java27-released/>)

Author: Michael Redlich

Published: 2026-09-16T10:00:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [java-27](<https://devfeed.tech/topics/java-27.md>), [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Security](<https://devfeed.tech/topics/security.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [releases](<https://devfeed.tech/topics/releases.md>)

Tags: [application-security](<https://devfeed.tech/tags/application-security.md>), [architecture-design](<https://devfeed.tech/tags/architecture-design.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [development](<https://devfeed.tech/tags/development.md>), [digital-signature](<https://devfeed.tech/tags/digital-signature.md>), [helidon](<https://devfeed.tech/tags/helidon.md>), [java](<https://devfeed.tech/tags/java.md>), [java-27](<https://devfeed.tech/tags/java-27.md>), [java27-released](<https://devfeed.tech/tags/java27-released.md>), [javafx](<https://devfeed.tech/tags/javafx.md>), [jdk-27](<https://devfeed.tech/tags/jdk-27.md>), [jdk-28](<https://devfeed.tech/tags/jdk-28.md>), [lattice](<https://devfeed.tech/tags/lattice.md>), [module](<https://devfeed.tech/tags/module.md>), [news](<https://devfeed.tech/tags/news.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [portfolio](<https://devfeed.tech/tags/portfolio.md>), [post-quantum-cryptography](<https://devfeed.tech/tags/post-quantum-cryptography.md>), [preview](<https://devfeed.tech/tags/preview.md>), [project-valhalla](<https://devfeed.tech/tags/project-valhalla.md>), [quantum-computing](<https://devfeed.tech/tags/quantum-computing.md>), [release](<https://devfeed.tech/tags/release.md>), [security](<https://devfeed.tech/tags/security.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

Oracle released Java 27, the second non-LTS release since JDK 25. Its final feature set contains nine JEPs, including post-quantum hybrid key exchange for TLS 1.3, structured concurrency, compact object headers, JFR data redaction, the Vector API, and PEM encodings for cryptographic objects. Five features remain in preview or incubator stages.

### Source excerpt

Oracle has released version 27 of the Java programming language and virtual machine. As the second non-LTS release since JDK 25, the final feature set includes nine JEPs, five of which are still progressing through the preview and incubator stages. This release focuses on strengthening security, future language innovation, and projects under the auspices of the Java Verified Portfolio. By Michael Redlich

## Java 27 Reaches GA With The G1 Garbage Collector By Default Everywhere

DevFeed: [Java 27 Reaches GA With The G1 Garbage Collector By Default Everywhere](<https://devfeed.tech/articles/java-27-reaches-ga-with-the-g1-garbage-collector-by-default-everywhere-26765.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/OpenJDK-27-Java-27>)

Author: Michael Larabel

Published: 2026-09-15T13:39:00Z

Content type: news

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [releases](<https://devfeed.tech/topics/releases.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Post-Quantum](<https://devfeed.tech/topics/post-quantum.md>), [TLS (Transport Layer Security)](<https://devfeed.tech/topics/tls.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [java](<https://devfeed.tech/tags/java.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [openjdk](<https://devfeed.tech/tags/openjdk.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [release](<https://devfeed.tech/tags/release.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [tls](<https://devfeed.tech/tags/tls.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

OpenJDK 27 has reached general availability. Its G1 garbage collector is now enabled by default across environments, replacing Serial as the default in constrained environments after improvements in throughput, latency, and memory usage. The release also includes post-quantum hybrid key exchange for TLS 1.3, preview features for lazy constants and structured concurrency, compact object headers by default, and an incubating Vector API.

### Source excerpt

Oracle christened Java 27 today with the OpenJDK 27 release reaching general availability (GA) status...

## 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.

## Structured Concurrency

DevFeed: [Structured Concurrency](<https://devfeed.tech/articles/structured-concurrency-39377.md>)

Original publisher: [Read original article](<https://kt.academy/article/structured_concurrency_patricio>)

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

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Structured concurrency](<https://devfeed.tech/topics/structured-concurrency.md>), [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Error Handling](<https://devfeed.tech/topics/error-handling.md>)

Tags: [coroutines](<https://devfeed.tech/tags/coroutines.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [guide](<https://devfeed.tech/tags/guide.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [memory-leaks](<https://devfeed.tech/tags/memory-leaks.md>), [processes](<https://devfeed.tech/tags/processes.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

A Kotlin-focused guide to structured concurrency explains how coroutine hierarchies establish ownership and completion guarantees. It covers cancellation of child coroutines, avoiding unnecessary work and resource leaks, awaiting completion, and handling errors.

### Source excerpt

The only guide to structured concurrency you'll ever need.

## How Kotlin influenced Java's development and future

DevFeed: [How Kotlin influenced Java's development and future](<https://devfeed.tech/articles/is-kotlin-a-savior-of-java-39347.md>)

Original publisher: [Read original article](<https://kt.academy/article/kotlin_vs_java>)

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

Content type: opinion

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Development](<https://devfeed.tech/topics/development.md>), [Android](<https://devfeed.tech/topics/android.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Scala](<https://devfeed.tech/topics/scala.md>), [Groovy](<https://devfeed.tech/topics/groovy.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [development](<https://devfeed.tech/tags/development.md>), [groovy](<https://devfeed.tech/tags/groovy.md>), [java](<https://devfeed.tech/tags/java.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [scala](<https://devfeed.tech/tags/scala.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [typescript](<https://devfeed.tech/tags/typescript.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This video transcript argues that Kotlin's growth, especially in Android and backend development, pressured Java to evolve. It compares Kotlin's interoperability, tooling, and developer appeal with Java's newer features, while concluding that Java is improving rather than doomed.

### Source excerpt

How Kotlin woke Java up, and what it means for the future of Java development.

## From error-handling to structured concurrency

DevFeed: [From error-handling to structured concurrency](<https://devfeed.tech/articles/from-error-handling-to-structured-concurrency-21946.md>)

Original publisher: [Read original article](<https://blog.nelhage.com/post/concurrent-error-handling/>)

Author: Nelson Elhage

Published: 2026-03-23T15:30:00Z

Content type: opinion

Language: en

Sources: [Nelson Elhage](<https://devfeed.tech/sources/nelson-elhage.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Error Handling](<https://devfeed.tech/topics/error-handling.md>), [Exception](<https://devfeed.tech/topics/exception.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [examples](<https://devfeed.tech/tags/examples.md>), [exception](<https://devfeed.tech/tags/exception.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>)

### AI overview

This article examines how error-handling patterns based on stack unwinding and cleanup should be adapted for concurrent programs with multiple tasks. It introduces the problem of unhandled errors in concurrent execution and compares possible behaviors when one task fails.

### Source excerpt

How should we think about error-handling in concurrent programs? In single-threaded programs, we've mostly converged on a standard pattern, with a diverse zoo of implementations and concrete patterns. When an error occurs, it is propagated up the stack until we find a stack frame which is prepared to handle it. As we do so, we unwind the stack frames in-order, giving each frame the opportunity to clean up or destroy resources as appropriate.

## How to Prevent Race Conditions in Coroutines

DevFeed: [How to Prevent Race Conditions in Coroutines](<https://devfeed.tech/articles/how-to-prevent-race-conditions-in-coroutines-25006.md>)

Original publisher: [Read original article](<https://typealias.com/articles/prevent-race-conditions-in-coroutines/>)

Author: author@typealias.com (Dave Leeds)

Published: 2025-11-24T00: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-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [actor](<https://devfeed.tech/tags/actor.md>), [atomicint](<https://devfeed.tech/tags/atomicint.md>), [atomics](<https://devfeed.tech/tags/atomics.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [limitedparallelism](<https://devfeed.tech/tags/limitedparallelism.md>), [mutex](<https://devfeed.tech/tags/mutex.md>), [programming](<https://devfeed.tech/tags/programming.md>), [race-condition](<https://devfeed.tech/tags/race-condition.md>), [shared-mutable-state](<https://devfeed.tech/tags/shared-mutable-state.md>), [state](<https://devfeed.tech/tags/state.md>), [stateflow](<https://devfeed.tech/tags/stateflow.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>)

### AI overview

This tutorial explains that Kotlin coroutines and structured concurrency do not automatically protect shared mutable state from race conditions. It introduces the issue using an example that creates 100,000 random bakery orders.

### Source excerpt

Thanks to structured concurrency, there are a lot of concerns that we don't have to handle manually when working with Kotlin coroutines. For example, parent coroutines automatically wait for their children to complete before completing themselves. And when a parent coroutine is cancelled, its children are automatically cancelled, too. But when it comes to shared mutable state - mutable data that multiple coroutines could update at the same time - there's nothing magical in the design of coroutines to ensure that the state is updated properly.

## Use Swift with Temporal

DevFeed: [Use Swift with Temporal](<https://devfeed.tech/articles/use-swift-with-temporal-36022.md>)

Original publisher: [Read original article](<https://temporal.io/blog/temporal-now-supports-swift>)

Author: Shy Ruparel

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

Content type: release

Language: en

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

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [SDKs](<https://devfeed.tech/topics/sdks.md>), [async/await](<https://devfeed.tech/topics/async-await.md>), [Swift 6.2](<https://devfeed.tech/topics/swift-6-2.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>)

Tags: [announcements](<https://devfeed.tech/tags/announcements.md>), [async](<https://devfeed.tech/tags/async.md>), [await](<https://devfeed.tech/tags/await.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [github](<https://devfeed.tech/tags/github.md>), [grpc](<https://devfeed.tech/tags/grpc.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [swift](<https://devfeed.tech/tags/swift.md>), [swift-6-2](<https://devfeed.tech/tags/swift-6-2.md>)

### AI overview

Temporal announces a Swift SDK for building durable, fault-tolerant, long-running workflows with Swift 6.2, async/await, and structured concurrency. The SDK supports automatic handling of failures, retries, persistence, and crash recovery, and integrates with Temporal through Swift C interop and gRPC-swift.

### Source excerpt

Announcing the Swift Temporal SDK. Build durable, fault-tolerant Workflows in Swift 6.2 with async/await and structured concurrency.

## Announcing Apollo iOS 2.0

DevFeed: [Announcing Apollo iOS 2.0](<https://devfeed.tech/articles/announcing-apollo-ios-2-0-23133.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/announcing-apollo-ios-2-0>)

Author: Anthony Miller

Published: 2025-10-07T07:00:46Z

Content type: release

Language: en

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

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [GraphQL](<https://devfeed.tech/topics/graphql.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [WebSocket](<https://devfeed.tech/topics/websocket.md>)

Tags: [announcement](<https://devfeed.tech/tags/announcement.md>), [apple](<https://devfeed.tech/tags/apple.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [release](<https://devfeed.tech/tags/release.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [swift](<https://devfeed.tech/tags/swift.md>), [websocket](<https://devfeed.tech/tags/websocket.md>)

### AI overview

Apollo iOS 2.0 is a release of Apollo's Swift client rebuilt around Swift's modern concurrency model. It introduces concurrency-aware APIs, streamlined layers, and updated platform and distribution requirements, including the retirement of CocoaPods support. GraphQL subscriptions currently support HTTP only; WebSocket support is planned for a future minor release.

### Source excerpt

Apollo iOS 2.0 is here, and it's the biggest reimagining of our Swift client yet. Built from the ground up for Swift's modern concurrency model, this release delivers snappier performance, stronger type guarantees, and a cleaner developer experience for teams shipping GraphQL-powered apps across Apple platforms. Improved APIs Swift's structured concurrency and the / syntax weren't just sugar, they introduced an entirely new mental model for reasoning about work, isolation, and cancellation.

## Kotlin Coroutines and Swift

DevFeed: [Kotlin Coroutines and Swift](<https://devfeed.tech/articles/kotlin-coroutines-and-swift-39324.md>)

Original publisher: [Read original article](<https://kt.academy/article/interop-coroutines-swift>)

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

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [Kotlin Multiplatform](<https://devfeed.tech/topics/kotlin-multiplatform.md>), [Structured concurrency](<https://devfeed.tech/topics/structured-concurrency.md>), [async/await](<https://devfeed.tech/topics/async-await.md>), [kotlin-flow](<https://devfeed.tech/topics/kotlin-flow.md>), [kotlin-native](<https://devfeed.tech/topics/kotlin-native.md>), [iOS](<https://devfeed.tech/topics/ios.md>)

Tags: [async](<https://devfeed.tech/tags/async.md>), [cancellation](<https://devfeed.tech/tags/cancellation.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-flow](<https://devfeed.tech/tags/kotlin-flow.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [kotlin-native](<https://devfeed.tech/tags/kotlin-native.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [swift](<https://devfeed.tech/tags/swift.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This tutorial explains how to bridge Kotlin Coroutines and Swift's async/await and structured concurrency in Kotlin Multiplatform iOS projects. It covers suspending functions, exception conversion, Kotlin Flow to AsyncSequence, and calling Swift async functions from Kotlin.

### Source excerpt

How to use Kotlin Coroutines in Swift projects, or Swift libraries from Kotlin Coroutines.

## Flash cards for Coroutines - KotlinFlashKards

DevFeed: [Flash cards for Coroutines - KotlinFlashKards](<https://devfeed.tech/articles/flash-cards-for-coroutines-kotlinflashkards-32050.md>)

Original publisher: [Read original article](<https://www.maiatoday.net/p/flash-cards-for-coroutines-kotlinflashkards/>)

Published: 2024-09-18T17:50:02Z

Content type: tutorial

Language: en

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

Topics: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [ide](<https://devfeed.tech/topics/ide.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Error Handling](<https://devfeed.tech/topics/error-handling.md>), [Testing](<https://devfeed.tech/topics/testing.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [flash-cards](<https://devfeed.tech/tags/flash-cards.md>), [ide](<https://devfeed.tech/tags/ide.md>), [jetbrains](<https://devfeed.tech/tags/jetbrains.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlinflashkards](<https://devfeed.tech/tags/kotlinflashkards.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

An in-IDE flash-card course called KotlinFlashKards helps learners practise Kotlin coroutines through questions, hints, code snippets, and tests. It covers basics, structured concurrency, error handling, and testing, and runs through the JetBrains Academy plugin.

### Source excerpt

I made something. I made a set of flash cards to practise and learn Kotlin coroutines. I call them KotlinFlashKards (with a K of course). This is the first of a series covering different topics. Why create flash cards? Does this happen to you? You are writing some code, you know something is possible but you can't remember exactly how to do it. By the time you have asked an AI or researched you have forgotten what it was you wanted to do in the first place. There is a way to fix this. Learn and remember the key concepts you use often. One way to do this is to use flash cards. I learnt this from the book The Programmers Brain by Felienne Hermans How does it work? The deck doesn't replace the docs or a good book. It is an in IDE course in the form of a question, a hint that hides the answer and a code snippet with a test to explain the concept. It has four sections Basics - 18 cards Structured Concurrency - 12 cards Error handling - 7 cards Testing - 6 cards You can explore the sections in order or dip in and try tasks at random. Strategies to get the best out of the course? Repeat at regular intervals - Memories are built up if you repeat the flash cards at regular intervals. It is better to do a few lessons more often than to do many lessons in one sitting. You can do the course many times or choose which areas to practise. Recall the answer before peeking - It is important to try to recall the syntax first before looking at the hints or letting the IDE help you. This means you practise your recall of the memory. Think about the solution - For each question and answer you will remember it better too if you think of a practical place where you could use similar code. How do I get it? You need: a JetBrains IDE like Android Studio or Intellij Community edition the JetBrains Acadamy plugin installed Then do the following: Before opening a project click on the Learn menu item on the left Click on New course In the Marketplace search for KotlinFlashKards and start the cou

## Job and children awaiting in Kotlin Coroutines

DevFeed: [Job and children awaiting in Kotlin Coroutines](<https://devfeed.tech/articles/job-and-children-awaiting-in-kotlin-coroutines-39237.md>)

Original publisher: [Read original article](<https://kt.academy/article/cc-job>)

Published: 2024-07-15T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Job](<https://devfeed.tech/topics/job.md>), [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Structured concurrency](<https://devfeed.tech/topics/structured-concurrency.md>), [cancellation](<https://devfeed.tech/topics/cancellation.md>)

Tags: [cancellation](<https://devfeed.tech/tags/cancellation.md>), [job](<https://devfeed.tech/tags/job.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This tutorial explains the Kotlin Coroutines Job context. It describes how each coroutine has its own Job, how parent-child Job relationships support structured concurrency, and how Jobs enable cancellation, completion waiting, and exception handling within a coroutine scope.

### Source excerpt

What Job is and how it is the most important context responsible for structured concurrency.

## Key advantages of Kotlin Coroutines

DevFeed: [Key advantages of Kotlin Coroutines](<https://devfeed.tech/articles/key-advantages-of-kotlin-coroutines-39257.md>)

Original publisher: [Read original article](<https://kt.academy/article/coroutines-advantages>)

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

Content type: article

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Structured concurrency](<https://devfeed.tech/topics/structured-concurrency.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [cancellation](<https://devfeed.tech/topics/cancellation.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [async/await](<https://devfeed.tech/topics/async-await.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [Android](<https://devfeed.tech/topics/android.md>), [WebSocket](<https://devfeed.tech/topics/websocket.md>)

Tags: [cancellation](<https://devfeed.tech/tags/cancellation.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [http](<https://devfeed.tech/tags/http.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [testing](<https://devfeed.tech/tags/testing.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This article explains the main advantages of Kotlin Coroutines: simpler imperative-style asynchronous code, structured concurrency, lighter execution than threads, cancellation, synchronization, and precise virtual-time testing. It discusses applications in Android and backend development, including Ktor.

### Source excerpt

Where Kotlin Coroutines shine and why you should use them.

## Zero downtime deployment with Arrow and Ktor Native

DevFeed: [Zero downtime deployment with Arrow and Ktor Native](<https://devfeed.tech/articles/zero-downtime-deployment-with-arrow-and-ktor-native-25515.md>)

Original publisher: [Read original article](<http://nomisrev.github.io/graceful-resource-handling-using-structured-concurrency-in-kotlin/>)

Author: Simon Vergauwen

Published: 2023-02-16T00:00:00Z

Content type: tutorial

Language: en

Sources: [nomisRev](<https://devfeed.tech/sources/nomisrev.md>)

Topics: [Ktor](<https://devfeed.tech/topics/ktor.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [zero downtime deployment](<https://devfeed.tech/topics/zero-downtime-deployment.md>), [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [resource](<https://devfeed.tech/tags/resource.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [structuredconcurrency](<https://devfeed.tech/tags/structuredconcurrency.md>), [zero-downtime-deployment](<https://devfeed.tech/tags/zero-downtime-deployment.md>)

### AI overview

A webinar explains zero-downtime deployment for functional microservices using Ktor and Kubernetes. It also covers structured concurrency, Arrow's Resource DSL, and KotlinX Coroutines for resource safety and complex use cases.

### Source excerpt

Webinar with Anton Arhipov on functional microservices with Ktor and Kubernetes about zero-downtime deployments.

## Graceful Shutdown with Structured Concurrency

DevFeed: [Graceful Shutdown with Structured Concurrency](<https://devfeed.tech/articles/graceful-shutdown-with-structured-concurrency-25516.md>)

Original publisher: [Read original article](<http://nomisrev.github.io/grateful-shutdown-with-structured-concurrency/>)

Author: Simon Vergauwen

Published: 2022-11-24T00:00:00Z

Content type: article

Language: en

Sources: [nomisRev](<https://devfeed.tech/sources/nomisrev.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Processes](<https://devfeed.tech/topics/processes.md>)

Tags: [applications](<https://devfeed.tech/tags/applications.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [resource](<https://devfeed.tech/tags/resource.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [structuredconcurrency](<https://devfeed.tech/tags/structuredconcurrency.md>)

### AI overview

This talk explains how structured concurrency can help reason about graceful application shutdown, concurrency, and parallel processes. It discusses issues that can arise when applications do not shut down gracefully.

### Source excerpt

In the modern world we often need to make strong guarantees about how our applications terminate; Structured Concurrency gives us a powerful tool to reason about concurrency, parallel processes and how they relate to each other.

## Advanced Swift, fifth edition

DevFeed: [Advanced Swift, fifth edition](<https://devfeed.tech/articles/advanced-swift-fifth-edition-21708.md>)

Original publisher: [Read original article](<https://oleb.net/2022/advanced-swift-5/>)

Author: Ole Begemann

Published: 2022-03-28T14:03:30Z

Content type: release

Language: en

Sources: [Ole Begemann](<https://devfeed.tech/sources/ole-begemann.md>)

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [async/await](<https://devfeed.tech/topics/async-await.md>)

Tags: [async](<https://devfeed.tech/tags/async.md>), [await](<https://devfeed.tech/tags/await.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [generics](<https://devfeed.tech/tags/generics.md>), [release](<https://devfeed.tech/tags/release.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [swift](<https://devfeed.tech/tags/swift.md>)

### AI overview

The fifth edition of Advanced Swift has been released. It is updated for Swift 5.6, adds a chapter on concurrency covering async/await, structured concurrency, and actors, and includes new material on property wrappers, result builders, protocols, and generics. The print edition is now a hardcover, and ebook owners receive a free update.

### Source excerpt

We released the fifth edition of our book Advanced Swift a few days ago. You can buy the ebook on the objc.io site. The hardcover print edition is printed and sold by Amazon (amazon.com, amazon.co.uk, amazon.de). Highlights of the new edition: Fully updated for Swift 5.6 A new Concurrency chapter covering async/await, structured concurrency, and actors New content on property wrappers, result builders, protocols, and generics The print edition is now a hardcover (for the same price) Free update for owners of the ebook A growing book for a growing language Updating the book always turns out to be more work than I expect. Swift has grown substantially since our last release (for Swift 5.0), and the size of the book reflects this. The fifth edition is 76 % longer than the first edition from 2016. This time, we barely stayed under 1 million characters: Character counts of Advanced Swift editions from 2016-2022. Many thanks to our editor, Natalye, for reading all this and improving our Dutch/German dialect of English. Hardcover For the first time, the print edition comes in hardcover (for the same price). Being able to offer this makes me very happy. The hardcover book looks much better and is more likely to stay open when laid flat on a table. We also increased the page size from 15x23 cm (6x9 in) to 18x25 cm (7x10 in) to keep the page count manageable (Amazon's print on demand service limits hardcover books to 550 pages). I hope you enjoy the new edition. If you decide to buy the book or if you bought it in the past, thank you very much! And if you're willing to write a review on Amazon, we'd appreciate it.

## Constructing a coroutine scope

DevFeed: [Constructing a coroutine scope](<https://devfeed.tech/articles/constructing-a-coroutine-scope-39234.md>)

Original publisher: [Read original article](<https://kt.academy/article/cc-constructing-scope>)

Published: 2021-10-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Structured concurrency](<https://devfeed.tech/topics/structured-concurrency.md>), [Back end](<https://devfeed.tech/topics/backend.md>)

Tags: [coroutine](<https://devfeed.tech/tags/coroutine.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [logging](<https://devfeed.tech/tags/logging.md>), [scope](<https://devfeed.tech/tags/scope.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

A tutorial on constructing Kotlin coroutine scopes for Android and backend code. It recommends holding a scope in a property, explains when a custom scope is needed, and discusses dispatchers, supervision, and exception handling.

### Source excerpt

How we generally define coroutine scope on Android and on the backend.

## 7 common mistakes you might be making when using Kotlin Coroutines

DevFeed: [7 common mistakes you might be making when using Kotlin Coroutines](<https://devfeed.tech/articles/7-common-mistakes-you-might-be-making-when-using-kotlin-coroutines-25414.md>)

Original publisher: [Read original article](<https://www.lukaslechner.com/7-common-mistakes-you-might-be-making-when-using-kotlin-coroutines/>)

Author: Lukas Lechner

Published: 2021-01-08T11:12:53Z

Content type: tutorial

Language: en

Sources: [Lukas Lechner](<https://devfeed.tech/sources/lukas-lechner.md>)

Topics: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [allgemein](<https://devfeed.tech/tags/allgemein.md>), [allgemein-kotlin](<https://devfeed.tech/tags/allgemein-kotlin.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [mistakes](<https://devfeed.tech/tags/mistakes.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>)

### AI overview

A tutorial on common mistakes when using Kotlin Coroutines, including creating a separate Job that breaks structured concurrency and installing SupervisorJob incorrectly. It explains how coroutine scope cancellation and job hierarchies affect cancellation behavior.

### Source excerpt

In my opinion, Kotlin Coroutines really simplify the way we write asynchronous and concurrent code. However, I identified some common mistakes that many developers make when using Coroutines. This way, our Coroutine now is cancelled when the Scope is cancelled: The suspend functions in the Kotlin standard library (like e.g. `delay()`) are all cooperative regarding Read More The post 7 common mistakes you might be making when using Kotlin Coroutines first appeared on Lukas Lechner.

## Structured Concurrency Anniversary

DevFeed: [Structured Concurrency Anniversary](<https://devfeed.tech/articles/structured-concurrency-anniversary-26028.md>)

Original publisher: [Read original article](<https://elizarov.medium.com/structured-concurrency-anniversary-f2cc748b2401?source=rss-4762e889f8fc------2>)

Author: Roman Elizarov

Published: 2019-09-28T15:02:02Z

Content type: article

Language: en

Sources: [Stories by Roman Elizarov on Medium](<https://devfeed.tech/sources/stories-by-roman-elizarov-on-medium.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [kotlin-coroutines](<https://devfeed.tech/topics/kotlin-coroutines.md>), [Android](<https://devfeed.tech/topics/android.md>), [reactive](<https://devfeed.tech/topics/reactive.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [code](<https://devfeed.tech/tags/code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [programming](<https://devfeed.tech/tags/programming.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [reactive-streams](<https://devfeed.tech/tags/reactive-streams.md>), [structured-concurrency](<https://devfeed.tech/tags/structured-concurrency.md>)

### AI overview

This retrospective examines the first year of Structured Concurrency in Kotlin Coroutines. It describes its origins in backend asynchronous programming, adoption in Android lifecycle-aware development, and its role in Kotlin Flows and reactive streams.

### Source excerpt

Photo by Annie Spratt on Unsplash A little over a year ago I announced big conceptual shift in the design of Kotlin Coroutines called Structured Concurrency. From that moment on, it took our team about a month to make the first stable 1.0.0 release of kotlinx.coroutines library. After a year of further work, kotlinx.coroutines had added stable support for cold flows that integrate nicely with reactive streams. The library had reached version 1.3.2 by now. It is good time to look back and see how it all worked out -- what was great, what could be improved. Structured Concurrency accomplished more than we hoped for. Originally, the design of structured concurrency was based on the woes experienced by backend developers trying to implement all sorts of asynchronous and concurrent logic. It was focused on making sure that you cannot ever lose a running coroutine or an exception. The key building block we added back then is coroutineScope { ... } function, which encapsulates concurrent operations and limits their scope to the scope of the current call. There was not much else to it, so our recommendation to UI developers was to implement CoroutineScope interface in various "closeable" entities of their applications. We envisioned a simple picture with a simple scope hierarchy. It turned out to be more elaborate in practice. Structured Concurrency was rapidly adopted by Android, which has quite complicated life-cycles. Android libraries added extensions like lifecycleScope and viewModelScope, enabling concise and safe integration of coroutines with those concepts. It became apparent that code looks clearer when an object encapsulating the scope is separate from the rest of code. Introductory Android Codelab on Coroutines recommends defining coroutine scope like this: private val scope = CoroutineScope(...) Nowadays, this style increasingly looks more appealing, so it's time to adjust our documentation to reflect it. At the same time, structured concurrency laid a solid fou