Gone Mobile

99: Architecting Plugins and Frameworks

March 22nd, 2024

In this episode, Jon and Allan discuss various topics related to creating and maintaining libraries and NuGet packages. They talk about their experiences with plugin libraries and the importance of supporting open source developers. They also touch on the challenges of avoiding vendor and framework lock-in. Overall, the conversation highlights the value of community-driven development and the need for collaboration and appreciation in the open source world. The conversation explores the process of creating libraries and plugins for cross-platform development. It delves into the challenges of balancing dependencies and code size, as well as the evolution of library development over time. The role of Microsoft Extensions and dependency injection in library development is also discussed. The conversation concludes with a discussion on the improvements in Maui and the use of Microsoft Extensions and DI in the framework. This part of the conversation explores the importance of familiar patterns and dependency injection in Xamarin development. It discusses the trade-off between performance and app size, as well as the challenges of implementing dependency injection in Xamarin.Forms. The conversation also touches on the growth of plugins in the Xamarin ecosystem and the controversy surrounding Reactive Extensions (RX). The creation of Xamarin Essentials and its goal of pleasing the majority of developers is highlighted, along with the focus on testability in Shiny. The chapter concludes with a discussion on the trade-off between performance and interfaces. In this conversation, Jon and Allan discuss various topics related to open source development, including generating interfaces and wrappers, elevating to platform API level, simplifying abstractions, creating custom implementations, using files and folders for caching, managing GitHub repos and libraries, forking and cloning repos, cleaning repos and business continuity, and appreciating open source contributors.


  • Support open source developers and be kind to them.
  • Avoid vendor and framework lock-in by creating your own libraries and packages.
  • Collaboration and community-driven development are essential in the open source world.
  • Maintaining and updating libraries and plugins requires ongoing effort and dedication.
  • Creating libraries and plugins for cross-platform development requires careful consideration of dependencies and code size.
  • The evolution of library development has led to a more streamlined and accessible process.
  • Microsoft Extensions and dependency injection play a significant role in library development.
  • Maui offers improvements in lifecycle management and the use of Microsoft Extensions and DI. Familiar patterns and dependency injection provide comfort and ease of use for Xamarin developers.
  • Balancing performance and app size is a challenge in mobile development.
  • Plugins play a significant role in extending the functionality of Xamarin applications.
  • Xamarin Essentials aims to provide essential functionality out of the box for Xamarin developers.
  • Testability is an important consideration in the design of Xamarin libraries. Consider generating interfaces and wrappers to simplify the usage of platform APIs.
  • Elevate your code to the platform API level and avoid unnecessary abstractions.
  • When creating custom implementations, focus on the core business logic and avoid abstracting unnecessary details.
  • Use files and folders for caching data, as it can be a simple and effective solution.
  • When managing GitHub repos and libraries, consider using a template for consistent setup.
  • Clone and fork repos to ensure business continuity and avoid dependencies on external sources.
  • Appreciate and support open source contributors by providing constructive feedback and contributing back to the community.


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


  • 00:00 Introduction and Episode 100
  • 00:21 Discussion about Dad Shoes
  • 01:37 Number of Episodes Together
  • 03:03 Discussion about Plugin Libraries
  • 03:45 Continued Support for Native Libraries
  • 04:08 MVVM Cross and Native App Code
  • 05:13 Be Nice to Open Source Developers
  • 06:05 Creating Libraries and NuGet Packages
  • 07:15 MVVM Cross Plugin Ecosystem
  • 07:27 Avoiding Vendor Lock-in
  • 08:01 Discussion about Framework Lock-in
  • 08:38 Creating the Push Notification App
  • 11:53 Building Libraries and Plugins
  • 14:02 The Evolution of Library Development
  • 16:09 Approaching Cross-Platform Development
  • 19:04 Balancing Dependencies and Code Size
  • 22:36 The Role of Microsoft Extensions
  • 29:10 Improvements in Maui
  • 31:59 Using Microsoft Extensions and DI
  • 32:36 Comfortable Patterns and Familiarity
  • 33:11 The Importance of Dependency Injection
  • 33:40 Balancing Performance and App Size
  • 35:09 The Need for Infrastructure and Rapid Application Development
  • 35:38 The Challenges of Dependency Injection in Xamarin.Forms
  • 36:59 The Trade-off Between Startup Time and Competitiveness
  • 37:55 The Importance of Simple and Easy-to-Use Plugins
  • 38:48 The Benefits of Boilerplate Code in Maui
  • 40:06 The Growth of Plugins in the Xamarin Ecosystem
  • 40:55 The Term 'Plugin' and its Usage
  • 41:53 The Xamarin Component Store
  • 42:47 The Challenges of Selling Components
  • 44:41 Starting with the Interface and Adapting to Platforms
  • 46:47 Designing for Simplicity and Usefulness
  • 48:05 The Controversy of Reactive Extensions (RX)
  • 48:44 The Origins of Xamarin Essentials
  • 51:42 The Goal of Xamarin Essentials: Pleasing the Majority
  • 53:59 The Original Code Name for Xamarin Essentials
  • 55:06 The Focus on Testability in Shiny
  • 55:42 The Trade-off Between Performance and Interfaces
  • 56:31 Generating Interfaces and Wrappers
  • 56:47 Elevating to Platform API Level
  • 57:46 Simplifying Abstractions
  • 58:46 Creating Custom Implementations
  • 59:42 Wrapping Essentials Interfaces
  • 01:00:57 Using Files and Folders for Caching
  • 01:03:57 Managing GitHub Repos and Libraries
  • 01:05:14 Template for Repo Setup
  • 01:05:44 Forking and Cloning Repos
  • 01:07:07 Cleaning Repos and Business Continuity
  • 01:08:14 Supporting Open Source Projects
  • 01:12:21 Appreciating Open Source Contributors

Episode Comments