111: Configuration & Logging

06/24/24 • 58 min

In this episode, Jon and Allan discuss logging and configuration in mobile app development. They talk about their personal experiences with configuration and logging, including using environment variables, embedded resources, and external libraries like Sentry. They also touch on the performance implications of logging and the potential for source generation to improve configuration handling. Overall, they emphasize the importance of considering the specific needs of the app and the trade-offs between convenience and performance. In this conversation, Allan and Jon discuss logging and error handling in mobile app development. They mention the importance of having good logging tools and the drawbacks of using outdated tools like App Center. They also talk about the benefits of using a local logging system for debugging purposes. The conversation concludes with a discussion on the proper use of try-catch blocks and the importance of handling exceptions at the right level.

Takeaways

Consider the specific needs of your app when implementing configuration and logging
Use environment variables or constants for simple configuration needs
Be mindful of the performance implications of logging, especially in mobile apps
Explore external libraries like Sentry for crash reporting and error handling
Source generation can be a powerful tool for handling configuration Having good logging tools is crucial for effective debugging and error handling in mobile app development.
Using outdated tools like App Center for logging can lead to code pollution and limited functionality.
Local logging can be useful for debugging purposes, especially in scenarios where cloud logging is not necessary or practical.
Try-catch blocks should be used strategically and not excessively. They should be placed at the event triggers or where exceptions can be handled effectively.
Proper error handling and logging practices can help improve the overall stability and user experience of mobile apps.

People

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

Chapters

00:00 Introduction and Episode Number
06:02 Exploring External Libraries for Error Handling
11:04 Finding the Right Balance: Convenience vs Performance
23:45 Considerations for Configuration and Logging in Mobile Apps
26:11 The Performance Implications of Logging
29:12 Logging and Performance: A Closer Look
32:05 The Drawbacks of Using Outdated Logging Tools
34:12 The Benefits of Local Logging
36:26 Strategic Use of Try-Catch Blocks
41:38 Proper Error Handling and Logging Practices

Links:

Sentry IO
Shiny.Extensions.Configuration — A configuration library that pulls appsettings json from Android assets & iOS bundles allowing for repackaging in white label solutions while still support the common configuration pattern
YouTube Episode 111

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

Previous Episode

110: 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:

Next Episode

112: The Tools & Libraries We Use

In this conversation, Jon and Allan discuss various tools they use for development. They talk about their preferred operating systems, monitors, and IDEs. They also mention specific tools like Insomnia for API testing and DevTools for debugging. The conversation is light-hearted and includes some banter about Canadian jokes and hockey. In this part of the conversation, Jon and Allan discuss various tools they use, including antivirus software, DevToys, Setapp, file managers, Docker, Cosmos DB, and coffee brewing equipment. In this conversation, Allan and Jon discuss various soft tools and libraries that they use in their development projects. They cover topics such as coffee-making methods, microphones and audio equipment, standing desks, and .NET libraries like MVVM Toolkit, .NET Orleans, and MediatorR. They also mention the Shiny Templates, a collection of templates for Xamarin and Maui apps. Overall, they provide insights into the tools and libraries they find useful in their development workflows.

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.