concurrency▌

Master Java concurrency patterns for thread-safe applications.

Offload CPU-intensive tasks to background isolates while keeping Flutter UIs responsive. \n \n Provides three concurrency patterns: async / await for I/O-bound work, Isolate.run() for one-off heavy computations, and Isolate.spawn() with message passing for persistent background workers \n Includes a decision matrix to choose between async operations and isolates based on task type (I/O vs. CPU-bound) and execution frequency \n Covers three complete workflows with step-by-step task checklists: st

Review and fix Kotlin Coroutines issues in Android codebases by applying structured concurrency, lifecycle safety, proper scoping, and modern best practices with minimal behavior changes.

Detect and exploit race condition vulnerabilities in web applications using Turbo Intruder's single-packet attack technique to bypass rate limits, duplicate transactions, and exploit time-of-check-to-time-of-use flaws.

Rust concurrency design: workload classification, sharing models, and Send/Sync requirements. \n \n Guides decision-making between threads (CPU-bound), async (I/O-bound), and hybrid approaches before implementing \n Covers Send/Sync marker traits, thread-safety patterns (Arc, Mutex, RwLock, channels), and atomic operations with quick reference tables \n Includes mandatory \"trace up\" to domain skills (web, fintech, cloud-native, CLI) to align concurrency design with architectural constraints \n

Swift Concurrency review and remediation for Swift 6.2+ codebases. \n \n Diagnoses and fixes actor isolation, Sendable safety, and data-race warnings through targeted edits that preserve existing behavior \n Applies minimal, concrete fixes: @MainActor annotations, actor isolation, Sendable conformance, and completion-handler-to-async/await migrations \n Triages compiler diagnostics by checking project concurrency settings, actor context, and whether code is UI-bound or background work \n Verifie

Profile and optimize Swift async/await code using Instruments.

Implement safe concurrent code using proper synchronization primitives and patterns for parallel execution.

$20

Go concurrency scales when goroutine lifetimes are explicit, cancellation is propagated with context.Context, and shared state is protected (channels or locks). Apply these patterns to build reliable services and avoid common failure modes: goroutine leaks, deadlocks, and data races.