Rodrigo Galvez

SwiftUI Tip 💡 In iOS 17.0+, use inspector() to show a trailing inspector panel, similar to desktop-style editing apps. Use inspectorColumnWidth() to control the preferred width of that inspector column. → learnandcodewithenid.com

51

Swift 5.9 brought the new @Observable macro to SwiftUI. Some of you may already know about it, but I’m sharing this visual guide for anyone who might find it useful - just like I did. @Observable works only on iOS 17 and above. If your deployment target is iOS 16 or earlier, you still need to use ObservableObject and @StateObject. #Swift #SwiftUI #iOS

81

21 comentarios

🚀 Swift Package Manager (SPM): the thing I underestimated for years For a long time, I used Swift Package Manager only for one reason: 👉 “Add a dependency and move on.” But once apps start growing, you realize SPM isn’t just a dependency tool — it’s an architecture decision. Let’s start with the small but important line everyone ignores // swift-tools-version: 5.9 This line does not mean: ❌ Swift language version What it actually means: ✅ Which Swift Package Manager features are allowed ✅ Which Xcode versions can build this package This one line can save your team hours of “works on my machine” issues. How SPM changes how you structure apps Instead of one giant target, SPM lets you think in modules: let package = Package( name: "AppModules", products: [ .library(name: "Networking", targets: ["Networking"]), .library(name: "UIComponents", targets: ["UIComponents"]) ] ) Now: • Networking doesn’t know about UI • UI doesn’t accidentally pull business logic • Each module is easier to test and reason about This is where SPM really shines. Adding a dependency feels… boring (and that’s good) .package( url: "https://lnkd.in/gS3nxCjB", from: "5.7.0" ) No Podfile. No pod install. No extra tooling. Xcode just… works. Why most teams are moving to SPM Honestly, the biggest wins I’ve seen: • Faster, more predictable builds • Cleaner ownership between teams • Better CI stability • One less tool to maintain It’s not perfect, but it’s good enough and getting better every year. A mistake I still see in real projects 👀 Using SPM only for third-party libraries and keeping all internal code in one target. You’re missing the biggest benefit: 👉 modularization + clear boundaries 💡 Interview-ready one-liner Swift Package Manager isn’t just for dependencies — it’s how you scale Swift codebases cleanly. If you’re working on a medium or large iOS app, SPM deserves a seat at your architecture discussions. #Swift #iOS

23

NEW: Xcode 26.3 unlocks the power of agentic coding "Developers can leverage coding agents, including Anthropic’s Claude Agent and OpenAI’s Codex, directly in Xcode to tackle complex tasks autonomously, helping them develop apps faster than ever! https://lnkd.in/dNzguKiB

3

In the opening keynote Next.js Conf 2025, Vercel CEO Guillermo Rauch acknowledged that they haven't been fully successful in the caching area of the Next.js framework, so they plan to understand the reasons behind their success in other areas and apply the same principles to caching. Those other areas, such as Server Components and Server Actions, were successful because they embrace composition and co-location, so with the latest changes they're bringing caching to the component boundary. The best session for understanding Cache Components is "Hands On: How To Migrate To Next.js 16 and Use Cache", in which the Next.js team insightfully explained how to update existing routes and components and what needs to be considered when doing so. Sam Selikoff explained beautifully why you don't have to use "use cache: remote" everywhere, when answering one of the participants' questions: “The reason you don’t want to just start spamming use cache remote everywhere is because that’s still runtime render which going to have to check Redis before and if there’s a way you can compose your app such that parts are actually static are part of the shell and you revalidate them with validate tag and revalidate path then you don’t have to like introduce this extra lookup every time. So it’s easy to kind of go wild with it, so use wisely.” Session - https://lnkd.in/gmJGJvST

5

