.NET Archives - XABLU

Managing Software Development: From Performance Art to Operational Excellence

Henk Kok — Wed, 29 Nov 2023 11:37:46 +0000

Your management skills are directly impacting the performance of your software development: some organizations merely go through the motions of management, while others truly embody operational excellence. If your management style resembles ‘performance art’ – maybe focussing on scrum ceremonies, but lacking the right level of operational outcome, than you might consider revisiting your strategy.
The key to transcending this strategy lies in adopting a structured management approach, like integrating Objectives and Key Results (OKRs) with Agile methodologies. This integration transforms abstract goals into concrete actions, ensuring each team member understands not just what they need to do but also why.

Performance Art in managing Software Development

Being in touch for many years with a large amount of software development companies, big and small, a surprising number of them operate in a mode that can best be described as ‘performance art.’ This term aptly captures the essence of teams that are managed in name only. Using for instance the Scrum label, they put on a show of organization and structure, but beneath the surface, there’s a lack of substantive direction and coherent strategy. Meetings are frequent, yet productive outcomes are rare. Tasks are assigned and pursued, but without a clear understanding of how they contribute to the broader objectives. This approach leads to confusion, misaligned efforts, and a work environment where the appearance of activity is mistaken for progress, much like an art performance that prioritizes aesthetics over functionality.

Transitioning to Structured Management with OKRs and Agile

The transition to structured management in software development signifies a pivotal shift from ambiguity to clarity. This transformation can be achieved through the integration of Objectives and Key Results (OKRs) with Agile methodologies. OKRs provide a clear, measurable framework for setting and tracking goals, which, when linked directly to Agile boards, offer a real-time view of progress against these objectives. This linkage ensures that every team member, from developers to managers, has a clear understanding of the company’s vision and their role in achieving it. It fosters transparency and enhances communication across the organization, ensuring that everyone is aligned and working in concert towards common goals. This approach not only streamlines the development process but also bridges the gap between strategic planning and execution.

OKR Initiatives are the Waterfall Connection with Agile

Incorporating OKR Initiatives from a Work Breakdown Structure perspective into Agile methodologies offers a more interconnected approach to project management. This integration effectively marries the meticulous planning characteristic of Waterfall with the dynamic execution of Agile. When these initiatives are grounded in UX research, they gain a deeper relevance, as they are directly tied to user needs and experiences. This synergy ensures that while Agile teams retain their flexibility and adaptability, they also benefit from the structured, goal-oriented framework provided by Waterfall-derived initiatives, leading to a more cohesive and user-centric development process.

Achieving Operational Excellence

In software development, operational excellence arises from the synergy of transparent communication, disciplined management, and a balanced mix of methodologies. This excellence is particularly evident in review sessions, both from Agile and OKR perspectives. These sessions foster a positive atmosphere by ensuring everyone’s efforts are aligned with company-wide objectives. They also encourage proactive synergy among team members, as successes and challenges are openly discussed and lessons are learned collectively. This process not only improves the team’s current performance but also strategically positions them for future successes, creating a cycle of continuous improvement and operational efficiency.

Additional Support

If you’re looking for additional information or support, Xablu specializes in training and coaching these techniques in your organization. We offer comprehensive services to assist with everything from assessing your existing process to optimizing performance for a successful adoption of the right techniques. Keep in mind that implementing new structures is people’s business

Here’s a list of links to additional resources:

Curious how Xablu can help your organization ?

The post Managing Software Development: From Performance Art to Operational Excellence appeared first on XABLU.

Maximize Your Mobile App’s Potential with .NET MAUI: A Migration Guide

Henk Kok — Thu, 09 Nov 2023 10:46:00 +0000

The Xamarin chapter is closing, with the end-of-life announcement ringing in changes across the board, especially with Xcode’s support shifts. Migrating to .NET MAUI isn’t just about keeping up; it’s about tapping into the full spectrum of the .NET ecosystem’s power—think quicker load times, more efficient memory use, and a unified codebase that stretches from mobile to desktop.

Here at Xablu, we’re in the business of making transitions like these as smooth as coding on a good day. We support your team with the migration of the Xamarin code, spot what needs to evolve on the UX side, and set you on a clear, efficient path to .NET MAUI. With an eye on the latest best practices, we’re talking about aligning with industry standards, and streamlining your process with Agile methodologies. Plus, we don’t just stop at code—UX design, DevOps and sharpening your strategic approach with OKRs are part of the package, ensuring that your app doesn’t just work well, but also aligns with business and user needs, looks good and ships fast.

So, ready to get started? Keep reading to find out how to make your app’s move to .NET MAUI as straightforward as it is smart.

Why it's Time to Move On

Let’s face it, Xamarin has been around for more than 10 years now. It’s been a solid pick for building cross-platform apps for many teams. But all good things must evolve, and Xamarin’s no different. With Microsoft sounding the end-of-life alarm for Xamarin, it’s clear the torch is being passed to .NET MAUI. And here’s the kicker: this isn’t just about keeping your apps on life support—it’s about introducing a whole new vision on cross platform, spanning more operating systems than ever.

