Takeaways

• Listener feedback is crucial for app development.
• AI tools can enhance coding but require understanding.
• Staying updated with iOS and Xcode is essential for developers.
• Maui and .NET updates bring new features and improvements.
• Creating a snack app can be a fun personal project.
• Cross-platform button development presents unique challenges.
• Documentation is key for using libraries effectively.
• Unit testing is important for ensuring code quality.
• Engaging with listeners can lead to interesting discussions.
• Future content may include coding demonstrations.

People

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

Chapters

• 00:00 Sports and Team Loyalty
• 02:57 Listener Feedback and App Development
• 06:02 The Role of AI in Coding
• 08:58 Using ChatGPT and Copilot Effectively
• 11:58 Navigating iOS and Xcode Updates
• 15:04 Exploring New Features in iPhone 16
• 17:58 Maui and .NET Updates
• 20:55 Understanding Workload Management in .NET
• 24:03 The Importance of Staying Updated
• 27:02 Building a Snack App for Disney World
• 30:05 Creating a Content Button in Maui
• 32:48 Final Thoughts and Future Plans

YouTube

YouTube: https://youtu.be/f9rAV9lW9tk

Links:

• YouTube

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

YouTube: https://youtu.be/cI0vf--ZQqY

Takeaways

• In-app purchases have evolved from one-time consumables to recurring subscriptions, allowing developers to generate continuous revenue.
• App stores like Apple and Google take a percentage cut from in-app purchases, which can impact the profitability of developers.
• Implementing in-app purchases involves dealing with complex APIs, handling subscription renewals, and validating transactions.
• Testing in-app purchases is crucial to ensure a seamless user experience and avoid revenue loss.
• The APIs and implementation details for in-app purchases differ between iOS and Android, with each platform having its own challenges and limitations. Existing payment processors for mobile apps, such as Apple's StoreKit and Google's Play Billing, can be complex and inflexible to work with.
• Implementing and maintaining payment functionality, including handling subscriptions, refunds, and transaction states, can be time-consuming and challenging for developers.
• RevenueCat is a potential solution that abstracts away the complexities of payment processing and provides a more streamlined experience for developers.
• Having a backend service like RevenueCat handle payment processing can free up developers to focus on providing value to their users.
• Simplifying the payment process and providing clear documentation and examples can greatly improve the developer experience. Implementing in-app purchases can be challenging and frustrating
• App stores have complex rules and limitations for in-app purchases
• Subscription management and revenue cat can help simplify the process
• Handling transactions and storing subscription data require careful consideration

People

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

Chapters

• 00:00 Introduction and Background
• 03:05 The Evolution of In-App Purchases
• 05:57 Implementing In-App Purchases: Challenges and Complexity
• 10:00 The Importance of Proper Testing
• 12:57 Differences in iOS and Android In-App Purchase APIs
• 24:58 The Complexity of Payment Processors
• 27:15 The Cost of Subscription Business
• 29:11 The Complexity of API Configuration
• 34:03 RevenueCat: Abstracting Payment Processing
• 36:09 Simplifying the Developer Experience
• 44:31 The Challenges of Implementing In-App Purchases
• 50:01 Simplifying Subscription Management with Revenue Cat
• 52:39 Handling Transactions and Storing Subscription Data

Links:

• James Montemagno's In-App Billing Plugin
• YouTube Episode 119

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

Takeaways

• Limited connectivity is still a common issue in remote areas, even with advancements in technology.
• Offline functionality in apps is crucial for users who frequently find themselves without internet access.
• GPS technology has come a long way, but some older devices still struggle with accuracy and reliability.
• Map providers like Google and Apple lack robust APIs for developers to easily implement offline maps in their apps. There are several map providers available, including ArcGIS, Google Maps, Apple Maps, Mapbox, and OpenStreetMap.
• Offline map capabilities are important for areas with limited internet coverage or for applications that require offline access to maps.
• Mapbox offers its own map tiles and also allows users to plug in different tile providers.
• OpenStreetMap is a community-driven project that provides up-to-date map data.
• Tesla cars use a combination of OpenStreetMap data and vision-based systems for features like speed limits.
• SVGs can be challenging to render and are not always suitable for offline use. Bluetooth Low Energy (BLE) can be used for offline communication, such as sending messages and images.
• Location technologies like GPS and LTE have limitations in terms of accuracy and availability.
• Ultra-wideband and other technologies are being explored for more precise location tracking.
• The nearby API by Google and the Estimote beacons are examples of technologies that enable proximity-based communication. Designing apps to work offline is important for scenarios where there is no internet connection.
• Bluetooth 5 can be used for data transfer even when the internet is unavailable.
• Range requests in HTTP can be used to resume interrupted uploads.
• Slow internet connections and the use of download managers were common challenges in the past.
• Consider using Bluetooth for offline communication and file transfers in IoT devices.

People

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

Chapters

• 00:00 Introduction and Discussion on Limited Connectivity
• 02:59 The Evolution of GPS Technology
• 08:00 Challenges with Offline Apps and Mapping
• 20:44 Exploring Different Map Providers
• 25:12 Mapbox Bindings and SVG Challenges
• 33:22 Importance of Internet on a Plane
• 36:02 Using Bluetooth Low Energy for Communication
• 39:00 Building a BLE Chat App for Offline Communication
• 41:23 Limitations of Location Technologies
• 44:37 Designing Apps for Offline Functionality
• 46:21 Resuming Interrupted Uploads with Range Requests
• 57:42 Challenges of Slow Internet Connections
• 01:03:01 Using Bluetooth for Offline Communication in IoT Devices

Links:

• YouTube Episode 117

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

Takeaways

• AI can be applied to improve the coffee-making process, leading to better quality and automation.
• AI has made significant advancements in image recognition and document intelligence, enabling the extraction of data from various sources.
• Training AI models for specific tasks, such as forms recognition and credit card scanning, can greatly enhance data processing and automation.
• Image resolution and optimization are crucial factors in achieving accurate results with AI models.
• The potential for on-device AI models offers benefits such as reduced bandwidth usage and improved energy efficiency. On-device barcode scanning is available through Azure Vision and Firebase ML.
• Azure Document Intelligence SDK works well in Maui apps and can be used for tasks like credit card scanning.
• AI can be used to automate documentation writing and make it sound more professional.
• AI can help identify duplicate issues and provide relevant suggestions on GitHub.
• AI language models like ChatGPT can be used to generate code samples and improve productivity.
• AI language models can also be used for multilingual apps and translation tasks.
• Roslyn analyzers can be used to analyze and provide suggestions for code quality and best practices. Source generators can be a powerful tool for generating code and fixing issues, but they require a good understanding of the underlying syntax and tree structure.
• AI can be used in various domains, such as creating assistants and analyzing data, but it's important to consider the potential liabilities and ensure accurate results.
• New barcode scanning packages for Maui, such as 'barcode-mobile.Maui' and 'barcode-scanning.native.Maui', provide improved functionality and integration with Apple Vision and AndroidX.
• Understanding the limitations and potential costs of AI systems is crucial for effective implementation and user satisfaction.
• Reflecting on past experiences with native packages, such as ACR Dialogues and HUD, highlights the longevity and continued use of certain libraries in the development community.

