Gone Mobile Podcast

The conversation revolves around the topic of offline battle tactics in mobile app development. Jon shares his experience with a pool app that required offline data storage and syncing. He initially used Realm, but faced issues with performance and scalability. He had to rewrite the login service and migrate data to a new backend. Allan discusses the challenges of offline data syncing, including handling deletes and updates, resolving conflicts, and ensuring data security. Jon explains his approach of using Cosmos DB and simple record types to handle offline data syncing. They emphasize the importance of considering the specific needs of the business and avoiding over-engineering solutions. The conversation explores the challenges and considerations of implementing offline functionality in mobile apps. The concept of 'end scars' is introduced, referring to the need to delete or reassign child data when the parent data is modified or deleted. The importance of handling offline scenarios gracefully and providin

The conversation covers various topics related to MSBuild and project files. It starts with an introduction and a discussion about the weather. The hosts then delve into the history and evolution of MSBuild, including the transition to SDK style projects. They explain the structure of new project files and highlight the benefits of using CS Proj for managing NuGet packages and CI. The conversation also covers customizing project files for platform-specific assets and the use of conditions in project files. The hosts discuss the importance of workloads and the rationale behind different SDKs. They also touch on the future of workloads and the challenges associated with them. This conversation explores various aspects of MSBuild, including workloads, importing MSBuild from NuGet packages, building custom entitlements, adding items to build from NuGet packages, customizing build props and targets, writing custom MSBuild tasks, using custom tasks and source generators, incremental source generation, and Michaela'

In this episode, Jon and Allan discuss the concept of slim bindings and their benefits. They explore the challenges of working with full bindings and the need for a more focused approach. The conversation centers around their experience with creating slim bindings for Firebase and other complex controls. They also touch on the difficulties of updating full bindings and the importance of understanding the API being consumed. The episode concludes with a discussion on the role of Sharpie in binding generation and the challenges of dependency management. In this episode, Jon and Allan discuss the challenges and possibilities of Swift interop with .NET and the ongoing work to make Swift interop possible with .NET. They also delve into the differences between Android and iOS bindings, including the ease of Android bindings and the challenges of Kotlin and generics. They explore the AndroidX library and the complexities of dependency management. The conversation concludes with a discussion on community efforts for

In this episode, the hosts celebrate the 100th episode of the podcast and engage in a casual conversation about various topics related to Xamarin and .NET MAUI. They introduce themselves and discuss their roles as product managers. The conversation covers the early days of Xamarin, the transition to .NET and mobile development, and the evolution of mobile development over the years. They also talk about the transition to Microsoft and the use of Microsoft tools. The episode concludes with a discussion about geographical locations and some trivia. The conversation covers the journey and challenges of.NET MAUI, including its adoption and success. It also explores the lessons learned and the importance of architecture and migration. The speakers reflect on the evolution of Xamarin and.NET MAUI and provide feedback and assessment of the current state of the project. In this episode, the hosts discuss various topics related to Maui and its tooling. They talk about the success of Maui and ports, the importance of r

In this episode, Jon and Allan discuss various topics related to creating and maintaining libraries and NuGet packages. They talk about their experiences with plugin libraries and the importance of supporting open source developers. They also touch on the challenges of avoiding vendor and framework lock-in. Overall, the conversation highlights the value of community-driven development and the need for collaboration and appreciation in the open source world. The conversation explores the process of creating libraries and plugins for cross-platform development. It delves into the challenges of balancing dependencies and code size, as well as the evolution of library development over time. The role of Microsoft Extensions and dependency injection in library development is also discussed. The conversation concludes with a discussion on the improvements in Maui and the use of Microsoft Extensions and DI in the framework. This part of the conversation explores the importance of familiar patterns and dependency inj

In this conversation, Jon and Allan discuss Blazor hybrid development, specifically in the context of Maui. They explore the benefits and challenges of using Blazor in a hybrid setting, including performance considerations and compatibility with different platforms. They also discuss the use of Blazor web views in Maui apps and the integration of native APIs. The conversation highlights the flexibility and potential of Blazor hybrid for building mobile apps. In this conversation, Allan Ritchie and Jon discuss the challenges of cross-platform development and the differences between Web Assembly and Maui. They also explore the use of view models in Blazor and Maui, as well as the benefits of Maui for businesses. The conversation concludes with a discussion on the slow progress of web standards and the plugin packages of the week: MudBlazor and Radzen. Takeaways Blazor hybrid development allows for the integration of Blazor web views in Maui apps, providing the flexibility to leverage web technologies in a nativ

