LowFile-scopeKotlin Plug & play

Extract common parallel processing patterns

Encapsulate coroutine parallelization (map async/awaitAll, limited concurrency) into utilities.

Why this matters

Avoids repeated, error-prone concurrency code and enforces limits.

Side-by-side examples engineers can pattern-match during review.

Avoid

val results = items.map { async { work(it) } }.map { it.await() } // inline everywhere

Prefer

suspend fun <T,R> parallel(xs: List<T>, limit: Int = 16, f: suspend (T) -> R): List<R> { /*...*/ }
val results = parallel(items) { work(it) }

Bad

items.map { async{...} }

Good

parallel(items) { work(it) }

From the same buckets as this rule.

Critical
Avoid Blocking Calls to Async Methods
Blocking async methods with `.Result` or `.Wait()` can cause deadlocks and prevent efficient asynchronous execution. Use `await` instead for proper async behavior.
concurrency-safetyperformance-efficiency
Critical
Do Not Call `wait()` When Holding Multiple Locks
Ensure that `wait()` is not called while holding multiple locks to prevent deadlocks.
concurrency-safety
High
Avoid Using Mutable Global Variables
Identify global variables that are mutable (e.g., lists, dictionaries). Global mutable state can cause unpredictable behavior. Recommend using local variables or encapsulating state in a class.
concurrency-safetymaintainability+1