The Magic of @dynamicMemberLookup in Swift: A Clean Way to Proxy Data Access One of Swift’s hidden gems is @dynamicMemberLookup. It allows you to create wrapper types that feel like native objects, even when the underlying data comes from something flexible like JSON, UserDefaults, Core Data, or a custom config. The Magic of @dynamicMemberLookup in Swift: A Clean Way to Proxy Data Access One of Swift’s hidden gems is @dynamicMemberLookup. It allows you to create wrapper types that behave like native objects — even when the underlying data comes from dynamic sources like JSON, UserDefaults, or custom config files. Cleaner code Improved readability Great for DSLs, wrappers, and dynamic data Use with care — it’s powerful, but easy to misuse. Ideal for proxy objects, configuration access, localization wrappers, or dynamic JSON parsing. Have you used @dynamicMemberLookup in production? Share your experience! #Swift #iOS #MobileDevelopment #SwiftTips #CleanCode

3

🚀 The Most Valuable iOS Development Insight for 2026 SwiftUI combined with Async/Await has become the gold standard for building modern, high-performance iOS applications. Here’s why every iOS developer should focus on mastering this powerful duo: ✅ Modern State Management SwiftUI with Combine enables clean, reactive data flows. Say goodbye to callback hell and hello to predictable, maintainable state handling using @Published and publishers. ✅ Simplified Concurrency Async/Await makes asynchronous code intuitive and readable, replacing complex GCD patterns with structured, maintainable concurrency. ✅ Noticeable Performance Gains Efficient view lifecycle handling and optimized rendering in SwiftUI can deliver 40–60% performance improvements over UIKit in many real-world scenarios. ✅ Strong Market Demand Over 87% of new iOS projects are now built with SwiftUI, and companies are actively looking for developers skilled in modern Swift concurrency. 💡 Pro Tip: Master Swift Concurrency patterns, handle errors effectively using async/await with try-catch, and always profile your SwiftUI views using Instruments. The iOS ecosystem is moving fast. Staying ahead means deeply understanding—and confidently applying—these modern development patterns. #iOS #SwiftUI #Swift #iOSDevelopment #AsyncAwait #MobileDevelopment #CareerGrowth

13

I built Sentrio in two days with AI. Without deep Swift expertise as I don't like Xcode. (https://lnkd.in/dVKSV-wc) Sentrio automatically routes your audio devices based on your priority rules. Now I can switch workplaces and have always right audio setup. I could build it as I had no architectural ceremony. and a clean documented API on a stable, secure, data privacy, infrastructure called operating system. It proofs the underrated importance of tech. Tech enables product and AI by a lot. AI was successful because the foundation was solid. I didn't need to debug the OS API, didn't need to read logs, didn't need to do maintenance on it. Just works out of the box. My App is just a thin frontend over a proven system. No hidden logic. No framework religion. No glue-and-pray. It's nice to ran into token limits, reminds me of doing breaks. Really healthy. Developing with ease and focus is simpler than you think. That's precisely when Good systems make both humans and AI dangerously effective. AI helps, and precisely when you no longer need AI. Don't get me wrong, I still belief in green code and not in AI. #Sentrio #BuildInPublic #IndieDev #macOS #Swift #AIEngineering #AIAssisted #SystemDesign #SoftwareArchitecture #ThinFrontend #OperatingSystems #DeveloperExperience #NoFrameworkReligion #CleanAPIs #InfrastructureMatters #TechFoundations #ProductEngineering #Automation #Minimalism #GoodSystems #Leverage #BuildWithFocus

24

3 comentarios

I wrote a short article explaining @retroactive in Swift, why it exists, what problem it solves, and how it makes protocol conformance failures predictable instead of surprising.

7

⚙️ 𝗦𝘁𝗮𝘁𝗶𝗰 𝘃𝘀 𝗗𝘆𝗻𝗮𝗺𝗶𝗰 𝗗𝗶𝘀𝗽𝗮𝘁𝗰𝗵 𝗶𝗻 𝗦𝘄𝗶𝗳𝘁 — 𝗪𝗵𝗮𝘁 𝗥𝗲𝗮𝗹𝗹𝘆 𝗛𝗮𝗽𝗽𝗲𝗻𝘀 𝗨𝗻𝗱𝗲𝗿 𝘁𝗵𝗲 𝗛𝗼𝗼𝗱 Ever wondered how Swift decides which function to actually call at runtime? That’s where dispatch — or method dispatching — comes in. Every function call in Swift is either statically dispatched or dynamically dispatched, depending on how it’s defined. Let’s break it down 👇 🧠 𝗦𝘁𝗮𝘁𝗶𝗰 𝗗𝗶𝘀𝗽𝗮𝘁𝗰𝗵 Used by:  ✅ structs, enums, final classes, and static functions At compile time, Swift already knows exactly which function to call. That means:  •  No runtime lookup  •  Faster execution  •  Inline optimizations 📸 Think of it like this:  When the app is built, Swift draws a direct arrow to the function’s memory address — no guessing. struct Math {  func add(_ a: Int, _ b: Int) -> Int { a + b } } let obj = Math() obj.add(3, 4) // ✅ Static dispatch 🧩 𝗗𝘆𝗻𝗮𝗺𝗶𝗰 𝗗𝗶𝘀𝗽𝗮𝘁𝗰𝗵 Used by:  ✅ class methods that are not final or private Here, the actual method call is decided at runtime using something called the vtable (virtual method table). Each class has a lookup table mapping method names → actual implementations.  When you call a method, Swift asks: “Which implementation should I use right now?” This enables polymorphism (overriding behavior), but adds a small runtime cost. class Animal {  func speak() { print("🐾 Animal sound") } } class Dog: Animal {  override func speak() { print("🐶 Bark!") } } let pet: Animal = Dog() pet.speak() // ✅ Dynamic dispatch (decided at runtime) ⚡ 𝗕𝗼𝗻𝘂𝘀: 𝗧𝗵𝗲 𝗠𝗶𝗱𝗱𝗹𝗲 𝗚𝗿𝗼𝘂𝗻𝗱 — “𝗪𝗶𝘁𝗻𝗲𝘀𝘀 𝗧𝗮𝗯𝗹𝗲𝘀” When you use protocols, Swift uses witness tables (similar to vtables) to dynamically resolve the right implementation at runtime — but with optimizations when possible.

16

Your code is only as good as your input. Guillermo Rauch, Vercel's CEO, posted that code should be treated as an output, and we should be turning our attention to production inputs. I agree. No amount of context in a system message will replace giving your coding agents access to production traces. Your agents need to see how real users actually hit your APIs. Which means looking at full request/response bodies, database calls, cache hits, etc. How we do it: - Record live traffic down to individual spans (with PII redacted) - Pipe traces to a coding agent via MCP so it can debug with real payloads - Replay traffic as a test suite in CI to diff API responses against user behavior Your app already knows what to test. You just didn't have something listening back then.

32

1 comentario

Swift 6.3 just dropped - and it's a bigger deal than most realize. Here's what stands out: 🔹 @c attribute - Expose Swift functions directly to C. No bridging headers. 🔹 Module Selectors (::) - Finally, no more ambiguous type conflicts. 🔹 Official Android SDK - Yes, really. Swift on Android is production-ready. 🔹 @specialize, @inline(always) - Fine-grained performance control for library authors. Full deep dive with runnable code examples you can try in your browser 👇 👉 https://lnkd.in/gU687kMS #Swift #iOSDevelopment #SwiftLang #MobileDevelopment #Apple #AndroidDev #Programming

4

Choosing between Combine and delegate/closure? 🔖 Save this mini-guide. 🧰 Use delegates/closures when: 🎯 You need a small, explicit link between two objects ✅ The event is simple/one-shot 🚀 You want minimal dependencies & fastest onboarding 🧪 Use Combine when: 🧩 You’re composing multiple async steps 🌀 You need operators, back-pressure, and cancellation 👥 Multiple listeners + clean lifecycle management matter I unpack the trade-offs, gotchas, and migration tips here (with code): 👉 https://lnkd.in/d_4EFSgy What did your team standardize on for new features—and why?👇 #iOS #Swift #Combine #SwiftUI #UIKit #Architecture #AsyncProgramming #DevTips

25

1 comentario

