Hey 👋🏻 I’m Yakov, and I’ve been building software with Swift for over 7 years. On this channel, I share the things I’ve learned along the way: everything from the fundamentals to advanced topics.
Highlights a gap in iOS privacy despite gated access to Photos and Contacts. Proposes a new system-level control to further restrict or compartmentalize sensitive data with clearer, granular consent. Explores impacts on permission flows, data handling, and UX. Takeaway: tighter scoping to reduce unnecessary data exposure.
Curated recap of WWDC26 for developers, moving beyond keynote to surface practical takeaways from across sessions: notable API updates, platform changes, deprecations, and performance implications. Focuses on what matters in code, pitfalls to avoid, and where to invest time next.
A comprehensive Swift-focused tour of protocols for scalable design: from basics and syntax to protocol-oriented design. Covers defining requirements, conformance, composition, and extensions with default implementations to decouple modules and scale. Explains when to prefer protocols over inheritance and common pitfalls. Takeaway: build flexible, testable architectures.
Explores how Swift protocol method dispatch affects runtime performance. Clarifies when calls are statically vs dynamically dispatched and how subtle design choices around protocol use can introduce overhead. Offers guidance to structure protocol APIs for speed and avoid common pitfalls.
Year-end recap of the top five Apple platform updates from 2025 that most affect developers. Covers major announcements and tooling/framework changes, their impact on workflows, app capabilities, and submission policies, plus practical adoption tips and migration considerations for iOS projects.
Explores how Swift dispatches function calls: direct/static calls, class vtables, protocol witness tables, generic specialization, and Objective‑C objc_msgSend. Explains how final, dynamic, @objc, protocol existentials, and extensions influence dynamic vs static dispatch, inlining, and devirtualization, with performance tradeoffs to guide optimization choices.
Explores two ways to use Swift protocols: as existential types (values of a protocol) vs as generic constraints. Highlights their differing performance traits—existentials often incur dynamic dispatch and overhead, while generics enable specialization/inlining. Takeaway: prefer generics in hot paths, use existentials for flexibility, and benchmark to guide choices.
Status update on an Apple privacy vulnerability: two weeks after being reported, the issue exposing developers’ internal Apple ID Numbers remains unfixed. Highlights what data is at risk and the implications for developer privacy. Takeaway: be aware of potential exposure until Apple addresses it.
Explains an Apple systems vulnerability that exposed internal identifiers of individuals—what the flaw was, how it enabled access, and its privacy impact. Takeaways for iOS developers: reinforce access controls, validate server/API responses, minimize identifier exposure, audit logs, and monitor for data leaks.
Narrative of finding and confirming an Apple-caused data leak and spending 60 days trying to get acknowledgment. Highlights responsible disclosure steps (repro, logs, PoC, impact) and the risk of slow vendor response. Takeaway for iOS devs: rigorously validate privacy, minimize data, prepare clear evidence, and plan for disclosure timelines.
A WWDC25 recap focused on what matters beyond the flashy “Liquid Glass” redesign. It surfaces overlooked platform updates, framework changes, and tooling notes, with guidance on what to adopt now, what to watch, and potential migration risks. A practical overview to help iOS developers prioritize post‑WWDC planning and roadmaps.
Overview of Swift 6.1 highlights for iOS developers: updates to TaskGroup in Swift Concurrency and new member import visibility controls. Covers how these changes impact async workflows and module/API exposure, with examples to adopt the new syntax and refine code organization.
Explores Swift–Objective‑C protocol interoperability: when Swift protocols can be exposed with @objc, Objective‑C optional requirements, class-only constraints, and limits like no associated types or generic requirements. Covers how Obj‑C protocols appear in Swift and common pitfalls. Takeaway: design @objc‑compatible APIs only when interop is required.
Comprehensive walkthrough of memory management for Swift and beyond: fundamentals (stack vs heap, value vs reference), how Swift’s ARC works, and using strong/weak/unowned references and capture lists. Focuses on avoiding retain cycles and leaks, with practical guidance to write safer, faster, more stable iOS apps.
Walkthrough of five Xcode productivity tricks to speed up day-to-day iOS development. Combines recent additions with long-standing features to streamline navigation, code editing, and overall workflow. Takeaway: adopt these Xcode tips to work faster with less friction.
Deep dive into Swift protocols: extend protocols with default implementations, declare protocols with associated types, understand the Self requirement, and combine protocols with generics. Learn practical patterns and constraints to build reusable, type-safe APIs for iOS apps.
Covers Swift protocols from basics to practical use: defining requirements, adopting and conforming, using protocols as types, and composing protocols with '&'. Introduces protocol-oriented programming via protocol extensions and default implementations, contrasts with inheritance, and highlights decoupling and testability benefits for iOS code.
Introduces composition vs. inheritance in Swift for iOS basics, comparing building behavior by combining small components with subclassing. Positions composition as an alternative or complement to protocols. Explains when to use each to improve maintainability, scalability, and testability, and warns about deep hierarchies and overusing protocols.
Intro to Swift protocols (interfaces): what they are, why they matter, and how types adopt and conform to them in iOS. Focuses on defining contracts to enable decoupling and polymorphism, with basic principles and simple use cases. Takeaway: model behavior with protocols to write flexible, testable code.