Gone Mobile Jonathan Dick, Allan Ritchie

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

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
Links:
Radzen Blazor ComponentsMudBlazor