Hacker News new | past | comments | ask | show | jobs | submit login
How one announcement damaged the .NET ecosystem on Windows (medium.com/ailon)
157 points by ailon on May 24, 2016 | hide | past | favorite | 95 comments

Great to see someone holding Sinofsky to task for this!

Some background, from what I recall: - During the planning for Windows 8 XAML was the leading candidate for the UI technology but late in the process Sinofsky personally overruled it to make HTML the preferred UI technology.

- Through the first half of Win8 development XAML support for Win8 was essentially a side project by DevDiv with very little support by Windows.

- Other orgs analyzing UI technologies we told point blank by Windows that Silverlight was dead and HTML was the way forward.

- DevDiv had fairly little confidence in the HTML strategy and was essentially hedging with XAML. But Windows was focused on HTML.

- After people started building apps it became apparent how painful HTML was (this is IE9 HTML- no web components, no ES6, with a framework written by JS noobs), and Jupiter was re-orged into Windows. This was where XAML re-appeared in the PDC slides.

- Sinofsky likes to re-imagine history and say that he was merely getting the Windows org to bolster the otherwise ignored HTML platform, but this is deceiving. The message was clear to the grunts on Windows for the first half of Win8 that HTML was the direction and there was a very hostile relationship with Jupiter.

There was a lot of damage internally to Silverlight through this process- morale was low, internal customers were being warned off of it, etc.

Also this comment just gets me mad: https://twitter.com/stevesi/status/733699065763004416

Sinofsky was the root of so much politicking and poison. Good riddance SteveSi.

I was always wondering why did this happen? Why there was so much hate for XAML/C#?

And why Jupiter didn't get full backwards compatibility with WPF?

I learned my lesson a couple years earlier with XNA.

This isn't about Silverlight vs Browser HTML.

This about creating "Native" apps using JavaScript and html as an interface for native apps. Fundamentally it still using the same components C++/Com store and .Net store apps. They've just written a language adapter for it.

XAML is alive and well in the WinRT apps.

This is about the XAML ecosystem which got slaughtered while Windows was promoting Windows Web Apps and remained silent about the future of XAML.

XAML is now alive and well (to the extent that Windows is), but it went through a very very tough patch in 2010-2011.

Was winrt(HTML/js apps, the thing this blog is talking about) even out in 2010/2011?

This article is dead on from my perspective. I was one of those long-time Windows devs, started on the Win16 API, and I had invested quite a bit of time and effort into WPF and Silverlight because I thought it was cool. I remember that exact announcement, and my immediate thought was that they were ditching WPF/XAML for this new thing, whatever it was, and I just could not see where that was going. I started working in python learning django on linux a few days later and haven't looked back at Windows much since. I don't know how the .NET ecosystem ultimately was impacted, but every developer has to make decisions about how to invest the scarce resource of time, and I am sure there were many people who reacted the same way the author and I did.

Same here. I have been heavily exposed to C# / .NET at that time, but after the announcement came out we started looking into other platforms, and it has never been the same ever since.

WPF and WinRT share similar ways of working.

You could say that about most Microsoft APIs/platforms over the years. The key difference for me is that when it was Win16 -> Win32 and then COM/DCOM -> MFC -> ATL -> .NET -> etc. there weren't really many viable alternatives to deliver software to a large user base. That has all changed dramatically, and so it was important for MS to be very clear, and they weren't. Of course there are other factors as well: it used to be cheap to be an MS dev and then it got very expensive and is now back to cheap-ish again; they used to be the jeans and a t-shirt insurgent and now they're the big enterprise IT vendor, etc., etc.

It's not just one announcement; they keep changing their mind about what the future of the windows API is. WinRT is the final nail in the coffin. Now with WinRT on one side being tied to Windows Store apps and .net/WPF on the other side being limited to normal desktop applications, who in their right mind would devote time to building an app in either?

In particular, if you're making enterprise software, for example, and aren't interested in the Windows Store, what can you do except throw up your hands in the air and switch to the web.

Even if you're determined to make a desktop app application, at this point WPF seems even more likely to become problematic in the future than the Win32 API!

I am also burnt out on them. Winforms, Silverlight, WPF, WinRT now UWP. Just wait for the next change of mind. We have gone web even for internal stuff that would have been web based before.

If I absolutely needed a desktop app I would either go Qt or write my own simple win32 wrapper.

WinRT isn't tied to store apps. You can use most of it just fine from .NET/C++ desktop apps. (not the XAML bits obviously)


