-
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.