110 episodes

All the latest in .NET Mobile & MAUI (formerly Xamarin) developer technologies, covering in-depth topics ranging from Android, iOS, macOS and Windows, to mobile marketing, design and more!

Gone Mobile Jonathan Dick, Allan Ritchie

    • Technology

All the latest in .NET Mobile & MAUI (formerly Xamarin) developer technologies, covering in-depth topics ranging from Android, iOS, macOS and Windows, to mobile marketing, design and more!

    Configuration & Logging

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

    • 58 min
    Tales from the Crypt

    Tales from the Crypt

    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

    • 1 hr 10 min
    Dependency Injection - Beyond the Basics

    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 SiegelDryIoc — DryIoc is fast, small, full-featured IoC Container for .NET

    • 1 hr
    Architecture Patterns

    Architecture Patterns

    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

    • 1 hr 8 min
    IoT and Small Devices

    IoT and Small Devices

    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

    • 1 hr 7 min
    Structuring Apps

    Structuring Apps

    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.

    • 1 hr 4 min

Top Podcasts In Technology

Bug Bounty Reports Discussed
Grzegorz Niedziela
Acquired
Ben Gilbert and David Rosenthal
Critical Thinking - Bug Bounty Podcast
Justin Gardner (Rhynorater) & Joel Margolis (teknogeek)
Lex Fridman Podcast
Lex Fridman
The Vergecast
The Verge
FT Tech Tonic
Financial Times

You Might Also Like

Merge Conflict
soundbite.fm
.NET Rocks!
Carl Franklin and Richard Campbell
The Modern .NET Show
Jamie Taylor
AppleInsider Podcast
AppleInsider
RunAs Radio
Richard Campbell
Pivot
New York Magazine