I don't even understand the naming. Wasn't WinRT supposed to be the ARM version of Windows 8? Thus the Surface RT product? Which is now pretty much dead?

.NET runs on both, just not 100% API compatible.

Mac OS X and iOS aren't also 100% compatible, neither are ChromeOS and Android.

What are some examples of well-known desktop applications written for .net? Recent versions of Visual Studio are the only ones I know of, and those are only well-known to developers.

I thought the ChromeOS/Android thing wasn't true anymore; that Android apps will soon run without any porting nescessary for ChromeOS.

They will run inside a container with API redirections to ChromeOS syscalls.

I consider that as an attack on General Purpose Computation by the likes of Apple and Google.

You make .Net store app, and then distribute it how you want? Thought that was obvious.

You can create your own business store if you want, or you distribute the app through a file.

It's crazy to think that the owner of the win32 API, probably the strongest asset in contemporary computing, ended up with such a disorganized developer story - winforms, wpf, winrt, silverlight, html.

The last thing you want your "developers, developers, developers" to do is to stop and think about which APIs they need to evaluate switching to. Because that's how you build mindshare on iOS, Android, OSX, ChromeOS.

It's WinRT via .net/C++/js for future apps. Everything else is legacy supported.

Until that also becomes legacy because there's a new hot API on the block ;)

Is anybody actually building Universal apps, though? I just don't see any of the desktop apps with massive existing code bases jumping ship anytime soon, if ever.

Well Microsoft have released Desktop App Converter, where you can distribute Win32 apps on the store. And allows access to universal app apis, so you can gradually transition.

Is there any evidence that desktop users want UWP applications? Given the reception of Windows 8 and MS's subsequent backtracking with Windows 10, it seems like most desktop users prefer traditional winapi applications.

And what if I need to continue to support users who are running Windows 7?

Doesn't mean it's not legacy

Just wait until they change their mind again.

This feels eerily reminiscent of my own dilemma 4 years ago: The lack of direction and leadership coming from within Microsoft when it comes to building software, the willy-nilly changing of core development strategies, creating unnecessary risk (learning curves, time, money) by getting a developer to invest in something that might be relegated to the dustbin by tomorrow (including his/her paycheck). Worst of all, you are to find out about that fact yourself, no announcements, just silence, and vague PR about the-next-big-thing, to lead you on once more. It just felt like they were flailing, thinking up something new well before the last new thing had decent support or community behind it.

I also wondered how a programmer used to strong-typed languages (like C#) and a robust IDE/debugger (like Visual Studio) would fare in the hell that was a browser 4 years ago, the joyful world of JS (vanilla + frameworks) debugging and the always entertaining fight with CSS (in)compatibility, (where IE in particular has caused many a dev to utter a sigh).

I even made a post about it back then: https://www.reddit.com/r/cscareerquestions/comments/p1r3s/st... (and it got on here as well IIRC). It was titled "Stick with Microsoft WPF et al or jump ship?"

I ran as hard as I could from Microsoft and picked up Linux Ubuntu and Android development. I'm a full-time Java developer now (on Ubuntu as we speak) and very happy with that.

Pretty glad I dodged that bullet.

> Pretty glad I dodged that bullet.

Yes, because Oracle is so much better.

Bob Muglia did something similar with Silverlight back in 2010. As I'd invested two years of my life into a Silverlight-based startup at that point, it effectively killed two years' worth of work, and left me rather soured on Microsoft.


> Silverlight-based startup

Even without hindsight, it seems short sighted to have bet on Silverlight.

I startup a Windows Store Analytics based startup - sometimes you take a bet on a technology taking off and it doesn't work out. Look at how many people ate shit building startups on top of Facebook's platforms over the years. Don't judge us too harshly ;)

In hindsight, I'd certainly agree :-). At the time, given what we were trying to do, it was really the only platform available to us, as it was the only way (at the time, or since) that we could get raw access to local audio/video streams and manipulate them.

The most annoying thing about Sinofsky is that nowadays he's all in on anything Apple related. That makes one wonder why he made such disastrous decisions when he was in charge of Windows.

Apple execs were publicly (and rightfully) mocking the Windows 8/RT mess he created and today he's unironically critical of its aftermath while praising Apples stellar execution.

I wouldn't be surprised if this contributed either directly or indirectly to the extremely barren Windows Store marketplace in terms of apps. I think Microsoft burned a whole lot of bridges with this affair in terms of people who were long time Windows developers.

In early 2013, shortly after the store opened, Microsoft had a thing going where they'd pay developers $100 for every app they published:


This was actually a net negative for the store, as it led to the bulk creation of a lot of crappy, low-effort applications, setting up the expectation for users that most of the content in the store was junk, and making legitimate applications harder to find. I wouldn't be surprised if this played a significant role in discouraging developers.

And Microsoft refused to help ISVs that had fake versions floating around the store. Even Netflix had trouble getting fake versions removed. It took several attempts and months before MS permanently fixed it.

I contacted several vendors during this time to figure out what was happening. All of them said MS was unhelpful.

Even when MS made that "email us about junk" push thru didn't respond to people and kept the junk piling up. Often, the store's own "Top" lists had this crap.

Bizarre, and a total waste of goodwill and trust in their new platform.

As a Lumia owner for about a year, I totally buy that. The Store was garbage.

Yep. I have them a shot. Bought two Lumias, including the flagship with the "nice" camera[1]. My wife, who isn't a power user, found it totally inadequate. Other users I know that really wanted to get into it also gave up. MS wasn't just late, they just bungled everything related to running the platform. Which is a shame because the Metro UI is really neat on phones.

1: Camera was able to take nice pics but so slow to actually fire that it turned it to be nearly useless.

I had the Lumia Icon and bought the induction charger (another $50) and it worked alright, except if the phone wasn't aligned perfectly it got frighteningly hot.

Microsoft quality I suppose.

Previous windows phone user. I loved the OS, I had a $40 brand new windows phone and I never once ran into any performance problems. Now with a considerably more expensive galaxy s5 I miss the responsiveness of my windows phone. But I sure as heck don't miss that app store. So much crap and so little quality.

The wife and I both had one, I moved to an iPhone (iOS developer, perk from work, woo!) and she's still on the Lumia she had. She's switching as soon as her upgrade is ready. She actually doesn't mind the Store being so lacking (though it's not a selling point for her) but her phone is pure garbage. The thing loses charge inside of 11 hours, after the last software update the camera is crap, and her speaker has gotten progressively quieter over the year and a half or so she's had the thing, which is a problem because she doesn't have great hearing.

