I certainly wouldn't expect anyone to know every answer off the top of their head, but talking through a candidate's educated guesses can be informative.
1,572 karma · joined April 24, 2015
I certainly wouldn't expect anyone to know every answer off the top of their head, but talking through a candidate's educated guesses can be informative.
I strongly support Trudeau's actions on this, and I'm sad that the government took so long to crack down on the "truckers". It's deeply damaging to civil society when a few extremists can shut down a city without consequences.
And sizes will be going quite a bit lower with NativeAOT this year.
The compiler is blazing fast and you get small fast statically linked executables by default. That's very appealing to me even though the language itself is a bit spartan.
If pressed I would say WinForms is the most practical choice for most apps today - even though it sucks, even though it's ugly. It's actively worked on (unlike WPF) and it lets you use the latest .NET version.
WebView2 (better Electron) is probably where most Windows development is going in the future, the Windows team is investing a heck of a lot more in it than other technologies.
idk, I hope I'm wrong but they have been promising improvements for a while and I'll believe it when I see it.
WPF has been more-or-less abandoned by the Windows team, and that's a little scary since VS uses WPF so much...
This is part of why the .NET hot reload fiasco was such a big deal to me; it felt like doubling down on one of .NET's biggest weaknesses.
I can speak to the UWP -> WinUI 3 transition a little: it's a hard transition because UWP did so many things its own way. It's often really difficult to migrate concepts from UWP to the Win32 app model. And I get the impression that the number of people working on WinUI+WASDK is pretty small; it's more of a "salvage what we can" operation than a "build out the future of Windows app development" one.
But, well... it certainly didn't help that they made it so difficult to adopt the new technologies. Project Reunion/WASDK makes it seems like they've learned that lesson and are trying to salvage what they can - but it's much too little and much too late.
They officially cancelled UWP 2 months ago, after a few years of "not quite dead, not actively supported" limbo. I guess it's settled down, but not in a good way. https://www.theregister.com/2021/10/26/microsofts_uwp_unwant...
FWIW they march to their own drum, they are largely independent of Windows and Developer Division. I would not tar all of Microsoft’s efforts with the same brush.
It’s not that simple. WPF has been mostly abandoned by the Windows team, while WinForms is owned by the .NET team and much better maintained. WPF will probably never be compatible with trimming and AOT compilation, WinForms will.
WinForms has its own issues, but there’s a reason why Scott Hunter recommended it over WPF at last year’s .NET Conf.
One thing to note: it was written for an older version of Notcurses. So some of the details aren’t 100% up to date, but it covers the fundamentals.
(but yes, true, WPF still works and it gets enough support to keep it limping along)
FWIW it was only recently migrated to a modern .NET version, give the latest version a spin if you haven't already.
Personally I think web UI via WebView2 is the only way forward; Chromium is far and away the most powerful UI framework shipping with Windows these days. Even if "native" UI frameworks were doing everything right, it's hard to compete with all the investments in Chromium.
P.S. WinForms isn't dead; it's maintained by the .NET team and it gets a lot more attention than WPF. But, well, it's WinForms :)
.NET apps can be published with AOT code (ReadyToRun). WPF apps are still pretty slow to launch with ReadyToRun enabled; I haven't profiled it to see why, but I suspect it has a lot more to do with WPF (somewhat abandoned for a decade, and the XAML bits have always been slow) than .NET.
In my experience the JIT penalty at startup isn't as bad as people think, the .NET JIT compiler is really fast and the average console app is very quick to start up.
It hasn't received major new features in a decade. It's currently owned by the Windows team (not the .NET team) and they have staffed it with a skeleton crew. They don't even have bandwidth to review most community PRs.
Even the .NET team doesn't get responses to issues they raise on the WPF repo: https://github.com/dotnet/wpf/issues/3811
Adding to all that, WPF has a massive dependency on C++/CLI which means it cannot take advantage of many new .NET features until that is rewritten. And from what I can tell (from the outside) that will never happen.
I've followed this rough pattern to build a rock-solid offline-first core for a personal application: https://flpvsk.com/blog/2019-07-20-offline-first-apps-event-... It's got some pain points; in particular it's quite difficult to evolve the schema once your app is out in the wild. But event sourcing is very amenable to TDD, and once all my tests were passing I had a nearly bulletproof solution for my current schema.
Strangely, offline-first functionality is usually not what event sourcing is pitched for. Maybe it's just a a legacy of its enterprise origins, but I often see it sold as a solution for enterprise applications where it's liable to cause more trouble than it's worth.
I would expect the additional checks on writes to be negligible in most cases (dwarfed by other bookkeeping and I/O). I imagine that strict mode could enable some optimizations for read queries, but I can't see those being huge wins.