Gone Mobile

In this episode, Jon and Allan discuss various topics related to backend development. They start by joking about Canadian stereotypes and accents. Then, they dive into the world of backend development using ASP.NET Core and API controllers. They talk about the changes in API controllers and the use of IActionResult. They also discuss the benefits of using OpenAPI and generating contracts from it. They mention tools like Kyoto and Refit/Refitter for generating contracts and API clients. The conversation ends with a humorous remark about the possibility of a future tool called 'Refitist.' The conversation covers topics such as Refit, resiliency, GraphQL, OData, and Mediator pattern. Refit is discussed as a tool to generate code for API consumption. Resiliency is mentioned as a client-side concern, and the use of Polly for retrying failed requests is debated. GraphQL and OData are compared in terms of their usefulness and complexity. The Mediator pattern is introduced as a way to structure code and facilitate future scalability. Real-time communication with SignalR is briefly mentioned. The conversation covers topics such as real-time data streaming, the use of Docker for development and deployment, and experiences with different SQL databases. The hosts discuss the pros and cons of real-time data streaming and the various methods available. They also explore the use of Docker for local development and deployment, highlighting its benefits in creating consistent environments. The conversation then shifts to experiences with different SQL databases, including Oracle, MySQL, and SQL Server. They discuss the challenges and advantages of each database and the importance of proper database design and optimization. In this final part of the conversation, Allan and Jon discuss their experiences with different backend technologies, including Postgres SQL and backend-as-a-service platforms like Firebase and Apprite. They also touch on the challenges of managing costs and scalability in cloud services. The episode concludes with a mention of the Packages of the Week segment and a reminder for listeners to leave a five-star review. Takeaways Backend development in ASP.NET Core involves using API controllers and IActionResult. OpenAPI is a useful tool for generating contracts and defining API endpoints. Tools like Kyoto and Refit/Refitter can be used to generate contracts and API clients. The conversation highlights the importance of keeping up with changes in backend development tools and practices. Refit is a tool for generating code to consume APIs Resiliency is a client-side concern and can be handled with tools like Polly GraphQL and OData are compared in terms of their usefulness and complexity The Mediator pattern is a way to structure code and facilitate future scalability Real-time communication with SignalR is challenging for mobile apps Real-time data streaming methods vary and depend on the specific use case and requirements. Docker is a useful tool for creating consistent development and deployment environments. Different SQL databases have their own strengths and weaknesses, and the choice depends on the specific needs of the project. Proper database design and optimization are crucial for efficient and scalable applications. Postgres SQL is a reliable and fast database option with excellent driver support in .NET Backend-as-a-service platforms like Firebase and Apprite offer a comprehensive set of tools and infrastructure for building apps Managing costs and scalability in cloud services can be challenging, but it's important to find the right balance Consider leaving a five-star review for the podcast to show support and provide feedback People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Canadian Stereotypes 04:42 Exploring Backend Development 09:03 Streaming Results and OpenAI 13:52 Generating Contracts with Kyoto and Refit/Refitter 19:46 The Future of Backend Development 27:19...