I used to do quite a bit of Windows development back in the day (started with win32/MFC, moved to winforms). I was wondering the other day why I stopped (to some extent because the modern Microsoft seems to be more hip with Linux support, containers, etc.). My guess was that things started getting wonky around the time LINQ came out. It seemed pretty unnatural to me personally, and it was being pushed hard. The metro apps was also being pushed hard at that time. My reaction was to leave the complexity/instability behind and go to an ecosystem that seemed/was more stable. Web based GUIs along with Python backends. I'm at the point now, where I've shipped a few projects using these tools, and am pretty satisfied for the most part. I do miss C# on some days, and I suspect I'll get a chance to work with it if Microsoft keeps up being hip :)

P.S. I never got into ASP/ASP.net ... is that what people use .net for most these days?

LINQ is far from wonky, it's essentially just a bunch of lambdas built to create execution trees which can be optimised then converted to e.g. SQL.

it's powerful and using typed-compile-time-checked LINQ for building DB queries is far superior as a developer experience than some monolithic blocks of SQL text and a test suite.

asp.net5 is getting pretty decent (and close to release) so for current projects I use c# to host my API and bootstrap the app up, but all the frontends are modern js frameworks (using typescript) rather than MS MVC.

Even leaving SQL out of the equation, LINQ is basically just standard functional programming constructs, albeit with SQL-y names. Select() == map, Where() == filter, Aggregate() == fold

> P.S. I never got into ASP/ASP.net ... is that what people use .net for most these days?

For web development, yes. MS's REST framework is called WebAPI, and most people pair that with Angular, but you can use your poison of choice. If you want a more traditional MVC framework, there's MVC. If you want be all hip and cool, you can deploy a web api container to one Ubuntu machine, and the your frontend to another.

A lot of people do use .NET through ASP. Personally, I use it through Powershell, loading libraries and invoking functions in scripts or the command line. I've put together a couple server applications in it, and a voice recognition application too.

When see stuff like this I think of Joel Spolsky's post


This I think was the beginning of the downfall of Windows as the controlling force in personal computing.

If that is the downfall of Windows, then it is also the downfall of Apple and Google development tools and OSe as they also have their share of "API of the year", deprecations or just plain removal without way forward.