.NET MAUI comes armed with a .NET 8 engine under the hood and a suite of new tools. It’s not just about maintaining the status quo; it’s about supercharging your apps. Smoother performance, more robust security measures, and a development experience that’s been polished to shine. And let’s not forget the streamlined workflows that come from a single project structure—no more juggling multiple codebases.

But why rush the migration? Well, staying put on Xamarin means you’ll soon will not be able to publish a new version in the app stores. Think about it: no more updates, no more cutting-edge features, and slowly but surely, a widening gap between your app and the current tech standards. On the other hand, making the move to .NET MAUI puts you back in the driver’s seat, with all the support, tools, and performance gains to keep your app racing ahead.

So, whether it’s the lure of enhanced features or the push of Xamarin’s end-of-life, now’s the time to gear up for migration. And hey, it’s not a solo journey—you’ve got a roadmap and a community of fellow developers to help navigate the path to .NET MAUI. Ready to roll? Let’s get your apps set for the future.

Advancements and Improvements in .NET MAUI

With the upgrade to .NET 8, .NET MAUI is not just a necessary step; it’s an opportunity to leverage the suite of enhancements that .NET 8 brings to the MAUI framework. Here are some of the most significant technical advancements in .NET MAUI that your software team can take advantage of:

Quality Focus: The primary aim for .NET MAUI in the .NET 8 release has been enhancing quality, with a significant number of bugs addressed to improve overall reliability.
AOT Improvements: The enhancements to Ahead-of-Time (AOT) compilation, such as Startup tracing or Profiled AOT, which leads to faster application launch times (NativeAOT on MAUI supports iOS) with a minimal increase in app size.
NuGet Packages: .NET MAUI simplifies package management by consolidating multiple project platforms into a single project. This streamlined approach enhances developer flexibility, allowing for easier management of dependencies and versioning across the unified codebase.
Unified Platform APIs: .NET MAUI’s unification of Android, iOS, macOS, and Windows APIs into a single API enhances developer productivity and application performance.
UI Control Quality: The focus on improving the quality of UI controls, layout, and memory management to provide a smoother user experience across different platforms.
Startup Performance: Notable improvements in startup times for complex applications, with some applications experiencing over a 30% improvement in startup speed.
Multi-window Support: A fundamental change in .NET MAUI is the introduction of the Window as the base foundation for creating multi-window applications, which enhances the desktop app experience.
Android Specific Features: Features like AndroidStripILAfterAOT for smaller assembly sizes and enhanced performance on Android devices.
Build Performance: Improvements such as filtering Android process outputs, porting tasks to C#, and optimizations in remote iOS builds on Windows.
Application Size Reductions: Various performance improvements that also contribute to reducing application size, such as removing unneeded reflection and using StringComparer.Ordinal for collections.

These improvements underscore the technical benefits of migrating to .NET MAUI, positioning it as a forward-thinking framework for building modern, performant applications across various platforms. They represent just a glimpse of the comprehensive enhancements that the .NET 8-based version of .NET MAUI offers, ensuring that your app development is not just up-to-date but also ahead of the curve.

Strategic Integration of OKRs, UX and Agile in .NET MAUI Development

When it comes to adopting .NET MAUI for mobile app development, there’s more to the process than just technical implementation. Xablu provides training and coaching on the introduction of Objectives and Key Results (OKRs), Agile methodologies, and User Experience (UX) design, ensuring these practices are closely tied to the actual technical process. By leveraging best practices, we help create control within an organization and align and communicate customer objectives with Key Results across projects through a blend of training, coaching, and the development of OKR masters within the organization.

OKRs: A Framework for Clarity and Focus Implementing OKRs offers a framework for setting, tracking, and achieving goals across an organization. OKRs enhance transparency, align team efforts with strategic vision, and foster a results-driven culture. They empower teams to focus on collaboratively set initiatives and understand how their individual contributions fit into wider organizational goals.

Kanban: Agile Planning and Execution In many project organizations, Kanban as a planning methodology aligns better than Scrum. It combines pre-established plans (Work Breakdown Structures) with an agile approach, promoting continuous collaboration through better visibility into planned tasks and the establishment of a clear communication structure.

UX: Enhancing the User Journey In .NET MAUI development, the integration of UX, OKRs, and Kanban is crucial. Where possible within a client’s existing communication structures, we implement this approach. Our vision is to deliver a customized, scalable solution that fits the project approach and culture of the client. Incorporating UX, OKRs, and Kanban is key to boosting operational efficiency and strategic execution.

The Role of Design Systems and Component Libraries The use of UX, design systems, and component libraries plays a pivotal role in creating cohesive and functional mobile applications. With .NET MAUI, we can help integrate these elements to ensure that the applications not only meet functional requirements but also deliver a consistent and compelling user experience. Design systems provide a shared language and set of components that streamline the design process, while component libraries offer reusable UI elements that save time and maintain consistency across different parts of one or more apps. Together, they form the cornerstone of a user-centric development approach that can be effectively managed with OKR-driven strategies and Agile execution.

Keeping the User Front and Center

When optimizing for .NET MAUI, the goal is to adapt without interrupting the user’s journey through the application. Each step in the user’s interaction should be coherent with the next, maintaining the narrative of the experience from start to finish. This is crucial because any disruption can lead to dissatisfaction and a break in the seamless experience that users have come to expect.

Embracing empathy is one of the major strategies to ensure continuity. By understanding and prioritizing the emotions and behaviors of users, UX professionals can make more informed decisions that align with user expectations. This involves perspective-taking, avoiding judgment, recognizing specific emotions, and taking action to communicate understanding.

Furthermore, incorporating UX into the product development process is essential. It’s not just about having a dynamite product; it’s about ensuring that the product is usable and enjoyable through strong UX. A holistic approach to UX ensures that every element of the user interface is consistent and contributes to a cohesive experience.

However, the pursuit of continuity in UX does not imply a resistance to change. The dynamic nature of technology means that improvements and updates are inevitable. The challenge is to balance these changes with the need for continuity, ensuring that updates enhance rather than disrupt the user experience.

To effectively transition existing UX designs to work with .NET MAUI, it’s crucial to utilize the platform’s capabilities. .NET MAUI allows for UI customization across different platforms and devices. This means you can optimize your application to make the most effective use of space on different screen sizes, take advantage of device capabilities like location sensors and cameras, and rearrange UI elements to best suit the input methods of each device.

The OnPlatform and OnIdiom markup extensions in .NET MAUI are powerful tools for creating a responsive UI tailored to various platforms and device idioms. OnPlatform allows customization on a per-platform basis, setting values for properties specific to Android, iOS, Mac Catalyst, Tizen, and WinUI, while OnIdiom facilitates customization based on whether the app is running on a phone, tablet, desktop, TV, or watch.

DevOps and Migration: Like Peanut Butter and Jelly

In the realm of app development, DevOps and migration to .NET MAUI go hand-in-hand, ensuring a smooth transition and continuous integration/delivery (CI/CD). Embracing DevOps with .NET MAUI simplifies the complexities of building and deploying apps across multiple platforms. Prior to setting up pipelines, necessary files such as signing certificates for iOS, keystores for Android, and package signing certificates for Windows are prerequisites.

The process begins with the creation of pipelines, for which .NET MAUI provides sample pipelines, like those in the Weather21 app, to guide developers through the setup. These starter pipelines, ideal for basic testing and build tasks, integrate seamlessly into DevOps strategies, focusing on essential steps like setting the .NET version, installing MAUI workloads, managing signing files, building/publishing the app, running unit tests, and uploading artifacts.

The dotnet CLI tool streamlines the DevOps workflow, eliminating the need for intricate scripts to manage builds and publications across different frameworks. This tool allows for executing dotnet build and dotnet publish commands for any TargetFramework, contributing to a more efficient CI/CD pipeline. The common tasks for pipelines in both GitHub Actions and Azure DevOps revolve around setting up the .NET SDK version and installing .NET MAUI, demonstrating the alignment of DevOps practices with .NET MAUI’s versatile framework.

The Step-by-Step Migration Playbook

Migrating your Xamarin.Forms app to .NET MAUI is a process made significantly simpler with the .NET Upgrade Assistant. Here’s how to make the transition smooth:

Preparation: Ensure your Xamarin.Forms project is updated to version 5.0 and running on .NET Standard 2.0 or higher for the best results before migration.
Installation: If using Visual Studio on Windows, install the .NET Upgrade Assistant from the Extensions menu. For CLI, use the command:
dotnet tool install -g upgrade-assistant
To update the tool, use:
dotnet tool update -g upgrade-assistant
Note that if you have additional NuGet feed sources configured, you may need to use --ignore-failed-sources to avoid errors.
Running the Upgrade: In Visual Studio, right-click on the project and select ‘Upgrade’. For CLI, navigate to your project folder and run:
upgrade-assistant upgrade
This will update all eligible files within your project.
Conversion and Code Updates: The .NET Upgrade Assistant will convert your project files to SDK-style projects, update target frameworks, set true, and handle NuGet package transitions:
- Remove Xamarin.Forms and Xamarin.Essentials packages.
- Replace Xamarin.CommunityToolkit with .NET MAUI Community Toolkit.
- Update SkiaSharp packages for .NET MAUI compatibility.
- Replace Xamarin.Forms and Xamarin.Essentials namespaces with Microsoft.Maui and Microsoft.Maui.Controls.

Remember, while the Upgrade Assistant does a lot, it might not cover everything. Manual adjustments and testing will be necessary to ensure a smooth transition. Keep the .NET MAUI documentation handy for reference and don’t hesitate to provide feedback to improve the tool further.

Watch Out for These Migration Speed Bumps

Migrating from Xamarin to .NET MAUI is a forward leap in app development, but it’s not without its hurdles. One of the common challenges is the absence of OpenTK on iOS, which means OpenGL is no longer available. For Xamarin.watchOS projects, it’s recommended to bundle Swift extensions with .NET for iOS apps.