People

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

Chapters

• 00:00 The Quest for the Perfect Cup of Coffee: AI-Powered Coffee Machines
• 03:21 Advancements in Image Recognition and Document Intelligence with AI
• 07:37 Automating Data Extraction with AI: Forms Recognition and Credit Card Scanning
• 11:52 Optimizing Image Resolution for Accurate AI Results
• 18:12 The Potential of On-Device AI Models: Efficiency and Convenience
• 20:40 On-Device Barcode Scanning
• 24:08 Azure Document Intelligence and Maui Apps
• 26:11 Automating Documentation Writing
• 37:14 AI-Powered Issue Management on GitHub
• 40:08 AI for Multilingual Apps and Translation Tasks
• 42:42 Using Roslyn Analyzers for Code Quality
• 42:51 Introduction
• 43:00 Challenges and Benefits of Source Generators
• 43:29 Applying AI in Various Domains
• 44:29 Creating Analyzers and Code Fixers
• 45:34 New Barcode Scanning Packages for Maui
• 46:21 Exploring Font Scaling and Modifiers
• 48:09 Understanding the Limitations and Liabilities of AI Systems
• 51:48 AI in Motion Detection and Trail Cameras
• 52:41 Using OpenAI Library for Creating Assistants
• 56:54 Reflecting on Past Experiences with Native Packages
• 01:02:01 New Barcode Scanning Packages for Maui
• 01:03:22 Long Live Barcode Scanning
• 01:06:04 Conclusion

Links:

• Barcode Scanning Native (MAUI)
• Barcode Scanner Mobile
• YouTube Episode 115
• YouTube Episode 114

Takeaways

• Backend development in ASP.NET Core involves using API controllers and IActionResult.
• OpenAPI is a useful tool for generating contracts and defining API endpoints.
• Tools like Kyoto and Refit/Refitter can be used to generate contracts and API clients.
• The conversation highlights the importance of keeping up with changes in backend development tools and practices. Refit is a tool for generating code to consume APIs
• Resiliency is a client-side concern and can be handled with tools like Polly
• GraphQL and OData are compared in terms of their usefulness and complexity
• The Mediator pattern is a way to structure code and facilitate future scalability
• Real-time communication with SignalR is challenging for mobile apps Real-time data streaming methods vary and depend on the specific use case and requirements.
• Docker is a useful tool for creating consistent development and deployment environments.
• Different SQL databases have their own strengths and weaknesses, and the choice depends on the specific needs of the project.
• Proper database design and optimization are crucial for efficient and scalable applications. Postgres SQL is a reliable and fast database option with excellent driver support in .NET
• Backend-as-a-service platforms like Firebase and Apprite offer a comprehensive set of tools and infrastructure for building apps
• Managing costs and scalability in cloud services can be challenging, but it's important to find the right balance
• Consider leaving a five-star review for the podcast to show support and provide feedback

People

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

Chapters

• 00:00 Introduction and Canadian Stereotypes
• 04:42 Exploring Backend Development
• 09:03 Streaming Results and OpenAI
• 13:52 Generating Contracts with Kyoto and Refit/Refitter
• 19:46 The Future of Backend Development
• 27:19 Comparing GraphQL and OData
• 32:59 Understanding the Mediator pattern
• 43:11 Real-time communication challenges with SignalR
• 45:06 Real-Time Data Streaming
• 48:36 Docker for Development and Deployment
• 55:46 Experiences with SQL Databases
• 01:09:28 Importance of Database Design and Optimization
• 01:19:13 Challenges of Managing Costs and Scalability in Cloud Services
• 01:30:54 Don't Forget to Leave a Five-Star Review

Links:

• MediatR
• GraphQL .NET
• ChilliCream (GraphQL)

Takeaways

• There are different approaches to implementing controls in mobile app development, including drawn controls and native controls.
• The choice between drawn controls and native controls depends on the specific requirements and goals of the app.
• A hybrid approach, combining drawn controls and native controls, can provide a balance between customization and platform conformity.
• Challenges in implementing drawn controls include scrolling, text entry, and performance optimization.
• Considerations for choosing between drawn controls and native controls include design consistency, resource management, and system integration. Drawing controls in cross-platform development can be challenging due to differences in rendering text and achieving platform-specific looks.
• MAUI offers the option to draw controls using native drawing surfaces or SkiaSharp, providing flexibility and consistency across platforms.
• Accessibility and sizing considerations are important when drawing controls, as they may require additional code to ensure proper functionality.
• Drawing controls can simplify unit testing and improve scalability by reducing the need for maintaining abstractions over native controls.
• The availability of drawing controls in MAUI opens up possibilities for easier customization and design flexibility. Using cross-platform code for drawing controls can be challenging and may require additional considerations, such as accessibility APIs on each platform.
• There is value in using libraries like Syncfusion for existing investments and documentation, but there may be limitations and complaints about library size.
• Creating custom layouts can be a solution for complex UI requirements and can be achieved by measuring and laying out elements.
• Libraries like AlohaKit and DrawnUI offer options for building visually appealing UIs with customizable controls and layouts.

People

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

Chapters

• 00:00 Introduction and Inside Joke
• 01:13 Topic Introduction: Drawn Controls
• 07:13 Design Consistency vs. Platform Conformity
• 13:35 Text Entry and Customization
• 22:26 Scrolling and Performance Optimization
• 25:48 Challenges and Considerations of Drawing Controls
• 27:33 The Availability of Drawing Controls in MAUI
• 29:09 Accessibility and Sizing Implications of Drawing Controls
• 31:17 Simplifying Unit Testing and Improving Scalability with Drawing Controls
• 47:52 Introduction
• 48:04 Challenges and Considerations of Cross-Platform Code for Drawing Controls
• 48:59 The Value Proposition of Using Libraries like Syncfusion
• 54:18 Exploring Custom Layouts for Complex UI Requirements
• 01:00:08 Building Visually Appealing UIs with AlohaKit and DrawnUI
• 01:08:07 Conclusion