The conversation revolves around the topic of drawn controls in mobile app development. The hosts discuss the pros and cons of using drawn controls versus native controls, as well as the challenges and considerations involved. They explore the idea of a hybrid approach, where some controls are drawn while others remain native. The conversation touches on topics such as scrolling, text entry, and performance implications. Overall, the hosts emphasize the importance of choosing the right approach based on the specific requirements and goals of the app. The conversation explores the challenges and considerations of drawing controls in cross-platform development. It discusses the options of using Skia or native APIs for rendering text and achieving platform-specific looks. The availability of drawing controls in MAUI is highlighted, along with the ability to choose between native drawing surfaces and SkiaSharp. The conversation also touches on the accessibility and sizing implications of drawing controls, as well as the potential benefits of easier unit testing and scalability. In this conversation, Allan and Jon discuss the challenges and considerations of using cross-platform code for drawing controls. They explore the value proposition of using libraries like Syncfusion and the trade-offs of using SkiaSharp for drawing controls. They also touch on the benefits of creating custom layouts and the potential of libraries like AlohaKit and DrawnUI for building visually appealing UIs. Takeaways There are different approaches to implementing controls in mobile app development, including drawn controls and native controls. The choice between drawn controls and native controls depends on the specific requirements and goals of the app. A hybrid approach, combining drawn controls and native controls, can provide a balance between customization and platform conformity. Challenges in implementing drawn controls include scrolling, text entry, and performance optimization. Considerations for choosing between drawn controls and native controls include design consistency, resource management, and system integration. Drawing controls in cross-platform development can be challenging due to differences in rendering text and achieving platform-specific looks. MAUI offers the option to draw controls using native drawing surfaces or SkiaSharp, providing flexibility and consistency across platforms. Accessibility and sizing considerations are important when drawing controls, as they may require additional code to ensure proper functionality. Drawing controls can simplify unit testing and improve scalability by reducing the need for maintaining abstractions over native controls. The availability of drawing controls in MAUI opens up possibilities for easier customization and design flexibility. Using cross-platform code for drawing controls can be challenging and may require additional considerations, such as accessibility APIs on each platform. There is value in using libraries like Syncfusion for existing investments and documentation, but there may be limitations and complaints about library size. Creating custom layouts can be a solution for complex UI requirements and can be achieved by measuring and laying out elements. Libraries like AlohaKit and DrawnUI offer options for building visually appealing UIs with customizable controls and layouts. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Inside Joke 01:13 Topic Introduction: Drawn Controls 07:13 Design Consistency vs. Platform Conformity 13:35 Text Entry and Customization 22:26 Scrolling and Performance Optimization 25:48 Challenges and Considerations of Drawing Controls 27:33 The Availability of Drawing Controls in MAUI 29:09 Accessibility and Sizing Implications of Drawing Controls 31:17 Simplifying Unit Testing and Improving Scalability with Drawing Controls 47:52 Introduction 48:04 Challenges and Considerations of Cross-Platform Code for...

In this conversation, Jon and Allan discuss various tools they use for development. They talk about their preferred operating systems, monitors, and IDEs. They also mention specific tools like Insomnia for API testing and DevTools for debugging. The conversation is light-hearted and includes some banter about Canadian jokes and hockey. In this part of the conversation, Jon and Allan discuss various tools they use, including antivirus software, DevToys, Setapp, file managers, Docker, Cosmos DB, and coffee brewing equipment. In this conversation, Allan and Jon discuss various soft tools and libraries that they use in their development projects. They cover topics such as coffee-making methods, microphones and audio equipment, standing desks, and .NET libraries like MVVM Toolkit, .NET Orleans, and MediatorR. They also mention the Shiny Templates, a collection of templates for Xamarin and Maui apps. Overall, they provide insights into the tools and libraries they find useful in their development workflows. Takeaways Visual Studio and Visual Studio for Mac are popular IDEs for development Insomnia is a useful tool for API testing DevTools is great for debugging Choosing the right operating system and monitor can greatly enhance the development experience Having a good set of tools can improve productivity and efficiency Antivirus software can sometimes cause issues with certain tools and applications. DevToys is a useful tool for various tasks like encoding/decoding strings and testing Xpath queries. Setapp is a subscription service that provides access to a wide range of tools and apps for Mac users. Forklift is a file browser and development toolkit for Mac. Total Commander is a file manager that offers a dual-pane interface and other advanced features. Using a proper coffee grinder, like a burr grinder, can result in a better coffee brewing experience. Chemex is a popular coffee brewing method that requires a specific type of kettle and filters. The choice of tools can greatly impact productivity and user experience in software development. There are various soft tools and libraries that developers can use to enhance their development workflows. Choosing the right tools and libraries depends on the specific needs and requirements of the project. Some popular soft tools and libraries mentioned in the conversation include MVVM Toolkit, .NET Orleans, and MediatorR. The Shiny Templates collection provides a wide range of templates for Xamarin and Maui apps. Experimenting with different tools and libraries can help developers find the ones that work best for them. People Hosts: Jon Dick, Allan Ritchie Audio/Video Engineer: Jim Heath Chapters 00:00 Introduction and Canadian Jokes 02:32 Exploring the Tools We Use for Development 09:17 Using Visual Studio and Rider for Development 13:07 Testing APIs with Insomnia 16:22 The Importance of a Good Monitor 21:07 Other Useful Tools for Development 22:30 Antivirus Software and Compatibility Issues 23:35 DevToys: A Handy Tool for Various Tasks 24:23 Setapp: A Subscription Service for Mac Users 25:24 Forklift: A File Browser and Development Toolkit for Mac 26:09 Total Commander: A Feature-Rich File Manager 29:30 Docker: Simplifying Development and Deployment 30:19 Kubernetes: A Powerful Container Orchestration Platform 31:33 Cosmos DB: Offline Development Challenges 33:19 PostgreSQL: A Versatile and Feature-Rich Database 36:16 Parallels: Efficient Virtualization for Mac 38:12 The Importance of a Proper Coffee Grinder 39:39 Brewing Coffee with Chemex: A Unique Experience 42:15 The Impact of Tools on Productivity and User Experience 43:21 The Shower Method of Making Coffee 45:36 Soft Tools for Podcasting 48:19 Microphones and Audio Equipment 49:22 Standing Desks and Key Lights 52:18 Soft Tools for Mobile App Development 55:49 MVVM Toolkit and .NET Orleans 58:11 Shiny Templates for Xamarin and Maui Apps 01:00:53 MediatorR for Modular Monoliths