At least for Apple I don't think it's fair to say that. Apple tends to deprecate little parts of the API of their API, but the core has been quite stable. By that I mean Cocoa / Cocoa Touch. Since the introduction of OSX these two and Carbon were the only core APIs you had to care about. Now with Swift there's some movement again (which isn't enforced yet), we'll see where that goes. All in all not bad for ~16 years of development. If you count things like the move to ARC or Auto layout, I think these transitions were handled well and didn't lead to that much additional investment, it's on the order of expected support you need to do.

It's a different kind of stability though. Windows tends to support everything old written for their platforms in some way or another through tons of compatibility layers. It's 98% legacy and 2% of what's currently the favourite thing Microsoft would like you to do (which is constantly shifting). With Apple it's a lot less legacy support but the stuff actively sanctioned by Apple is also more stable.

I remember when Java was being sold as having the same first class support as Objective-C, Web Objects, the Qt framework for Java, how GC support in Objective-GC was going to be great, how Carbon was going to stay around.

Before Mac OS X, I remember Pascal being the best thing, only to be replaced by C and C++, then as they couldn't improve their own tools, having them based on Metrowerks.

I remember Common Lisp, Dylan, Hypercard, Newton, Quickdraw, Quickdraw 3D,...

So I think it is more than fair to put them on the same bag.

I think your viewpoint is really wrong-headed. Since around 2001, Apple has given you pretty much a single way to write OS X apps: Objective-C and Cocoa. Yes, there was a brief flirtation with Java, but that lasted what? A year? And afterwards it was 100% clear that Objective-C was the way forward. Same thing with GC. They tried it, decided they didn't like it, and then got rid of it. No ambiguity. Furthermore, the basic structure of a desktop application has not changed much at all in the OS X era. In contrast, MS pushed C#+WinForms for a while, then moved on to C#+WPF (without really killing WinForms), then moved on to C++/WinRT (again without really killing C#+WPF). Also, none of these post-Win32 technologies seemed to get anything near universal buy-in from developers. Furthermore, the switch from C#+WPF to C++/WinRT was a profound change: If you had a WPF app, you pretty much had to redesign the whole UI when you switched to WinRT, because it's based on an entirely different way of organizing a UI.

And I say all this as someone who has mostly stuck with Windows since NT 4. Personally, I find it just sad the way they've mismanaged the developer story for the platform, starting, really, with the introduction of WPF.

On OS X, in contrast, the developer story has been pretty consistent since the introduction of OS X: Write your apps in Objective-C+Cocoa. Full stop.

Of course, now Apple has introduced Swift, and the coexistence of Obj-C and Swift does seem like it complicates the developer story. But not nearly to the extent the MS developer story has been, and continues to be, a mess.

Thank you, that's exactly what I meant.

I remember it all too well. I was a WPF contractor in early 2011 and Silverlight was the one of the best paying skills so it was the thing to learn until the confusion of that announcement. I got a short Silverlight role at the end of 2011 but after that things dried up totally just as I was hoping to buy a home when they were affordable.

I mistakenly stuck with .Net and ended up going to back end data work before returning to the web side as I had begun years before. Things are good on the web and cloud side but I stick see Xaml as too risky to go back to now, even with Xamarin.

ASP.NET MVC has served me well for pretty much a decade. Has a bright future as well.

Microsoft is just that good in "Orborning" themselves.

(also "Ratnering" too, and saw some people here in HN creating the name "Elop effect" that is when you do a "Osborne" and a "Ratner" in the same announcement).

Some examples:

1. That Memo "Symbian is dead", when in the third world Symbian was crushing the iPhone like a hydraulic press, due to its sheer utility/price performance (ie: being almost useful was the iPhone was, for much lower price, this is including all the informal dev ecosystem). In Brazil Symbian had 68% of the market share... in the end of that year it was zero, and chinese OEMs instead took over the market selling unbranded Android phones. Nokia now in Brazil is a unknown brand, some people recognize chinese OEM factories and don't recognize Nokia.

2. Microsoft repeat killings, and unkillings of their game APIs, for example they removed DirectDraw from Vista, noticed part of the sales stall was direct result of that, and put it back (in emulation form), still, this was enough to make many, many people do their best to not switch from XP, and introduced in gamers the notion to not upgrade immediately (also MS notoriously removed in Vista support for 3D Audio Hardware Acceleration, and only added partial support back on Win8, that one killed an entire industry, 3D Audio chip companies went dead left and right, or became zombies, now that 3D Audio is /needed/ for VR to make people not feel sick, it is the GPU companies that are trying to pick up the slack and make hacky workarounds to generate 3D Audio using the video API to go around Microsoft).