Links:

• YouTube Episide 113

Takeaways

• Visual Studio and Visual Studio for Mac are popular IDEs for development
• Insomnia is a useful tool for API testing
• DevTools is great for debugging
• Choosing the right operating system and monitor can greatly enhance the development experience
• Having a good set of tools can improve productivity and efficiency Antivirus software can sometimes cause issues with certain tools and applications.
• DevToys is a useful tool for various tasks like encoding/decoding strings and testing Xpath queries.
• Setapp is a subscription service that provides access to a wide range of tools and apps for Mac users.
• Forklift is a file browser and development toolkit for Mac.
• Total Commander is a file manager that offers a dual-pane interface and other advanced features.
• Using a proper coffee grinder, like a burr grinder, can result in a better coffee brewing experience.
• Chemex is a popular coffee brewing method that requires a specific type of kettle and filters.
• The choice of tools can greatly impact productivity and user experience in software development. There are various soft tools and libraries that developers can use to enhance their development workflows.
• Choosing the right tools and libraries depends on the specific needs and requirements of the project.
• Some popular soft tools and libraries mentioned in the conversation include MVVM Toolkit, .NET Orleans, and MediatorR.
• The Shiny Templates collection provides a wide range of templates for Xamarin and Maui apps.
• Experimenting with different tools and libraries can help developers find the ones that work best for them.

People

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

Chapters

• 00:00 Introduction and Canadian Jokes
• 02:32 Exploring the Tools We Use for Development
• 09:17 Using Visual Studio and Rider for Development
• 13:07 Testing APIs with Insomnia
• 16:22 The Importance of a Good Monitor
• 21:07 Other Useful Tools for Development
• 22:30 Antivirus Software and Compatibility Issues
• 23:35 DevToys: A Handy Tool for Various Tasks
• 24:23 Setapp: A Subscription Service for Mac Users
• 25:24 Forklift: A File Browser and Development Toolkit for Mac
• 26:09 Total Commander: A Feature-Rich File Manager
• 29:30 Docker: Simplifying Development and Deployment
• 30:19 Kubernetes: A Powerful Container Orchestration Platform
• 31:33 Cosmos DB: Offline Development Challenges
• 33:19 PostgreSQL: A Versatile and Feature-Rich Database
• 36:16 Parallels: Efficient Virtualization for Mac
• 38:12 The Importance of a Proper Coffee Grinder
• 39:39 Brewing Coffee with Chemex: A Unique Experience
• 42:15 The Impact of Tools on Productivity and User Experience
• 43:21 The Shower Method of Making Coffee
• 45:36 Soft Tools for Podcasting
• 48:19 Microphones and Audio Equipment
• 49:22 Standing Desks and Key Lights
• 52:18 Soft Tools for Mobile App Development
• 55:49 MVVM Toolkit and .NET Orleans
• 58:11 Shiny Templates for Xamarin and Maui Apps
• 01:00:53 MediatorR for Modular Monoliths

Links:

• YouTube Episode 112

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

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

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

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 Implementation
• 01:03:49 Future Developments and Feedback

Links:

• MAUI Reactor
• Rearch

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

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 library
• Refitter — 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.

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

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

Takeaways

• Offline data syncing in mobile app development can be challenging and requires careful consideration of business needs.
• Choosing the right technology for offline data storage and syncing is crucial for performance and scalability.
• Handling deletes, updates, conflicts, and data security are important aspects of offline data syncing.
• Simplifying the data model and using simple record types can make offline data syncing easier to implement and maintain.
• Avoid over-engineering solutions and focus on meeting the specific needs of the business. Offline functionality in mobile apps requires careful consideration and handling of data synchronization.
• Handling 'end scars' is crucial, ensuring that child data is properly managed when parent data is modified or deleted.
• Providing clear feedback to users about offline status and data synchronization is essential for a good user experience.
• Using frameworks and abstractions for offline sync may have limitations and can lead to loss of control over data management.
• SQLite is a reliable and widely-used option for local offline storage, with the added benefit of JSON support for flexible data storage. Optimizing app startup time is crucial, and SQLite can be a bottleneck in this process.
• Using SQL and libraries like SQLite-PCL-NET can provide more control and flexibility in working with databases.
• Offline functionality and device-to-device communication are important considerations in mobile app development.
• The challenges of offline functionality in airplane environments include limited connectivity options and the need for peer-to-peer networks.
• The SQLite raw library, maintained by Eric Sink, is a foundational piece for many SQLite-based solutions and enables advanced features like geolocation.

People

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

Chapters

• 00:00 Introduction and Setting the Stage
• 01:43 Offline Battle Tactics and Scars
• 08:14 Challenges with Realm and Login Service
• 14:17 Avoiding Over-Engineering and Building Dependencies
• 25:15 Simplifying the Data Model for Easier Syncing
• 27:04 Conclusion and Key Takeaways
• 27:34 Managing 'End Scars' in Data Synchronization
• 29:23 Importance of Clear Feedback in Offline Scenarios
• 32:30 Benefits of Using SQLite for Local Offline Storage
• 37:28 Limitations of Frameworks for Offline Sync
• 48:57 Optimizing App Startup Time and the Role of SQLite
• 50:47 The Benefits of Using SQL and SQLite-PCL-NET
• 51:20 Offline Functionality and Device-to-Device Communication
• 52:21 Challenges of Offline Functionality in Airplane Environments
• 55:18 The Importance of the SQLite Raw Library and Advanced Features

Links:

• SQLite Raw

Takeaways

• MSBuild is a powerful tool for managing project files and building applications.
• SDK style projects provide a more streamlined and approachable format for project files.
• CS Proj files can be customized to include platform-specific assets and configurations.
• Using CS Proj for managing NuGet packages and CI can simplify the development process.
• Workloads in MSBuild provide a way to manage and organize project dependencies and configurations. MSBuild is a powerful build system that allows for customization and automation of the build process.
• Importing MSBuild from NuGet packages provides an easier way to test nightly builds and service releases.
• Customizing build props and targets allows for fine-grained control over the build process and the inclusion of specific assets.
• Writing custom MSBuild tasks in C# can be a powerful way to extend the build system and perform complex build operations.
• Using custom tasks and source generators can enhance the build process and improve performance.
• Mikayla's MSBuild Editor Extension provides helpful features like IntelliSense and package version management for CSProj files.