In this episode, Jon and Allan discuss logging and configuration in mobile app development. They talk about their personal experiences with configuration and logging, including using environment variables, embedded resources, and external libraries like Sentry. They also touch on the performance implications of logging and the potential for source generation to improve configuration handling. Overall, they emphasize the importance of considering the specific needs of the app and the trade-offs between convenience and performance. In this conversation, Allan and Jon discuss logging and error handling in mobile app development. They mention the importance of having good logging tools and the drawbacks of using outdated tools like App Center. They also talk about the benefits of using a local logging system for debugging purposes. The conversation concludes with a discussion on the proper use of try-catch blocks and the importance of handling exceptions at the right level. Takeaways Consider the specific needs of your app when implementing configuration and logging Use environment variables or constants for simple configuration needs Be mindful of the performance implications of logging, especially in mobile apps Explore external libraries like Sentry for crash reporting and error handling Source generation can be a powerful tool for handling configuration Having good logging tools is crucial for effective debugging and error handling in mobile app development. Using outdated tools like App Center for logging can lead to code pollution and limited functionality. Local logging can be useful for debugging purposes, especially in scenarios where cloud logging is not necessary or practical. Try-catch blocks should be used strategically and not excessively. They should be placed at the event triggers or where exceptions can be handled effectively. Proper error handling and logging practices can help improve the overall stability and user experience of mobile apps. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Episode Number 06:02 Exploring External Libraries for Error Handling 11:04 Finding the Right Balance: Convenience vs Performance 23:45 Considerations for Configuration and Logging in Mobile Apps 26:11 The Performance Implications of Logging 29:12 Logging and Performance: A Closer Look 32:05 The Drawbacks of Using Outdated Logging Tools 34:12 The Benefits of Local Logging 36:26 Strategic Use of Try-Catch Blocks 41:38 Proper Error Handling and Logging Practices

The conversation covers various mobile app development pitfalls and best practices, including the use of assembly scanning, loading large JSON files, and the misuse of dependency injection. The hosts share their experiences and insights on these topics, highlighting common mistakes and potential solutions. The conversation covers topics related to app performance, dependency injection, service management, constructor logic, and the impact of changes from Xamarin Forms to Maui. It delves into the challenges of resolving services, the use of async calls in constructors, and the importance of separating concerns in service management. The discussion emphasizes the need for thoughtful design and the avoidance of unnecessary complexity. In this conversation, Allan and Jon discuss the challenges and misconceptions surrounding observable collections in app development. They explore the performance implications, misuse, and alternative solutions, as well as the complexities of source generators and incremental generators. The conversation also touches on the importance of learning from mistakes and the potential for Roslyn analyzers in XAML. The episode concludes with a discussion about a new plugin package and listener feedback. Takeaways Mobile app development often involves common pitfalls and best practices that developers should be aware of. Assembly scanning and loading large JSON files can impact app performance and should be approached with caution. Misuse of dependency injection, such as making pages singleton for faster loading, can lead to unexpected issues and should be carefully considered. Source generators can be a valuable tool for optimizing app performance and reducing unnecessary code. Understanding the implications of various development practices is crucial for creating efficient and reliable mobile applications. App performance can be impacted by the management of services and the logic within constructors. Separating concerns in service management is crucial for maintaining code quality and performance. The transition from Xamarin Forms to Maui introduces changes that can affect app performance and behavior. Avoiding unnecessary complexity and thoughtful design are key principles for effective service management and app performance optimization. Observable collections can lead to performance issues and are often misused in app development. Source generators and incremental generators present complexities and challenges in app development. Learning from mistakes is an important part of growth and improvement in software development. Listener feedback and engagement are valuable for shaping future podcast episodes and content. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Nostalgic Reflections 02:50 Common Pitfalls in Mobile App Development 24:22 Dependency Injection Best Practices 42:27 The Impact of Xamarin Forms to Maui Transition 48:53 Constructor Logic and Service Resolution Challenges 51:29 Challenges of Observable Collections in App Development 54:14 Learning from Mistakes in Software Development 01:05:30 Engaging with Listener Feedback

