Gone Mobile Jonathan Dick, Allan Ritchie

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

In this conversation, Jon and Allan discuss various topics related to architecture and performance in mobile app development. They touch on the challenges of implementing the MVVM pattern and the potential for excessive property changed notifications. They also discuss the use of observable collections and the importance of using them only when necessary. Additionally, they express their dislike for messaging services and suggest using events or actions instead. Overall, the conversation emphasizes the need for thoughtful architecture and optimization in mobile app development. The conversation explores the use of mediator pattern in mobile and app development. The mediator pattern is seen as a solution to prevent service overrun and to provide logical separation in the app. It allows for vertical slicing of concerns and prevents the need for injecting multiple services. The conversation also discusses the challenges of messaging services and the benefits of using a mediator pattern in terms of scalability, error handling, and unit testing. The potential application of the mediator pattern in Xamarin and .NET Maui apps is explored. In this conversation, Allan and Jon discuss the concept of using a mediator pattern in mobile app development. They explore the benefits of using a mediator to handle communication between different components of an app, such as view models and services. They also discuss existing implementations of the mediator pattern, such as MediatR, and potential future developments in this area. Overall, they highlight the potential value of using a mediator pattern in mobile app architecture.


Takeaways


Implementing the MVVM pattern can lead to excessive property changed notifications, which may impact performance.
Observable collections should be used only when data is constantly changing, such as in real-time applications.
Consider using events or actions instead of messaging services for better control and clarity in event handling.
Thoughtful architecture and optimization are crucial for improving performance in mobile app development. The mediator pattern can be a solution to prevent service overrun and provide logical separation in mobile and app development.
Using a mediator pattern allows for vertical slicing of concerns and prevents the need for injecting multiple services.
The mediator pattern offers benefits such as scalability, error handling, and ease of unit testing.
The potential application of the mediator pattern in Xamarin and .NET Maui apps is worth exploring. The mediator pattern can be a valuable tool for handling communication between different components of a mobile app.
Using a mediator can simplify unit testing by allowing developers to focus on testing individual components rather than the entire app.
Existing implementations of the mediator pattern, such as MediatR, can provide a solid foundation for incorporating this pattern into mobile app development.
The mediator pattern can help clean up code and improve the organization and separation of concerns in mobile app architecture.


People


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


Chapters


00:00 Introduction and Personal Updates
03:00 Challenges of Implementing the MVVM Pattern
09:04 Optimizing the Use of Observable Collections
14:57 Avoiding Excessive Messaging Services
22:18 Challenges with Messaging Services
24:02 Exploring the Mediator Pattern
27:07 The Role of Mediators in Routing
30:17 Separation of Concerns and Dependency Injection
33:30 Handling Events in Temporary View Models
36:00 Benefits of the Mediator Pattern
40:08 Scaling and Breaking Down Hotspots
44:20 Command Handlers and Mediator Interaction
46:27 Focusing on the Action with Mediators
49:28 Simplifying Unit Testing with a Mediator
52:17 Existing Implementations of the Mediator Pattern
55:11 Handling Unsolicited Notifications with a Mediator
57:24 Mediator Libraries and Best Practices
01:00:57 Challenges and Considerations for Mediator Im

In this conversation, Jonathan discusses his experience with building automation control systems for his swimming pool using microcontrollers and IoT devices. He talks about controlling the pool temperature, pool pumps, and a saltwater generator. He also explores the challenges and considerations of using different microcontrollers, such as the ESP8266 and the Meadow board, which runs .NET. Jonathan shares his passion for building IoT projects and the potential for using favorite programming languages in these environments. The conversation covers various topics related to IoT platforms, including the evolution of hardware into software-as-a-service (SaaS) platforms, the expansion of Meadow's ecosystem, the integration of Raspberry Pi with Meadow, the challenges of running web servers on microcontrollers, and personal projects involving IoT devices. The conversation also touches on the use of Meadow in pool automation and coffee brewing, as well as the ingenuity of building custom solutions using sensors and Raspberry Pi.


Takeaways


Building automation control systems for swimming pools using microcontrollers and IoT devices is a fascinating and practical application of technology.
Controlling the pool temperature, pool pumps, and other aspects of pool maintenance can be automated using microcontrollers and relays.
Different microcontrollers, such as the ESP8266 and the Meadow board, offer various capabilities and programming options for building IoT projects.
The Meadow board, which runs .NET, provides a more familiar programming environment for developers and offers the potential for using favorite programming languages in IoT - projects. IoT platforms often evolve from hardware devices to full-fledged software-as-a-service (SaaS) platforms.
Meadow is building an ecosystem around its platform, expanding its libraries and compatibility with devices like Raspberry Pi.
Running web servers on microcontrollers like Meadow can be challenging, but Meadow provides solutions like BLE servers and basic web server functionality.
Personal projects involving IoT devices can range from pool automation to coffee brewing, and can be built using sensors and Raspberry Pi.
Building custom solutions using sensors and Raspberry Pi can be a creative and practical way to solve real-world problems.


People


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


Chapters


00:00 Introduction and Background
02:26 Interest in IoT and Microcontrollers
03:50 Comparing IoT to Early Xamarin Days
08:11 Controlling Pool Temperature with Microcontrollers
09:37 Automating Pool Pumps and Saltwater Generator
28:27 Exploring the Meadow Board and .NET in IoT
33:19 The Evolution of IoT Platforms
34:41 Building an Ecosystem and Extending Compatibility
35:10 Challenges of Running Web Servers on Microcontrollers
39:23 Personal Projects: Pool Automation and Coffee Brewing
52:59 Meadow Desktop: Coding Against APIs and Simulating Graphics
01:03:38 Building Custom Solutions with Sensors and Raspberry Pi
Links:
Meadow Desktop

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
Links:
Refit — The automatic type-safe REST libraryRefitter — Refitter is a tool for generating a C# REST API Client using the Refit library. Refitter can generate the Refit interface and contracts from OpenAPI specifications.

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
Links:
Sharpnado CollectionView