People

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

Chapters

• 00:00 Introduction and Weather
• 00:20 Introduction to MSBuild
• 01:12 Acquiring Taste for MSBuild
• 03:17 Slim CS Proj
• 04:03 Structure of New Project Files
• 05:12 Default Maui Project Template
• 06:36 Using CS Proj for NuGet Packages
• 07:56 Benefits of Using CS Proj for CI
• 08:26 Customizing Project Files for Platform-Specific Assets
• 09:53 Leveraging MSBuild for Customization
• 10:57 Command Line vs. CS Proj
• 11:33 Importing Files and Directory Build Props
• 12:37 Multiple SDK Imports
• 13:15 Properties and Item Groups in Project Files
• 14:05 Conditions in Project Files
• 19:48 Rationale for Different SDKs
• 22:19 Directory Build Props for Performance
• 24:07 Workloads and SDK Imports
• 26:17 Future of Workloads
• 29:08 Challenges with Workloads
• 31:09 MSBuild and Workloads
• 32:03 Importing MSBuild from NuGet Packages
• 33:12 Custom Entitlements and Build Props
• 34:09 Building Custom Entitlements
• 36:29 Adding Items to Build from NuGet Packages
• 37:38 Automatically Making Apps Work with Libraries
• 38:36 Customizing Build Props and Targets
• 39:40 Doing Build-Related Tasks in MSBuild
• 42:10 Writing Custom MSBuild Tasks
• 44:23 Using Custom Tasks and Source Generators
• 46:19 Incremental Source Generation
• 49:46 Michaela's MSBuild Editor Extension
• 56:19 Getting Started with MSBuild

Links:

• MSBuild Editor for Visual Studio

Takeaways

• Slim bindings offer a more focused and simplified approach to working with complex controls and APIs.
• Creating slim bindings requires a deep understanding of the API being consumed and the ability to map it to the target language.
• Full bindings can be challenging to update, especially when there are major changes between versions of the API.
• Dependency management can be complex, and colliding dependencies can cause issues in the binding process.
• The goal is to make binding generation repeatable and provide patterns and examples for popular libraries to simplify the process for developers. Swift interop with .NET is being actively worked on, making it easier to generate bindings and interop code.
• Android bindings can be easier than iOS bindings, but Kotlin and generics present challenges.
• AndroidX library and dependency management can be complex, but slim bindings can simplify the process.
• Binding at the bytecode level in Kotlin can be tricky, but slim bindings provide a workaround.
• Community efforts are underway to create and maintain bindings for various libraries and frameworks.
• Slim bindings offer a focused and simplified approach to binding native libraries.

People

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

Chapters

• 00:00 Introduction and Setting the Stage
• 02:25 Understanding Slim Bindings
• 04:15 Working on Firebase Bindings
• 06:16 Challenges with Package Managers
• 09:12 Creating Slim Bindings for Complex Controls
• 11:40 The Difficulty of Updating Full Bindings
• 14:27 The Value of Slim Bindings
• 19:06 The Role of Sharpie in Binding Generation
• 21:14 Making Binding Generation Repeatable
• 22:42 Avoiding Duplicated Dependencies
• 24:21 Challenges with Dependency Management
• 25:17 Dealing with Colliding Dependencies
• 25:44 Swift Interop with .NET
• 28:10 Android and Kotlin Bindings
• 30:23 Challenges with Kotlin and Generics
• 32:23 AndroidX and Dependency Management
• 39:12 Binding at the Bytecode Level
• 46:39 Community Efforts for Bindings
• 47:26 Upcoming Bindings and Slim Bindings

Links:

• Plugin Firebase

Takeaways

• The hosts celebrate the 100th episode of the podcast and engage in a casual conversation about Xamarin and .NET MAUI.
• They discuss their roles as product managers and their experiences with Xamarin and mobile development.
• The conversation covers the early days of Xamarin, the transition to .NET and mobile development, and the evolution of mobile development over the years.
• They also talk about the transition to Microsoft and the use of Microsoft tools, as well as their geographical locations and some trivia. The adoption of.NET MAUI has been steadily growing, with an increasing number of apps being developed using the framework.
• Customer satisfaction and success stories are important indicators of the impact of.NET MAUI.
• The journey of.NET MAUI has had its challenges, including delays and technical issues, but the team has been working hard to address them.
• Lessons learned include the need for careful planning and evaluation of architectural decisions, as well as the importance of prioritizing tech debt and considering the impact on existing codebases during migration.

People

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

Chapters

• 00:00 Introduction and Episode 100 Celebration
• 01:00 Introductions
• 01:19 Background and Roles
• 03:09 Early Days of Xamarin
• 06:05 Transition to .NET and Mobile Development
• 06:32 Evolution of Mobile Development
• 09:30 Transition to Microsoft and Remote Work
• 11:43 Transition to Microsoft Tools
• 12:15 Transition to Microsoft Tools (contd.)
• 13:06 Transition to Microsoft Tools (contd.)
• 15:11 Transition to Remote Work
• 16:24 Geographical Locations and Trivia
• 18:06 The Journey of.NET MAUI
• 19:10 Shipping.NET MAUI
• 20:30 Adoption and Success of.NET MAUI
• 22:20 Customer Impact and Satisfaction
• 23:25 Challenges and Obstacles Faced
• 25:40 Lessons Learned
• 28:16 The Evolution of Xamarin and.NET MAUI
• 31:17 Reflections on the Journey
• 39:55 The Importance of Architecture and Migration
• 43:37 Feedback and Assessment
• 43:56 Success with Maui and Ports
• 45:19 Reflecting on Code and Engineering
• 46:39 Desired Features in Maui
• 49:08 Tooling and Templates in Maui
• 50:32 Visualizing App Navigation and Image Assets
• 56:10 Improving Shell and View Model Lifecycle
• 01:00:01 Enjoying the Outdoors and Positive Community
• 01:02:57 Appreciating the Engineering Team and Community
• 01:05:30 Conclusion and Episode 100 Celebration

Special Guests: David Ortinau and Maddy Montaquila.

Links:

• .NET MAUI

Takeaways

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

People

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

Chapters

• 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

Links:

• Create Your Own .NET MAUI Plugins with This Template

Takeaways

