The hottest Swift Substack posts right now

The Objective-C runtime has powerful internals that go well beyond @objc and selectors, and those capabilities can be leveraged in modern Swift apps today.
Learning how message dispatch, objc_msgSend, and the runtime’s class/method structures work lets you apply practical techniques to simplify and extend UIKit and Swift codebases.
Studying Objective‑C’s design and runtime is both interesting and immediately useful, giving you new tools and insights to improve current app development.

Swift has four types of method dispatch that determine how function calls are executed, and understanding these can help improve your code's performance.
The Swift compiler and runtime perform many optimizations behind the scenes, making some traditional coding tips less important.
Learning about method dispatch can help you write faster, more efficient code and build a better intuition about how Swift works.

Understanding SwiftUI is crucial for coding interviews, especially for positions focused on iOS development. It helps you stand out as a candidate.
Practicing Swift Concurrency will give you an edge in solving problems more efficiently during interviews. It's an important skill that employers value.
Interviews don't have to be stressful or frustrating. Using structured approaches can make the process smoother and more enjoyable for both candidates and interviewers.

Booleans in Swift are very basic - just true or false.
Behind the scenes, Swift Booleans are actually structs with a 1-bit integer property.
Swift uses protocols like ExpressibleByBooleanLiteral for instantiating Boolean values.

Get a weekly roundup of the best Substack posts, by hacker news affinity:

Understanding method dispatch in Swift is crucial for optimizing code performance.
Static dispatch is fast but inflexible, while dynamic dispatch is slower but more flexible.
By using final classes, private methods, and whole-module optimization, developers can reduce dynamic dispatch and improve code performance.

isKnownUniquelyReferenced checks if strong reference count is 1
Swift components like Builtin, AST, SIL, LLVM work together for this optimization
Understanding memory management internals can help in optimizing code

Unit testing @Observable view models is crucial for ensuring reliability and stability in iOS development.
The Observation Framework provides a solution for testing @Observable properties using withObservationTracking, improving the unit testing process.
By leveraging the ObservationTestUtils package, developers can streamline unit testing of @Observable view models with less boilerplate code.

Understanding Swift actors is crucial for managing re-entrancy and interleaving in your code.
Building an optimal authentication service involves utilizing Swift actors to minimize duplicate work and network overhead.
Swift concurrency model utilizes cooperative threading, executors, and actors to create an illusion of single-threadedness and prevent data races.

Access control in Swift has a hierarchy from most restrictive to least restrictive.
The `private` keyword in Swift makes code invisible outside the entity it's defined in.
Using access control keywords like `public` and `internal`, along with modifiers like `private(set)` and `public private(set)`, helps maintain clean, secure code.

Combine and async/await can be used together to write robust and maintainable software with modern language features.
Testing @ObservableObject view models, Combine publishers in async methods, and Combine publishers converted to AsyncSequence are key in achieving unit test mastery.
Understanding the interoperation between Combine and async/await is a powerful skill for writing unit tests and marrying the two concurrency approaches.