110: Tales from the Crypt

06/14/24 • 70 min

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:

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:

Previous Episode

109: Dependency Injection - Beyond the Basics

The conversation delves into the topic of dependency injection (DI) and its evolution over the years. It covers the history of DI, different DI libraries, considerations for mobile development, and the future of DI with source generation. The discussion also touches on performance optimizations and the impact of DI on app startup time. The conversation covers topics related to dependency injection, scoping mechanisms, and the challenges of managing scopes in Maui apps. It also delves into the use of Prism and the need for out-of-the-box conventions for handling life cycles and navigation services in Maui. The conversation covers a deep dive into dependency injection, scope boundaries, and the challenges of managing dependencies in the context of mobile app development. It also delves into the nuances of using different DI containers and the impact on app performance. The hosts share their experiences, insights, and recommendations for handling these complexities effectively.

Takeaways

Dependency injection has evolved over the years and has become a crucial part of app development, especially in the mobile space.
Different DI libraries have their own strengths and considerations, and the choice of library depends on the specific use case and performance requirements.
The future of DI may involve source generation, which could lead to significant improvements in performance and reduce complexity in the registration process.
Considerations for mobile development include the impact of DI on app startup time and the need for performance optimizations.
Property injection and constructor injection are both relevant approaches in DI, and the choice between them depends on the specific requirements of the application. Understanding the challenges of managing scopes in Maui apps
The need for out-of-the-box conventions for handling life cycles and navigation services in Maui
Insights into the use of Prism and its impact on dependency injection in Maui apps Understanding scope boundaries is crucial for effective dependency injection in mobile app development.
Choosing the right DI container can significantly impact app performance and memory management.
Managing dependencies and understanding scope lifetimes is essential for avoiding memory leaks and performance issues in mobile apps.

People

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

Chapter

00:00 The Evolution of Dependency Injection
07:18 Considerations for Mobile Development
13:47 The Future of Dependency Injection
23:23 Understanding Scoping Mechanisms and Life Cycles
26:34 The Need for Out-of-the-Box Conventions in Maui
29:04 Dependency Injection and Prism in Maui Apps
41:28 Understanding Scope Boundaries in Dependency Injection
43:21 Common Misconceptions about Dependency Injection
45:23 Impact of Dependency Injection in Prism and Maui Apps
47:11 Debugging and Validation in Dependency Injection
53:45 Audio Quality and Listener Engagement

Links:

.NET MAUI Micro MVVM — A small MVVM framework with navigation services & lifecycle built around .NET MAUI Shell by the great Dan Siegel
DryIoc — DryIoc is fast, small, full-featured IoC Container for .NET

Next Episode

111: Configuration & Logging

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