3. Sort of part of point 2, but MS killing XNA out of the blue, the intention of XNA was to be a Xbox 360 dev API that you could also use in Windows, they killed XNA before announcing Xbox One, and now are advertising Windows Universal Platform for Xbox One with selling points very "XNA-like", but this time you don't see devs rushing to evangelize for MS, instead they are writing opinion pieces on Guardian (EPIC) warning against it, creating their own Linux Distro (Valve) to go around it, and so on. Also it caused a mono gamedev ecosystem to show up, with XNA dead, all the C# devs had to go to mono, making the previously MS-only platform games now become cross-platform (something that is probably bad for MS in the business sense).

4. The "DX12 is Win10 only" thing while Win10 is not being able to overcome past Windows versions in market share, the best outcome for this for the wide public is instead of using DX12 the devs go with Vulkan, something that for MS is obviously bad in the platform clamping-down sense. But probably what will happen is the worst outcome: like in the DX10 for Vista era, devs will just keep staunchingly supporting DX9, like they are still are (even new AAA games with native DX9 support come out sometimes), resulting into a even messier backwards compatibility environment.

In PC gaming, Windows 10 is 38% now. It's more than Windows 7. PC gamers prefer Windows 10 because of DX12. See in Steam. http://store.steampowered.com/hwsurvey

You mean in "Steam Gaming", Steam is not all PC gamers.

Also, Steam defaults to "Windows lastest version" in some situations (example: the stats for game purchases by platform, count as lastest windows when you buy using mobile)

Also Wine counts as Windows.

Finally, you forgot to count the 32 bits versions of each OS.

Win10 64+32 is 39.51%, Win7 64+32 is 39.54%

And for a dev standpoint, going exclusive DX12 now would still be a stupid decision, if you look in the "DX graph", you will see that only 33.52% has Windows 10 AND DX12 GPU at the same time, meaning a DX12 exclusive game would lock itself to a minority of the market.

> while Win10 is not being able to overcome past Windows versions in market share

Windows 10 past 20% market share http://gs.statcounter.com/#desktop-os-ww-monthly-201504-2016...

According to the chart on that site, Windows 7 is still at 44%.

That very much sounds like "not being able to overcome past Windows versions in market share" to me.

Nope. Look at the graphs for Windows 7 and Windows 10(assuming that's the dotted line) over the whole recorded time starting in 2008. Windows 10 is roughly following Windows 7's trajectory, if not exceeding it a little bit. It took Windows 7 over two years to initially reach 44%. Windows 10 has been out for only about a year now.

Forced upgrades help move the installed line up, (but move the pro-Microsoft line down).

The old DirectX redists are dead and has been since Vista. I think they relied on the old XP display driver model. Only time they did it since was Platform Update for Windows Vista.

That emulation of DirectDraw by the way is trash. Age of Empires II practically redlines my Alienware which can run Sins of a Solar Empire without breaking a sweat.

Somehow all of the remastered Ages games ended up running on it. They'll happily choke computers that can handle the latest-and-greatest FPS, just because most of their cycles are being spent on god knows what.

I admit this is my side computer, it's far from the latest and greatest (that's the other one on my desk, heh) I don't use it for a ton other than playing longer strategy games while relaxing in my home office, but I was shocked when a game from 1999 actually managed to overheat it.

Even if it's only a machine for strategy games, it's awfully surprising. If I can crank XCOM to high graphics on something, it shouldn't be struggling on a game 15 years older.

I will guess

1. MS anticipated cheap Android OEMs

2. They anticipated VR and anticipated the need to integrate 3D audio in 3D hardware, which is the grafics cards at the moment. They were involved with VR from Kinect.

3. Multiplatform is not bad.

4. DX9 is probably good enough.

I just don't get why they did that.

As was the case with the old Soviet Union, Microsoft decisions frequently only make sense when viewed through the lens of internal politics -- of one apparatchik trying to stick a knife in the back of another, in order to increase their own power.

My guess on this one: the new Metro-style app platform was the work of Sinofsky's Windows Division, while traditional XAML app tooling belonged to some other division. In such a scenario, if XAML could be deprecated and Metro-style apps made the One Way to develop apps on Windows, it would mean that a big slice of Microsoft's business that had previously belonged to some other exec would now belong to Sinofsky.

(A turf war, in other words.)

