ReadMeFeed / Community knowledge
Real questions. Useful conversations. Find the people who know your stack.
Languages & runtimes · #swift
Developers want to guarantee that a timeout set with Task.sleep stops any further work as soon as the cancellation signal is received, preventing unnecessary execution after the deadline. The common approach of racing Task.sleep against a task and checking Task.isCancelled after the sleep finishes creates a race window: the task may observe cancellation only
I have a Swift service where a method on an actor needs to kick off a background export. The work should not hold the actor's lock while it runs, but it does rely on a task-local tracing ID and should still stop if the caller's task is cancelled. I am weighing two documented options: a structured child task via async let , or an unstructured Task.detached .
SwiftNIO's NIOConnectionPool throws ConnectionPoolError.connectionPoolExhausted when all pooled connections are in use and no idle connection is available for a new request. The error is surfaced through the ChannelFuture 's failure handler, allowing developers to detect intermittent exhaustion under load. Because the pool size is fixed at initialization and
When designing a Swift notification strategy that balances useful alerts with minimal user noise, silent pushes using content-available:1 appear attractive because they avoid visible banners or sounds. However, iOS background execution limits can throttle these pushes, leading to inconsistent delivery of application(_:didReceiveRemoteNotification:fetchComple
I'm designing a networking layer in Swift using Combine (iOS 15+) where requests are wrapped with .timeout(_:scheduler:) so subscribers receive an error if no value arrives in time. My goal is to guarantee that when a timeout fires, the underlying work — for example a URLSession.DataTaskPublisher request — stops consuming resources rather than continuing in
Goal Serialize object graphs that include custom model types without manually flattening them to property-list containers before calling JSONSerialization . Constraints and uncertainty Foundation's JSONSerialization throws an NSInvalidArgumentException with the reason Invalid top-level type in JSON writing when the root object is not an NSArray or NSDictiona
Cancellation Behavior in Distributed Actor Isolation Swift's cooperative cancellation model ensures that cancellation propagates from parent tasks to child tasks created via async let or TaskGroup . This mechanism relies on the task hierarchy to signal termination to all nested operations. When asynchronous operations transition across different actor isolat
When developing modular architectures in Xcode, managing the visibility of types across different targets is critical for maintaining a clean API. Swift provides internal as the default access level, which restricts visibility to the defining module, and public for external access. A design challenge arises when a type must be visible to an external module,
Background Swift 6 introduces a language mode that enforces strict data‑race safety by default. When a target is compiled with swiftLanguageMode = v6 , many diagnostics that were merely warnings in Swift 5.9 become build‑time errors. For a small Swift application that must remain available, the question is how to activate this mode incrementally without trig
apple
foundation
xcode