Gone Mobile

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 Tactics and Scars
• 08:14 Challenges with Realm and Login Service
• 14:17 Avoiding Over-Engineering and Building Dependencies
• 25:15 Simplifying the Data Model for Easier Syncing
• 27:04 Conclusion and Key Takeaways
• 27:34 Managing 'End Scars' in Data Synchronization
• 29:23 Importance of Clear Feedback in Offline Scenarios
• 32:30 Benefits of Using SQLite for Local Offline Storage
• 37:28 Limitations of Frameworks for Offline Sync
• 48:57 Optimizing App Startup Time and the Role of SQLite
• 50:47 The Benefits of Using SQL and SQLite-PCL-NET
• 51:20 Offline Functionality and Device-to-Device Communication
• 52:21 Challenges of Offline Functionality in Airplane Environments
• 55:18 The ...

This conversation discusses the concept of bindings in a mobile.NET, Maui world. Bindings are used to integrate native libraries into the.NET ecosystem. The conversation covers the challenges and complexities of creating bindings for Android and iOS platforms. It explores the differences between Android X libraries and platform APIs. The concept of slim bindings is introduced, which involves creating a simplified interface for interacting with native libraries. The conversation also touches on the use of platform channels for message passing between.NET and native code. The future of bindings and the need for improved tools and processes are discussed. The conversation discusses the challenges and considerations when integrating platform channels in Xamarin projects. It explores the difficulties of referencing native frameworks and dependencies in Xcode projects and suggests the need for improved tooling to simplify the process. The conversation also delves into the complexities of handling AndroidX dependencies and the potential issues with duplicate libraries. Additionally, it highlights the concept of platform channels in Maui and the potential for creating a seamless integration experience. The recommended plugin for this episode is Xamarin Binding Helpers.

Plugins, Packages, and Products

This week we're talking about Xamarin.Binding.Helpers which helps make it easier to create slim bindings on Android, as well as Platform Channels which is an experiment for creating a message passing interface between native code and .NET MAUI apps.

People

• Hosts: Jon Dick, Allan Ritchie
• Audio Engineer: Jim Heath

Chapters

• 00:00 Introduction
• 01:09 Understanding Bindings in a Mobile.NET, Maui World
• 02:00 Projections of Native APIs into the Managed.NET World
• 03:41 The Evolution of Bindings
• 04:06 The Challenge of Android X Libraries
• 05:00 Dealing with Bindings in Xamarin
• 06:07 The Complexity of Android Libraries
• 07:03 Creating Android Bindings
• 07:30 The Process of Android Binding
• 08:16 Challenges with Java and Kotlin Libraries
• 09:08 Handling Complex Inheritance in Java and Kotlin Libraries
• 10:22 The Sprawl of Android X Libraries
• 11:31 The Challenges of Binding Android X Libraries
• 12:09 The Simplicity of Binding Platform APIs
• 13:16 The Differences Between iOS and Android Bindings
• 14:22 Creating iOS Bindings
• 15:48 The Challenges of Objective-C and Swift Libraries
• 18:36 The Need for Slim Bindings
• 20:00 The Challenge of Dependency Chains
• 21:54 The Concept of Slim Bindings
• 23:46 The Advantages of Slim Bindings
• 27:11 Determining When to Bind the Whole Library
• 29:34 Debugging Slim Bindings
• 34:52 The Concept of Platform Channels
• 38:58 Performance Considerations of Platform Channels
• 40:37 The Future of Bindings
• 40:46 Integration with Xcode Project
• 42:41 Challenges with Tooling
• 46:48 Handling AndroidX Dependencies
• 50:15 Platform Channels in Maui
• 53:00 Plugin Recommendation: Xamarin Binding Helpers

Links:

• Objective Sharpie
• Xamarin.Binding.Helpers
• Platform Channels

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

Links:

• Source Generators Kit
• YouTube Episode 110

In this episode, Jon and Allan discuss various topics, including listener feedback, using SQLite for local data storage, changes in Android's page size, creating a personalized video for a Disney trip, and working on a marketing app with custom requirements. In this conversation, Jon and Allan discuss the challenges and best practices of using collection views and bindable layouts in mobile app development. They caution against nesting collection views and bindable layouts within each other, as it can lead to performance issues and difficulties with recycling views. They also emphasize the importance of using cancellation tokens to properly handle asynchronous operations and avoid memory leaks. The conversation concludes with a discussion on the EmbedIO plugin, which allows developers to host a local web server within their mobile apps.

Takeaways

• Listener feedback is important and should be addressed in future episodes
• Using SQLite for local data storage can be a simple and efficient solution
• Android's change in page size will require rebuilding native libraries
• Creating a personalized video for a Disney trip can be a fun and memorable experience
• Working on a marketing app with custom requirements can be challenging but rewarding Avoid nesting collection views and bindable layouts within each other to prevent performance issues and difficulties with view recycling
• Use cancellation tokens to properly handle asynchronous operations and avoid memory leaks
• Consider alternative approaches, such as lazy loading or logical collapsing, when dealing with large datasets or complex UI structures
• The EmbedIO plugin allows developers to host a local web server within their mobile apps

People

• Hosts: Jon Dick, Allan Ritchie
• Audio/Video Engineer: Jim Heath

Chapters

• 00:00 Introduction and Listener Feedback
• 03:47 Using SQLite for Local Data Storage
• 12:11 Android's Change in Page Size
• 16:17 Creating a Personalized Video for a Disney Trip
• 20:12 Working on a Marketing App with Custom Requirements
• 31:11 Authentication Flows and Security
• 49:03 Challenges with Collection Views and Bindable Layouts
• 53:11 Avoid Nesting Scrolling Views
• 01:01:25 Exploring the EmbedIO Plugin

YouTube: https://youtu.be/MH4bwX3JsNY

Links:

• unosquare/embedio: A tiny, cross-platform, module based web server for .NET

Frank is pretty much a machine himself, so we have him teach us the basics of Machine Learning and how he's been using it in his own apps! Listen to see how you can get started in Machine Learning with C# and .NET!

Special Guest: Frank Krueger.

Sponsored By:

• Telerik: Capitalizing on the innate benefits of the native UI while exposing all objects and properties in C#, Telerik UI for Xamarin is a collection of Xamarin.Forms controls and Xamarin wrappers which offer fast loading, excellent drawing capabilities and pixel-perfection while providing “no-compromise” customization, flexibility and stunning UI. Telerik UI for Xamarin. .NET Tools for .NET Ninjas. Download a trial today! 

Links:

• Frank's Blog: Code Prediction with a Neural Network
• Frank's Blog: "Hotdog or Not" Using Azure Custom Vision, CoreML,...
• Frank's Podcast: Merge Conflict
• Continuous C# and F# IDE for iPads and iPhones
• Kaggle ML Competitions
• Book: Deep Learning with Python