• Blazor hybrid development allows for the integration of Blazor web views in Maui apps, providing the flexibility to leverage web technologies in a native app environment.
• Blazor's Razor syntax and evolving language features make it a powerful tool for building UI components, especially for forms and complex layouts.
• Blazor hybrid development can offer a faster development loop and improved productivity, especially when working on UI components that are shared between web and mobile platforms.
• The performance of Blazor web views in Maui apps can vary depending on the platform and the debugging environment, but overall, it can provide a reasonably good user experience. Maui hybrid apps provide a way to run code in both Web Assembly and Maui, allowing for cross-platform development.
• View models in Blazor and Maui can be used to organize code and share functionality between different platforms.
• Maui offers performance advantages and a native look and feel compared to web-based solutions.
• Maui provides an escape route for rendering technology and opens up new hiring markets for businesses.
• The slow progress of web standards can hinder the development of web apps compared to native solutions.

People

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

Chapters

• 00:00 Introduction and Small Talk
• 00:35 Introduction to Blazor Hybrid
• 01:23 Blazor Rendering Modes
• 02:15 Experience with Blazor Hybrid
• 04:21 Using Razor in Blazor
• 05:19 Mobile Blazor Bindings for Xamarin and Maui
• 06:18 Choosing Between Blazor and XAML
• 07:36 Using Blazor for Complex Layouts
• 08:39 Blazor Web Views in Maui
• 09:38 Benefits of Blazor Hybrid for Forms
• 10:22 Mixing Blazor and Native Components
• 11:38 Using Third-Party Control Libraries in Blazor
• 12:37 Improvements in Web View Performance
• 13:48 Comparing App Performance on Different Platforms
• 14:38 Preloading Blazor Content in Maui
• 15:12 Loading Experience in Blazor Hybrid
• 16:09 Debugging and Performance in Blazor Hybrid
• 19:57 Injecting Maui Services into Blazor Pages
• 21:05 Debugging Experience in Windows
• 22:25 Separating Blazor and Maui Projects
• 23:21 Using WebAssembly for Blazor
• 24:18 Benefits of Blazor Hybrid for Development
• 26:11 Choosing Between Blazor and Native App
• 27:28 Challenges of Cross-Platform Development
• 29:13 Understanding Maui Hybrid Apps
• 30:02 Differences Between Web Assembly and Maui
• 31:21 Performance and Native Look
• 33:08 View Models in Blazor
• 35:23 Using View Models in Maui
• 36:44 Navigation in Maui and Blazor
• 38:18 Naming Confusion: Maui Blazor Hybrid
• 39:25 Benefits of Maui for Businesses
• 43:29 Transitioning from Web App to Native App
• 45:20 The Slow Progress of Web Standards
• 49:45 Plugin Packages of the Week: MudBlazor and Radzen

Links:

• Radzen Blazor Components
• MudBlazor

In this episode, Jon and Allan discuss their recent vacations to Belize and Disney World. They dive into the features and functionality of the Disney mobile app, which allows users to book trips, manage reservations, and access various services. They highlight the seamless integration of the app with hotel check-in, mobile food ordering, and car locator features. The chapter also explores the user interface and navigation of the app, as well as the integration of Magic Bands and Apple Wallet for a convenient and magical experience. The episode concludes with a discussion on the Genie Plus and Lightning Lanes services, as well as the animated passes in Apple Wallet. Disney's attention to detail is evident in their interactive photo experiences, such as the PhotoPass and on-ride photos. The app allows users to book Lightning Lane reservations and participate in scavenger hunts, creating a seamless and engaging experience. Disney's crowd management and analytics ensure a smooth flow of visitors throughout the park. The backend infrastructure supporting these features is a marvel in itself. Overall, Disney's gamification approach enhances the park experience while providing value for the price. In this episode, Allan and Jon discuss the impressive features and functionality of the Disney mobile app. They highlight the interactive droids that react to Bluetooth events in the park and the immersive experience they provide. The conversation then delves into the magic of Disney's app, including its use of Google Maps for detailed mapping and navigation. They also explore the use of Magic Bands for child safety and the seamless integration of various features within the app. The discussion touches on the technical challenges faced by Disney and the solutions implemented to ensure a smooth user experience. The episode concludes with a summary of the main takeaways and a mention of Bluetooth plugin packages for developers interested in similar functionality.

Takeaways

• The Disney mobile app offers a wide range of features and functionality to enhance the vacation experience.
• The app seamlessly integrates with hotel check-in, mobile food ordering, and car locator features for a convenient and efficient experience.
• The user interface and navigation of the app are well-designed, providing easy access to information and services.
• The integration of Magic Bands and Apple Wallet allows for a seamless and magical experience throughout the park.

People

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

Chapters

• 00:00 Vacation experiences: Belize and Disney
• 03:10 The Disney app and its features
• 05:01 Booking a trip and managing reservations
• 07:22 Hotel reservations and check-in
• 08:17 Mobile food ordering
• 09:15 Car locator feature
• 11:43 User interface and navigation
• 14:12 Magic Band and Apple Wallet integration
• 19:58 Express pass and Magic Band
• 21:29 Animated passes in Apple Wallet
• 24:13 Attention to Detail
• 25:20 PhotoPass and Cast Members
• 26:16 Interactive Photos
• 27:13 Real-Time Photo Processing
• 28:19 On-Ride Photos
• 29:29 Scavenger Hunts and App Interactions
• 32:46 Crowd Management and Analytics
• 38:24 Lightning Lanes and Ride Availability
• 44:41 The Backend and Infrastructure
• 46:05 The Gamification Experience
• 47:10 Interactive Droids and Bluetooth
• 48:09 The Magic of Disney's App
• 51:12 Disney's Use of Google Maps
• 53:18 Magic Bands and Child Safety
• 55:06 Technical Challenges and Solutions
• 59:00 Cellular Connectivity and Redundancy
• 01:01:42 The Marvel of Disney's Mobile App
• 01:04:57 Conclusion and Plugin Packages

Links:

• Shiny BluetoothLE
• Plugin BLE

Takeaways

