Gone Mobile

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

Links:

• Sentry IO
• Shiny.Extensions.Configuration — A configuration library that pulls appsettings json from Android assets & iOS bundles allowing for repackaging in white label solutions while still support the common configuration pattern
• YouTube Episode 111

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 conversation, Jon and Allan discuss the upcoming features in .NET 9 and Maui. They talk about the challenges faced during the development of Maui and the improvements made in the tooling. They also discuss the new C# language features, including collection expressions and the system threading lock type. They touch on the concept of workloads and the introduction of workload version sets to improve the stability and repeatability of builds. They also mention the new title bar customization feature in Maui. In this conversation, Jon and Allan discuss several topics related to .NET MAUI. They cover the customization of the title bar, the new disconnect handlers feature, the embedding of Maui code into native apps, the upcoming CollectionView handler 2, and the potential switch to using unpackaged templates for Windows. They also mention the importance of having an escape hatch when using external libraries and the benefits of the dev loop on Windows. They conclude by encouraging listeners to leave five-star reviews and recommending the Warp tool for Mac users.

Takeaways

• The development of Maui faced challenges, but improvements have been made in the tooling.
• New C# language features in .NET 9 include collection expressions and the system threading lock type.
• Workloads and workload version sets have been introduced to improve the stability and repeatability of builds.
• Maui now has a title bar customization feature for windows. The conversation highlights the importance of open and transparent communication in the development process. Customizing the title bar in .NET MAUI allows for the addition of various elements such as icons and menus.
• Disconnect handlers in .NET MAUI help manage memory leaks and provide control over when resources are released.
• The embedding feature in .NET MAUI allows developers to integrate Maui code into existing native apps.
• The upcoming CollectionView handler 2 in .NET MAUI will use newer APIs, improving performance and reducing complexity.
• There is a potential switch to using unpackaged templates for Windows in .NET MAUI, which would improve the development experience and deployment process.
• Having an escape hatch when using external libraries allows for flexibility and easier swapping of components.
• The dev loop on Windows is fast and efficient, making it a preferred platform for development.
• Leaving five-star reviews and recommending tools like the Warp tool for Mac users helps support the community and discover new resources.

People

• Hosts: Jon Dick, Allan Ritchie
• A/V Engineer: Jim Heath

Chapters

• 00:00 Introduction and Challenges in Maui Development
• 02:31 New C# Language Features in .NET 9
• 04:58 Workloads and Workload Version Sets
• 10:00 Title Bar Customization in Maui
• 14:20 Importance of Open and Transparent Communication
• 32:56 Customizing the Title Bar
• 39:30 Disconnect Handlers
• 43:35 Embedding Maui Code
• 49:05 CollectionView Handler 2
• 55:44 Switching to Unpackaged Templates for Windows
• 59:04 The Dev Loop on Windows
• 01:03:52 Having an Escape Hatch
• 01:05:56 Recommendation: The Warp Tool

Links:

• YouTube Episode 116

In this episode, Jon and Allan discuss various topics, including office renovations, phone migrations, and the use of mediator patterns in app development. They explore the concept of vertical slicing in architecture and the benefits of using a mediator to route messages. Allan shares his experience with mediator patterns in server architecture and highlights the need for a mediator pattern in app development. They also touch on the scalability of mediator patterns and the potential challenges of using them in certain scenarios. The conversation explores the concept of using a mediator pattern to handle services in an app. The mediator pattern allows for loose coupling and easier unit testing. It also simplifies the management of common services and reduces the need for multiple service injections. The conversation also touches on the use of events and requests with responses in the mediator pattern. The implementation of the mediator pattern in the context of a Maui app is discussed, including handling events and requests, offline mode, caching, and resiliency. In this conversation, Jon and Allan discuss the benefits and use cases of using MediatR in mobile app development. They explore the concept of middleware and how it can be used to handle various aspects of app functionality. They also discuss the challenges of finding and managing dependencies in a loosely coupled architecture. Allan introduces his MediatR library and explains how it simplifies the implementation of Mediator patterns in mobile apps. They also touch on topics like offline caching, resiliency, and event handling.

Takeaways

• Mediator patterns can be used to vertically slice business domains in app development.
• Mediators act as traffic cops, directing messages to the appropriate services.
• Mediator patterns can improve code organization and reduce the need for injecting multiple services.
• Using a mediator pattern can make testing and maintaining code easier.
• Mediator patterns may not be suitable for high-frequency messaging or performance-critical scenarios. The mediator pattern can be used to handle services in an app, providing loose coupling and easier unit testing.
• Using a mediator pattern simplifies the management of common services and reduces the need for multiple service injections.
• Events and requests with responses are key components of the mediator pattern.
• The mediator pattern can be implemented in a Maui app to handle events and requests, enable offline mode, caching, and resiliency.
• Attributes can be used to customize the behavior of the mediator pattern, such as handling offline mode, caching, and user notifications. MediatR is a powerful library that simplifies the implementation of Mediator patterns in mobile app development.
• Middleware can be used to handle various aspects of app functionality, such as offline caching, resiliency, and event handling.
• Loosely coupled architectures can be challenging to manage, but tools like MediatR can help alleviate some of the complexity.
• Finding and managing dependencies in a messaging-based architecture can be difficult, but there are strategies like namespacing and code navigation that can help.
• MediatR provides a flexible and extensible solution for handling requests and events in mobile apps.

People

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

Chapters

• 00:00 Introduction and Office Renovations
• 09:07 Phone Migrations and Mediator Patterns
• 14:21 Understanding Mediator Patterns
• 17:13 Challenges of Scaling Mediator Patterns
• 23:04 Implementing the Mediator Pattern in a Maui App
• 27:59 Enabling Offline Mode, Caching, and Resiliency
• 41:42 Source Generation and Runtime Lookup
• 43:24 Replay: Handling Async Enumerables
• 46:04 Mediator as a Stepping Stone
• 48:26 Removing Attributes and Changing Behavior
• 52:05 Improving Developer Experience
• 55:11 Using Essentials API for Main Thread Handling
• 57:20 Offline Caching with MediatR
• 01:00:18 Using Middleware for Request Handling
• 01:02:34 Considering Dependencies and Library Usage

Links:

• Shiny Mediator — A Mediator for your .NET Apps with some of the most awesome middleware around
• MediatR — Simple, unambitious mediator implementation in .NET
• YouTube Episode 118

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