Forem: mtmattei

10 XAML Binding Pitfalls That Trip Up Even Experienced .NET Developers

mtmattei — Tue, 21 Oct 2025 02:47:16 +0000

Binding in XAML is one of the cleanest ways to keep your UI and logic in sync. You just have to know how it thinks.

Once you understand how {Binding} and {x:Bind} behave under the hood, how they resolve data, when they update, and what they quietly ignore, it stops feeling like magic and starts feeling like control.

These are the ten common binding pitfalls that, once you spot them, make XAML feel like the powerful, predictable system it was meant to be.

1. Missing DataContext

Your binding path looks correct but nothing displays. The Visual Studio XAML Binding Failures window shows "Cannot resolve symbol" errors. You forgot to set DataContext on the element or any of its ancestors.

Fix it by setting DataContext explicitly in code-behind or XAML, or use ElementName or Source to bypass DataContext entirely. In WinUI 3, {x:Bind} uses the page or control itself as the default source instead of DataContext, so you might not need DataContext at all.

For advanced scenarios where you need to bind to parent controls, check out AncestorBinding and complex UI hierarchies.

2. Binding path typos

Runtime bindings fail silently when you misspell property names because the reflection engine simply doesn't find the property. {x:Bind} catches typos at compile time, but {Binding} won't.

Switch to compiled bindings or use nameof(ViewModel.PropertyName) in code-behind scenarios. The XAML Binding Failures tool will surface typos in the error list during debugging.

If you want a quick refresher on how binding expressions are parsed, the Uno.Extensions Binding 101 guide walks through the fundamentals.

3. Wrong default binding mode

You use {x:Bind UserName} in a TextBox expecting two-way updates, but the value never propagates back to your ViewModel. WinUI's {x:Bind} defaults to OneTime, while {Binding} generally defaults to OneWay.

Add Mode=TwoWay explicitly:{x:Bind UserName, Mode=TwoWay}

Make this a code review checkpoint since it's easy to overlook.

Important Note:While {Binding} generally defaults to OneWay for most properties, certain editable properties like TextBox.Text, CheckBox.IsChecked, and Slider.Value default to TwoWay because they have BindsTwoWayByDefault metadata in their property definitions.

This means will work for two-way updates without explicitly specifying Mode=TwoWay. However, {x:Bind} always defaults to OneTime regardless of any property metadata, so you must always specify Mode=TwoWay explicitly for editable controls:

If you’d rather see real examples than theory, check out the x:Bind feature overview.

4. UpdateSourceTrigger confusion

Your TextBox binding only updates the ViewModel when the user tabs away, causing validation to feel sluggish. Both {Binding} and {x:Bind} default UpdateSourceTrigger for TextBox.Text is LostFocus.

Change to UpdateSourceTrigger=PropertyChanged for live updates:{Binding UserName, UpdateSourceTrigger=PropertyChanged} or {x:Bind UserName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}

Be aware this increases update frequency, so validate efficiently.

5. Converter overuse

You have dozens of IValueConverter classes converting booleans to visibility, numbers to strings, and dates to formatted text. Each converter invocation adds overhead and makes bindings harder to debug.

In WinUI 3, replace converters with function bindings that call methods directly:{x:Bind local:Helpers.FormatDate(User.BirthDate)}

Alternatively, add computed properties to your ViewModel that return pre-formatted values.

Note:WinUI 3 does not include a built-in BooleanToVisibilityConverter. Use CommunityToolkit.WinUI.Converters or implement your own.

The best practice in modern WinUI 3 is to use function bindings with {x:Bind} which eliminate the need for converters entirely.

6. Performance regressions in lists

Your list scrolls smoothly with 10 items but stutters with 1,000. You're using TwoWay bindings on read-only data, or you're triggering property change notifications too frequently during batch updates.

Switch read-only bindings to OneWay or OneTime. When updating multiple properties, suspend change notifications, make all changes, then raise a single notification. Consider using {x:Bind} with OneTime mode for static list data.

7. Asynchronously loaded data issues

Your bindings don't update when data loads asynchronously. The {x:Bind} initialization happens during the page's Loading event, before your async data arrives.

After loading data asynchronously, force compiled bindings to update by calling this.Bindings.Update(). For frequently changing data, use OneWay bindings instead of OneTime.

8. x:DataType missing in DataTemplates

Your DataTemplate bindings work but don't compile, losing all the performance benefits. Without x:DataType on the template, the compiler can't generate strongly typed code.

Add x:DataType="local:ItemType" to your DataTemplate definition. This enables compiled bindings for all {x:Bind} expressions within the template:

<DataTemplate x:DataType="local:Person"> <TextBlock Text="{x:Bind Name}" /> </DataTemplate>

9. Casting required for object properties

You have a property typed as object but actually containing a specific type. The binding {x:Bind MyObjectProperty.Title} results in a compile error because Title isn't found on type object.

Add a cast to your path syntax:{
x:Bind ((local:MyType)MyObjectProperty).Title}

This tells the compiler the actual type at compile time.

10. Trimming and NativeAOT breaks bindings

Your app works in debug but crashes in release when published with NativeAOT or full trimming enabled. Reflection-based bindings can't find properties because the linker removed metadata.

Migrate to compiled bindings ({x:Bind}, x:DataType}).If you absolutely need runtime bindings for dynamic scenarios, use DynamicallyAccessedMembers attributes to preserve the required metadata. Uno Platform fully supports compiled bindings across all target platforms.

Quick Reference: {Binding} vs {x:Bind}

Feature	{Binding}	{x:Bind}
Default Mode	OneWay (TwoWay for editable controls*)	OneTime
Compile-time checking	❌ No	✅ Yes
Default source	DataContext	Page/Control
Performance	Reflection (slower)	Compiled (faster)
UpdateSourceTrigger default	LostFocus	LostFocus
Function bindings	❌ No	✅ Yes
Requires x:DataType in templates	❌ No	✅ Yes