The conversation delves into the topic of dependency injection (DI) and its evolution over the years. It covers the history of DI, different DI libraries, considerations for mobile development, and the future of DI with source generation. The discussion also touches on performance optimizations and the impact of DI on app startup time. The conversation covers topics related to dependency injection, scoping mechanisms, and the challenges of managing scopes in Maui apps. It also delves into the use of Prism and the need for out-of-the-box conventions for handling life cycles and navigation services in Maui. The conversation covers a deep dive into dependency injection, scope boundaries, and the challenges of managing dependencies in the context of mobile app development. It also delves into the nuances of using different DI containers and the impact on app performance. The hosts share their experiences, insights, and recommendations for handling these complexities effectively. Takeaways Dependency injection has evolved over the years and has become a crucial part of app development, especially in the mobile space. Different DI libraries have their own strengths and considerations, and the choice of library depends on the specific use case and performance requirements. The future of DI may involve source generation, which could lead to significant improvements in performance and reduce complexity in the registration process. Considerations for mobile development include the impact of DI on app startup time and the need for performance optimizations. Property injection and constructor injection are both relevant approaches in DI, and the choice between them depends on the specific requirements of the application. Understanding the challenges of managing scopes in Maui apps The need for out-of-the-box conventions for handling life cycles and navigation services in Maui Insights into the use of Prism and its impact on dependency injection in Maui apps Understanding scope boundaries is crucial for effective dependency injection in mobile app development. Choosing the right DI container can significantly impact app performance and memory management. Managing dependencies and understanding scope lifetimes is essential for avoiding memory leaks and performance issues in mobile apps. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapter 00:00 The Evolution of Dependency Injection 07:18 Considerations for Mobile Development 13:47 The Future of Dependency Injection 23:23 Understanding Scoping Mechanisms and Life Cycles 26:34 The Need for Out-of-the-Box Conventions in Maui 29:04 Dependency Injection and Prism in Maui Apps 41:28 Understanding Scope Boundaries in Dependency Injection 43:21 Common Misconceptions about Dependency Injection 45:23 Impact of Dependency Injection in Prism and Maui Apps 47:11 Debugging and Validation in Dependency Injection 53:45 Audio Quality and Listener Engagement

