Now we are talking about entire apps being built with that stuff, down to the window border (or lack of it). It's impossible to have a consistent looking and working OS with this approach. It's impossible to share code between these things and the actual native apps, and often things have to be written from scratch and end up using 10x memory than the native solution.
Not very useful because you quickly realize you mostly obscure your desktop with actual applications you want to use on your computer.
But you don't. So it doesn't.
(I've pinned Visual Studio to the start menu.)
https://www.windowscentral.com/microsoft/windows-11/after-30...
---
Type something in the Start menu
Top right meatballs menu button
'Search settings'
'Let search apps show results' -> Off (or disable only Bing)
---
I don't know about the Home edition.
You can also launch that Settings page by running in powershell:
Start-Process "ms-settings:cortana-windowssearch"
Or just 'Settings' and in the left navigation 'Privacy & Security' -> 'Search'If I type "Visual Std" instead of "Visual Stu" it goes to the Bing results.
Alternatively it shows No results if you disable Bing in the Search settings found in the top right meatballs menu.
I also would expect fuzzy search by default instead of typos sending users to Bing.
When I use the Windows key to open the Start menu I cannot reproduce this, as eg. Win + E opens the Explorer instead of the Start menu.
It does not appear on my machine as if this could possibly happen when opening the Start menu during regular use. Can you reproduce this on your machine?
> orrelates with missing the first letter off
Intended?Still, that shows an issue of using fuzzy search for Bing but not programs. There should be a precedent on local items. A typo is far more likely than a web search, especially when the web search is resulting in the intended application.
Did no one think of that feedback loop? That if the web search is suggesting an installed app that that installed app should be prioritized?
You know, like KDE Plasma in 2026.
It’s been this way for over a decade. The year of the Linux desktop was 2009; the world is only just catching up.
Yeah, that’s a misconfigured system. I bet you can fuck up Linux enough to get a similar experience.
I’ve always been using Windows and the only time I ever had to wait that long was around the Win98 times on slow hardware.
After login, I can instantly use everything on Win 11, and the only delay is a bunch of apps starting (that I chose to start on boot).
One can only imagine what the product managers of like .NET think of all this.
At least in Windows 10, there was even still the occasional Windows 3.1 file picker hanging around in the really dusty locations
And I say this hating everything about Microsoft and Windows. That phone clicked just right with the tile design and overall usability. Of course, MS having pulled the plug, it's basically a DRM brick now.
MeeGo from Nokia was pretty amazing as well and I'm sure it could have launched Linux phones into actual competitors to iOS and Android - if only Microsoft and Elop didn't manage to kill Linux at Nokia.
The game was broken from the start. Microsoft had no chance.
If it wasn’t for 3rd parties sunsetting their apps, there would have been no reason to give it up.
Despite being a highly underpowered dirt cheap phone it was incredibly smooth and fast to use.
Unfortunately it was a big ball of mud in mismanagement.
But this results in chasing a new paradigm every few years to elicit new excitement from the developers. It'll always be more newsworthy to bring in a new framework than add incremental fixes to the old one.
React has had tremendous success in the web world, so why not try and get those developers more comfortable producing apps for your platform?
(Tangentially, see also the mixed reaction to Mac native apps switching from AppKit to SwiftUI)
IIRC .NET was banned from core Windows components after longhorn died, but its been 20 years. .NET is fast now, and C++ is faster still. Externally developed web frameworks shouldn’t be required for Windows.
Microsoft has produced some great technology and when I was last there I was definitely focusing on getting as much of the good stuff out into open source as possible.
Back in the early V8 days the execs imagined JavaScript would keep getting exponentially faster, I tired to explain with a similar investment anything V8 could do dotnet could do better as we had more information available for optimization.
Windows team even refuses to have managed bindings for DirectX, like Apple and Google do on their platforms.
Managed DirectX and XNA were pushed by highly motivated individuals, and lasted only as long as they stayed at Microsoft.
DevDiv is a "here C++ rules!" silo, even the Rust adoption is being widely embraced at Azure, less so on Windows team.
Basically you have tight OS integration vs developer friendly cross platform.
That was my impression of one of the major problems when I worked there 2008-2011. But I don't think it's just one problem.
Besides, because it's an older company, it might have more organizational entropy, i.e. dysfunctional middle-management. As you say it's probably several other causes too. But still, hard to understand how they can create F#, F*, and Dafny, just to name a few, and fail with their mainstream products.
All different business units.
I think a few years after I left when more Big Tech opened offices in Seattle, competing companies started paying Bay Area salaries for Seattle living, removing this argument. I haven't watched this closely in recent years.
But fwiw, I was able to save and invest a lot in my Seattle days, despite a salary that was lower than in the bay.
Amazon also isn't a restaurant, and while they do sort of sell groceries through Whole Foods and Amazon Fresh, those are again priced locally.
Basically the housing price difference can mean buying a nice house close to your job vs renting a room in a share-apartment.
Best of both worlds is to save in a high-cost area then move to a cheaper area.
I don't know. I know there are a lot of people who want to work on the OS source code, given the chance, but need some hand holding in the beginning. Companies in general are not willing to give them the chance, because they don't want to hand hold them.
It is my opinion that developer ability is on a Pareto distribution, like the 80 20 rule when 80% of the work is done by 20% of the people. The job market is more liquid for those that are extremely productive so it’s pretty easy to for them to get a pay rise of 30% by switching companies. In the worst case you can often come back with a promotion because, like many companies, Microsoft is more likely to promote you when trying to poach you back. Doing a 2 year stint at Amazon was quite common. The other problem is that when your best people leave is that the process is iterative, not only are you getting paid less but you are now working with people who couldn’t easily switch jobs. You start being surrounded by incompetence. Stack ranking, which I hear is still being done unofficially, also means that you put your promotion and career in danger by joining a highly productive team. So it is rather difficult to get highly productive people to work on the same team.
Being paid less, being surrounded by incompetence, and being forced to engage in constant high stakes politicking really sucks.
Otherwise as you said the only way is to offer the best compensation so that people don't leave. But again those people probably would leave for different reasons (culture e.g.).
But the actual issue is that if you underpay people they will not feel respected and valued so they will either not be motivated or leave. So you cannot pay below market, but you do not need to pay FB salaries either.
Also compensation is a sign of respect and influences motivation. If you position yourself lower in the market, there is no reason to deliver top results for less money, correct? This attracts mediocrity, especially in management, and slowly kills companies. Usually there is no way back, no large company can replace the entire management and once and the mediocre ones will reject new, better ones.
And the fact that it's impossible to poach people from companies offering a higher salary than you do. Unless you give them something more, like better conditions, or "mission", or the idea to work on something cool, but I don't think any of those apply to Microsoft.
I thought about this a lot while working at a high-growth company recently.
Decided that regular (quarterly) manager rankings (HR-supported, anonymous) by 2-3 levels of subordinates is the only way to solve this at scale.
The central problem is: assuming a CEO accidentally promoted a bad middle manager, then how do they ever find out?
Most companies (top-down rankings-only) use project success as their primary manager performance signal.
Unfortunately, this has 3 problems: (1) project success doesn't prove a manager isn't bad, (2) above-managers only hear from managers, and (3) it incentivizes managers to hack project success metrics / definitions.
Adding a servant/leader skip-level metric is a critical piece of information on "On, this person is toxic and everyone thinks poorly of them, despite the fact that they say everyone loves them."
Certainly, few companies have managed to avoid this trap. It's largely an unsolved problem.
I've often met managers and execs two levels above me that had a completely delusional view of what was going on below them due to lies spread by middle-management.
Corporate dysfunction made more sense to me when I realized higher execs, because of span of control, are too busy to dig into any issue themselves.
Consequently, it's trivial in most orgs for the only information path to be through managers.
Also why I think more effective execs tend to have parallel investigation resources. E.g. their do-anything assistant who they task with fact finding
Just go watch a few recordings on their YouTube channel.
Because web stuff utterly sucks for making UIs on the desktop. Microsoft either doesn't know this (bad sign), or is choosing to use the trendy thing even though it'll make their software worse for customers (a worse sign). Either way it's a very bad look from MS.
sadly I loved azure data studio despite its being afflicted with electron, but it became so bug infested they had to completely abandon it.
I attempted to use WinUI 3, and could not even get PNGs to render the colors correctly, no matter what setting I tried.
Then I gave Tauri a try, and everything worked out of the box, with the PNGs rendering even better than in the Windows Photos app.
Building the UI was much easier, it looked better, and you get to build the "backend" in Rust.
Nothing about this sucked.
my Windows API knowledge (essentially: just Win32) is still exactly as useful as it was then, having missed the 7 or 8 different UI frameworks in the interim
I think MFC is now long-time dead and buried, but at the time I liked it despite the ugly macros.
Since Vista most newer APIs are done in COM, or WinRT nowadays.
I've heard a Microsoft executive talk about win32 as legacy that they want to replace. I don't think that's realistic though, it's probably the last piece of technology keeping people on the platform.
https://learn.microsoft.com/en-us/uwp/win32-and-com/win32-an...
Win32, the C API, is stagnant since Windows XP, other than some ...Ex and ...ExN kind of additions.
As mentioned above, the new APIs are mostly delivered as COM, occasionally with some .NET bindings.
There is still a silo trying to push WinRT now on Win32 side, although given how they made a mess of the developer experience only those with Microsoft salaries care about it.
This oldie shows some of the background,
https://arstechnica.com/features/2012/10/windows-8-and-winrt...
Smells like Microsoft was trying to create APIs based on assumptions versus a 1:1 method that exposes managed code and hides unmanaged.
WinRT can be avoided if you don't do any modern stuff like the new context menu, WinUI, or Windows ML.
UWP as separate subsystem, yes it is deprecated, and no one should be using it, although Microsoft was forced to introduce .NET 9 support on UWP, because many refuse to move away from UWP into WinUI 3.0, given the lack of feature parity.
Now, when WinRT was made to also work on Win32 side, it also brought with it the concept of package identity, which forms a part of the whole app isolation from UWP similar to Android, now on Win32 as well, hence the MSIX.
https://learn.microsoft.com/en-us/windows/win32/secauthz/app...
On the specific case of the context menu, it depends on what is being done,
https://blogs.windows.com/windowsdeveloper/2021/07/19/extend...
You can work around app identity when using the suggested alternative of unpackaged Win32 apps with sparse manifests.
I've seen time and again, things like apps rewritten from scratch because nobody knew C++, and they only had C# devs. Or a massive runaround because the last guy on the team who knew C++ wrote a bunch of stuff and left a couple years back, and now nobody really knew how any of that stuff worked.
> React has had tremendous success in the web world, so why not try and get those developers more comfortable producing apps for your platform?
IMO - this is worth talking about. Zune, Windows Phone, and some others died when they did not, in fact, suck, and were pretty good products which while late to the game, could have competed if there had just been a decent app ecosystem.
Their only misstep was making one of their colorways poop brown! That and being too late to market with a phone that used the same design language
There was also the crap that was Windows Media Player 11 which I tried to like for about a month.
There was also the incompatibility with Microsoft’s own DRM ecosystem in PlaysForSure which was full of these subscription music services, some of which were quite popular with the kind of people that were inclined to buy a Zune: folks in Microsoft’s ecosystem that had passed up on using an iPod and used something from SanDisk, Creative, Toshiba or iRiver instead. This is because they wanted to replicate the entire iPod+iTunes model entirely.
The 2006 lineup of iPods was also particularly strong, and included the first aluminum iPod nano’s. When Microsoft announced and released the Zune, they were counter-programming against that, right into the Holiday season with a new brand that had no name ID, with a product that was just like the iPod, couldn’t play any of your music from iTunes or Rhapsody, but with… HD radio.
More than a few missteps were made.
> Their only misstep was making one of their colorways poop brown
i think the other big issue was calling it a 'zune' but thats just me...I mean, iPhone is a really ridiculous name as well if you stop to think about it.
Google was extremely aggressive in muscling Microsoft out. They refused to release a Gmail, YouTube or Maps client for Windows Phone but made sure those services did not work (properly).
And indeed on top of that, Microsoft switched UI frameworks 3 or 4 times. And they left phones behind on the old OS releases repeatedly, that then couldn't run the new frameworks.
Still, Windows Phone its UI concept was really great, and I sorely miss the durability of polycarbonate bodies versus the glass, metal and standard plastic bodies of today.
They basically couldn't stick to a strategy and alienated every potential audience one by one. I was trying to make a Windows Phone app back then and for developers they forced them to go through an extremely difficult series of migrations where some APIs were supported on some versions and others on other versions and they were extremely unhelpful in the process.
They had a great opportunity with low-end phones because Nokia managed to make a very good ~$50 Windows Phone. Microsoft decided there was no money in that after they bought Nokia they immediately wanted to hard pivot to compete head-to-head with Apple with Apple-like prices. They then proceeded to churn through 'flagships' that suffered updates that broke and undermined those flagships shortly after they released thus alienating high end users as well.
Having worked at Microsoft I think the greatest problem with the culture there is that everyone is trying to appeal to a higher up rather than customers, and higher ups don't care because they're doing the same. I think that works out OK when defending incumbency but when battling in a competitive landscape Microsoft has no follow through because most shot callers are focused on their career trajectory over a <5 year time frame.
I think Microsoft’s framework chasing has been a betrayal of that philosophy. Internal divisional politics have been major drivers behind fracturing and refusing to unify the stack and its UI approach, and without clear guidance from the Office team the direction of the entire platforms UI is opaque. Short term resume and divisional wins at the expense of the whole ecosystem.
A developer centric platform would let developers easily create platform specific UIs that look modern and normal. As-is the answer to how to ‘hello world’ a windows desktop app is a five hour “well, akshully…” debate that can reasonably resolve to using Meta’s stack. “VB6 for the buttons, C++ for the hard stuff” is a short conversation, at least.
I'll take AppKit -> SwiftUI over Win32-> windowsx.h -> VB6 -> MFC -> ATL -> WTL -> WFC -> WinForms -> WPF -> WinRT -> UWP -> WinUI3 -> MAUI.
Even with all that Microsoft still went outside and used React Native for the start menu and Electron for the Visual Studio installer and Visual Studio Code.
How long did it last. Ironically it still gives me the shits because you can't select text on Netflix's front end.
Building a macOS 26 only app in SwiftUI today is a great UX, just as fast as AppKit.
But it takes quite some effort to turn an iOS SwiftUI app into a real macOS experience. Though most macOS optimizations help for iPadOS as well.
UX was fine in the Windows Forms days, and WPF was a large step forward (responsive layouts, etc...). The problem was after that it all fell apart with Windows 8 and the attempt to switch to Metro, followed by the Windows Store fiasco and attempting to move to a sandboxed application model.
It all comes down to Microsoft's failure to adapt to mobile/tablets in so many ways. Which is kind of hilarious, because they had some really cool tech for the time (the PocketPCs were pretty fun back in the day, before touch came along).
But anyways, it is not the problem. The problem is just that Microsoft today is doing a terrible job.
The best example, I think, is the control panel. Starting from Windows 8, they changed it. Ok fine, you may like it or hate it, but to be honest, it is not a big deal. The problem is that they never finished their job, more than a decade later! Not all options are available in the new UI, so sometimes the old control panel pops up in a completely different style with many overlaps in features. And every now and then, they shuffle things around in hope that one day, the old control panel won't be needed anymore.
If you make a change, commit to it! If you decide to replace the old control panel, I don't want to see it anymore. It is certainly easier said than done, but if you are a many-billion dollar company and that's your flagship product, you can afford to do hard things!
Using a web engine to build UIs is fine too. As an OS-wide component, a web engine is not that big in terms of resource use, if properly optimized. The problem with Electron is that every app ships with its own engine, so if you have 10 apps, you have 10 engines loaded. But everything uses the same engine, and apps don't abuse it, then the overhead is, I think, almost negligible. It is rare not to have a browser loaded nowadays, so system components can take advantage of this. But again, you need to do it right and it takes skills, effort and resources.
I've worked with all major GUI frameworks, from MFC to Qt, they all suck compared with React/Vue
Every single web or mobile app does his own custom thing nowadays. As a user I couldn't care less how it's implemented, what I want consistency in behavior and style across the board.
It feels like this has been completely lost, even on platforms like mac where consistency used to be important.
I'd take MFC everything over random behavior if I could.
There are two kinds of consistency: across apps within a platform and across platforms within the same app. As someone who uses multiple platforms regularly, I have forever been annoyed when eg keyboard shortcuts change when I switch to a different computer, especially when I’m using the same app.
Apps like Discord, Spotify and VSCode are consistently the most pleasurable to use because they are largely the same.
For a unique piece of hardware like the old iPod, it made more sense to do your special custom UX as a unified product. But we’re talking about general purpose computers. The ”platform” shouldn’t be special imo, it should simply be predictable and stay out of the way. They mostly provide the same thing, like copy paste and maximizing a window, yet have different controls. This differentiation adds no value, at least to me.
If you need a lot of graphical elements and customization to get a look and feel that matches what you want, then yeah, nothing really beats html/css/js for both it's flexibility and available ecosystem.
But if what you need is an application with a button that does magic things when you push it, or a text box or table that allows for customization of the text color, then all the other types of UX frameworks work just fine. You just can't expect to do something like make a pretty chart.
Even the most complete “UI frameworks” on the web are full of holes, leaving you to build a patchwork monster out of a laundry list of third party widgets (all of which themselves are full of shortcomings and concessions) or build your own.
As an aside, this gripe isn’t exclusive to the web. It’s a problem with many others such as Windows App SDK (aka WinUI) and Flutter, among others. At least for the things I build, they’re unsuitable at best.
Late millennials and gen Z have been spoiled by declarative, reactive frameworks that work identically whether you're doing a local UI or the Web, and the tools (for example Figma) that have grown up around these frameworks. Using C++, Objective-C, or even Swift will be just fine for a personal project, but if you're talking something that needs to be maintained and refined over the long term by a team, you will have a much worse time finding people competent in those languages than in JavaScript+React+Electron.
This is also one of the reasons behind rewriting everything in Rust: C is so dangerous, people who don't already know it inside and out are unwilling to touch it. Virtually all of the younger system developers are already working in Rust, and would vastly prefer it over working in C given the choice, so keeping a C project maintained has gotten a whole lot harder.
I'd love to know where you get your statistics from.
FYI, as an anecdote, I am 'younger', in the sense of 'only recently joined the workforce', and I write 100+ lines of C and C++ a day, both at work and in side projects. Haven't touched Rust once, although I would like to get into it.
And funnily, the one UI framework I did use at work is Avalonia, which is strongly inspired by Windows Presentation Foundation.
Declarative UI has its upsides, but it’s hardly a panacea. There are places where it’s a straightforward dramatic improvement and then others where it’s an awkward contortion at best. Reactivity can be great but works in imperative setups too.
The explosion of popularity of front end web frameworks comes down almost entirely to two things: accessibility and commodity talent. It has a low bar to entry and JS+React is the closest the industry has come yet to achieving its undying dream of cheap, easily replaceable, interchangeable developers. In most other aspects it’s objectively worse than alternatives.
I remember when people argued that because the time spent running an app was so much greater than the time spent developing it that one should be more conscientious about a user's time than a developer's.
After all, wasting a minute of time from 20 million users is 38 man-years of lost life. Doing that just to save a developer a week or a month is ethically troubling.
Of course, people also upgraded their computers a lot less frequently and you'd publish minimum machine requirements for software which probably made it easier to make such arguments as you'd also lose customers if software was slow or had minimum hardware requirements a lot of people didn't have.
That largely went out the window with web developers where users were just as likely to blame browser makers or their ISP for poor performance. Now with app developers and OS makers doing it, I guess there's just so many users at this point that losing a few with older hardware just doesn't matter.
There was a cross-platform QT tool, running on macOS, Windows, and Linux, for debugging and updating the firmware for an embedded platform solution. macOS & Linux both were quick and fast to code. Windows needed more work and also an abstracted write management system because the application was bringing the OS to screeching halt while writing the debug messages to a SQLite database. The write issue was only on Windows. HTML pages / reports were being saved into the SQLite database and viewable with-in the application. This was all packed into a single file executable so nothing and to be installed, just copied to the computer and ran.
Often low-end hardware is sold in product solutions and frameworks like QT are better suited to make the end user happy with load and response time than HTML5. The only reason I find bloated frameworks being used on such hardware is because the developer only understood one programing language and one UI framework. The former developer who's job I took over jumped ship because he did not want to learn WPF and only knew WinForms.
QT, HTML5, React, WinForms, Gtk ... are all tools in a tool box and each has a proper usage. Hell, if I ever make an iPhone based application I will be learning Swift and the Apple frameworks for such a task.
Then I hear that now ctrl alt delete is a webview. Its difficult to believe. Do you have a reference?
how the OS implements what is displayed is irrelevant
windows has all kinds of virtualizations today, it can literally run web views in separate (invisible) VMs for security purposes
From the parent:
> if a OS manufacturer can’t be bothered to interact with their own UI libraries to build native UIs something has gone horribly wrong.
With SwiftUI you’ve been able to pick and choose where to integrate it over the years, it’s not like you had to go whole-hog.
> if a OS manufacturer can’t be bothered to interact with their own UI libraries to build native UIs something has gone horribly wrong.
I was merely extrapolating their conditions and their words.
It is inconsequential, until it isn't. In front of me I've got a 2017 lenovo thinkpad running the latest Fedora+KDE, as well as a 2025 HP elitebook running "last corporate-friendly-stable version of W11". I can pop open the lenovo, key in my session password and hit enter, and I'm instantly productive, with shortcuts like meta+E giving me a working file explorer within milliseconds. On the Windows' side, there are several seconds of delay between typing my password and the on-screen feedback. Once finally unlocked, I've got a laggy environment where OS-essentials like the start menu and file explorers take whole seconds to render and respond.
It's a shame, if you ask me, that a dozen-or-so CPU and "general hardware" generations between those two devices got to waste due to poor software engineering and practices. And I'm not even talking about quality/reliability which is another sore point for Windowses of late.
I even ran Windows 10 on Thinkpad x240 a couple of years ago, it also ran fine.
I honestly think that has way less to do with Microsoft, more of a representation of "software engineering" practices these days.
For example, Gnome shell has bunch of javascript in it, GTK has layout and styling defined in some flavour of CSS, etc.
I'm of opinion if you start writing OS userland in either javascript or python (or both), you should be fired on the spot, but I don't make the shots.
Most technical decisions aren't really driven by what makes a better end-user experience or a better product, it's mostly defined by convenience and familiarity of substandard software developers - with mostly and primarily web-slop background.
Compared to Windows it's of course absolutely unreal.
The software industry has always had more juniors than seniors so this issue of juniors calling the shots is not a new one but it does feel like it's been getting worse and worse... Now it's basically AI slop vibe coders calling the shots about coding best-practices.
KDE Plasma, which is in my opinion the most advanced desktop environment is written in Qt QML which is JavaScript. There are advantages to that over C++, namely your session won't simply crash.
(While you can use some JavaScript from QML, the application still have a C++ core. QML applications can still crash. There is no DOM with QML, no browser overhead)
Neglecting the fact that almost everyone else is doing similar things.
> For example, Gnome shell has bunch of javascript in it, GTK has layout and styling defined in some flavour of CSS, etc.
What GTK is doing isn't really any different than how many UI framework work and have done so for quite a while now.
Almost every desktop UI toolkit/library/framework in the past 15-20 years has the following:
- Markup interface for defining the layout. If they don't have that they have a declarative way of defining the UI.
- Some sort of bindings for popular scripting language that hook into native code.
- Some of styling language that isn't that different from CSS.
This has been the norm for quite some time now. It works reasonably well.
Futhermore there isn't much difference between what desktop developers are doing and what web developers are doing.
> I'm of opinion if you start writing OS userland in either javascript or python (or both), you should be fired on the spot, but I don't make the shots.
Why? I find Gnome works really well on Linux. I have a pretty nice desktop environment after adding two extensions (Dash To Dock and App Indicators). Gnome runs well on relatively ancient hardware I own (2011 Dell E6410) with a garbage GPU (it isn't OpenGL 3.3 compliant). It actually performs a lot better than some other DEs that are 100% native.
JavaScript is indeed a slow language. However in Gnome that isn't the bottleneck. People have been making UIs with JScript (basically JavaScript) using WSH back in the 90s on Windows 98.
> Most technical decisions aren't really driven by what makes a better end-user experience or a better product, it's mostly defined by convenience and familiarity of substandard software developers - with mostly and primarily web-slop background.
What makes a better end user experience has nothing to do with any of this. There has to be an incentive to create a good end user experience and there simply isn't in the vast majority of cases.
In many cases it doesn't matter really what the tech behind something is. Most popular programmings and associated frameworks all work reasonably well on machines that are over a decade old. I am running Discord on a 15 year machine dual core laptop processor and it works "ok".
So this sort of complaining about "modern devs" I've been hearing about for almost 20 years now. The issues I've faced with doing quality work has been almost always to do with how projects are (mis)-managed.
I've always wondered what things would be like the Microsoft break up went though, I really do think personal computing would be better off and the people involved would probably have even more money to boot
But if they don’t use web tech it would be too expensive to build the start menu in a way that works cross platform!
Oh wait
It doesn't help that their own UI libraries are unfinished, unpolished, hot garbage.
I commend on using React, though. Like it or hate it, React is the closest to one true framework for everything.
But no. We cannot have nice things. Microsoft has lost the ability and management capability to release nice things. For some reason, Microsoft is trying to reinvent the wheel with UWP (aka WinUI2) and WinUI3. They are trying to replace everything with these half-arsed libraries when very complete and well-thought, future proof stuff already exists in Windows' DNA. They are shitting on the work of their earlier engineering.
Yet somehow I am OK with gnome shell.
I am considering writing software specifically to feed random junk jnto Microsoft's telemetry cloud. I will call it "fusk-MS" and it will send random searches to Bing and fake screenshots of a linux desktop to copilot ten times a second until Microsoft stops acting like such a jerk.
I've noticed Microsoft has introduced things like programs hijacking the screen (e.g. first launch of Edge, even if the launch was unintentional) and they have been making it increasingly difficult to make a local account on installation (even in the Pro version). Things like promotions for Xbox whatever popping up while I'm at work also tweak me the wrong way. Of course they don't know I'm at work, which is all the more reason not to do it!
As an operating system, I would rate it as fine. Compared to Linux, it appears to have performance issues in some areas, with file access being the main one I notice. They have made some progress in some areas (improved terminal, winget for software management). Compared to Windows of 20 years ago, the base operating system appears to be much better. But none of that means little when your main goal is for the "operating system" to get out of your way and let you use what matters.
And that's just one example. I curse Microsoft every day.
Newer version of Windows seem to add latency were there was none before.
> OS manufacturer can’t be bothered to interact with their own UI libraries to build native UIs
i wonder if they ever thought about using copilot to fix that (insert thinking-face)Why they thought it couldn't be done with the .NET stack they already had (this was after the purchase of Xamarin and Blazor becoming a thing, mind you) still baffles me.
Haven’t used windows in five years or so but I’ve kept hearing bad things. This really is the icing on the cake though. Yea the AI stuff is dumb but if a OS manufacturer can’t be bothered to interact with their own UI libraries to build native UIs something has gone horribly wrong.