Summary

Bindings are sneaky. One minute your UI’s humming, the next, a blank screen with no clue why. It’s almost always the same villains: bad DataContext, wrong binding mode, or {Binding} doing reflection gymnastics behind your back.

{x:Bind} fixes most of that. It compiles your bindings, catches typos before runtime, and runs faster because it skips reflection. Think of it as {Binding} after a few cups of coffee and a performance review.

If you’re building with Uno Platform, use {x:Bind} by default. Keep {Binding} around only when things really have to stay dynamic. Add x:DataType, set your binding modes explicitly, and use the diagnostic tools. They may not be glamorous, but they will save your sanity.

For a deeper look at how binding ties into broader cross-platform UI patterns, see XAML Fundamentals for Web, Mobile, and Advanced Binding Techniques. or If you want to see how Uno Platform implements this system under the surface, check out the Uno UI x:Bind architecture guide.

Why Microsoft Won't Revive WinForms (And What Developers Are Using Instead

mtmattei — Tue, 30 Sep 2025 14:47:19 +0000

When a Reddit thread about "reviving WinForms" pulls in 350+ comments, it tells you something.

Developers still care about the fast iteration loop that WinForms nailed. Even if the framework itself is decades old.

"WinForms was ugly but damn was it fast."
"If WinForms worked on macOS and Linux, I'd still be using it daily."
"Microsoft will never revive WinForms. They barely keep it alive."

Then there's the XAML Designer for .NET MAUI thread on Visual Studio Developer Community. Started in December 2022. Over 3 years of developer requests for a visual designer.

In September 2025, Microsoft closed the thread with this response:

"A drag-and-drop UI designer is not part of our direction for .NET MAUI. We're focused on providing a high-fidelity design-time experience through XAML Live Preview and Hot Reload."
— Beth Massi, Microsoft [MSFT]

The community response was... mixed:

"Live Preview works fine after you build the UI. Then you don't need it." — Larry Leach
"Microsoft need to realise that a drag and drop designer and a hot reload system serve two distinct functions. One allows for content creation, while the other allows for content debugging and testing." — David Newman

These two threads, one about nostalgia, one about current direction, point to the same gap.

Microsoft isn't reviving WinForms. They're not building a designer for MAUI. But the need for a fast, reliable, visual UI workflow hasn't disappeared.

What WinForms Got Right (And What It Left Behind)

WinForms worked because it was fast.

You could drag controls, wire up events, and see results in minutes. For internal tools, dashboards, and small apps, nothing matched that loop.

But it wasn't perfect:

Windows-only lock-in limited its lifespan
High-DPI scaling was (and is) painful
Designer mismatch: what you saw at design-time rarely matched runtime
Messy at scale: small apps thrived, large ones turned brittle

Developers didn't love WinForms because it was modern. They loved it because it let them move fast.

Why Microsoft Won't Revive It

Microsoft has shifted focus.

Their investment is in web, mobile, and cross-platform frameworks like MAUI and Blazor. WinForms still runs. But it isn't evolving.

Designers in general have been deprioritized. Visual tools are expensive to build and maintain. The industry has moved toward code-first workflows. Microsoft's bet is on XAML Live Preview, Hot Reload, and AI-assisted development.

From the official response on the MAUI thread:

"You should be able to efficiently create and iterate on your UI, particularly when paired with Copilot Vision."

This is the stated direction. XAML Live Preview for design-time feedback. Hot Reload for runtime iteration. Copilot for code assistance.

The challenge? Many developers don't find this workflow as efficient as a visual designer. The feedback loop is still longer. You write XAML, preview it, adjust, repeat.

But productivity gaps don't disappear because the tooling changes. The demand for faster UI iteration is still there. Both threads prove it.

What's Out There (And Why It's Still Not Enough)

Let's talk about what already exists.

XAML Hot Reload and Live Preview

Visual Studio has two features: XAML Hot Reload and XAML Live Preview. Hot Reload lets you tweak XAML and see changes without rebuilding. Live Preview shows a real-time render of your XAML as you type.

But both have limitations:

Instability: Hot Reload frequently breaks or requires restarts
Design-time vs runtime gap: You're still editing code, not manipulating a live UI
Platform-specific: Works best on Windows, less reliable for iOS/Android emulators
Preview-only: Live Preview shows you the UI but you can't drag and drop controls

JetBrains Rider XAML Previewer

Rider has a XAML previewer that works across platforms. It's faster than Visual Studio's. But:

WPF-only. No support for MAUI, UWP, or WinUI3
Limited to preview-only. You're still writing XAML by hand
No drag-and-drop or visual manipulation

VS Code XAML Extensions

Extensions like XAML Complete add IntelliSense and snippets. But they're text-first tools. They don't solve the core problem: the feedback loop is still too long.

The gap: These tools are all improvements over writing raw XAML in Notepad. But none of them fully recreate the "drag, click, see it running" experience that WinForms delivered across all major .NET UI frameworks. They're either preview-only, framework-specific, or still require the rebuild-redeploy cycle.

Microsoft's position is that Live Preview and Hot Reload address this need. But for many developers coming from WinForms, the gap remains.

Hot Design: A Modern Take on the WinForms Loop

If WinForms was the "fast, drag-drop, get-it-running" bedrock, Hot Design is a modern, cross-platform successor built for the Uno Platform ecosystem.

Here's how it works.

The Mechanism

Hot Design is a runtime visual designer. It transforms your live, running app into a real-time design environment.

That means:

Changes you make in the designer are reflected in real, running UI, not a render approximation
You're manipulating actual controls with actual data contexts
Works with real data or mock data sources
Supports MVVM and MVUX architectures
What you see is what you ship. No design-time vs runtime mismatch