👨‍💻Being an iOS Dev Means More Than Writing Code Shipping an iOS app isn’t just about building it in Xcode — you also need to understand how to get it approved and discovered: • App Store Connect: Manage builds, provisioning, versioning, pricing, and localization. • TestFlight: Crucial for beta testing. Know the difference between internal and external testers. • App Review: Apple checks for things like crashes (2.1), spammy behavior (4.3), or copycat content (4.2). Read the guidelines — seriously. • Build Setup: Don’t mess up your Bundle ID, entitlements, or capabilities (like background audio or notifications). • ASO Matters: Keywords, title, screenshots — they all impact how your app shows up in search. Think of it as SEO for the App Store. In short: great code is step one — getting through Apple’s gates and reaching users is the rest of the game. #iOSDeveloper #BeyondCoding #MobileDevelopment #AppDevelopment #iOSDevLife #CodingAndMore #SoftwareEngineering #TechLife #DeveloperMindset #iOSProgramming

7

1 comentario

Testing Mobile Games is Tricky Here’s Why (and What QA Needs to Know) Mobile game testing isn’t just fun and games. It’s a complex QA challenge a perfect storm of device diversity, performance sensitivity, and unpredictable user behavior. Unlike traditional app testing, mobile game QA requires balancing visuals, functionality, performance, and real-world environments, all in one seamless experience. 📱 1. Device & OS Fragmentation From low-end Android phones to high-performance iPhones and tablets, games must work flawlessly across a massive range of devices. 🧠 QA Trick: Maintain a device matrix. Test on real devices and emulators. Prioritize by user base and region. 🧩 2. Screen Sizes & Resolutions A game UI that looks great on one device might break on another. Oversized elements, clipped buttons, or overlapping menus can ruin user experience. 🧠 QA Trick: Validate game layout and responsiveness across multiple screen resolutions and orientations. 🌐 3. Network Conditions & Latency Games often rely on real-time interactions, leaderboards, or cloud sync all affected by internet quality. 🧠 QA Trick: Simulate poor or fluctuating network conditions (3G, 2G, no internet). Test how the game handles loss of connectivity or lag. 🚀 4. Performance & Battery Drain Games are resource-hungry. Frame drops, overheating, and fast battery drain lead to user frustration and uninstalls. 🧠 QA Trick: Track FPS, memory usage, CPU load, and battery impact during gameplay using profiling tools. 🎯 5. Touch Gestures & UX Flow Taps, swipes, pinches, drags mobile games rely heavily on fluid and intuitive interactions. A slight delay or misrecognition can ruin gameplay. 🧠 QA Trick: Test all gestures manually and in edge scenarios (like screen rotation mid-gesture). 🐛 6. Unpredictable User Behavior Players break things in ways you never imagined, quitting mid-level, tapping rapidly, switching apps, incoming calls. 🧠 QA Trick: Perform exploratory testing with creative, chaotic, and non-linear behavior to simulate real-world usage. 🧪 7. In-App Purchases & Ads Monetization flows are mission-critical. Glitches in IAP or ads = lost revenue and user trust. 🧠 QA Trick: Test various payment methods, retry flows, and regional pricing and always validate what happens when a purchase fails. 🕹️ Final Thought Testing mobile games is a high-skill QA art, combining creativity, chaos engineering, and precision. It’s not just about finding bugs; it’s about protecting the player experience. The most successful games aren’t just beautifully designed, they’re thoroughly tested under every condition imaginable. So the next time someone thinks testing games is easy, remind them it takes brains, tools, and a little bit of gamer instinct. 🎯🎮 #MobileGameTesting #GameQA #MobileTesting #QATips #GamingQA #GameDevelopment #QualityEngineering #ShiftLeft #SudhanshuYadavQualityExpert #TestLikeAPro #PerformanceTesting #MobileAppQA

14

1 comentario

Working Kotlin code is easy to identify; however, senior Kotlin code reveals itself through the decisions made behind it. While both types compile and pass tests, they convey significantly different levels of intent. Senior code prioritizes readability over cleverness, making trade-offs clear in the design. This clarity in production reduces review time and enhances the safety of future changes. Teams can progress more swiftly when the code explains why it works, not just how it functions. In Kotlin backends, the maturity of the code is often evident in what it chooses not to do. #Kotlin #Backend

3

“Any application that can be written in JavaScript…” introducing LLaMainer - statistical analysis of Knowledge Base embeddings datasets wip powered by: - NestJS - React Router - MongoDB - LlamaIndex - TanStack DB - shadcn/ui (Mira 🫶) - MLJS

34

4 comentarios