The Disney experience app is a mobile engineering marvel. Jon and Allan take a slightly less technical conversation on the anatomy of an app and geek out over the happiest app on earth. In this episode, Jon and Allan discuss their recent vacations to Belize and Disney World. They dive into the features and functionality of the Disney mobile app, which allows users to book trips, manage reservations, and access various services. They highlight the seamless integration of the app with hotel check-in, mobile food ordering, and car locator features. The chapter also explores the user interface and navigation of the app, as well as the integration of Magic Bands and Apple Wallet for a convenient and magical experience. The episode concludes with a discussion on the Genie Plus and Lightning Lanes services, as well as the animated passes in Apple Wallet. Disney's attention to detail is evident in their interactive photo experiences, such as the PhotoPass and on-ride photos. The app allows users to book Lightning La

In this episode, Jon and Allan discuss Reactive Extensions (Rx) and its advantages over traditional event handling. They start by addressing Jon's resistance to dependency injection and his concerns about taking dependencies on external libraries. Allan introduces Rx as a solution to handle events more effectively and efficiently. They explore the benefits of Rx, such as composability, filtering, and transforming events. The conversation delves into the implementation of Rx in different platforms and its integration with Maui. They also discuss challenges and solutions in using Rx, including canceling requests and validating input. Overall, the episode highlights the power and versatility of Rx in simplifying event handling and improving code readability. In this conversation, Jon and Allan discuss Reactive UI and Reactive Extensions. They explore the features and benefits of Reactive UI.net and how it simplifies event handling and data binding in UI development. They dive into topics such as throttling and t

In this episode, Jon and Allan discuss the migration experiences from Xamarin.Forms to .NET MAUI. They highlight the opportunity for architectural improvements during the migration process, such as cleaning up code and removing static untestable components. They also explain the evolution of Xamarin.Forms into .NET MAUI and the introduction of handlers. The benefits of the single project structure and the ease of migrating third-party libraries are discussed. The conversation also covers the customization of entry handlers and the migration of resources, including images and fonts. This conversation covers various challenges and solutions related to image management, including the use of vectors, app icons, and splash screens. It also discusses the migration process from Xamarin.Forms to .NET MAUI, highlighting the importance of a methodical approach. The conversation concludes with a recommendation for the Maui Community Toolkit as a valuable resource for developers. Takeaways Migrating from Xamarin.Forms to

In this episode, Jon and Allan discuss the process of building a mobile app, starting with the analogy of building a lightsaber at Disney. They explore the anatomy of a mobile app, including the use of MVVM architecture and the importance of gluing logic together. They also delve into navigation and the use of Shell in Xamarin.Forms. The conversation then shifts to the benefits of using dependency injection in app development and the considerations for cross-platform development. In this episode, Allan and Jon discuss various aspects of app development, including dependency injection, core services, and cross-platform services. They emphasize the importance of creating a base set of services and thinking outside the box when faced with UI design challenges. They also highlight the significance of solving business problems first and introduce Prism as a comprehensive app architecture framework. Takeaways Building a mobile app involves various components, including the user interface, logic, and navigation. MVV

In this episode, Jon and Allan discuss the importance of templates for mobile app development. They explore the challenges of remembering details like Android manifest and info.plist, and how templates can help simplify the process. They also discuss the default templates in Maui and the benefits of item templates in VS Code. The conversation covers the balance between complexity and simplicity in templates, and the value of custom templates for saving time. They also touch on managing permissions and entitlements, and the power of MSBuild and CSProj files in customizing projects. The episode concludes with a discussion on the benefits of community templates. In this episode, Jon and Allan discuss different types of templates available for building mobile apps with .NET Maui. They cover item templates, Maui templates, solution templates, Visual Studio templates, VS Code templates, and command line templates. They also talk about the benefits of creating custom templates and how they can help standardize devel