It's IDE-agnostic. Works in Visual Studio, VS Code, and JetBrains Rider. The designer syncs instantly with your XAML code.

The difference isn't just speed. It's flow. You stay in the design context instead of context-switching between editor, compiler, and emulator.

How It Addresses WinForms' Gaps

WinForms Appeal / Gap	How Hot Design Addresses It
Drag-and-drop + fast loop	Drag-and-drop + adjust UI in your running app, see changes instantly. No rebuild/deploy cycle
Windows-only lock-in	Runs on Windows, macOS, Linux, iOS, Android, and WebAssembly. IDE-agnostic (VS, VS Code, Rider)
Scaling / DPI pain	Test responsive layouts, switch themes, preview on remote devices in real-time
Messy at scale	Supports MVVM and MVUX architectures. Works with real or mock data sources
Designer instability	Built on Uno Platform's stable tooling, actively maintained since 2018. Integrates with Hot Reload
Limited reach	One codebase, multiple targets: iOS, Android, Web, Desktop

Key difference: Hot Design works at runtime, not design-time. Your app is running. You're designing in the live environment. That's how it avoids the preview vs runtime mismatch that plagued WinForms and still affects XAML Live Preview.

Why Designers Still Matter

Developers are tired of the compile-debug dance.

They want to see real changes in real time. That's what WinForms gave us. That's what we've lost in modern frameworks.

Visual designers aren't about replacing code. They're about shortening the loop. When you can preview real states, test across themes, and tweak layouts instantly, you save hours of context-switching.

That's productivity. That's flow.

A typical XAML tweak in MAUI takes 30-60 seconds (edit, build, deploy to emulator). Multiply that by dozens of tweaks per feature, and you're looking at significant time lost. Hot Design removes that cycle entirely.

Hot Design isn't nostalgia. It's a reminder that visual feedback still matters. Especially when you're building cross-platform apps where complexity multiplies.

The Bottom Line

Microsoft won't revive WinForms. But the gap it filled is still there.

Fast, visual, low-friction UI work. That's what developers want.

Hot Design isn't nostalgia. It's an attempt to solve the same problem WinForms solved, in a world where cross-platform is the default. Whether it's the right tool for you depends on your workflow and whether you're already in (or willing to adopt) the Uno Platform ecosystem.

But if you've spent more time fighting XAML preview bugs than actually designing? Worth understanding what's possible.

The WinForms iteration loop doesn't have to be a relic. It just needs to work across more than one platform.

10 Productivity Killers when using XAML (and How Hot Design Fixes Them)

mtmattei — Tue, 02 Sep 2025 18:13:15 +0000

Look, we've all been there. You make a UI change, hit build, wait for the app to compile, launch it, navigate to the right screen, and... the button's still three pixels off. Rinse and repeat. By lunch, you've aged a year and accomplished what should've taken ten minutes.

It's 2025, and you're still playing the "change-compile-pray" game.

Hot Design fixes that. With a single click, your running app becomes the designer. No context switching, no lost state, no rebuild purgatory. Just live editing where it matters

So let’s talk about ten classic XAML UI headaches and how Hot Design finally puts them out of their misery.

Uno Platform Studio
Uno Platform Studio is the premium companion to the open-source Uno Platform. It brings together a set of productivity tools; Hot Design, Hot Reload, and Design to Code—that help you move faster when building cross-platform .NET apps. No matter what OS or IDE you prefer, Studio keeps your workflow consistent and efficient.

Hot Design
Hot Design is a visual editor that works while your app is running. You can pause the app, make changes to the UI and jump right back in without a rebuild or restart. Every tweak you make stays in sync with your source code, so you get the speed of live editing without losing the reliability of your codebase.E.

1. Why do I need a full rebuild for one UI change?

The Problem: Every UI tweak requires a full rebuild. You spend more time watching progress bars than actually designing. Your coffee goes cold.

Hot Design Solution: Click once to turn your running app into a visual designer. Make your changes. Click again, and you're back in the app. No rebuild. No context switching. No existential crisis. Your changes happen in real-time on the actual running application, not some disconnected design-time surface.

2. Why does my app look different at design time vs. runtime?

The Problem: What you see in traditional designers rarely matches what you get at runtime. That perfect layout in the designer? It explodes when real data shows up. You're basically designing blind.

Hot Design Solution: You're designing on your actual running app with live data flowing through it. What you see is literally what you get because you're manipulating the real thing, not a simulation. No more surprises when you hit F5.

3. How do I test my UI with real data, not mock data?

The Problem: Mock data lies. Your beautifully crafted UI that handles five items gracefully turns into a dumpster fire with 500. You don't discover this until QA finds it. Or worse, production.

Hot Design Solution: Connect to your actual data sources and see how your UI behaves with real-world data: the good, the bad, and the "why does this user have 10,000 items in their cart?" Your data bindings update in real-time as you adjust them, so you catch issues while designing, not after shipping.

4. Do I really need to learn another UI designer??

The Problem: Most visual designers silo you into their unique environment. Different shortcuts, different workflows, different everything. You lose all your muscle memory and productivity tools.

Hot Design Solution: It works with Visual Studio, VS Code, or Rider, on any OS. Keep your key bindings, your extensions, your workflow. Hot Design adapts to you, not the other way around. Think WinForms designer, but cross-platform.

5. How do I debug responsive layouts faster?

The Problem: Testing responsive design means constantly resizing windows, switching device emulators, or maintaining a small electronics store worth of test devices. You miss edge cases until users with that one weird tablet complain.

Hot Design Solution: Switch between form factors with a single click. See instantly how your layout adapts to different screen sizes and orientations. Test on actual remote devices or emulators without redeploying. Find and fix layout issues before they find your users.

6. Do I really need to learn another flavor of XAML?