• Reactive Extensions (Rx) is a powerful library that simplifies event handling and provides a more composable and efficient way to work with events.
• Rx offers advantages over traditional event handling, such as the ability to filter, transform, and compose events, as well as handle asynchronous operations.
• RxUI is an open-source project that integrates Rx with Maui and other platforms, providing additional features and simplifying event handling in user interfaces.
• Using Rx can help address common challenges in event handling, such as memory leaks, complex event patterns, and managing asynchronous operations.
• Regular expressions can be used with Rx to validate and filter input, improving the quality and reliability of user interactions. Reactive UI.net simplifies event handling and data binding in UI development.
• Reactive Extensions provide powerful tools for manipulating and transforming events.
• Throttling and filtering events can improve performance and reduce unnecessary processing.
• Reactive UI and Reactive Extensions have limitations and may require careful consideration in certain scenarios.

People

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

Chapters

• 00:00 Introduction and Small Talk
• 01:07 Jon's Resistance to Dependency Injection
• 02:21 Introducing Reactive Extensions (Rx)
• 03:45 Advantages of Rx and Issues with Events
• 08:34 Rx in Different Platforms
• 10:00 Transforming and Filtering Events with Rx
• 15:29 Understanding Observables and Observers
• 19:21 Simplifying Event Handling with Rx
• 22:21 RxUI and its Integration with Maui
• 25:03 Challenges and Solutions in Using Rx
• 28:26 Implementing a Search Feature with Rx
• 31:03 Handling Continuous Typing and Caching Results
• 33:32 Validating Input with Regular Expressions
• 34:09 Introduction to Reactive UI and Reactive Extensions
• 34:38 Exploring Reactive UI.net
• 35:11 Throttling and Transforming Events
• 36:25 Distinct Until Changed
• 37:12 Filtering Empty or Invalid Values
• 37:45 Subscribing to Events
• 38:13 Canceling and Restarting Events
• 39:05 Complex Use Cases and Limitations
• 40:08 Using Reactive Extensions with Async
• 41:23 Challenges with Reactive Extensions
• 42:21 Assembly Size of System.Reactive
• 43:16 Reflection and Dynamic Usage
• 44:34 Considerations for Mobile Apps
• 48:35 Benefits of Reactive UI in UI Development
• 51:08 Identifying Use Cases for Reactive UI
• 54:04 Reactive UI and Reactive Extensions as Picks of the Week
• 55:06 Conclusion and Future Discussion

Links:

• ReactiveUI
• Reactive Extensions

Takeaways

• Migrating from Xamarin.Forms to .NET MAUI provides an opportunity to improve the architecture of the app.
• The introduction of handlers in .NET MAUI allows for cleaner and more testable code.
• The single project structure in .NET MAUI simplifies the development process and improves compile times.
• Migrating third-party libraries may require finding alternatives or porting them to .NET MAUI.
• Customizing entry handlers and migrating resources, such as images and fonts, can be done more easily in .NET MAUI. Image management in mobile app development can be challenging, especially when dealing with different resolutions and densities.
• Using vectors can simplify image management by allowing for easy scaling to different sizes.
• App icons and splash screens can be generated automatically in .NET MAUI, reducing the manual effort required.
• When migrating from Xamarin.Forms to .NET MAUI, it is important to approach the process methodically, starting with dependencies and gradually bringing over pages and components.

People

• Hosts: Jon Dick, Allan Ritchie

Chapters

• 00:00 Introduction and Migration Experiences
• 01:11 Opportunity for Architectural Improvements
• 03:16 Evolution of Xamarin.Forms to Maui
• 06:27 Architecture of Maui Handlers
• 09:30 Benefits of Single Project Structure
• 13:56 Migration of Third-Party Libraries
• 18:13 Handling Dependency Service and Renderers
• 25:09 Porting Plugins and Controls
• 32:48 Customizing Entry Handlers
• 35:45 Migration of Resources
• 37:23 Image Management Challenges
• 39:25 Building a Solution: Resize-itizer
• 41:03 Vector Images in Maui
• 44:05 App Icons and Splash Screens
• 46:38 Migrating Resources to Maui
• 49:35 Font Handling in Maui
• 51:37 Replacing Frames with Borders
• 53:10 Avoiding Tap Gesture Issues with Stack Layouts
• 55:12 Namespace Changes in XAML
• 56:45 Methodical Migration Process
• 59:28 Package of the Week: Maui Community Toolkit

Takeaways

• Building a mobile app involves various components, including the user interface, logic, and navigation.
• MVVM (Model-View-ViewModel) architecture is a popular approach for separating the presentation logic from the user interface.
• Shell in Xamarin.Forms provides a convenient way to handle navigation in mobile apps.
• Dependency injection (DI) can simplify the management of dependencies and improve testability in app development.
• Cross-platform development allows for code sharing and reduces development time and effort. Use dependency injection and service injection to manage dependencies and improve code maintainability.
• Create a base set of services that are core to every page in your app to simplify dependency injection.
• Think outside the box and consider alternative approaches when faced with UI design challenges.
• Solve business problems first and focus on reusability only when patterns emerge.

People

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

Chapters

• 00:00 Introduction and Building a Lightsaber
• 03:11 Anatomy of a Mobile App
• 08:15 Gluing Logic with MVVM
• 17:36 Navigation and Shell
• 23:42 Using Dependency Injection
• 30:34 Cross-Platform Considerations
• 33:24 Dependency Injection and Service Injection
• 34:35 Core Services and Cross-Platform Services
• 36:25 Creating a Base Set of Services
• 37:11 Anatomy of a Maui App
• 38:19 The UI as the Top Bun
• 39:17 The Importance of Connectivity
• 41:14 Thinking Outside the Box in App Development
• 44:48 Navigating UI Design Challenges
• 48:09 Custom Controls and Creative Solutions
• 54:29 Solving Business Problems First
• 58:38 Prism: A Comprehensive App Architecture Framework

Links:

• Prism

Takeaways

• Templates are essential for simplifying mobile app development and helping developers remember important details.
• Default templates in Maui and item templates in VS Code provide a starting point for building mobile apps.
• Custom templates can save time and help manage permissions and entitlements. MSBuild and CSProj files offer powerful customization options for projects.
• Community templates provide additional resources and options for developers. There are various types of templates available for building mobile apps with .NET Maui, including item templates, Maui templates, solution templates, Visual Studio templates, - VS Code templates, and command line templates. Item templates are used to add specific elements, such as XAML pages or views, to an existing project.
• Maui templates provide a starting point for building cross-platform apps with .NET Maui and include pre-configured project structures and dependencies.
• Solution templates allow developers to generate a complete solution with multiple projects and project references.
• Visual Studio templates offer a rich mechanism for creating templates with dynamic interfaces and advanced features.
• VS Code templates focus on command line interactions and provide a more lightweight and streamlined experience.
• Command line templates are used with the 'dotnet new' command and offer a simple and flexible way to generate project structures.
• Creating custom templates can help standardize development practices within an organization and simplify the onboarding process for new projects.
• Using templates can save time and effort by automating repetitive tasks and providing a consistent starting point for app development.
• Consider using existing templates or creating your own templates to improve productivity and maintain coding best practices.