In this conversation, Jon and Allan discuss various topics related to architecture and performance in mobile app development. They touch on the challenges of implementing the MVVM pattern and the potential for excessive property changed notifications. They also discuss the use of observable collections and the importance of using them only when necessary. Additionally, they express their dislike for messaging services and suggest using events or actions instead. Overall, the conversation emphasizes the need for thoughtful architecture and optimization in mobile app development. The conversation explores the use of mediator pattern in mobile and app development. The mediator pattern is seen as a solution to prevent service overrun and to provide logical separation in the app. It allows for vertical slicing of concerns and prevents the need for injecting multiple services. The conversation also discusses the challenges of messaging services and the benefits of using a mediator pattern in terms of scalability, error handling, and unit testing. The potential application of the mediator pattern in Xamarin and .NET Maui apps is explored. In this conversation, Allan and Jon discuss the concept of using a mediator pattern in mobile app development. They explore the benefits of using a mediator to handle communication between different components of an app, such as view models and services. They also discuss existing implementations of the mediator pattern, such as MediatR, and potential future developments in this area. Overall, they highlight the potential value of using a mediator pattern in mobile app architecture. Takeaways Implementing the MVVM pattern can lead to excessive property changed notifications, which may impact performance. Observable collections should be used only when data is constantly changing, such as in real-time applications. Consider using events or actions instead of messaging services for better control and clarity in event handling. Thoughtful architecture and optimization are crucial for improving performance in mobile app development. The mediator pattern can be a solution to prevent service overrun and provide logical separation in mobile and app development. Using a mediator pattern allows for vertical slicing of concerns and prevents the need for injecting multiple services. The mediator pattern offers benefits such as scalability, error handling, and ease of unit testing. The potential application of the mediator pattern in Xamarin and .NET Maui apps is worth exploring. The mediator pattern can be a valuable tool for handling communication between different components of a mobile app. Using a mediator can simplify unit testing by allowing developers to focus on testing individual components rather than the entire app. Existing implementations of the mediator pattern, such as MediatR, can provide a solid foundation for incorporating this pattern into mobile app development. The mediator pattern can help clean up code and improve the organization and separation of concerns in mobile app architecture. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Personal Updates 03:00 Challenges of Implementing the MVVM Pattern 09:04 Optimizing the Use of Observable Collections 14:57 Avoiding Excessive Messaging Services 22:18 Challenges with Messaging Services 24:02 Exploring the Mediator Pattern 27:07 The Role of Mediators in Routing 30:17 Separation of Concerns and Dependency Injection 33:30 Handling Events in Temporary View Models 36:00 Benefits of the Mediator Pattern 40:08 Scaling and Breaking Down Hotspots 44:20 Command Handlers and Mediator Interaction 46:27 Focusing on the Action with Mediators 49:28 Simplifying Unit Testing with a Mediator 52:17 Existing Implementations of the Mediator Pattern 55:11 Handling Unsolicited Notifications with a Mediator 57:24 Mediator Libraries and Best Practices 01:00:57 Challenges and Considerations for Mediator Implementation...

In this conversation, Jonathan discusses his experience with building automation control systems for his swimming pool using microcontrollers and IoT devices. He talks about controlling the pool temperature, pool pumps, and a saltwater generator. He also explores the challenges and considerations of using different microcontrollers, such as the ESP8266 and the Meadow board, which runs .NET. Jonathan shares his passion for building IoT projects and the potential for using favorite programming languages in these environments. The conversation covers various topics related to IoT platforms, including the evolution of hardware into software-as-a-service (SaaS) platforms, the expansion of Meadow's ecosystem, the integration of Raspberry Pi with Meadow, the challenges of running web servers on microcontrollers, and personal projects involving IoT devices. The conversation also touches on the use of Meadow in pool automation and coffee brewing, as well as the ingenuity of building custom solutions using sensors and Raspberry Pi. Takeaways Building automation control systems for swimming pools using microcontrollers and IoT devices is a fascinating and practical application of technology. Controlling the pool temperature, pool pumps, and other aspects of pool maintenance can be automated using microcontrollers and relays. Different microcontrollers, such as the ESP8266 and the Meadow board, offer various capabilities and programming options for building IoT projects. The Meadow board, which runs .NET, provides a more familiar programming environment for developers and offers the potential for using favorite programming languages in IoT - projects. IoT platforms often evolve from hardware devices to full-fledged software-as-a-service (SaaS) platforms. Meadow is building an ecosystem around its platform, expanding its libraries and compatibility with devices like Raspberry Pi. Running web servers on microcontrollers like Meadow can be challenging, but Meadow provides solutions like BLE servers and basic web server functionality. Personal projects involving IoT devices can range from pool automation to coffee brewing, and can be built using sensors and Raspberry Pi. Building custom solutions using sensors and Raspberry Pi can be a creative and practical way to solve real-world problems. People Hosts: Jon Dick, Allan Ritchie Audio Engineer: Jim Heath Chapters 00:00 Introduction and Background 02:26 Interest in IoT and Microcontrollers 03:50 Comparing IoT to Early Xamarin Days 08:11 Controlling Pool Temperature with Microcontrollers 09:37 Automating Pool Pumps and Saltwater Generator 28:27 Exploring the Meadow Board and .NET in IoT 33:19 The Evolution of IoT Platforms 34:41 Building an Ecosystem and Extending Compatibility 35:10 Challenges of Running Web Servers on Microcontrollers 39:23 Personal Projects: Pool Automation and Coffee Brewing 52:59 Meadow Desktop: Coding Against APIs and Simulating Graphics 01:03:38 Building Custom Solutions with Sensors and Raspberry Pi

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