The Problem: You know what you want the UI to look like but translating that into XAML feels like writing poetry in Klingon. You type, rebuild, check, curse, repeat.

Hot Design Solution: Changes in the visual designer instantly sync to your XAML code and vice versa. See the XAML generated as you build visually, or code your XAML and watch it render live. It's bidirectional learning: you get better at XAML while being productive.

7. How do I quickly test light and dark themes?

The Problem: Supporting dark mode means testing everything twice. You inevitably miss that one label that becomes invisible in dark mode. Users notice. Twitter notices. Your manager notices.

Hot Design Solution: Toggle between light and dark mode with one click. See immediately how every element adapts. Fix theme issues on the spot, not after someone posts a screenshot of your invisible text on Reddit.

8. Where do I find the right property in XAML controls?

The Problem: XAML controls have approximately infinity properties. Finding the right one requires scrolling through endless property panels or diving into documentation. Half your day disappears into property hunting.

Hot Design Solution: Smart Properties surfaces the most important and frequently used properties right when you need them. No more spelunking through hundreds of properties to find BorderThickness. The common stuff is right there, the esoteric stuff is still available when you need it.

9. Why don’t my custom controls show up in designers?

The Problem: Your carefully crafted custom controls work great in code but turn into question mark boxes in designers. Third-party controls? Forget about it. You're designing around black boxes and hoping for the best.

Hot Design Solution: Custom and third-party controls render and behave exactly as they will at runtime because, well, they're actually running. See how that fancy chart component really looks with your data. Adjust properties and see real results, not placeholder rectangles.

10. How do I design for real app states?

The Problem: Traditional designers don't understand your app's state. You design for one scenario, but your app has fifty different states. The designer shows a perfect world that doesn't exist once real user interactions begin.

Hot Design Solution: Your MVVM or MVUX patterns work normally because you're designing against your running app. State changes reflect immediately in the designer. Design for the actual states your app will be in, not some theoretical happy path. Your view models are live, your commands work, your data flows.

The Bottom Line

Hot Designisn't just another visual designer for developers. It's a fundamental rethinking of how we build UIs. It collapses the artificial boundaries between design-time and runtime, between mockups and production.

You stay in flow. You see the real results. You ship better apps faster.

And your coffee stays hot.

3 more productivity tips for .NET developers

mtmattei — Mon, 07 Oct 2024 19:37:30 +0000

Welcome to the second edition of Productivity tips for .NET developers. This time around, we didn’t just stick to the Uno Platform team—we reached out to fellow developers from the .NET community to hear how they stay productive. From discovering creative ways to use new tools to sticking with those tried-and-true habits, these tips offer something for everyone.

Daren May
We asked for 3 tips and ended up with 5 — talk about being productive!

✨Top 3 Productivity Tips (+2 bonus tips):

Customize Visual Studio Window Title: Use the "Customize Visual Studio Window Title" extension to display repository and branch as well as the solution name in the VS title bar. This helps keep track of multiple instances of Visual Studio, repositories, and branches.
Embrace Command-Line and Scripting: Don't overlook the power of the command-line and scripting. Visual Studio, build systems, and Git have many powerful command-line options. Invest time in learning their full capabilities and a scripting environment like PowerShell to enhance your workflow.
Ask Questions Freely: Don't be afraid to ask questions, regardless of your position or seniority. No one knows everything, and your team, peers, and the community can all assist when an answer doesn't spring to mind. Remember, the only dumb questions are the ones that aren't asked!
Invest in Ergonomics: Pay attention to the ergonomics of your working environment. Factors like monitor height, standing desks, comfortable and supportive chairs, mouse, and keyboard can have a huge impact on your productivity and well-being over time.
**Continuous Learning: **Keep learning as nothing stands still in our field. What's considered best practice today might become legacy implementation tomorrow. Stay updated with the latest developments in the .NET ecosystem.

Follow Darren on: GitHub & Twitter

Leomaris Reyes (Microsoft MVP)

✨Top 3 Productivity Tips:

Resting is Part of Being Productive: Recognize that rest is crucial for productivity. An overworked brain doesn't function properly. When you take breaks and disconnect completely, your brain gets to rest. This can significantly improve your efficiency when you return to work.
Take Care of Your Mental Health: Pay attention to your mental health as much as your physical health. Listen to what your body tells you, whether good or bad. Don't hesitate to seek therapy when feeling exhausted, ask for a vacation when tired, or say "I can't" when overwhelmed.
Learn to Say No: Saying no is not a bad thing; it's both human and professional. Avoid overcommitting by saying yes to everything. Being selective about your commitments allows you to be 100% responsible for the tasks you do take on, leading to better quality work and less stress.

Follow Leomaris on: AskXammy& Twitter

Andres Pineda

✨Top 3 Productivity Tips:

Spend time learning your tools: Whatever tool you use to work, learn your way around it. You might not believe the amount of time you can save by using the shortcuts that are part of your developer environment.
Keep easy wins: We only sometimes have the chance to work on things that keep us motivated or when we have been working for a long time on the same task. In such situations, I often tackle low-hanging tasks that, after completion, will provide a sense of progress.
Organize your work around your most productive hours: There are times when you are more productive. Block that time in your calendar to focus solely on work

Follow Andres on: GitHub& Twitter

These productivity tips offer a range of strategies to help you work smarter, not harder. Whether it's leveraging new tools, improving ergonomics, or simply learning to say 'no,' there's something here for everyone to improve their workflow.

Have your own tips to share? We’d love to hear them! Drop your tips in the comments below and follow Uno Platform for more insights and updates from the .NET developer community.

Is the Web Browser the Most Important Platform for App Development?

mtmattei — Thu, 03 Oct 2024 14:52:41 +0000

As technologies like WebAssembly (WASM) and Progressive Web Apps (PWAs) continue to push the boundaries of in-browser functionality, the distinction between web and native applications becomes increasingly blurred. This raises a key question: has the web browser become the most important platform for app development?

The Shift in App Development

While native mobile and desktop apps continue to play a crucial role, web-based applications have come a long way. The reasons for this are clear: web browsers are everywhere, web technologies have dramatically improved, and the demand for cross-platform compatibility has surged.

But is the browser now the best target platform for apps? To answer this, I’ll explore the advantages and challenges of web browsers for app development and assess whether they’ve become the go-to platform.

Why the Web Browser Stands Out

It's widely acknowledged in the industry that the web browser has long served as a foundational platform for app development. This isn’t a new revelation; browsers have always been central in providing access to applications across devices. Their ubiquity, ease of deployment, and cross-platform nature are well-established advantages developers have leveraged for years. As these fundamentals remain strong, recent advancements in web technologies have further solidified the browser's position.

1. Web Browsers as a Ubiquitous Platform

Web browsers are found on virtually every internet-connected device, from smartphones and tablets to desktops, smart TVs, and IoT devices. This ubiquity brings several benefits:

Global Reach: A web-based application can be accessed by users around the world without needing platform-specific versions or app store approvals.
Seamless Updates: I can push updates immediately, ensuring users always access the latest version.
Cross-Device Consistency: Users experience consistent performance and data continuity across multiple devices.

With the introduction of WebAssembly, web browsers can now handle complex and computationally intensive tasks at near-native speeds:

High-Performance Web Apps: WebAssembly enables high-performance applications, such as games and video editors, to run in the browser.
Language Flexibility: Developers can build web apps using languages like C#, C++, Rust, and Go, breaking away from the traditional reliance on JavaScript.

That said, WebAssembly’s ecosystem is still fragmented. Tools like Emscripten (C/C++), wasm-bindgen (Rust), and JSGo (Go) serve different languages, but this complicates the standardization of interactions with web APIs, limiting broader WASM integration with web development.

It’s worth noting that while WebAssembly is a significant advancement, most web apps don’t use it directly or rely on it as part of third-party libraries. Web development is much broader, encompassing WebGPU, Browser APIs, ECMAScript advancements, and new CSS specifications.

WebGPU, the successor to WebGL, is particularly noteworthy because it provides direct access to the render and shader pipeline of the graphics card, bringing web performance closer to native for graphics-intensive applications.

2. Cross-Platform Development with Web Technologies

Cross-platform frameworks have solidified the role of web technologies in app development:

Unified Codebases: Frameworks like Uno Platform and .NET MAUI enable developers to write once and deploy across web and native platforms.
Web-Centric Frameworks: Web-based frameworks like Blazor or Flutter for Web allow developers to target web browsers with minimal additional effort.
Cost Efficiency: Building a single app for multiple platforms reduces development and maintenance costs, making the browser appealing.

3. Progressive Web Apps (PWAs): Bridging the Gap

PWAs have revolutionized web apps by offering features traditionally found only in native apps:

Native-like Experience: PWAs allow offline access, push notifications, and device hardware integration.
Instant Accessibility: PWAs can be accessed directly via a browser, bypassing app store downloads.
Automatic Updates: PWAs ensure users have the latest version by updating themselves automatically.

However, WebAssembly still faces challenges with browser integration, particularly with accessing the DOM (Document Object Model). While frameworks like Dioxus and Sycamore (Rust) have made progress, the lack of native DOM access remains a limiting factor for WASM's potential in web apps.

It's worth noting that there's a growing "grey area" with hybrid solutions like Uno Platform, Electron, and Blazor Hybrid, which further blur the lines between web and native applications. These frameworks allow developers to leverage web technologies while still accessing native features, including local storage (HDD/SSD) access, balancing web flexibility and native capability.

4. Economic and Market Considerations

From a business perspective, web apps offer significant advantages:

Rapid Iteration: Web apps can be updated instantly without the delays imposed by app store review processes.
Lower Distribution Costs: Web apps bypass app store fees, which can result in cost savings.
Market Flexibility: Web apps allow businesses to test and iterate ideas quickly without committing to native development.

Web apps also offer significant advantages in terms of maintenance. Developers don't need to support multiple versions of their product across different platforms. Instead, they can focus on maintaining a single, up-to-date version that's immediately accessible to all users with a reasonably current browser. This streamlined approach to maintenance can lead to significant time and cost savings over the lifecycle of an application.

Challenges of Web Browsers for App Development

Despite its many advantages, web browsers are not always the ideal platform, especially when compared to native apps.

1. Hardware Utilization and Performance

Native applications fully leverage a device’s hardware, offering advantages in:

High-Performance Apps: Applications requiring heavy computing power, such as 3D rendering or real-time video processing, are better suited to native platforms.
Device-Specific Features: Native apps can better integrate with hardware features like cameras, GPS, and local storage.

WebAssembly, though performant, still encounters specific bottlenecks. For example, string encoding mismatches (UTF-8 in Rust vs. UTF-16 in JavaScript) can cause performance hiccups. Additionally, WASM’s ability to fully harness hardware capabilities, particularly in browsers, is still evolving through projects like the WebAssembly System Interface (WASI).

2. Offline Capabilities

PWAs have improved offline functionality, but native apps generally provide more robust and reliable offline experiences. Apps like Google Maps, which rely on continuous background processing, still perform better as native applications.

3. User Experience & Interface Design

Native apps provide a more polished user experience because they can be fine-tuned to match each platform’s design guidelines. Web apps, on the other hand, may struggle to adapt to varying screen sizes and operating systems, leading to an inconsistent experience.

WebAssembly: Promise and Challenges

WebAssembly (WASM) holds immense potential for web development but also faces key challenges:

Fragmentation: The WASM ecosystem remains fragmented, with different tools and approaches for various languages. This fragmentation hinders broader adoption and complicates the standardization of WASM interactions with web APIs.
Standardization Efforts: Projects like WASI aim to create an ABI standard that facilitates better integration between WebAssembly and the host operating system. However, WASI’s full browser support, especially for web-specific APIs like WebGPU, is still a work in progress.
Ongoing Development: The WASM ecosystem is actively evolving, with updates to both WASM web APIs and the WASI component model.

WASI is particularly important in this space. It aims to standardize how WebAssembly interacts with system interfaces, potentially allowing developers like me to write "almost OS-native" applications in any language that can be compiled to WebAssembly. This could enable WebAssembly to run efficiently not just in browsers but directly on operating systems, expanding its potential uses.

That said, while WebAssembly and WASI hold great promise, they are still evolving technologies. Many successful web apps don’t rely on WebAssembly at all. The browser’s strength as a platform for app development comes from the entire ecosystem of web technologies, not just WebAssembly.

For more details on WebAssembly’s evolving features, visit the WebAssembly Features page. To follow the development of WASM and related feature proposals, check out WebAssembly's GitHub repository.

Hybrid Approaches: Bridging Web and Native Development

Hybrid development frameworks, like React Native and Uno Platform, address some of the trade-offs between web and native apps by allowing developers to write code that works across platforms:

React Native: Allows JavaScript to interact with native components, enabling a native-like user experience with less platform-specific code.
Uno Platform: Enables developers to build cross-platform applications with C# and XAML using a shared codebase that runs natively on various devices, allowing for a blend of performance and development efficiency.

So, is the Browser the Most Important Platform?

In short, the answer is yes—but it's complicated. The web browser has become a pivotal platform in app development thanks to its universal reach, ease of updates, and the advancements of technologies like WebAssembly and PWAs. For many developers, it's the go-to choice for building scalable, cross-platform applications quickly.

Ultimately, the web browser's strength as a development platform comes from its entire ecosystem of technologies—from JavaScript and CSS to WebGL and emerging standards like WebGPU. While WebAssembly is an exciting part of this ecosystem, it's just one piece of the puzzle. The browser's ubiquity, coupled with the rapid pace of web technology advancements and the large pool of skilled web developers, makes it an increasingly attractive platform for a wide range of applications.

So, is the browser the most important platform? It’s certainly up there, but whether it’s the most important depends on what your app needs to do—and how fast you need it to do it.

The new wave: Top 10 emerging .NET content creators

mtmattei — Tue, 03 Sep 2024 20:24:55 +0000

Whether you’re diving into .NET best practices, learning about architectural principles, or trying to wrap your head around microservices, there’s always someone willing to break things down in a way that clicks. The wealth of knowledge available in .NET community —from newsletters and blogs to vlogs and technical articles—makes it easier to keep growing and stay current.

We’ve grown accustomed to names like Scott Hanselman, Mary Jo Foley, Richard Campbell, and Tim Corey. Influencers that have become staples, not just in social media but also on conference stages, in magazine articles, and beyond.

But who are some of the newer .NET content creators who might one day reach the heights of these established figures? While this list is by no means exhaustive, it’s a great starting point to discover fresh perspectives and perhaps find a few creators you haven’t come across yet.

The List

1. Steven Giesel

About the author: Steven Giesel is a .NET Developer, and Microsoft MVP based in Zurich, Switzerland He’s an active maintainer of multiple open-source libraries and is passionate about both sharing and gaining knowledge. If you're into clean code, best practices, and Blazor, Steven is someone you'll want to follow closely. He’s a passionate advocate for writing maintainable, efficient code and dives deep into software development's technical aspects.

Main Content: What I love about Steven’s content is how practical and accessible it is. He has this knack for breaking down complex topics like software architecture and design patterns into actionable .NET tips that you can immediately apply to your projects. His content isnt just educational—its easily digestable must-reads if you’re looking to sharpen your coding skills or enhance your software architecture know-how.

If you're in Zurich, Steven regularly hosts meetups for the local .NET User Group, offering a great opportunity to connect and learn from him in person. He’s also recently launched a video series, which is another fantastic way to dive into his content.

Follow Steven: Blog | LinkedIn

2. Milan Jovanovic

About the Author: Milan Jovanovic is a Software Architect and Microsoft MVP who’s been in the tech industry for years but whose personal content has clearly resonated with the .NET community. Milan is one of those people who genuinely enjoys mentoring others—he’s all about helping software engineers refine their .NET development skills and deepen their understanding of software architecture.

Main Content: Milan’s content is where I go when I need to get my head around architectural principles, microservices, or cloud-native applications. He has a gift for making complex topics feel manageable, no matter where you are in your developer journey. His practical and personable approach makes learning from him both enjoyable and impactful.

Follow Milan: Blog | Twitter | LinkedIn | YouTube

3. Jade Wilson

About the Author: Jade Wilson is a Senior Software Engineer at Microsoft, known for her deep expertise in agile methodologies and DevOps. With a strong passion for building scalable and maintainable solutions, Jade is dedicated to helping customers succeed in delivering high-quality software.

Main Content: What I appreciate most about Jade’s work is how she brings agile and DevOps to life with real-world examples. Her advice is practical and easy to apply, regardless of the project you’re working on. She genuinely believes there’s no single “right” way to deliver software, and that open-mindedness makes her content feel like a conversation with a trusted mentor.

Follow Jade: LinkedIn | YouTube

4. Nick Randolph

About the author: About the Author: Nick Randolph might not be the loudest voice on social media, but he’s a go-to resource for developers interested in Windows and multi-platform development. As a Microsoft MVP, Nick shares his wealth of knowledge in a down-to-earth and approachable way, both on Twitter and through his blog. Whether you're a seasoned pro or just starting out, Nick's insights are always worth the read.

Main Content: Nick blog, "Nick's .NET Travels," is a treasure trove for developers interested in .NET, Windows, and cross-platform development. Covering everything from the latest in Uno Platform to practical guides on mobile and web development, Nick’s posts are designed to help developers navigate the evolving landscape of modern app development and offers a blend of technical depth and real-world applications that make it an essential resource for any developer.

Follow Nick: Website

5. Claudio Bernasconi

About the author: Claudio Bernasconi is a seasoned Software Engineer with over a decade of experience in desktop, mobile, and web development, all with a strong focus on the .NET platform. In addition to his technical expertise, Claudio is passionate about mentoring junior developers and helping them grow their skills.

Main Content: Claudio runs a popular .NET development YouTube channel where he shares his insights on process optimization, code quality, and building sustainable software systems. His content is perfect for developers looking to deepen their understanding of .NET and improve their overall coding practices. Claudio’s approachable style and commitment to quality make him a valuable resource for both new and experienced developers.

Follow Claudio: Twitter | YouTube | LinkedIn

6. Aram Tchekrekjian

About the Author: Aram is a seasoned .NET developer passionate about cloud computing, DevOps, and web technologies. His expertise spans .NET, Web APIs, and Web Security, focusing on cloud-based .NET applications, DevOps practices, and CI/CD pipelines.

Main Content: Aram is great at breaking down complex topics into bite-sized, easily digestible pieces. His carousels are always on point, and his blog, CodingSonata.com, pairs concise explanations of .NET concepts with classical music—how cool is that? Whether you're into cloud-based .NET applications or DevOps practices, Aram's content is as insightful as it is enjoyable.

Follow Aram: Blog | Twitter | LinkedIn

7. Leomaris Reyes

About the Author: Leomaris Reyes has quickly made a name for herself in the .NET community, and it’s easy to see why. As a Microsoft MVP, she’s a passionate advocate for modern software development practices and a strong supporter of women in STEM.

Main Content: Leomaris is the go-to person for anything related to .NET MAUI. Her content is comprehensive, from detailed UI tutorials to advanced coding techniques. If you’re diving into cross-platform development or .NET MAUI, you’ll find her content invaluable.

Follow Leomaris: Blog | Twitter| LinkedIn

8. Martin Zikmund

About the Author: I might be a bit biased since I work with him, but Martin Zikmund’s credentials speak for themselves. He’s a fantastic .NET developer, a Microsoft MVP, and a key contributor to the Uno Platform community—plus, he’s still holding out hope for a Windows phone comeback!

Main Content: Martin’s posts are packed with insights into cross-platform development, especially when it comes to Uno Platform and Windows technologies. His content is clear, accessible, and incredibly useful for developers at any level. If you’re looking to make cross-platform development more straightforward, Martin’s work is where you should start.

Follow Martin: Blog | Twitter | LinkedIn | YouTube

9. Nick Cosentino

About the Author: I recently stumbled onto Nick's content and really took to it. Maybe it's because he is a fellow Canadian, or maybe it is just that his passion resonates in his content. Not just a .NET enthusiast—he’s a passionate open-source contributor and, someone I’m excited to follow.

Main Content: Nick’s work spans a wide range of topics, from .NET performance optimization to open-source contributions. What I really appreciate is how he blends technical insights with the perspective of a software engineering manager. His focus on community engagement and knowledge sharing makes his content both informative and relatable.

Follow Nick: Website | Twitter| LinkedIn | YouTube

10. Oleg Kyrylchuk

About the author: Oleg Kyrylchuk is a software engineer who specializes in .NET technologies and scalable systems. His deep dives into performance tuning and distributed systems are nothing short of impressive.

Main Content: Oleg’s content is all about tackling advanced .NET topics and solving complex technical challenges. If you’re looking to improve your understanding of C# concepts, performance tuning or distributed systems, Oleg’s posts and newsletter are a fantastic resource.

Follow Oleg: Newsletter| Twitter | LinkedIn

I’m sure there are plenty of amazing .NET content creators we didn’t get to cover, so if we missed one of your favorites, drop their names in the comments! We’d love to hear about them.

If you’re looking for even more .NET content creators, I highly recommend the dotnet-content-creators list by Matthias—it’s one of the best and most up-to-date resources for finding creators of all kinds in the .NET community

3 productivity tips for .NET developers

mtmattei — Tue, 16 Jul 2024 18:57:35 +0000

The .NET ecosystem provides a variety of tools, and libraries designed to boost your productivity. However, there's invaluable insight to be gained from experienced developers who've honed their skills over the years.

To uncover these tips and tricks, we reached out to some of our seasoned Uno Platform developers. They've generously shared practical advice that has boosted their productivity—and can do the same for you

Dan Siegel - Microsoft MVP
Years of experience: 28 years writing code (14 full-time / professionally)
Dev Environment: Visual Studio on Windows
Favorite Library: Prism

Dan’s Top 3 Productivity Tips:

Step Away: Take breaks away from your computer. Many solutions to complex issues come to mind when you're not actively working on them.
“Honestly, you'd be surprised how many answers/solutions I come up with for things I'm working on when I walk away from the computer and go to lunch. I have even fixed bugs or come up with radical ideas for solving a complex issue while I'm on the dive boat. Software development is a creative process... and many times you need to get away from the computer to let your brain solve problems.
Development is a team sport. No matter how good you think you can make something, you’ll make something better collaborating with someone else. Sometimes, the simple exercise of explaining it to someone else can lead to mind-blowing breakthroughs.
When you’re working with open-source code, don’t be afraid to look at the code. You’d be amazed at how many things you’ll have a better understanding of just by looking at the code, and how many possibilities that will unlock for you.

Follow Dan on: GitHub & Twitter

Martin Zikmund - Microsoft MVP
Years of experience: 15 years
Dev Environment: Visual Studio on Windows
Favorite Library: Uno Platform (of course 😁)