In this episode, Jon and Allan discuss backgrounding in mobile development. They start by reviewing the virtual list view and how it solved Allan's problem. Then, Jon reveals the story behind his nickname 'Red.' The conversation then shifts to backgrounding in mobile development, covering common scenarios such as data synchronization, image uploads, and real-time GPS. They explore the different approaches to backgrounding on Android and iOS, including the use of services, broadcast receivers, foreground services, and job scheduling. Finally, they discuss background transfers on both platforms. This episode explores background transfers, background tasks, and code execution in mobile apps. The hosts discuss the challenges of handling slow APIs, managing state in background jobs, and scheduling one-off and periodic jobs. They also delve into the intricacies of background GPS in iOS and Android, as well as the considerations for background tasks in Windows. The episode concludes with a brief mention of backgroun

In this episode, Jon and Allan discuss the challenges and history of implementing lists in mobile apps. They start by addressing a listener question about the difference between CLI commands in MAUI and other UI frameworks. They then dive into the topic of dealing with lists in mobile apps, including the challenges of performance and dynamic sizing. They explore the history of list implementations on different platforms and the limitations of the current CollectionView in MAUI. They also discuss alternative list view controls and the misuse of observable collections in list views. In this episode, Allan and Jon discuss various aspects of building performant lists in mobile apps. They cover topics such as using observable collections for data in motion, optimizing list performance, choosing the right list control, and introduce the Virtualized List View plugin. Takeaways Implementing lists in mobile apps can be challenging due to performance and dynamic sizing issues. The history of list implementations on dif

Summary In this episode, Jon and Allan discuss the complexities of implementing push notifications on iOS and Android. They delve into the history of push notifications and the challenges developers face in tackling this topic. They explore the setup and configuration process for both platforms, including the use of certificates and entitlements on iOS and the use of Firebase on Android. They also discuss the lifecycle of notifications, handling background execution, and the differences between iOS and Android in terms of permissions and notification handling. In this episode, Jon and Allan discuss various aspects of push notifications on Android, including permissions and changes, setting up notifications, specifying intents in notification payloads, silent notifications, sending notifications to tags, handling multiple devices, and the Shiny Push library. They also touch on source generators and boilerplate code. Overall, the conversation provides valuable insights into the complexities and best practices o

Summary In this episode, Jon and Allan discuss the state of .NET Maui, the challenges of mobile development, and the benefits of using Blazor WebView in Maui apps. They also talk about the evolution of the Mono runtime, the use of handlers in Maui, and the transition from custom renders to source generators. Overall, they highlight the improvements and advancements in the .NET Maui framework and its potential for creating cross-platform mobile apps. In this episode, Jon and Allan discuss app profiling and performance optimization, highlighting the use of tools like DS router and DS dotnet trace to profile apps and identify performance issues. They emphasize the importance of measuring and optimizing early in the development process to avoid potential problems. The conversation then shifts to the introduction of a new segment called 'Plugin Package or Product,' where they showcase a library called compiled bindings that enhances the XAML experience by providing additional operators and reducing verbosity. They

This conversation discusses the concept of bindings in a mobile.NET, Maui world. Bindings are used to integrate native libraries into the.NET ecosystem. The conversation covers the challenges and complexities of creating bindings for Android and iOS platforms. It explores the differences between Android X libraries and platform APIs. The concept of slim bindings is introduced, which involves creating a simplified interface for interacting with native libraries. The conversation also touches on the use of platform channels for message passing between.NET and native code. The future of bindings and the need for improved tools and processes are discussed. The conversation discusses the challenges and considerations when integrating platform channels in Xamarin projects. It explores the difficulties of referencing native frameworks and dependencies in Xcode projects and suggests the need for improved tooling to simplify the process. The conversation also delves into the complexities of handling AndroidX dependenc

It's been a few years since we've talked Couchbase on the show, so with their recent release of Couchbase Mobile 2.5 we thought we'd bring Robert Hedgpeth on to catch us up! Special Guest: Robert Hedgpeth.

You may know Eric Sink from the database syncing product Zumero, or perhaps the source control versioning system SourceGear. Now, Eric is building a platform for High School sports fundraising, and he's doing it in .NET. Special Guest: Eric Sink.

OutSystems allows you to do some pretty amazing things with Low to No Code. We talk to Stacey Levine about their platform to see just how much you an accomplish without coding! Special Guest: Stacey Levine.

Creating apps from spreadsheets? You bet! In this episode we're joined by Jason Smith and Mark Probst, formerly of Xamarin/Microsoft, to talk about their new endeavor called Glide. Glide's goal is to let you build beautiful, data-powered apps quickly and easily, so tune in to learn what it's all about! Special Guests: Jason Smith and Mark Probst.