Additionally, before upgrading your Xamarin native projects to .NET, ensure they are SDK-style projects and that dependencies are updated to .NET 7+. Also, while the .NET Upgrade Assistant can streamline the migration of multi-project Xamarin.Forms apps to .NET MAUI, be prepared to invest additional effort post-upgrade to address any nuances and ensure your app is fully functional in the new environment.

When transitioning from frameworks like MvvmLight or MvvmCross to the MVVM Toolkit, you’ll encounter several changes:

ObservableObject: Replace MvvmLight’s ObservableObject with the MVVM Toolkit’s version, adjusting the using directives in your components accordingly.
SetProperty Methods: The signature for methods like Set(Expression, ref T, T) does not have a like-for-like replacement in the MVVM Toolkit. Instead, use SetProperty(ref T, T, string) which offers similar functionality with performance benefits.
PropertyChanged Event: For raising property change notifications, switch from RaisePropertyChanged(string) to OnPropertyChanged(string) in the MVVM Toolkit. The new method infers the property name automatically, simplifying the code.
VerifyPropertyName: The VerifyPropertyName(string) method does not have a replacement in the MVVM Toolkit due to the availability of the nameof keyword for verifying property existence.
PropertyChangedHandler: There is no direct replacement for PropertyChangedHandler. Use OnPropertyChanged() to raise property change events instead.
ViewModelBase Migration: For components using ViewModelBase, the MVVM Toolkit offers ObservableRecipient, which provides similar functionality.
Namespace changes: Replace MvvmCross namespaces with their CommunityToolkit.Mvvm counterparts. For instance, change using MvvmCross.ViewModels; to using CommunityToolkit.Mvvm.ComponentModel; and using MvvmCross.Commands; to using CommunityToolkit.Mvvm.Input;. This change is necessary for ViewModel and Command implementations to align with CommunityToolkit.Mvvm’s structure.
Navigation Changes: CommunityToolkit.Mvvm doesn’t include built-in navigation features like MvvmCross. You’ll need to implement a navigation service that works with the navigation patterns in .NET MAUI.
Dependency Injection: whether you are using MVVMCross (with it’s own DI container), MVVMLight (with SimpleIoc), Prism (with Unity Container) or implementations like DryIoc or Autofac, evaluate if you should continue with it or switch to the built-in .NET DI framework.

Testing and quality checks are integral throughout this process. Rigorous testing will highlight any discrepancies that need your attention, ensuring that the final product maintains the high-quality standards users expect from a .NET MAUI app.

Additional Support

If you’re looking for additional expertise and support during your migration journey, Xablu specializes in the transition from Xamarin to .NET MAUI. We offer comprehensive services to assist with everything from assessing your existing codebase and guiding the migration process to optimizing performance for a successful adoption of .NET MAUI. Keep in mind that with Xamarin support ending on May 1, 2024, now is a critical time to embrace the transition to .NET MAUI to stay ahead in cross-platform development.

Here’s a list of links to these resources:

Please share your thoughts

Curious how Xablu can help your organization ?

The post Maximize Your Mobile App’s Potential with .NET MAUI: A Migration Guide appeared first on XABLU.

Unlocking the power of .NET Blazor: using component libraries for development

XABLU HQ — Sat, 17 Jun 2023 13:54:00 +0000

.NET Blazor is emerging as a game-changer by enabling developers to build interactive web applications using C# instead of JavaScript. This shift not only leverages existing C# skills but also brings new opportunities for performance optimization and component customization. Integrating component libraries with .NET Blazor can significantly streamline the development process, enhance performance, and improve user experience. Whether you’re a software developer, product manager, or technical leader, understanding Blazor’s capabilities will provide valuable insights.

Understanding Blazor

Blazor, part of the .NET ecosystem, allows developers to create web applications using C#. It offers two hosting models: Blazor WebAssembly, where the application runs directly in the browser, and Blazor Server, where the application runs on the server and communicates with the browser via SignalR. Blazor bridges the gap between client-side and server-side development, enabling developers to leverage their existing C# skills to build rich, interactive web applications.

The primary advantage of Blazor lies in its ability to enable code sharing between the client and server. This unified approach reduces development time, simplifies maintenance, and enhances code reusability. Blazor’s component-based architecture further promotes modularity and scalability, making it an ideal choice for modern web development.

The role of component libraries in the development of Blazor

Component libraries are collections of pre-built, reusable UI elements that can be integrated into Blazor applications. These libraries provide a wide range of components, from simple buttons and forms to complex data grids and charts, helping developers save time and effort by avoiding the need to build these elements from scratch.

Using a component library offers several benefits. It accelerates development by providing ready-to-use components, ensures consistency in UI design by adhering to design standards and best practices, enhances the overall user experience with well-tested and optimized components, and simplifies maintenance by reducing the amount of custom code that needs to be managed.

Our development toolkit includes a comprehensive set of components designed to meet a variety of needs, from basic UI elements to advanced data visualization tools. By using our component library, developers can leverage a consistent and high-quality set of components, ensuring that their applications are not only functional but also visually appealing and performant.

Blazor development phases

In the planning phase, teams define the project scope, requirements, and objectives. This phase involves identifying key features and functionalities, selecting the appropriate Blazor hosting model, and choosing the component libraries to be used. Thorough planning sets the foundation for a successful project, ensuring that all stakeholders are aligned and that the project goals are clear.

The development phase is where the actual coding takes place. Developers build the application’s core functionalities, integrating the selected component libraries to create a cohesive and interactive user interface. During this phase, it is crucial to follow best practices for Blazor development, such as component-based architecture, proper state management, and efficient data binding.

Testing is an integral part of the Blazor development process. It involves verifying that the application functions as expected and meets the defined requirements. Testing can be divided into unit testing, where individual components are tested in isolation, and integration testing, where the interaction between different components is tested. Automated testing tools can help streamline this process and ensure comprehensive test coverage.

Once the application has been thoroughly tested, it is ready for deployment. The deployment phase involves publishing the application to a web server or cloud platform. Blazor applications can be easily deployed to services like Azure App Services, AWS, or any other hosting environment that supports .NET applications. Post-deployment, continuous monitoring and maintenance are essential to ensure the application remains performant and secure.

Optimizing Blazor performance

Performance optimization is critical for delivering a fast and responsive Blazor application. Efficient data binding is essential. Blazor supports both one-way and two-way data binding. While two-way data binding is convenient, it can lead to performance issues if overused. Use one-way data binding where possible to minimize unnecessary updates and improve performance.

Lazy loading is a technique where components and data are loaded only when needed. This approach reduces the initial load time and improves the application’s responsiveness. Blazor supports lazy loading of assemblies, which can significantly enhance performance, especially for large applications.

Reusing components not only promotes code reuse but also improves performance. Instead of creating new components for similar functionalities, use existing components and pass different parameters to customize their behavior. This approach reduces the amount of rendering and processing required.

While Blazor allows for JavaScript interoperability, excessive use of JavaScript can degrade performance. Minimize JavaScript interop calls and use Blazor’s built-in functionalities whenever possible to maintain optimal performance.

Customizing Blazor components

Customizing Blazor components allows developers to tailor the UI to meet specific requirements and enhance the user experience. Blazor components can accept parameters, which are used to customize their behavior and appearance. Understanding how to use parameters effectively allows for flexible and reusable components. Use attributes to define component parameters and pass different values to achieve the desired customization.

Styling is an essential aspect of component customization. Blazor supports CSS isolation, which allows for scoped styles that apply only to specific components. Use CSS classes and styles to customize the appearance of components and ensure consistency across the application.

Handling events is crucial for creating interactive components. Blazor supports various event handlers, such as onclick, onchange, and oninput. Use these event handlers to implement custom behavior and enhance the interactivity of components. For example, you can create a custom button component that performs a specific action when clicked.

Template components provide a way to create highly customizable components by allowing developers to define the component’s structure using templates. Use template components to create flexible and reusable UI elements that can be customized with different content and layouts.

Additional Support

If you’re seeking further guidance or support in navigating the crucial choices on your road ahead, or in effectively setting and implementing Blazor components, our team is here to assist. We specialize in offering bespoke training and coaching to integrate these techniques seamlessly into your organization. Our services range from evaluating your current processes to fine-tuning your performance, ensuring a successful adoption of the strategies that best suit your business needs. Remember, the journey to operational excellence and strategic decision-making is as much about people as it is about processes. Here’s a link to an additional resource:

Curious how Xablu can help your organization ?

The post Unlocking the power of .NET Blazor: using component libraries for development appeared first on XABLU.

5 things for .NET MAUI devs to look forward to in 2022

Sebastián Pérez — Tue, 28 Dec 2021 16:21:49 +0000

The year 2021 has brought us a lot of news related to .NET 6. However, we are going to highlight some milestones that must be taken into account for next year:

1. .NET MAUI release: This year we had a working preview of .NET MAUI and a lot of announcements. However, we will have the release of this long-awaited framework for mobile cross-platform development by the middle of next year. If you can’t wait, stay tuned because a release candidate will be out very soon

2. Visual Studio 2022 for Mac: This tool, which was once known as Xamarin Studio, is used by developers who use MacOS environments. For this version 2022 a new version was created using native components to achieve an improvement in performance. The bad news are that we don’t have currently a stable version, but we will soon in 2022. If you want to try, you can find a preview version that can be downloaded here.

3. C#11: Although there is no official announcement of what will come in the next version of this programming language, some issues have already appeared in the Github repository that give us some clues. For example, the keyword field and list patterns, features that were left out of version 10. When ? Probably at .NET 7 release.

4. Microsoft Build 2022: Starting in Q2 2022 we will find Microsoft’s most important developer-oriented event: Microsoft Build. This event, that used to be face-to-face, adopted full-remote in recent years due to the pandemic and although there is no official announcement of the event, we can imagine that it will continue in the same way. In this event the releases roadmap is usually announced for the rest of the year, will it be the chance to see the stable version of .NET MAUI?

5. .NET 7 release: Although .NET 6 is a long support version, the roadmap for this technology tells us that in 2022 we will have version 7 available. This version will be very important for the integration of .NET MAUI, since it will be the first version that supports it from the beginning. When ? November 2022, and as expected a new edition of the .NET Conf will accompany this release.

What are you looking forward the most? I definitely vote .NET MAUI release !

On behalf of the Xablu team, we wish you a great 2022!

The post 5 things for .NET MAUI devs to look forward to in 2022 appeared first on XABLU.

.NET Conf 2021: Updates in .NET MAUI

Sebastián Pérez — Wed, 24 Nov 2021 13:13:08 +0000

In the previous post I shared the videos that I recommend to see of the conference, however we didn’t see anything on .NET MAUI. Why? First because I was planning to do it in this post, but mainly because we are still in a preliminary version of this new .NET component and there weren’t many announcements.

To start, if it is your first approach to .NET MAUI I recommend you to read this post and watch this video of the conference:

A very interesting functionality that was presented is to use the controls already known in Xamarin Forms but a drawn version instead of its native version:

Blazor + MAUI: We can write web applications with Blazor in the same way as we did before but adding the chance of deploy them also on mobile devices:

Finally I here you have some updates related to one of the most used libraries which was created and maintained by the community: (Former Xamarin Community Toolkit) .NET Maui Community Toolkit

Although there were no big announcements, this point helps us to catch up and be ready for when the stable version comes out next year. Stay connected !

The post .NET Conf 2021: Updates in .NET MAUI appeared first on XABLU.

.NET Conf 2021: 5 videos you have to see

Sebastián Pérez — Thu, 18 Nov 2021 04:22:01 +0000

The new version of .NET was released and the best place to present it is the most important conference that this platform has: .NET Conf. The conference was held over 3 days and had more than 100 speakers from around the world. And as I mentioned in the last post, I had the honor of being as a speaker

The conference had several topics of interest related to the launch of .NET 6 of which I will recommend 5 videos you have to see:

Keynote: General overview on what’s new including some very interesting metrics.

2. What’s new on C#: Details on this new version of the most used language in .NET.

3. .NET Hot Reload: Something familiar to Xamarin developers now applied to .NET.

4. Minimal API: Don’t forget to read this post before !

5. Creating NFT with .NET: My talk about implementing NFT on blockchain using .NET

You can see more videos on .NET playlist: dotNET – YouTube

Unlike the previous version (.NET 5) this new version shows a remarkable level of improvement and stability. I’m really excited about the idea of starting to develop with this platform. What do you think? Are you excited?

The post .NET Conf 2021: 5 videos you have to see appeared first on XABLU.

.NET Conf 2021 is coming

Sebastián Pérez — Tue, 09 Nov 2021 16:58:32 +0000

As every year there will be a new edition of the most important .NET conference in the world: .NET Conf. This year will feature two tasty ingredients: the release of .NET 6 and … my first participation in the event

The conference will be held from November 9th to 11th and will focus mainly on what is new that introduces .NET 6. Also, it will introduce Visual Studio 2022 that has been recently released and we can see some news about .NET MAUI (preview 10). If you want to know more about the topics that will be presented I invite you to read these posts:

You can follow all the news of the event in the following link: .NET Conf 2021 (dotnetconf.net)

Finally, I invite you to be part of my presentation on “Creating NFT with .NET” next Thursday 11th at 6 am (PT) / 10 am (ARG) / 2 pm (NT). See you there !

The post .NET Conf 2021 is coming appeared first on XABLU.

.NET MAUI: Implementing platform behavior

Ruud Kobes — Fri, 17 Sep 2021 15:16:07 +0000

.NET MAUI is right around the corner. Like its predecessor it offers sharing most code while building for multiple platforms. This includes the UI part. Of course there are still elements that require access to the platform, like accessing the camera, or something less common like customizing HttpMessageHandler behavior on iOS.

For common use-cases Xamarin.Essentials was offered to Xamarin Forms users. Now with MAUI this library will be included in your application by default (named MAUI Essentials), making it easy to use SecureStorage or implement permissions on Android and iOS. Additionally there is a MAUI Community Toolkit which, as the name implies, provides free tools: effects, converters, controls and more.

Manual platform implementation

In some apps .NET MAUI with the Essentials pack and the Xamarin Community Toolkit can be sufficient. For most apps though, there is a point where some custom adjustment is necessary. A good example would be control adjustment using Handlers or Effects. We’ll describe Handlers and their value in more detail in a future blogpost.

There are several ways to go about defining platform specific behavior in MAUI. Because of multi-targeting the code will be in the single shared project. With Xamarin Forms this was also possible using the Shared Project architecture, but the recommended and most common approach was using a PCL and implementing platform behavior using dependency injection. Let’s run through some options!

Using #if

To add a few lines of platform-specific code to an otherwise shared class we can use compiler directives like #if __IOS__. This is a quick and easy solution and keeps the related code close together, in the same file. For smaller handler mappings this could be a nice and easy to manage approach. It could also make Effects easier, because we don’t need the routed effects and DI registration of every platform implementation. With larger sections of platform-specific code this can get messy and harder to read though.

				
					//SecureSettingsProvider.cs

namespace MyApp.Settings;