Martin’s Top 3 Productivity Tips:

Invest in workplace: If you have control over your environment, investment into everything you are using while working is a worthwhile investment. This means a quality PC to ensure its performance does not hinder your efficiency; comfortable chair to save your back; standing desk; and ergonomic keyboard and mouse. You are likely spending a lot of time at your PC, so any investments in this regard are worthwhile as they will return to you in both health and time.
Use PowerToys: Don’t get me wrong, Windows is a productive OS out of the box, however, you can make it even better by extending it with useful tools. And one of the best comes directly from Microsoft – PowerToys! It is a set of small modules that enhance the OS in ways that will make it hard to imagine your life without after you integrate it into your workflow. I am currently making a series of videos about this on my YouTube channel, if you want to learn more!
Know your shortcuts: Nothing can speed up your work as much as knowing keyboard shortcuts of your IDE and other apps you use frequently. Just not having to reach for your mouse and being able to keep your hands on the keyboard saves a surprising amount of time! So, find the list of keyboard shortcuts, print it out, and start learning them as you go. My trick to learn faster is to put your mouse on the side of your non-dominant hand for 30 minutes. Just the fact that the mouse is not where you expect it will make force you to think whether using a keyboard shortcut could be better for that specific task!

Follow Martin on: GitHub & Twitter

Steve Bilogan - Microsoft MVP
Years of experience: 8.5 years
Dev Environment: Visual Studio on Windows / VS Code on macOS
Favorite Library: unoplatform/uno.toolkit.ui

Steve’s Top 3 Productivity Tips:

Take a walk, every couple of hours or whenever needed: walk around the block, let your mind wander, decompress, and come back fresh.
Visual Studio CTRL+T Quick Search can search by just the capital letters. Example: Searching for RDP.xaml will resolve properly to RecipeDetailsPage.xaml
Open on GitHub - Visual Studio Marketplace Great extension for quickly opening the highlighted lines in the browser from the GitHub repo. Great for needing to quickly grab the link to lines that you are talking about when communicating on Teams

Follow Steve on: GitHub & Twitter

Youssef Victor - Microsoft MVP
Years of experience: 2 years
Dev Environment: Visual Studio on Windows
Favorite Library: NodaTime, PolySharp

Youssef’s Top 3 Productivity Tips:

Master Keyboard Shortcuts: Learn to use Visual Studio's Quick Search (Ctrl+T) to navigate quickly through both your code and IDE features.
Leverage Multi-Caret Editing: Use your editor's multi-caret functionality in specific situations where it can significantly speed up your editing process. This allows you to edit multiple locations in your code simultaneously.
Consider using grep.app for advanced text searching within your codebase. It offers more powerful search capabilities than the basic search functions within your editor.

Follow Youssef on: GitHub & Twitter

Nick Randolph - Microsoft MVP
Years of experience: 30 years
Dev Environment: Windows (Desktop) + VS
Favorite Library: Moq for mocking interfaces for testing

Nicks Top 3 Productivity Tips:

Better team work through focused, and frequent pull requests.
Release when features are complete rather than try to hit arbitrary deadlines
Don't spin cycles; If you're stuck reach out to someone for help.

Follow Nick on: GitHub & Twitter

Forem: mtmattei

10 XAML Binding Pitfalls That Trip Up Even Experienced .NET Developers

1. Missing DataContext

2. Binding path typos

3. Wrong default binding mode

4. UpdateSourceTrigger confusion

5. Converter overuse

6. Performance regressions in lists

7. Asynchronously loaded data issues

8. x:DataType missing in DataTemplates

9. Casting required for object properties

10. Trimming and NativeAOT breaks bindings

Quick Reference: {Binding} vs {x:Bind}

Summary

Why Microsoft Won't Revive WinForms (And What Developers Are Using Instead

What WinForms Got Right (And What It Left Behind)

Why Microsoft Won't Revive It

What's Out There (And Why It's Still Not Enough)

XAML Hot Reload and Live Preview

JetBrains Rider XAML Previewer

VS Code XAML Extensions

Hot Design: A Modern Take on the WinForms Loop

The Mechanism

How It Addresses WinForms' Gaps

Why Designers Still Matter

The Bottom Line

Further Reading

10 Productivity Killers when using XAML (and How Hot Design Fixes Them)

1. Why do I need a full rebuild for one UI change?

2. Why does my app look different at design time vs. runtime?

3. How do I test my UI with real data, not mock data?

4. Do I really need to learn another UI designer??

5. How do I debug responsive layouts faster?

6. Do I really need to learn another flavor of XAML?

7. How do I quickly test light and dark themes?

8. Where do I find the right property in XAML controls?

9. Why don’t my custom controls show up in designers?

10. How do I design for real app states?

The Bottom Line

3 more productivity tips for .NET developers

Is the Web Browser the Most Important Platform for App Development?

The Shift in App Development

Why the Web Browser Stands Out

1. Web Browsers as a Ubiquitous Platform

2. Cross-Platform Development with Web Technologies

3. Progressive Web Apps (PWAs): Bridging the Gap

4. Economic and Market Considerations

Challenges of Web Browsers for App Development

1. Hardware Utilization and Performance

2. Offline Capabilities

3. User Experience & Interface Design

WebAssembly: Promise and Challenges

Hybrid Approaches: Bridging Web and Native Development

So, is the Browser the Most Important Platform?

The new wave: Top 10 emerging .NET content creators

The List

1. Steven Giesel

2. Milan Jovanovic

3. Jade Wilson

4. Nick Randolph

5. Claudio Bernasconi

6. Aram Tchekrekjian

7. Leomaris Reyes

8. Martin Zikmund

9. Nick Cosentino

10. Oleg Kyrylchuk

3 productivity tips for .NET developers