People

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

Chapters

• 00:00 Introduction
• 00:31 The Importance of Templates for Mobile Apps
• 01:38 Default Templates in Maui
• 02:35 Item Templates in VS Code
• 03:28 The Challenge of Remembering Details
• 04:11 Customizing Templates
• 05:38 Balancing Complexity and Simplicity in Templates
• 06:55 Different Needs for New and Experienced Users
• 07:45 Creating Custom Templates
• 08:23 Managing Permissions and Entitlements
• 09:44 The Power of Templates in Saving Time
• 11:05 The Challenge of Changing Requirements
• 13:21 Managing Permissions in Templates
• 14:42 Working with Templates in Different Environments
• 15:23 Using Conditional Logic in Templates
• 17:42 Generating Entitlements in Templates
• 19:14 Simplifying Project Files
• 21:17 The Power of MSBuild and CSProj Files
• 23:01 Overcoming Fear of Project Files
• 25:21 Using Project Files for Customization
• 26:41 The Benefits of Plugin Templates
• 30:51 Including Popular Packages in Templates
• 32:33 The Value of Community Templates
• 33:32 Introduction to Templates
• 34:05 Different Template Options
• 35:39 Item Templates
• 36:09 Maui Templates
• 37:46 Solution Templates
• 38:15 Visual Studio Templates
• 39:21 VS Code Templates
• 41:45 Command Line Templates
• 43:08 Creating Custom Templates
• 45:16 Standardizing Templates
• 45:58 Conclusion

Links:

• dotnet-maui-templates (egvijayanand)
• Shiny Templates
• Plugin.Maui.Feature
• MauiAppAccelerator

Takeaways

• Backgrounding in mobile development is the ability to execute code when an app is not in the foreground.
• Common scenarios for backgrounding include data synchronization, image uploads, and real-time GPS.
• On Android, backgrounding can be achieved using services, broadcast receivers, foreground services, and job scheduling.
• On iOS, backgrounding is more restricted, with foreground services and background transfers being the primary options.
• Developers should consider the specific platform guidelines and limitations when implementing backgrounding functionality. Background transfers are useful for uploading or downloading large files or data sets.
• Managing state in background jobs can be challenging, but there are various ways to handle it, such as using preferences or messaging frameworks.
• Background GPS in iOS and Android allows for tracking location and other data, but it should be used judiciously to avoid excessive battery drain.
• Background tasks in Windows can be achieved using WinRT APIs, but they may be less relevant in desktop scenarios.
• Consider the specific use case and user needs before implementing background tasks, and be mindful of the impact on battery life and data usage.

People

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

Chapters

• 00:00 Introduction and Virtual List View
• 05:28 The Story Behind the Nickname 'Red'
• 08:50 Backgrounding in Mobile Development
• 19:21 Backgrounding on Android
• 27:45 Backgrounding on iOS
• 30:31 Background Transfers on Android
• 31:55 Background Transfers on iOS
• 32:42 Background Transfers
• 33:45 Handling Slow APIs
• 34:38 Background Tasks in iOS 13
• 36:46 Managing State in Background Jobs
• 37:45 One-Off and Scheduled Jobs
• 40:20 Background Execution in iOS
• 41:36 Passing State to Background Jobs
• 44:22 Challenges of Data Synchronization
• 45:45 Background Execution in Windows
• 46:19 Background GPS in iOS
• 47:39 Background GPS in Android
• 51:53 Considerations for Background Tasks
• 55:12 Background Tasks in CarPlay and Android Auto

Links:

• Shiny Jobs

Takeaways

Implementing lists in mobile apps can be challenging due to performance and dynamic sizing issues.
The history of list implementations on different platforms, such as ListView, RecyclerView, and UICollectionView, has influenced the current state of CollectionView in MAUI.
The current CollectionView in MAUI tries to do too much and can be complex to use in certain scenarios.
Alternative list view controls, such as Sharpnado and Syncfusion, provide different approaches and features for handling lists in mobile apps.
Observable collections are often misused in list views, leading to performance issues. It is important to use them appropriately and consider using a regular list when the data is not changing frequently. Observable collections are useful for handling data in motion, such as real-time updates or changing distances.
Optimizing list performance should be done based on actual needs and user behavior, rather than prematurely optimizing for potential issues.
Consider the specific requirements of your app when choosing a list control, and don't be afraid to explore alternative solutions like Blazor or web technologies.
The Virtualized List View plugin by Jon is a powerful tool for building performant lists in Xamarin.Forms and can be a great solution for complex scenarios.

People

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

Chapters

00:00 Introduction and Weather
01:14 Listener Question: CLI Command in MAUI
05:36 Topic: Dealing with Lists in Mobile Apps
19:35 History of List Implementations
25:51 Challenges with Collection View in MAUI
30:17 Alternative List View Controls
35:38 Observable Collections and List Views
39:18 Observable Collection and Data in Motion
46:11 Optimizing List Performance
52:26 Choosing the Right List Control
56:25 Virtualized List View Plugin
01:00:53 Optimizing List Performance (Continued)
01:04:08 Conclusion and Plug-in of the Week

Links:

• Redth's MAUI VirtualListView
• Sharpnado CollectionView

In this episode, Jon and Allan discuss the complexities of implementing push notifications on iOS and Android. They delve into the history of push notifications and the challenges developers face in tackling this topic. They explore the setup and configuration process for both platforms, including the use of certificates and entitlements on iOS and the use of Firebase on Android. They also discuss the lifecycle of notifications, handling background execution, and the differences between iOS and Android in terms of permissions and notification handling. In this episode, Jon and Allan discuss various aspects of push notifications on Android, including permissions and changes, setting up notifications, specifying intents in notification payloads, silent notifications, sending notifications to tags, handling multiple devices, and the Shiny Push library. They also touch on source generators and boilerplate code. Overall, the conversation provides valuable insights into the complexities and best practices of implementing push notifications on Android.

Takeaways

