-
CocoaHeads meetup at Photoroom featuring two talks: Franck Letellier explains how building early for iOS 26 helped showcase new OS capabilities and secure an App Store feature. Amine Bensalah presents “Gérer votre …” (topic not specified). Takeaway: plan ahead for new iOS releases to boost visibility and readiness.
Conference talk on making notifications users enjoy with Live Activities. Explores when to use them, ActivityKit basics (attributes, starting/updating/ending), local vs remote updates via APNs, UX best practices for relevance, and system constraints. Takeaway: design real-time, glanceable experiences that add value.
How to run and develop Swift for Linux on macOS using virtualization and containers. Covers setting up the environment, building and testing with Swift Package Manager, and deployment workflows. Highlights platform/architecture differences and tips to keep macOS dev aligned with Linux production.
A product-focused talk on the psychology of habit-forming apps: why some experiences stick and how to design triggers, actions, rewards, and investment that boost engagement and retention. Covers onboarding, streaks, reminders, feedback loops, and ethical boundaries. Takeaway: practical, ethical engagement patterns iOS teams can apply.
Explores iOS private APIs—what they are, why they’re tempting, and why you shouldn’t ship them. Discusses App Review detection, brittleness across OS releases, and safer public alternatives. Takeaway: avoid private APIs in production to keep apps stable and approvable.
Introduces Swift Testing (WWDC24) as a modern alternative to XCTest. Covers setup, key differences, and migration: organizing tests, assertions, discovery, async handling, and reporting. Weighs pros/cons and adoption tips. Takeaway: when and how to replace or mix with XCTest for cleaner, more maintainable tests.
How to evolve from Objective-C–style NSError/return codes to modern Swift 6 error handling. Discusses designing domain error types, when to use throws vs Result, do/catch, and bridging to/from NSError for Cocoa APIs and user-facing messages. Highlights pitfalls like try? swallowing errors. Takeaway: adopt consistent, Swift‑native error patterns.
Manuel Kehl presents how to architect SwiftUI apps that scale from the smallest to larger screens with a single codebase. Emphasizes reusable components, adaptive layouts, and minimal platform-specific tweaks to avoid duplication—embracing a “write once, deploy everywhere” approach for multi‑device SwiftUI apps.
Talk explores designing for the post‑screen era, moving beyond touch UIs toward personalized, ambient, multimodal interactions (gesture, voice, spatial/AR). Focus on principles and patterns for Swift developers rethinking UX in spatial contexts, with privacy and accessibility considerations. Conceptual; no specific APIs.
Mikaela Caron presents the technical side of Liquid Glass—what it is, how it works, and how to adopt it in iOS apps. The talk covers relevant APIs, integration patterns, and practical considerations like performance and accessibility, helping developers responsibly leverage this new visual effect.
Conference talk from Swift Connection 2025 by Peter Steinberger titled “You Can Just Do Things.” The description includes no technical details, APIs, or topics, so specific techniques, caveats, or takeaways cannot be determined from the provided information.
Introductory talk on Apple’s foundation models for iOS developers. Covers what they are, their capabilities, and how to start integrating them into Swift apps with practical guidance. Outlines integration options and considerations to help you plan AI‑powered features responsibly.
Explores how to prevent analytics regressions in iOS apps—when tracked events break, change, or go missing. Discusses practices to keep event schemas and payloads reliable, with safeguards like validation and automated checks. Takeaway: make analytics a testable, stable part of your codebase.
Talk on streamlining iOS work with selective testing—running only the most relevant tests to shorten feedback loops. Explains how to choose subsets, use Xcode/XCTest filtering and test plans, and plug this into CI. Notes trade-offs (flaky tests, missed coverage) and mitigation. Takeaway: targeted runs speed builds while preserving quality.
A talk on making Swift concurrency approachable: structuring async code with async/await, Tasks, and actors; adopting concurrency incrementally; reasoning about state, isolation, and cancellation; and avoiding pitfalls like data races. Practical guidance for safer, clearer concurrent code in modern Swift.
Deep dive into what happens to your iOS app during compilation: how Xcode and the Swift toolchain transform source into a final binary—parsing, type checking, intermediate representation, optimization, code generation, and linking. Learn to read build phases/logs and which settings influence build time, size, and runtime performance.
How to design reusable SwiftUI components in the style Apple uses. The talk focuses on component decomposition and API design: consistent naming, sensible defaults, configurability, and composability to match platform conventions. Takeaway: build SwiftUI building blocks that are easy to reuse and maintain.
Conference talk on building robust voice interactions on iOS—making apps speak and listen without talking over themselves. Focuses on coordinating text-to-speech with speech recognition, handling audio sessions and interruptions, preventing feedback loops/echo, and designing clear turn-taking for reliable, user-friendly voice UX.
Introductory talk on visionOS and spatial computing. Outlines what sets spatial apps apart and how to begin building for Apple’s platform, with high-level guidance on interaction models and immersive app design. Takeaway: understand the possibilities of spatial computing and where to start on visionOS.
A talk on common misconceptions about accessibility in iOS apps—what developers often get wrong and how to fix it. Emphasizes practical guidance on mindset, testing, and avoiding implementation pitfalls to create more inclusive experiences, clarifying what “accessible” should mean in practice and how to improve app quality for all users.
Gui Rambo reverse‑engineers iOS 26’s Liquid Glass refractive UI, outlining how the system synthesizes the effect via the rendering pipeline (materials, shaders, compositing) and its performance/energy trade‑offs. Offers guidance for recreating similar visuals in apps with Metal while keeping effects efficient.
Thomas Ricouard shows how to build iOS apps without relying on Xcode by using Cursor and Claude Code as AI-driven development tools. The talk focuses on alternative workflows for editing Swift, project setup, and building/running outside Xcode, along with tradeoffs and when Xcode is still needed. Takeaway: AI tooling can handle much of the iOS dev loop beyond Apple’s IDE.
Swift Connection 2025 session by Josh Holtz and Zach Brass showing there’s no single way to give a talk—presenting the same topic in two different ways. A community-focused, non-code session for iOS/Swift developers about presentation approaches and communication.
Adam Viaud dives into the internals of modern virtualization, contrasting virtual machines and containers. He explains how isolation works, resource sharing, and performance/security trade‑offs, and offers guidance on when to choose each for development and testing workflows. Takeaway: understand the runtime model to pick the right tool.
Recording of a June CocoaHeads talk hosted at Dashlane. Frank Lefebvre’s “Off the beaten track” likely explores unconventional iOS development ideas, but the description provides no technical details (APIs, code, or patterns). Watch to glean alternative perspectives and lessons.
Rew Islam (Dashlane) shares how collaborating with FIDO partners helped persuade Apple and Google to introduce new credential features. The talk outlines the standards process, security/UX trade‑offs, and implications for iOS apps adopting FIDO/passwordless sign‑in and platform credential APIs.
Talk tackles long-running UI tests that slow teams. Proposes splitting/sharding the suite and running tests in parallel (“Split. Run. Done.”) to cut execution time, using XCTest in Xcode and CI runners. Takeaway: parallelize UI tests to speed feedback and pipelines.
Alexis Bridoux presents a SwiftData talk on writing predicated fetches and making queries safer. He introduces the SafeFetching library to achieve type-safe, predictable data reads, covering patterns for building predicates, reducing runtime errors, and improving reliability of fetch logic. Takeaway: adopt safer predicate-driven fetching in SwiftData.
Deep dive into Objective‑C method and isa swizzling: how message dispatch works, swapping method implementations, and redirecting behavior by changing an object’s isa. Covers runtime mechanics and caveats around safety, thread‑safety, and performance. Takeaway: powerful but risky—use sparingly and test thoroughly.
Talk on building a proximity-driven, location-based matching experience: modeling proximity signals, handling location updates, and balancing accuracy, battery use, and privacy. Highlights permissions and noisy data considerations for discovering/matching nearby users or places in mobile apps.
Conference talk on how recent React (2023+) changes apply to React Native. Covers which React features matter for mobile, how to adopt them in RN apps, and implications for architecture and performance. Helps teams align React Native code with modern React while planning migration and compatibility.
Britta Evans-Fenton explores how to improve accessibility in React Native apps with help from AI—why it matters, common pitfalls when teams rush to ship, and how AI-assisted checks and guidance can streamline auditing and remediation to deliver more inclusive experiences.
Talk explores integrating web experiences into React Native apps: when to reuse web vs build native, patterns for embedding web content, navigation and deep-link flows, code sharing, and performance/UX trade-offs. Takeaway: use web integrations pragmatically to ship faster without degrading mobile quality.
Designing APIs for a multi‑platform world (iOS, Android, web, React Native). Covers principles for consistent resource modeling, choosing REST vs GraphQL, versioning, pagination, error contracts, authentication, performance via batching/caching, schema evolution, and strong testing/documentation to keep clients interoperable and backward‑compatible.
Recording of a panel from React Native Connection 2025 featuring Riccardo Cipolleschi, Thibault Malbranche, and Saad Najmi. Description lacks specifics; expect a high-level discussion around the React Native ecosystem and cross‑platform development. Useful for broad insights rather than hands-on iOS APIs or code.
Session on boosting React Native JavaScript performance with Static Hermes. Explains what Static Hermes is, how to enable it in builds, expected gains in startup and responsiveness, configuration changes, and migration caveats. Takeaway: adopt Static Hermes to speed up RN apps with careful setup and validation.
A talk about building a custom Flutter design system started in 2023 to streamline UI development, improve consistency, and reduce waste (time and CO2). It outlines creating shared components and workflows, adoption lessons, and trade-offs like maintenance overhead. Takeaway: a design system can boost efficiency and sustainability.
Hands-on session on moving from building a Flutter front end to a full‑stack workflow. Practical guidance for connecting a Flutter app with backend services and managing end‑to‑end development. Aimed at developers exploring cross‑platform full‑stack practices.
In-depth talk unpacking how React Native turns JavaScript updates into on-screen UI, tracing the rendering pipeline from JS execution through layout and native view updates. Covers scheduling, batching, and threading impacts, common pitfalls, and how understanding this flow helps iOS developers debug and optimize UI performance.
Intro to Flutter slivers for those struggling with CustomScrollView. Explains how sliver widgets integrate with CustomScrollView to build flexible, efficient scrolling UIs, covering basic composition patterns and common pitfalls. Useful for iOS devs exploring cross‑platform Flutter.
Talk dives into React Native’s Shadow Tree internals and how they influence layout/rendering performance, then outlines the evolution and design of Unistyles 3.0 for theming and dynamic styling. Expect implementation tips and pitfalls. Takeaway: use Shadow Tree insights and Unistyles to build faster, consistent cross‑platform UI.
Session explores WebGPU and Skia within React Native to build high‑performance, graphics‑heavy UI. Compares their rendering models, APIs, and performance characteristics, and discusses trade‑offs for complex animations and custom drawing. Takeaway: pick the engine that fits portability vs. speed needs.
Talk discusses adopting over-the-air (OTA) app updates in a Flutter app: why teams hesitate, how to implement safe rollout/rollback, and how to integrate OTA into a CI/CD pipeline. It notes platform constraints—especially iOS App Store policies—and risk mitigation. Takeaway: faster releases if you plan for compliance and safety.
François Nollen and Adrien Body share their journey to Continuous Delivery with Flutter—why CD matters and how to build a pipeline from commit to release. They emphasize automated builds, testing, and repeatable releases to ship frequently and reliably. Useful guidance for mobile (including iOS) teams adopting CI/CD.
Explores bringing Flutter apps to the terminal, applying Flutter’s UI paradigm to text-based TUIs. Touches on the TUI resurgence, potential rendering strategies to terminals, input/event handling, and tradeoffs. Takeaway: cross‑platform UI ideas can extend beyond mobile—consider the terminal as a lightweight, portable surface.
Samuel Newman shares how to build and scale multi‑platform React Native apps, drawing on Bluesky’s experience. Focus: maximize shared business logic, use clear module boundaries and platform abstractions, keep platform‑specific code isolated, and standardize tooling. Takeaway: adopt a sane, scalable cross‑platform architecture.
Deep-dive talk on Flutter’s Semantics widget: how to describe UI meaning for assistive technologies, structure a coherent semantic tree, and apply best practices to improve app accessibility. Takeaway: use Semantics effectively to make cross‑platform Flutter apps more accessible and understandable.
Talk introduces an AI-powered visual development workflow for Flutter using FlutterFlow, showing how AI and visual tools can accelerate UI building and app scaffolding for cross-platform apps. Though Flutter-focused, iOS developers can glean trends in AI-assisted tooling and rapid prototyping workflows.
A talk on memory leaks in Dart and Flutter: what they are, common causes, how to detect them, and strategies to fix and prevent them. Emphasizes diagnosing issues from long‑lived references and lifecycle mismanagement, plus practical troubleshooting and prevention. Useful for iOS teams shipping Flutter apps to improve performance and stability.
Talk on speeding up app development by building UI widgets in isolation. Shows creating isolated environments with mocks/sample data to develop, preview, and test components independently, improving reuse and reliability. Flags integration gaps and state issues. Takeaway: adopt component-driven workflow.
Strategies to ship mobile apps safely: plan phased/staged rollouts, use beta channels, feature flags/remote config, and A/B testing, all backed by CI/CD. Emphasizes monitoring KPIs, crash reporting, segmentation, kill switches, and rollback plans to reduce risk and learn during deployment.
Conference talk on color in mobile apps (React Native): choosing and managing colors, aligning design and implementation, handling device differences and color spaces, ensuring accessibility/contrast, and organizing a theme/design-token system. Takeaway: adopt a consistent color pipeline for predictable UI and maintainable cross‑platform (including iOS) design.
Talk explores how to build a SwiftUI-like DSL in Swift: design a declarative “language” with protocols and generics, using @resultBuilder/ViewBuilder, custom modifiers, and composition. Discusses structuring nodes, type safety, and ergonomics, plus pitfalls like type inference limits and cryptic compile errors. Takeaway: craft expressive domain-specific APIs.
Talk presents Periphery, a static analysis tool for Swift that detects unused types, functions, and properties to remove dead code. It shows how to run it on a project, interpret reports, configure exclusions, and handle false positives (e.g., dynamic/Obj‑C/reflection). Takeaway: automate dead-code cleanup to keep your codebase lean and safer.
Jason Akakpo shares how his team achieved smooth scrolling while displaying hundreds of videos, highlighting performance pitfalls, the impact of animations, and how adopting ASTC influenced their approach. Practical strategies focus on reducing rendering cost, efficient resource handling, and keeping UI responsive. Key takeaway: architect for throughput to scale video-heavy feeds.
Majid Boudaoud presents Radio France’s practical use of the Backend for Frontend pattern: a dedicated backend layer tailored to the iOS app that aggregates services and shapes responses to simplify networking, reduce client logic, and speed iteration. Covers trade-offs such as potential duplication, ownership, versioning, and maintenance.
Talk from CocoaHeads Paris (at happn) where Greg Lhotellier discusses the future of developers—skills, roles, and industry trends affecting the Apple developer community. Conceptual session; no specific code or APIs. Takeaway: prepare for evolving tooling and practices across the iOS/macOS ecosystem.
CocoaHeads talk introducing MapKit in SwiftUI. It focuses on the SwiftUI Map view and how MapKit features are now accessible in a SwiftUI-first way: embedding maps in views, configuring content and interactions, and deciding when to use SwiftUI vs UIKit APIs. Takeaway: build rich maps natively with SwiftUI.
Advanced techniques for Apple’s unified logging on iOS. Contrasts debugger vs logs and shows how to structure logs with subsystems/categories, levels, and privacy annotations using os_log/Logger. Emphasizes practices to reduce overhead and make diagnostics actionable. Takeaway: robust, well-structured logs improve production troubleshooting.
Talk covers a progressive path to adopt SwiftUI in an existing app. It explains introducing SwiftUI views incrementally, coexisting with the current stack, handling navigation and data flow between layers, and planning scope and rollout. Highlights trade-offs of a mixed codebase and testing concerns. Takeaway: migrate iteratively with clear boundaries and strategy.
React Native Paris (2019) talk on adopting React Hooks in RN apps: why shift from classes, how hooks handle state and side-effects, using custom hooks, and common pitfalls (dependency arrays, unnecessary re-renders). Practical takeaways for improving React Native iOS codebases.
Talk outlines a minimal, low‑cost CI approach for React Native apps without relying on Expo EAS. It shows how to automate builds/tests with simple scripts and hosted runners, produce artifacts, and ship quickly. Notes trade‑offs (manual setup, limited scalability/monitoring). Takeaway: iOS teams can bootstrap CI cheaply before adopting full platforms.
Nicolas Torion présente Ficus UI pour React Native, une approche visant à simplifier le style et la construction d’interfaces. Le talk couvre la rationalisation du styling des composants, le theming et la cohérence avec un design system pour accélérer le développement cross‑platform. Takeaway: des patterns réutilisables et plus simples pour l’UI RN.
Talk on studying and improving an app’s resilience for Apple platforms: analyze failure modes, improve error handling, add monitoring and crash reporting, plan offline/retry and degraded modes, and validate robustness with tests. Takeaway: practical strategies to keep apps stable and usable under adverse conditions.
Talk covers boosting productivity by adding a Pull Request badge that surfaces key status directly in PRs (build/tests/coverage/review). Shows wiring CI (e.g., GitHub Actions) to generate/update the badge in the PR body. Notes permissions/secrets and API rate-limit considerations. Takeaway: automate PR signals to speed reviews.
High-level “State of AI” talk offering an overview of current AI capabilities, benefits and pitfalls (“the good, the bad, and the ugly”), and implications for app development. Aimed at CocoaHeads attendees, it helps iOS developers evaluate where AI fits and plan responsible, practical adoption.
Talk on React Native bridge implementation: why/when to build a bridge, how to expose native functionality to React Native, and the related challenges and maintenance considerations. Takeaway for iOS devs: design native modules with clear contracts and plan for long-term upkeep and compatibility.
Talk presents a method to bootstrap a Flutter app fast: define MVP scope, use templates, set up project structure, pick essential packages, automate configuration, testing, and releases, and reuse a checklist for repeatability. Focus is on speeding cross‑platform delivery and reducing time‑to‑market.
Intro talk from React Native Paris explaining what Node.js is and why it matters for developers. Covers the Node.js runtime and JS tooling ecosystem (npm, scripts) and its role alongside React Native apps (bundling, tooling, backends). Takeaway: understand Node.js basics to work effectively in cross‑platform mobile projects.
Talk introduces Flutter Eco Mode, a Flutter plugin to help apps handle constrained conditions (e.g., network) by reducing resource usage to improve battery life and performance. Relevant for iOS Flutter apps needing graceful degradation under poor connectivity, with practical guidance on using the plugin.
Talk on Flutter golden tests to catch visual regressions by comparing rendered widgets/screenshots to baseline images. Covers setting up and maintaining golden files, reviewing diffs, and CI integration. Notes pitfalls like flaky renders (fonts, scaling, themes). Takeaway for iOS: similar to snapshot UI testing to keep UIs stable.
Talk on pushing React Native UIs to true edge-to-edge. Focuses on building immersive screens that consider system bars, safe areas, and gesture zones, with Android vs iOS differences. Takeaway for iOS devs: handle insets consistently to deliver robust cross-platform edge-to-edge layouts.