Gone Mobile Jonathan Dick, Allan Ritchie

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 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