public class SecureSettingsProvider
{
    public string GetSecureSetting(string context, string key)
    {
        return GetLocalSetting($"{context}-{key}");
    }

    private string GetLocalSetting(string contextSpecificKey)
    {
        #if __IOS__
        // retrieve value from secure storage / keychain
        #elif __ANDROID__
        // do the same for android
        #endif
    }
}

Using platform folders

MAUI projects using the single project structure will provide platform folders out-of-the-box. They will be compiled conditionally by default, e.g. the Android folder will only be included when building for Android. Within this option there are still 2 distinctive approaches:

Dependency injection using interfaces

Like the old-school Xamarin Forms pattern, using an interface in the cross-platform code, and explicit implementations in each platform folder. Any logic that could be shared will have to be copied between the implementations, although to make it slightly more complex, one could also define a cross-platform base class.

Partial classes

Partial classes are not a new concept in C#. Check the docs if you want to read more about them. We can define one cross-plaform partial class and another partial class with the same name and namespace in each platform folder. This is a pretty clean alternative to using #if directives when working with larger classes/code sections. A potential disadvantage of this approach is that both partial classes live quite far-away from each other, which could hinder discoverability and increase cognitive load, if there is a lot of shared code. If the partial class has little shared code, the experience is a lot like using interfaces.

				
					//SecureSettingsProvider.cs in shared code

namespace MyApp.Settings;
public partial class SecureSettingsProvider.cs
{
    public string GetSecureSetting(string context, string key)
    {
        var settingValue = GetLocalSetting($"{context}-{key}");

        // do some work that's shared between implementations
        if(String.IsNullOrEmtpy(something))
          return "nothing";
        else
          return settingValue;
    }
}

				
					//SecureSettingsProvider.cs in Android platform folder

namespace MyApp.Settings;
public partial class SecureSettingsProvider.cs
{
    private string GetLocalSetting(string contextSpecificKey)
    {
        // retrieve secure setting value for Android
    }
}

Using filename based conditional compiling

This pattern is used in the MAUI github repository itself. Concretely this again means using partial classes, but this time the platform specific implementation is defined in the same folder in a separate file. For example for our SecureSettingsProvider, we would have a partial class in SecureSettingsProvider.cs and another one in SecureSettingsProvider.Android.cs, SecureSettingsProvider.iOS.cs , etc.
A potential advantage of this is that platform implementations are directly next to the shared part, which improves discoverability and can reduce cognitive load.

This approach is not supported out of the box though. The compiler needs to be informed which files to include or more accurately, which NOT to include, so we need to add this information to our project file. For an example of how this could look, see the first +-30 lines in MultiTargeting.targets file in the MAUI repository. The following sample is taken from line 2-7 there and slightly adjusted:

				
					<ItemGroup Condition="$(TargetFramework.StartsWith('Xamarin.iOS')) != true AND $(TargetFramework.StartsWith('net6.0-ios')) != true AND $(TargetFramework.StartsWith('net6.0-maccatalyst')) != true ">
  <Compile Remove="**\**\*.iOS.cs" />
  <None Include="**\**\*.iOS.cs" Exclude="$(DefaultItemExcludes);$(DefaultExcludesInProjectFolder)" />
</ItemGroup>

This ItemGroup definition informs the compiler to ignore all *.iOS.cs files in the project unless the current build target is Xamarin.iOS, net6.0-ios or .net6.0-maccatalyst. Similar project configuration can also be used to allow for custom platform folders thoughout the code:

				
					  <Compile Remove="**\iOS\**\*.cs" />
  <None Include="**\iOS\**\*.cs" Exclude="$(DefaultItemExcludes);$(DefaultExcludesInProjectFolder)" />

Which option is best?

As always in software development, the answer here is “it depends”. For multitargeting libraries, like MAUI itself, it is likely a good option to look at the the filename or nested folder approach we discussed. With a little project setup this allows you to group code by functionality, keeping related code close together.

For apps, it depends on how much platform-specific code really needs to be written. For some apps only a few adjustments may be needed using Effects, Behaviors and handler mappings. It is very possible for these to be only a few lines which allows for keeping everying in one file using #if directives. If these grow it is convenient to use the existing platform folders. In both these alternatives you can forego the need to use interfaces and register the platform services for dependency injection which can be convenient.

Please note that we’ve been looking at these patterns fairly strictly from MAUI perspective. Of course it is possible that you prefer to use interfaces to making testing and mocking easier. In that case you will be setting up the DI container anyway. It may still be easier to register one implementation and use above options, instead of registering every platform service separately, but keep in mind your overall architecture before choosing any of these patterns.

The post .NET MAUI: Implementing platform behavior appeared first on XABLU.

10 Things You Should Know About Xamarin

Sebastián Pérez — Thu, 06 Aug 2020 15:25:13 +0000

Xamarin is used to create amazing cross-platform mobile applications! Did you know that cross-platform means you can actually share classes across .NET platforms?

Our colleague Seba takes center-stage to explain 10 different things you should know about Xamarin. He shares some core definitions for Xamarin, as well as how to use it in practice:

Here is a summary of the ten points Seba described:

You can create amazing applications using .NET as a platform. You can write C# code, as well as F# code. Basically, you can write everything you want using .NET as a platform.
Creating a library with Xamarin using .Net Standard, means you can share this library with other platforms, such as .NET core. Therefore, you can reuse your libraries.
The combination of the .NET environment and Visual Studio means you can write your application on both Windows and Mac machines.
Xamarin is cross-platform! You can share modals, classes and logic functionality across all the platforms, such as Android, iOS and Windows. In practice, you can share 75% of your code!
Xamarin will compile your application as native: there is no additional layer between Xamarin and your application. Your application will have native controls and native performance! Also, this allows you to use all the functionalities your devices offer.
In the traditional approach, you will have different projects with different views for each platform. However, Xamarin.Forms actually does allow you to share views across platforms as well. In Xamarin.Forms, you can write XAML views. It will still include native controls in the different platforms. Tip: take a look at Xamarin.Forms if you want to work with Xamarin for the first time.
Xamarin Essentials allows you to add device functionality, such as GPS, to your Xamarin.Forms projects. Xamarin Essentials is included with the Visual Studio application you need to install to start working with Xamarin.
Xamarin is open-source: you can find all the code in GitHub! There are more than 60.000 contributors: a real big and active community which we cherish at Xablu a lot!
There is a great community working with Xamarin. There are a lot of videos, blogs and youtube channels to find the information to learn about using Xamarin.
Xamarin is free! It has no licenses for commercial use! If you want to publish your apps, you do have to pay the platform subscription, such as for Apple or Android, but you never have to pay a fee for using Xamarin.

What is your favourite point on this list?

The post 10 Things You Should Know About Xamarin appeared first on XABLU.

Meet the Developer: 5 questions for our newest developer Luuk Jongebloet

Sabine Alberts — Mon, 22 Jul 2019 08:24:29 +0000

A few weeks ago, Luuk Jongebloet, officialy became a team member of Xablu’s Xamarin Development team. We’ve asked Luuk to answer a few questions. Curious about Luuk? See his interview below!

What brought you to Xamarin development and where do you want to go with it?

For me it all started some time ago, in 2015, with the development of a smartwatch application. This whole process of creating fascinated me. Seeing something rise and evolve every time you adjust the code makes my job fun and lively.

As a developer I want to be able to create many iOS and Android applications which result in an easier and beneficial life for the end-user.

What’s the coolest thing you have ever been working on regarding development?

That must be the creation of an AI robot car which is able to imitate a train! This specific “train” is following a set track, and while it goes, it is picking up people from set stations. That sounds like some cool stuff right?!

What has your experience at XABLU been like so far?

Xablu, in its essence, is a group of carefully handpicked Xamarin professionals. All with very high expertise in my opinion. Being a part of this team is great. Next to that, being a team member, also enables to learn a bunch of new things from my colleagues all the time.

How do you like to spend your free time?

I like to spend my free time with either gaming, working out in the gym, and of course some quality time with friends has never hurt anybody.

What’s your favourite food?!

I can’t say for certain since I like á LOT of food! But lately I do like to eat ramen. Ramen is a Japanese dish, very salty, and mainly consisting of wheat noodles.

Good luck to Luuk from the whole team!

We’re always happy to grow our team with eager developers interested in working their hand at real app projects.

Curious how Xablu can help your organization ?

The post Meet the Developer: 5 questions for our newest developer Luuk Jongebloet appeared first on XABLU.

.NET Archives - XABLU

Managing Software Development: From Performance Art to Operational Excellence

Table of Contents

Performance Art in managing Software Development

Transitioning to Structured Management with OKRs and Agile

OKR Initiatives are the Waterfall Connection with Agile

Achieving Operational Excellence

Additional Support

Maximize Your Mobile App’s Potential with .NET MAUI: A Migration Guide

Table of Contents

Why it's Time to Move On

Advancements and Improvements in .NET MAUI

Strategic Integration of OKRs, UX and Agile in .NET MAUI Development

Keeping the User Front and Center

DevOps and Migration: Like Peanut Butter and Jelly

The Step-by-Step Migration Playbook

Watch Out for These Migration Speed Bumps

Additional Support

Unlocking the power of .NET Blazor: using component libraries for development

Table of Contents

Understanding Blazor

The role of component libraries in the development of Blazor

Blazor development phases

Optimizing Blazor performance

Customizing Blazor components

Additional Support

5 things for .NET MAUI devs to look forward to in 2022

.NET Conf 2021: Updates in .NET MAUI

.NET Conf 2021: 5 videos you have to see

.NET Conf 2021 is coming

.NET MAUI: Implementing platform behavior

Manual platform implementation

Using #if

Using platform folders

Dependency injection using interfaces

Partial classes

Using filename based conditional compiling

Which option is best?

10 Things You Should Know About Xamarin

Meet the Developer: 5 questions for our newest developer Luuk Jongebloet

What brought you to Xamarin development and where do you want to go with it?

What’s the coolest thing you have ever been working on regarding development?

What has your experience at XABLU been like so far?

How do you like to spend your free time?

What’s your favourite food?!