Gone Mobile

The conversation discusses the importance of structuring apps in terms of business requirements and how to make them easier to navigate and understand. It emphasizes the need to focus on translating business requirements into technology and suggests organizing projects based on business logic rather than technology layers. The conversation also touches on the use of services and the benefits of grouping them by section or feature. Additionally, the conversation explores the challenges of using IL manipulators and the limitations of certain frameworks in the context of C# hot reload. It concludes with a discussion on the need for base implementations and templates that provide guidance on structuring apps and implementing MVVM patterns. In this conversation, Jonathan and John discuss the importance of structuring services in mobile app development. They explore the use of MVVM frameworks like Prism and the challenges of writing technical code on top of existing tech services. They also discuss the benefits of using events and observables in services, as well as the use of dependency injection and the Microsoft implementation. The conversation concludes with a recommendation for the Refit library as the plugin packager product of the week. Takeaways Organize projects based on business logic rather than technology layers Group services by section or feature to improve discoverability Be cautious when using IL manipulators in mobile apps Consider the limitations of certain frameworks in the context of C# hot reload Provide base implementations and templates to guide app structure and MVVM implementation Structuring services in mobile app development is crucial for maintaining code organization and scalability. MVVM frameworks like Prism provide a comprehensive structure for building full-featured apps. Writing technical code on top of existing tech services can lead to complexity and bugs. Using events and observables in services can simplify communication between components and reduce code duplication. Dependency injection is a powerful tool for managing service dependencies and improving testability. The Refit library is a recommended tool for generating HTTP clients from interfaces in a clean and efficient way. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 00:59 Challenges of App Layout 01:27 Discoverability of Business Logic 03:18 Organizing Projects by Business Logic 04:47 Grouping Services by Section 06:44 Considerations for Global Services 08:42 Moving Services to Relevant Folders 10:03 Multiple Implementations of Services 13:18 Challenges of IL Manipulators and C# Hot Reload 19:07 Importance of Base Implementations and Templates 00:12 Introduction 00:29 Structuring Services in Mobile App Development 34:20 The Benefits of Using Events and Observables in Services 39:43 Dependency Injection and the Microsoft Implementation 53:07 Plugin Packager Product of the Week: Refit 01:03:36 Conclusion

Jon and Allan discuss their experiences and excitement surrounding tech conferences like WWDC and Google IO. They reminisce about attending conferences in the past and the thrill of new announcements and hardware giveaways. They also speculate on what they hope to see at upcoming conferences, such as immersive movies and a foldable iPhone. The conversation touches on the evolution of UI design and the convenience of using smartphones as cameras. The conversation covers topics such as foldable phones, APIs, UI changes, app stores, and permissions. The hosts discuss their preferences for foldable phones and the potential impact on UI design. They also explore the idea of integrating AI and context awareness into app development. The conversation touches on the App Store fees and the review process. They express their frustrations with Android permissions and suggest improvements for a more streamlined process. The conversation covers various topics including the challenges of changing APIs, the user experience of notifications on different platforms, the potential for new features in Apple TV, the power of Apple's M-series chips, the future of gaming on ARM-based devices, and a shout-out to Gerald Versluis and his packages. Takeaways Tech conferences like WWDC and Google IO are exciting events for developers and tech enthusiasts. Attending conferences provides opportunities to learn about new announcements and interact with engineers. The early days of conferences were filled with groundbreaking announcements and new hardware. The current conference landscape is less surprising, but still offers valuable insights and updates. The hosts express their hopes for future conferences, including immersive movies and a foldable iPhone. The convenience and quality of smartphone cameras have made dedicated cameras less necessary. Foldable phones have advantages in terms of screen size and potential for improved UI experiences. APIs can be used to integrate AI and context awareness into app development. The App Store fees are a topic of debate, but the convenience and services provided by the platform are valuable. Android permissions can be complex and could benefit from a more unified and streamlined approach. - Changing APIs can be challenging, especially when they are frequently updated. The user experience of notifications varies between platforms, with Android offering more customization options. Apple TV could benefit from new features and updates. Apple's M-series chips are powerful and efficient, but their graphics capabilities for gaming are still uncertain. Gaming on ARM-based devices may require cloud streaming to achieve AAA game performance. Gerald Versluis has developed useful packages, such as a screenshot API and an audio plugin, that fill gaps in functionality. New features and APIs may be introduced through plugins before being integrated into cross-platform frameworks like Maui. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Discussion of Fun Topics 07:30 The Excitement of Early Conferences 26:38 App Store Fees and Review Process 45:08 Navigating the Challenges of Changing APIs 52:05 The Power and Uncertainty of Apple's M-series Chips 59:59 Shout-out to Gerald Versluis and His Useful Packages

The conversation covers topics related to coffee-making methods and the use of XAML in app development. The hosts discuss their preferences for coffee machines and the process of making coffee. They also delve into the use of converters in XAML and the debate between putting logic in the view model or the view. The conversation explores the use of converters, extensions, and behaviors in XAML and their potential drawbacks. It also discusses the benefits of using compiled bindings and the importance of declaring data types in XAML for improved performance. The conversation touches on the use of XAML in Blazor and the potential future of XAML in web development. In this conversation, Jon and Allan discuss various optimization techniques for Xamarin.Forms and .NET MAUI apps. They cover topics such as compiled bindings, the performance impact of converters in collection views, optimizing XAML layouts, and the use of third-party libraries like Sharpnado CollectionView. They also touch on the challenges of building responsive layouts and the importance of considering platform-specific optimizations. Overall, the conversation provides valuable insights into improving the performance of Xamarin.Forms and .NET MAUI apps. Takeaways There are different preferences for coffee-making methods, from simple machines like Keurig to more complex ones like Chemex. XAML can be verbose, and there is a debate about whether to put logic in the view model or the view. Converters in XAML can be useful for transforming data, but it's important to avoid excessive use and keep business logic separate. Localization in XAML can be done using dictionary strings and bindings, without the need for extensions. The use of AI for auto-localization and translation is an interesting possibility. In some cases, it may be beneficial to handle certain UI-related tasks in the view, even if it goes against the purist approach of separating concerns. Converters, extensions, and behaviors in XAML can be powerful but should be used judiciously and not overused. Compiled bindings and X-bind can be alternatives to converters and provide better performance. Declaring data types in XAML can improve performance and enable better IntelliSense. XAML can be used in Blazor, but the heavier the reliance on XAML, the more challenging it may be to migrate to Blazor. The future of XAML in web development is uncertain, with the web being the dominant platform. Compiled bindings can significantly improve the performance of Xamarin.Forms and .NET MAUI apps by eliminating the need for runtime reflection. Converters in collection views can introduce performance overhead, especially when used extensively. It's important to minimize their usage and consider alternative approaches. Optimizing XAML layouts involves avoiding unnecessary nesting of controls, using bindable grids instead of content views, and being mindful of the performance implications of stack layouts and scroll views. Third-party libraries like Sharpnado CollectionView can provide additional performance optimizations and features for collection views in Xamarin.Forms and .NET MAUI apps. Building responsive layouts can be challenging, and platform-specific optimizations may be necessary to achieve optimal performance. Consider leaving a review on Apple Podcasts and checking out the Gone Mobile YouTube channel for more content. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 The Art of Coffee-Making: From Keurig to Chemex 09:39 The Power and Pitfalls of Converters in XAML 35:28 The Power of Compiled Bindings and X-bind in XAML 45:21 Challenges of Migrating XAML-heavy Apps to Blazor 55:17 Challenges of Building Responsive Layouts 01:04:59 Leaving Reviews and Exploring the Gone Mobile YouTube Channel

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 providing clear feedback to users is emphasized. The conversation also touches on the use of frameworks and abstractions for offline sync, with a discussion of Azure Mobile Apps and the limitations of such solutions. The benefits of using SQLite and the JSON support it offers are highlighted. In this final part of the conversation, Jon and Allan discuss their experiences with SQLite and offline functionality in mobile apps. They talk about the importance of optimizing app startup time and how SQLite can be a bottleneck in this process. They also share their preference for using SQL and the benefits of using SQLite-PCL-NET. The conversation then shifts to offline functionality and device-to-device communication, with Jon sharing his experience with Google's SDK for nearby communication. They briefly touch on the challenges of offline functionality in airplane environments and the limitations of Bluetooth connectivity. The episode concludes with a discussion on the importance of the SQLite raw library and its role in enabling advanced features like geolocation. Takeaways Offline data syncing in mobile app development can be challenging and requires careful consideration of business needs. Choosing the right technology for offline data storage and syncing is crucial for performance and scalability. Handling deletes, updates, conflicts, and data security are important aspects of offline data syncing. Simplifying the data model and using simple record types can make offline data syncing easier to implement and maintain. Avoid over-engineering solutions and focus on meeting the specific needs of the business. Offline functionality in mobile apps requires careful consideration and handling of data synchronization. Handling 'end scars' is crucial, ensuring that child data is properly managed when parent data is modified or deleted. Providing clear feedback to users about offline status and data synchronization is essential for a good user experience. Using frameworks and abstractions for offline sync may have limitations and can lead to loss of control over data management. SQLite is a reliable and widely-used option for local offline storage, with the added benefit of JSON support for flexible data storage. Optimizing app startup time is crucial, and SQLite can be a bottleneck in this process. Using SQL and libraries like SQLite-PCL-NET can provide more control and flexibility in working with databases. Offline functionality and device-to-device communication are important considerations in mobile app development. The challenges of offline functionality in airplane environments include limited connectivity options and the need for peer-to-peer networks. The SQLite raw library, maintained by Eric Sink, is a foundational piece for many SQLite-based solutions and enables advanced features like geolocation. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Setting the Stage 01:43 Offline Battle...

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's MSBuild Editor Extension. The hosts emphasize the importance of understanding MSBuild and encourage listeners to explore and experiment with CSProj files to optimize their build processes. Takeaways MSBuild is a powerful tool for managing project files and building applications. SDK style projects provide a more streamlined and approachable format for project files. CS Proj files can be customized to include platform-specific assets and configurations. Using CS Proj for managing NuGet packages and CI can simplify the development process. Workloads in MSBuild provide a way to manage and organize project dependencies and configurations. MSBuild is a powerful build system that allows for customization and automation of the build process. Importing MSBuild from NuGet packages provides an easier way to test nightly builds and service releases. Customizing build props and targets allows for fine-grained control over the build process and the inclusion of specific assets. Writing custom MSBuild tasks in C# can be a powerful way to extend the build system and perform complex build operations. Using custom tasks and source generators can enhance the build process and improve performance. Mikayla's MSBuild Editor Extension provides helpful features like IntelliSense and package version management for CSProj files. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Weather 00:20 Introduction to MSBuild 01:12 Acquiring Taste for MSBuild 03:17 Slim CS Proj 04:03 Structure of New Project Files 05:12 Default Maui Project Template 06:36 Using CS Proj for NuGet Packages 07:56 Benefits of Using CS Proj for CI 08:26 Customizing Project Files for Platform-Specific Assets 09:53 Leveraging MSBuild for Customization 10:57 Command Line vs. CS Proj 11:33 Importing Files and Directory Build Props 12:37 Multiple SDK Imports 13:15 Properties and Item Groups in Project Files 14:05 Conditions in Project Files 19:48 Rationale for Different SDKs 22:19 Directory Build Props for Performance 24:07 Workloads and SDK Imports 26:17 Future of Workloads 29:08 Challenges with Workloads 31:09 MSBuild and Workloads 32:03 Importing MSBuild from NuGet Packages 33:12 Custom Entitlements and Build Props 34:09 Building Custom Entitlements 36:29 Adding Items to Build from NuGet Packages 37:38 Automatically Making Apps Work with Libraries 38:36 Customizing Build Props and Targets 39:40 Doing Build-Related Tasks in MSBuild 42:10 Writing Custom MSBuild Tasks 44:23 Using Custom Tasks and Source Generators 46:19 Incremental Source Generation 49:46 Michaela's MSBuild Editor Extension 56:19 Getting Started with MSBuild

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 bindings and the benefits of slim bindings. Takeaways Slim bindings offer a more focused and simplified approach to working with complex controls and APIs. Creating slim bindings requires a deep understanding of the API being consumed and the ability to map it to the target language. Full bindings can be challenging to update, especially when there are major changes between versions of the API. Dependency management can be complex, and colliding dependencies can cause issues in the binding process. The goal is to make binding generation repeatable and provide patterns and examples for popular libraries to simplify the process for developers. Swift interop with .NET is being actively worked on, making it easier to generate bindings and interop code. Android bindings can be easier than iOS bindings, but Kotlin and generics present challenges. AndroidX library and dependency management can be complex, but slim bindings can simplify the process. Binding at the bytecode level in Kotlin can be tricky, but slim bindings provide a workaround. Community efforts are underway to create and maintain bindings for various libraries and frameworks. Slim bindings offer a focused and simplified approach to binding native libraries. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Setting the Stage 02:25 Understanding Slim Bindings 04:15 Working on Firebase Bindings 06:16 Challenges with Package Managers 09:12 Creating Slim Bindings for Complex Controls 11:40 The Difficulty of Updating Full Bindings 14:27 The Value of Slim Bindings 19:06 The Role of Sharpie in Binding Generation 21:14 Making Binding Generation Repeatable 22:42 Avoiding Duplicated Dependencies 24:21 Challenges with Dependency Management 25:17 Dealing with Colliding Dependencies 25:44 Swift Interop with .NET 28:10 Android and Kotlin Bindings 30:23 Challenges with Kotlin and Generics 32:23 AndroidX and Dependency Management 39:12 Binding at the Bytecode Level 46:39 Community Efforts for Bindings 47:26 Upcoming Bindings and Slim Bindings

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 reflecting on code and engineering, and the desired features in Maui. They also discuss the need for better tooling and templates, visualizing app navigation and image assets, and improving the shell and view model lifecycle. The hosts express their appreciation for the positive community and the engineering team. The episode concludes with a celebration of the 100th episode of the podcast. Takeaways The hosts celebrate the 100th episode of the podcast and engage in a casual conversation about Xamarin and .NET MAUI. They discuss their roles as product managers and their experiences with Xamarin and mobile development. 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, as well as their geographical locations and some trivia. The adoption of.NET MAUI has been steadily growing, with an increasing number of apps being developed using the framework. Customer satisfaction and success stories are important indicators of the impact of.NET MAUI. The journey of.NET MAUI has had its challenges, including delays and technical issues, but the team has been working hard to address them. Lessons learned include the need for careful planning and evaluation of architectural decisions, as well as the importance of prioritizing tech debt and considering the impact on existing codebases during migration. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Episode 100 Celebration 01:00 Introductions 01:19 Background and Roles 03:09 Early Days of Xamarin 06:05 Transition to .NET and Mobile Development 06:32 Evolution of Mobile Development 09:30 Transition to Microsoft and Remote Work 11:43 Transition to Microsoft Tools 12:15 Transition to Microsoft Tools (contd.) 13:06 Transition to Microsoft Tools (contd.) 15:11 Transition to Remote Work 16:24 Geographical Locations and Trivia 18:06 The Journey of.NET MAUI 19:10 Shipping.NET MAUI 20:30 Adoption and Success of.NET MAUI 22:20 Customer Impact and Satisfaction 23:25 Challenges and Obstacles Faced 25:40 Lessons Learned 28:16 The Evolution of Xamarin and.NET MAUI 31:17 Reflections on the Journey 39:55 The Importance of Architecture and Migration 43:37 Feedback and Assessment 43:56 Success with Maui and Ports 45:19 Reflecting on Code and Engineering 46:39 Desired Features in Maui 49:08 Tooling and Templates in Maui 50:32 Visualizing App Navigation and Image Assets 56:10 Improving Shell and View Model Lifecycle 01:00:01 Enjoying the Outdoors and Positive Community 01:02:57 Appreciating the Engineering Team and Community 01:05:30 Conclusion and Episode 100 Celebration Special Guests: David Ortinau and Maddy Montaquila.

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 injection in Xamarin development. It discusses the trade-off between performance and app size, as well as the challenges of implementing dependency injection in Xamarin.Forms. The conversation also touches on the growth of plugins in the Xamarin ecosystem and the controversy surrounding Reactive Extensions (RX). The creation of Xamarin Essentials and its goal of pleasing the majority of developers is highlighted, along with the focus on testability in Shiny. The chapter concludes with a discussion on the trade-off between performance and interfaces. In this conversation, Jon and Allan discuss various topics related to open source development, including generating interfaces and wrappers, elevating to platform API level, simplifying abstractions, creating custom implementations, using files and folders for caching, managing GitHub repos and libraries, forking and cloning repos, cleaning repos and business continuity, and appreciating open source contributors. Takeaways Support open source developers and be kind to them. Avoid vendor and framework lock-in by creating your own libraries and packages. Collaboration and community-driven development are essential in the open source world. Maintaining and updating libraries and plugins requires ongoing effort and dedication. Creating libraries and plugins for cross-platform development requires careful consideration of dependencies and code size. The evolution of library development has led to a more streamlined and accessible process. Microsoft Extensions and dependency injection play a significant role in library development. Maui offers improvements in lifecycle management and the use of Microsoft Extensions and DI. Familiar patterns and dependency injection provide comfort and ease of use for Xamarin developers. Balancing performance and app size is a challenge in mobile development. Plugins play a significant role in extending the functionality of Xamarin applications. Xamarin Essentials aims to provide essential functionality out of the box for Xamarin developers. Testability is an important consideration in the design of Xamarin libraries. Consider generating interfaces and wrappers to simplify the usage of platform APIs. Elevate your code to the platform API level and avoid unnecessary abstractions. When creating custom implementations, focus on the core business logic and avoid abstracting unnecessary details. Use files and folders for caching data, as it can be a simple and effective solution. When managing GitHub repos and libraries, consider using a template for consistent setup. Clone and fork repos to ensure business continuity and avoid dependencies on external sources. Appreciate and support open source contributors by providing constructive feedback and contributing back to the community. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Episode 100 00:21 Discussion about Dad Shoes 01:37 Number of Episodes Together 03:03...

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 native app environment. Blazor's Razor syntax and evolving language features make it a powerful tool for building UI components, especially for forms and complex layouts. Blazor hybrid development can offer a faster development loop and improved productivity, especially when working on UI components that are shared between web and mobile platforms. The performance of Blazor web views in Maui apps can vary depending on the platform and the debugging environment, but overall, it can provide a reasonably good user experience. Maui hybrid apps provide a way to run code in both Web Assembly and Maui, allowing for cross-platform development. View models in Blazor and Maui can be used to organize code and share functionality between different platforms. Maui offers performance advantages and a native look and feel compared to web-based solutions. Maui provides an escape route for rendering technology and opens up new hiring markets for businesses. The slow progress of web standards can hinder the development of web apps compared to native solutions. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Small Talk 00:35 Introduction to Blazor Hybrid 01:23 Blazor Rendering Modes 02:15 Experience with Blazor Hybrid 04:21 Using Razor in Blazor 05:19 Mobile Blazor Bindings for Xamarin and Maui 06:18 Choosing Between Blazor and XAML 07:36 Using Blazor for Complex Layouts 08:39 Blazor Web Views in Maui 09:38 Benefits of Blazor Hybrid for Forms 10:22 Mixing Blazor and Native Components 11:38 Using Third-Party Control Libraries in Blazor 12:37 Improvements in Web View Performance 13:48 Comparing App Performance on Different Platforms 14:38 Preloading Blazor Content in Maui 15:12 Loading Experience in Blazor Hybrid 16:09 Debugging and Performance in Blazor Hybrid 19:57 Injecting Maui Services into Blazor Pages 21:05 Debugging Experience in Windows 22:25 Separating Blazor and Maui Projects 23:21 Using WebAssembly for Blazor 24:18 Benefits of Blazor Hybrid for Development 26:11 Choosing Between Blazor and Native App 27:28 Challenges of Cross-Platform Development 29:13 Understanding Maui Hybrid Apps 30:02 Differences Between Web Assembly and Maui 31:21 Performance and Native Look 33:08 View Models in Blazor 35:23 Using View Models in Maui 36:44 Navigation in Maui and Blazor 38:18 Naming Confusion: Maui Blazor Hybrid 39:25 Benefits of Maui for Businesses 43:29 Transitioning from Web App to Native App 45:20 The Slow Progress of Web Standards 49:45 Plugin Packages of the Week: MudBlazor and Radzen

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 Lane reservations and participate in scavenger hunts, creating a seamless and engaging experience. Disney's crowd management and analytics ensure a smooth flow of visitors throughout the park. The backend infrastructure supporting these features is a marvel in itself. Overall, Disney's gamification approach enhances the park experience while providing value for the price. In this episode, Allan and Jon discuss the impressive features and functionality of the Disney mobile app. They highlight the interactive droids that react to Bluetooth events in the park and the immersive experience they provide. The conversation then delves into the magic of Disney's app, including its use of Google Maps for detailed mapping and navigation. They also explore the use of Magic Bands for child safety and the seamless integration of various features within the app. The discussion touches on the technical challenges faced by Disney and the solutions implemented to ensure a smooth user experience. The episode concludes with a summary of the main takeaways and a mention of Bluetooth plugin packages for developers interested in similar functionality. Takeaways The Disney mobile app offers a wide range of features and functionality to enhance the vacation experience. The app seamlessly integrates with hotel check-in, mobile food ordering, and car locator features for a convenient and efficient experience. The user interface and navigation of the app are well-designed, providing easy access to information and services. The integration of Magic Bands and Apple Wallet allows for a seamless and magical experience throughout the park. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Vacation experiences: Belize and Disney 03:10 The Disney app and its features 05:01 Booking a trip and managing reservations 07:22 Hotel reservations and check-in 08:17 Mobile food ordering 09:15 Car locator feature 11:43 User interface and navigation 14:12 Magic Band and Apple Wallet integration 19:58 Express pass and Magic Band 21:29 Animated passes in Apple Wallet 24:13 Attention to Detail 25:20 PhotoPass and Cast Members 26:16 Interactive Photos 27:13 Real-Time Photo Processing 28:19 On-Ride Photos 29:29 Scavenger Hunts and App Interactions 32:46 Crowd Management and Analytics 38:24 Lightning Lanes and Ride Availability 44:41 The Backend and Infrastructure 46:05 The Gamification Experience 47:10 Interactive Droids and Bluetooth 48:09 The Magic of Disney's App 51:12 Disney's Use of Google Maps 53:18 Magic Bands and Child Safety 55:06 Technical Challenges and Solutions 59:00 Cellular Connectivity and Redundancy 01:01:42 The Marvel of Disney's Mobile App 01:04:57 Conclusion and Plugin Packages

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 transforming events, filtering empty or invalid values, canceling and restarting events, and handling complex use cases. They also discuss the challenges and limitations of Reactive Extensions, including assembly size and reflection usage. The conversation concludes with a discussion on identifying use cases for Reactive UI and plans for future discussions on the topic. Takeaways Reactive Extensions (Rx) is a powerful library that simplifies event handling and provides a more composable and efficient way to work with events. Rx offers advantages over traditional event handling, such as the ability to filter, transform, and compose events, as well as handle asynchronous operations. RxUI is an open-source project that integrates Rx with Maui and other platforms, providing additional features and simplifying event handling in user interfaces. Using Rx can help address common challenges in event handling, such as memory leaks, complex event patterns, and managing asynchronous operations. Regular expressions can be used with Rx to validate and filter input, improving the quality and reliability of user interactions. Reactive UI.net simplifies event handling and data binding in UI development. Reactive Extensions provide powerful tools for manipulating and transforming events. Throttling and filtering events can improve performance and reduce unnecessary processing. Reactive UI and Reactive Extensions have limitations and may require careful consideration in certain scenarios. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Small Talk 01:07 Jon's Resistance to Dependency Injection 02:21 Introducing Reactive Extensions (Rx) 03:45 Advantages of Rx and Issues with Events 08:34 Rx in Different Platforms 10:00 Transforming and Filtering Events with Rx 15:29 Understanding Observables and Observers 19:21 Simplifying Event Handling with Rx 22:21 RxUI and its Integration with Maui 25:03 Challenges and Solutions in Using Rx 28:26 Implementing a Search Feature with Rx 31:03 Handling Continuous Typing and Caching Results 33:32 Validating Input with Regular Expressions 34:09 Introduction to Reactive UI and Reactive Extensions 34:38 Exploring Reactive UI.net 35:11 Throttling and Transforming Events 36:25 Distinct Until Changed 37:12 Filtering Empty or Invalid Values 37:45 Subscribing to Events 38:13 Canceling and Restarting Events 39:05 Complex Use Cases and Limitations 40:08 Using Reactive Extensions with Async 41:23 Challenges with Reactive Extensions 42:21 Assembly Size of System.Reactive 43:16 Reflection and Dynamic Usage 44:34 Considerations for Mobile Apps 48:35 Benefits of Reactive UI in UI Development 51:08 Identifying Use Cases for Reactive UI 54:04 Reactive UI and Reactive Extensions as Picks of the Week 55:06 Conclusion and Future Discussion

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 .NET MAUI provides an opportunity to improve the architecture of the app. The introduction of handlers in .NET MAUI allows for cleaner and more testable code. The single project structure in .NET MAUI simplifies the development process and improves compile times. Migrating third-party libraries may require finding alternatives or porting them to .NET MAUI. Customizing entry handlers and migrating resources, such as images and fonts, can be done more easily in .NET MAUI. Image management in mobile app development can be challenging, especially when dealing with different resolutions and densities. Using vectors can simplify image management by allowing for easy scaling to different sizes. App icons and splash screens can be generated automatically in .NET MAUI, reducing the manual effort required. When migrating from Xamarin.Forms to .NET MAUI, it is important to approach the process methodically, starting with dependencies and gradually bringing over pages and components. People Hosts: Jon Dick, Allan Ritchie Chapters 00:00 Introduction and Migration Experiences 01:11 Opportunity for Architectural Improvements 03:16 Evolution of Xamarin.Forms to Maui 06:27 Architecture of Maui Handlers 09:30 Benefits of Single Project Structure 13:56 Migration of Third-Party Libraries 18:13 Handling Dependency Service and Renderers 25:09 Porting Plugins and Controls 32:48 Customizing Entry Handlers 35:45 Migration of Resources 37:23 Image Management Challenges 39:25 Building a Solution: Resize-itizer 41:03 Vector Images in Maui 44:05 App Icons and Splash Screens 46:38 Migrating Resources to Maui 49:35 Font Handling in Maui 51:37 Replacing Frames with Borders 53:10 Avoiding Tap Gesture Issues with Stack Layouts 55:12 Namespace Changes in XAML 56:45 Methodical Migration Process 59:28 Package of the Week: Maui Community Toolkit

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. MVVM (Model-View-ViewModel) architecture is a popular approach for separating the presentation logic from the user interface. Shell in Xamarin.Forms provides a convenient way to handle navigation in mobile apps. Dependency injection (DI) can simplify the management of dependencies and improve testability in app development. Cross-platform development allows for code sharing and reduces development time and effort. Use dependency injection and service injection to manage dependencies and improve code maintainability. Create a base set of services that are core to every page in your app to simplify dependency injection. Think outside the box and consider alternative approaches when faced with UI design challenges. Solve business problems first and focus on reusability only when patterns emerge. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Building a Lightsaber 03:11 Anatomy of a Mobile App 08:15 Gluing Logic with MVVM 17:36 Navigation and Shell 23:42 Using Dependency Injection 30:34 Cross-Platform Considerations 33:24 Dependency Injection and Service Injection 34:35 Core Services and Cross-Platform Services 36:25 Creating a Base Set of Services 37:11 Anatomy of a Maui App 38:19 The UI as the Top Bun 39:17 The Importance of Connectivity 41:14 Thinking Outside the Box in App Development 44:48 Navigating UI Design Challenges 48:09 Custom Controls and Creative Solutions 54:29 Solving Business Problems First 58:38 Prism: A Comprehensive App Architecture Framework

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 development practices within an organization. Takeaways Templates are essential for simplifying mobile app development and helping developers remember important details. Default templates in Maui and item templates in VS Code provide a starting point for building mobile apps. Custom templates can save time and help manage permissions and entitlements. MSBuild and CSProj files offer powerful customization options for projects. Community templates provide additional resources and options for developers. There are various types of templates available for building mobile apps with .NET Maui, including item templates, Maui templates, solution templates, Visual Studio templates, - VS Code templates, and command line templates. Item templates are used to add specific elements, such as XAML pages or views, to an existing project. Maui templates provide a starting point for building cross-platform apps with .NET Maui and include pre-configured project structures and dependencies. Solution templates allow developers to generate a complete solution with multiple projects and project references. Visual Studio templates offer a rich mechanism for creating templates with dynamic interfaces and advanced features. VS Code templates focus on command line interactions and provide a more lightweight and streamlined experience. Command line templates are used with the 'dotnet new' command and offer a simple and flexible way to generate project structures. Creating custom templates can help standardize development practices within an organization and simplify the onboarding process for new projects. Using templates can save time and effort by automating repetitive tasks and providing a consistent starting point for app development. Consider using existing templates or creating your own templates to improve productivity and maintain coding best practices. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 00:31 The Importance of Templates for Mobile Apps 01:38 Default Templates in Maui 02:35 Item Templates in VS Code 03:28 The Challenge of Remembering Details 04:11 Customizing Templates 05:38 Balancing Complexity and Simplicity in Templates 06:55 Different Needs for New and Experienced Users 07:45 Creating Custom Templates 08:23 Managing Permissions and Entitlements 09:44 The Power of Templates in Saving Time 11:05 The Challenge of Changing Requirements 13:21 Managing Permissions in Templates 14:42 Working with Templates in Different Environments 15:23 Using Conditional Logic in Templates 17:42 Generating Entitlements in Templates 19:14 Simplifying Project Files 21:17 The Power of MSBuild and CSProj Files 23:01 Overcoming Fear of Project Files 25:21 Using Project Files for Customization 26:41 The Benefits of Plugin Templates 30:51 Including Popular Packages in Templates 32:33 The Value of Community Templates 33:32 Introduction to Templates 34:05 Different Template Options 35:39 Item Templates 36:09 Maui...

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 background tasks in CarPlay and Android Auto. Takeaways Backgrounding in mobile development is the ability to execute code when an app is not in the foreground. Common scenarios for backgrounding include data synchronization, image uploads, and real-time GPS. On Android, backgrounding can be achieved using services, broadcast receivers, foreground services, and job scheduling. On iOS, backgrounding is more restricted, with foreground services and background transfers being the primary options. Developers should consider the specific platform guidelines and limitations when implementing backgrounding functionality. Background transfers are useful for uploading or downloading large files or data sets. Managing state in background jobs can be challenging, but there are various ways to handle it, such as using preferences or messaging frameworks. Background GPS in iOS and Android allows for tracking location and other data, but it should be used judiciously to avoid excessive battery drain. Background tasks in Windows can be achieved using WinRT APIs, but they may be less relevant in desktop scenarios. Consider the specific use case and user needs before implementing background tasks, and be mindful of the impact on battery life and data usage. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Virtual List View 05:28 The Story Behind the Nickname 'Red' 08:50 Backgrounding in Mobile Development 19:21 Backgrounding on Android 27:45 Backgrounding on iOS 30:31 Background Transfers on Android 31:55 Background Transfers on iOS 32:42 Background Transfers 33:45 Handling Slow APIs 34:38 Background Tasks in iOS 13 36:46 Managing State in Background Jobs 37:45 One-Off and Scheduled Jobs 40:20 Background Execution in iOS 41:36 Passing State to Background Jobs 44:22 Challenges of Data Synchronization 45:45 Background Execution in Windows 46:19 Background GPS in iOS 47:39 Background GPS in Android 51:53 Considerations for Background Tasks 55:12 Background Tasks in CarPlay and Android Auto

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 different platforms, such as ListView, RecyclerView, and UICollectionView, has influenced the current state of CollectionView in MAUI. The current CollectionView in MAUI tries to do too much and can be complex to use in certain scenarios. Alternative list view controls, such as Sharpnado and Syncfusion, provide different approaches and features for handling lists in mobile apps. Observable collections are often misused in list views, leading to performance issues. It is important to use them appropriately and consider using a regular list when the data is not changing frequently. Observable collections are useful for handling data in motion, such as real-time updates or changing distances. Optimizing list performance should be done based on actual needs and user behavior, rather than prematurely optimizing for potential issues. Consider the specific requirements of your app when choosing a list control, and don't be afraid to explore alternative solutions like Blazor or web technologies. The Virtualized List View plugin by Jon is a powerful tool for building performant lists in Xamarin.Forms and can be a great solution for complex scenarios. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Weather 01:14 Listener Question: CLI Command in MAUI 05:36 Topic: Dealing with Lists in Mobile Apps 19:35 History of List Implementations 25:51 Challenges with Collection View in MAUI 30:17 Alternative List View Controls 35:38 Observable Collections and List Views 39:18 Observable Collection and Data in Motion 46:11 Optimizing List Performance 52:26 Choosing the Right List Control 56:25 Virtualized List View Plugin 01:00:53 Optimizing List Performance (Continued) 01:04:08 Conclusion and Plug-in of the Week

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 of implementing push notifications on Android. Takeaways Push notifications are a complex topic that require careful setup and configuration on both iOS and Android. Developers face challenges in implementing push notifications due to the differences between platforms and the evolving nature of the technology. The setup and configuration process involves obtaining certificates and entitlements on iOS and using Firebase on Android. The lifecycle of notifications and the handling of background execution differ between iOS and Android. Permissions and changes in Android, such as the introduction of post-notifications, add another layer of complexity to push notification implementation. Permissions and changes in Android can impact the implementation of push notifications. Notifications on Android can be set up to route directly to an activity by specifying an intent in the notification payload. Silent notifications on Android can be used to wake up the app and perform background tasks. Sending notifications to tags allows for logical grouping and targeted delivery on Android. Handling multiple devices and ensuring notifications are received on all devices can be challenging. The Shiny Push library simplifies the implementation of push notifications on Android. Source generators can help reduce boilerplate code and make implementation easier. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 01:09 Tackling Hard Problems 04:00 History of Push Notifications 08:30 Setup and Configuration on iOS 13:02 Registering for Notifications on iOS 15:22 Lifecycle of Notifications on iOS 17:43 Silent Notifications on iOS 19:27 Handling Background Execution on iOS 22:06 Complexity of Cross-Platform Implementation 24:19 Setup and Configuration on Android 28:35 Handling Notifications on Android 32:19 Permissions and Changes in Android 33:16 Permissions and Changes 35:27 Setting Up Notifications on Android 36:43 Specifying Intents in Notification Payloads 38:19 Silent Notifications on Android 41:48 Sending Notifications to Tags on Android 44:29 Handling Multiple Devices on Android 49:15 Shiny Push Library 52:21 Server-to-Server Notifications 56:08 Source Generators and Boilerplate 57:44 Plugin Pick: Shiny Push

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 dependencies and the potential issues with duplicate libraries. Additionally, it highlights the concept of platform channels in Maui and the potential for creating a seamless integration experience. The recommended plugin for this episode is Xamarin Binding Helpers. Plugins, Packages, and Products This week we're talking about Xamarin.Binding.Helpers (https://github.com/Redth/xamarin.binding.helpers) which helps make it easier to create slim bindings on Android, as well as Platform Channels (https://github.com/Redth/Microsoft.Maui.Platform.Channels) which is an experiment for creating a message passing interface between native code and .NET MAUI apps. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction 01:09 Understanding Bindings in a Mobile.NET, Maui World 02:00 Projections of Native APIs into the Managed.NET World 03:41 The Evolution of Bindings 04:06 The Challenge of Android X Libraries 05:00 Dealing with Bindings in Xamarin 06:07 The Complexity of Android Libraries 07:03 Creating Android Bindings 07:30 The Process of Android Binding 08:16 Challenges with Java and Kotlin Libraries 09:08 Handling Complex Inheritance in Java and Kotlin Libraries 10:22 The Sprawl of Android X Libraries 11:31 The Challenges of Binding Android X Libraries 12:09 The Simplicity of Binding Platform APIs 13:16 The Differences Between iOS and Android Bindings 14:22 Creating iOS Bindings 15:48 The Challenges of Objective-C and Swift Libraries 18:36 The Need for Slim Bindings 20:00 The Challenge of Dependency Chains 21:54 The Concept of Slim Bindings 23:46 The Advantages of Slim Bindings 27:11 Determining When to Bind the Whole Library 29:34 Debugging Slim Bindings 34:52 The Concept of Platform Channels 38:58 Performance Considerations of Platform Channels 40:37 The Future of Bindings 40:46 Integration with Xcode Project 42:41 Challenges with Tooling 46:48 Handling AndroidX Dependencies 50:15 Platform Channels in Maui 53:00 Plugin Recommendation: Xamarin Binding Helpers

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 express their interest in incorporating such concepts into the core product. The episode concludes with a call to action for listeners to subscribe, leave reviews, and provide topic suggestions for future episodes. Takeaways The .NET Maui framework has made significant progress, with improvements in tooling, performance, and support for modern mobile app development. Blazor WebView in Maui allows developers to leverage their existing Blazor skills and codebase to build hybrid mobile apps. The transition from custom renders to handlers in Maui simplifies the development process and improves performance. Source generators in Maui enable automatic code generation, reducing the need for manual coding and improving productivity. App profiling and performance optimization are crucial for identifying and resolving performance issues in apps. Tools like DS router and DS dotnet trace can be used to profile apps and gather trace files and speed scope logs for analysis. Early measurement and optimization can help prevent performance issues and improve the overall user experience. Compiled bindings is a library that enhances the XAML experience by providing additional operators and reducing verbosity, making it easier to work with XAML. Plugins, Packages, and Products This week we're talking about Compiled Bindings: https://github.com/levitali/CompiledBindings which provides {x:Bind} Markup Extension for WPF, MAUI and Xamarin Forms. Chapters 00:00 Introduction and Changes to the Podcast 06:17 State of .NET Maui 09:24 Dependency Injection in .NET Maui 11:12 Evolution of the Mono Runtime 13:14 Challenges of Mobile Development 19:22 Long-Term Release of .NET Maui 21:20 Blazor Hybrid App 23:43 Benefits of Blazor WebView 25:49 Mixing Blazor and Maui 31:35 Handlers in .NET Maui 35:13 Porting Custom Renders to Handlers 37:03 Source Generators in .NET Maui 38:56 App Profiling and Performance Optimization 41:29 Plugin Package or Product: Compiled Bindings 47:04 Closing Remarks and Call to Action

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.