Push notifications are a complex topic that require careful setup and configuration on both iOS and Android.
Developers face challenges in implementing push notifications due to the differences between platforms and the evolving nature of the technology.
The setup and configuration process involves obtaining certificates and entitlements on iOS and using Firebase on Android.
The lifecycle of notifications and the handling of background execution differ between iOS and Android.
Permissions and changes in Android, such as the introduction of post-notifications, add another layer of complexity to push notification implementation. Permissions and changes in Android can impact the implementation of push notifications.
Notifications on Android can be set up to route directly to an activity by specifying an intent in the notification payload.
Silent notifications on Android can be used to wake up the app and perform background tasks.
Sending notifications to tags allows for logical grouping and targeted delivery on Android.
Handling multiple devices and ensuring notifications are received on all devices can be challenging.
The Shiny Push library simplifies the implementation of push notifications on Android.
Source generators can help reduce boilerplate code and make implementation easier.

People

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

Chapters

• 00:00 Introduction
• 01:09 Tackling Hard Problems
• 04:00 History of Push Notifications
• 08:30 Setup and Configuration on iOS
• 13:02 Registering for Notifications on iOS
• 15:22 Lifecycle of Notifications on iOS
• 17:43 Silent Notifications on iOS
• 19:27 Handling Background Execution on iOS
• 22:06 Complexity of Cross-Platform Implementation
• 24:19 Setup and Configuration on Android
• 28:35 Handling Notifications on Android
• 32:19 Permissions and Changes in Android
• 33:16 Permissions and Changes
• 35:27 Setting Up Notifications on Android
• 36:43 Specifying Intents in Notification Payloads
• 38:19 Silent Notifications on Android
• 41:48 Sending Notifications to Tags on Android
• 44:29 Handling Multiple Devices on Android
• 49:15 Shiny Push Library
• 52:21 Server-to-Server Notifications
• 56:08 Source Generators and Boilerplate
• 57:44 Plugin Pick: Shiny Push

Links:

• Shiny Push Notifications

Plugins, Packages, and Products

This week we're talking about Xamarin.Binding.Helpers which helps make it easier to create slim bindings on Android, as well as Platform Channels which is an experiment for creating a message passing interface between native code and .NET MAUI apps.

People

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

Chapters

• 00:00 Introduction
• 01:09 Understanding Bindings in a Mobile.NET, Maui World
• 02:00 Projections of Native APIs into the Managed.NET World
• 03:41 The Evolution of Bindings
• 04:06 The Challenge of Android X Libraries
• 05:00 Dealing with Bindings in Xamarin
• 06:07 The Complexity of Android Libraries
• 07:03 Creating Android Bindings
• 07:30 The Process of Android Binding
• 08:16 Challenges with Java and Kotlin Libraries
• 09:08 Handling Complex Inheritance in Java and Kotlin Libraries
• 10:22 The Sprawl of Android X Libraries
• 11:31 The Challenges of Binding Android X Libraries
• 12:09 The Simplicity of Binding Platform APIs
• 13:16 The Differences Between iOS and Android Bindings
• 14:22 Creating iOS Bindings
• 15:48 The Challenges of Objective-C and Swift Libraries
• 18:36 The Need for Slim Bindings
• 20:00 The Challenge of Dependency Chains
• 21:54 The Concept of Slim Bindings
• 23:46 The Advantages of Slim Bindings
• 27:11 Determining When to Bind the Whole Library
• 29:34 Debugging Slim Bindings
• 34:52 The Concept of Platform Channels
• 38:58 Performance Considerations of Platform Channels
• 40:37 The Future of Bindings
• 40:46 Integration with Xcode Project
• 42:41 Challenges with Tooling
• 46:48 Handling AndroidX Dependencies
• 50:15 Platform Channels in Maui
• 53:00 Plugin Recommendation: Xamarin Binding Helpers

Links:

• Objective Sharpie
• Xamarin.Binding.Helpers
• Platform Channels

In this episode, Jon and Allan discuss the state of .NET Maui, the challenges of mobile development, and the benefits of using Blazor WebView in Maui apps. They also talk about the evolution of the Mono runtime, the use of handlers in Maui, and the transition from custom renders to source generators. Overall, they highlight the improvements and advancements in the .NET Maui framework and its potential for creating cross-platform mobile apps. In this episode, Jon and Allan discuss app profiling and performance optimization, highlighting the use of tools like DS router and DS dotnet trace to profile apps and identify performance issues. They emphasize the importance of measuring and optimizing early in the development process to avoid potential problems. The conversation then shifts to the introduction of a new segment called 'Plugin Package or Product,' where they showcase a library called compiled bindings that enhances the XAML experience by providing additional operators and reducing verbosity. They express their interest in incorporating such concepts into the core product. The episode concludes with a call to action for listeners to subscribe, leave reviews, and provide topic suggestions for future episodes.

Takeaways

The .NET Maui framework has made significant progress, with improvements in tooling, performance, and support for modern mobile app development.
Blazor WebView in Maui allows developers to leverage their existing Blazor skills and codebase to build hybrid mobile apps.
The transition from custom renders to handlers in Maui simplifies the development process and improves performance.
Source generators in Maui enable automatic code generation, reducing the need for manual coding and improving productivity. App profiling and performance optimization are crucial for identifying and resolving performance issues in apps.
Tools like DS router and DS dotnet trace can be used to profile apps and gather trace files and speed scope logs for analysis.
Early measurement and optimization can help prevent performance issues and improve the overall user experience.
Compiled bindings is a library that enhances the XAML experience by providing additional operators and reducing verbosity, making it easier to work with XAML.

Plugins, Packages, and Products

This week we're talking about Compiled Bindings: https://github.com/levitali/CompiledBindings which provides {x:Bind} Markup Extension for WPF, MAUI and Xamarin Forms.

Chapters

• 00:00 Introduction and Changes to the Podcast
• 06:17 State of .NET Maui
• 09:24 Dependency Injection in .NET Maui
• 11:12 Evolution of the Mono Runtime
• 13:14 Challenges of Mobile Development
• 19:22 Long-Term Release of .NET Maui
• 21:20 Blazor Hybrid App
• 23:43 Benefits of Blazor WebView
• 25:49 Mixing Blazor and Maui
• 31:35 Handlers in .NET Maui
• 35:13 Porting Custom Renders to Handlers
• 37:03 Source Generators in .NET Maui
• 38:56 App Profiling and Performance Optimization
• 41:29 Plugin Package or Product: Compiled Bindings
• 47:04 Closing Remarks and Call to Action

Links:

• CompiledBindings.Maui