If the idea of a Microsoft executive being willing to pursue a course that would hurt Microsoft just to increase his own power seems unrealistic, I would refer you to the Iron Law of Institutions (http://www.tinyrevolution.com/mt/archives/001705.html):

The people who control institutions care first and foremost about their power within the institution rather than the power of the institution itself. Thus, they would rather the institution "fail" while they remain in power within the institution than for the institution to "succeed" if that requires them to lose power within the institution.

It is also a reason why Longhorn kind of failed.

Windows division wasn't happy seeing the new .NET guys getting all the focus and I bet most of the issues weren't technical challenges that couldn't be solved, rather political between divisions.

After all, history of computing has enough examples of OSes being done in memory safe languages.

I also bet it is no coincidence that WinRT model isn't nothing more that the COM+ Runtime brought back from the ashes, using .NET metadata instead of COM type libraries.

This is what .NET was supposed to be like, before Microsoft decided to go with the CLR approach instead.

> while traditional XAML app tooling belonged to some other division

That would be Developer Division. And a little later, this happened http://www.zdnet.com/article/microsoft-splits-up-its-xaml-te...

Yes, that's a story of pretty much every structure big enough.

Sinofsky had a reputation for not working well with anyone outside of his team[1]..Net (including WPF) occurs outside of the Windows team.

[1]: http://allthingsd.com/20121113/in-the-sinofsky-departure-bil...

And indeed it wasn't popular at all with devs: http://www.zdnet.com/article/windows-8-developers-are-shunni...

And here I am still stuck on WinForms grids. WPF is too slow and the JS frameworks just spin endlessly when I try to throw the amount of data I need to display at them.

Glad I made that decision my self, I had a chance to switch to WPF in 2010, two years later it was on the out.

I don't agree.

Switched my main focus to .NET around 4 years ago, and we keep on having more requests for proposals than we can fulfil, including new applications.

Now yes, .Net is gaining popularity a on the asp.net and web api side since they open sourced it so you aren't tied to MS and still have Mono and Linux support but Windows is dead AFAIC. I've moved to F# and may well move to Reason from there as I switch my skills to Linux.

I totally agree the mishandling on the Windows 8 announcement is what killed windows just as it was getting good. The freedom to style WPF apps would have made Windows keep it's place as the OS that you could make your own but Windows 10 is trying to be Apple, constraining what you can and can't do and forcing you through an App Store.

.NET never lost any popularity on the enterprise space, that is what I care about.

All our projects are either Java or .NET stacks, both with native and web deployments, with some C++ on the side when required.

We started to focus again in .NET around 2010, way before any of the open source announcements took place.

Microsoft used to make most of their money by continuously moving the cheese; hopefully their transition to a focus on cloud stuff will continue to reduce this needless churn.

When I get all of the cheese that I used to have back, I'll be happy. There's still a lot of stuff there that I used to have fairly solid, powerful libraries for that has been replaced by brittle, incomplete APIs.

There's always moving to cross-platform solutions, use their nice API and let them handle the shit-show behind curtains. As a bonus, you now have portability!

The Windows Store is still a wasteland, and we're four or five years on at this point.

The Windows 8 tablet-ification push was a serious misstep, and it is a damned shame, because the underlying guts of Windows have gotten much better since Win7.

> because the underlying guts of Windows have gotten much better since Win7.

I'd love to read a summary of the improvements if anyone has a link handy.


Everything other than #2



Everything other than #s 1.3, 1.4, 2.3, and 3.3

I guess I was specifically curious about the "underlying guts" comment. Things like adding a windows store + apps seem more like bolt-on additions rather than improvements in the underlying core OS.

A few examples that come to mind: The task manager got better. Copying multiple files is handled better, as is the dialogue box you see while that's going on. Window snapping (Win+arrow keys) is pretty great - there were a few other nice Win-key combos that got introduced that I don't really use, related to projectors and multi-screen stuff. The wifi code's better. I believe Windows 8 introduced the ability to natively mount ISOs.

In my experience, Windows 8 & 10 boot faster, are more stable, and use less memory. I was able to install and run Windows 8.1 on a eeePC 901 that could just barely handle a severely stripped down version of XP when I bought it.

There's some other nice things, like finally being able to mount ISOs natively without DaemonTools.

Adding a store/apps does require core changes though - those apps need to be sandboxed, suspended, etc. which needs kernel support.

I remember that many of this stuff was in the old developer preview from 2011. While at it, I should also mention the update that was originally planned for Win8.1 to bring start menu back.

Some people will complain that windows tries too hard to maintain backward compatibility and others will complain when they don't. Its like damned if you do or damned if you don't.

In this case they undermined a major new technology (XAML) three years after introducing it.

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact