Gone Mobile Jonathan Dick, Allan Ritchie

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 O

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