@Miguel: You are right about developer culture being a huge factor. Linux geeks all to often see the OS as the end in itself, whereas the rest of the world knows the OS is merely the means to an end. The OS is the least important component in the ecosystem: what actually matters is the applications and services they can use to get things done. Either it enables that or it obstructs it.
You also mentioned excessive fragmentation as being one of those obstructions. Now, I do believe the 'let a thousand flowers bloom' approach of the OSS world is valuable: where it completely falls down is in its abject failure to asset-strip the less successful variants for whatever merits they have unveiled, then put them wholesale to the sword. Evolution doesn't succeed by ideology or sentimentality; it works through merciless competition culling the weak so the strongest may dominate.
The best immediate remedy for Linux's desktop ills would be to put 80% of current DEs to the axe. Really you only need three mainstream distros: one to cover general users (Ubuntu; sorry Gnome 3), one to cover the inveterate tinkerers (KDE), and one to cover the reactionary conservatives (one of the Gnome 2 clones/derivatives). Retain a few specialised distros for niches such as very elderly/low-powered machines (hi, Pi!) and security work. Anything else is a research project to produce new ideas that can then be stolen by the mainstream distros, or just a leach on the body Linux that should be salted forthwith that the rest may grow stronger.
However, I think you completely missed one other valuable - and uncomfortable - point; arguably the most essential of them all.
While addressing the excessive dilution of manpower and message may help in the short term, there is a far more fundamental cultural problem: the Linux desktop world (and even the kernel world beneath it) has completely and utterly forgotten its roots. Unix Philosophy isn't merely a neat marketing phrase: it describes a very specific way to construct large, complex systems. Not by erecting vast imposing monoliths, ego-gratifying as that may be, but by assembling a rich ecosystem of small, simple, plug-n-play components that can be linked together in whatever arrangement best suits a given problem.
By mimicking the Apple and Microsoft tactic of constructing vast monolithic environments and applications, you have all unwittingly been playing to their strengths, not yours. Such enormous proprietary companies can afford such brute-force strategies because they have vast financial and manpower resources to draw on. Indeed, it works in their favour to do so because vast monolithic applications help to create user lock-in: look at Adobe Creative Suite; look at Microsoft Office. Nobody can truly compete with them because to assemble comparably featured applications takes at least a decade: until then, any competing applications are fewer featured and far more susceptible to being excluded by the vast user-side network effect that the big boys have formed around themselves.
Conversely, look at what has happened when the above vendors have tried to take a more component-oriented approach. For instance, Apple's attempt to implement OpenDoc failed not because it was fundamentally, fatally flawed at the technical level. (It may not have been perfect, but what is? It was still a good and promising platform in itself.) It failed because the business model it proposed - lots of small, cheap, single-purpose components from many vendors that users could purchase and mix-and-match however they liked - was utterly disruptive and utterly incompatible to the business model used by the very application vendors that Mac OS relied on to survive. Adobe's control of the market was predicated on it being the 800-pound gorilla in the room; it was never going to give that up by choice.
Whereas the Linux business model has no such requirements for maintaining artificial scarcity; indeed, given its far more limited development resources, it should be pouring every ounce of its strength into finding ways to work smart, not hard, like this. Unix Philosophy was a reaction to the inescapable hardware limitations of the day; now those limitations are no longer enforced, nix developers have gotten flabby and soft. They build these vast, inflexible edifices simply because they are not required to find a more ingeniously efficient way, and because as a short-term strategy diving straight in and copying how everyone else already does it is inevitably the easiest, laziest approach available. As a long-term strategy, however, it's an absolute disaster. Projects like Gnome and Open Office become like our banking industries: vast, baroque, impossible to regulate effectively, and cripplingly expensive to maintain.
The result is: vast projects that are far too big to fail. The thought of axing, say, Gnome 3 - not on technical merit but simply because it consumes too much resource from Linux as a whole - becomes unthinkable. So rather than killing it and folding its best bits into other, fewer distros, even more manpower must be poured into keeping it going and looking like it actually serves a critical purpose instead of acting as yet another boat anchor on the whole show. Manpower that should've been invested in finding ingenious ways to play to Linux/Unix's unique strengths, not to its competition's.
Apple didn't go from virtually dead husk to #1 in the whole damned industry by continuing to play Microsoft's game by Microsoft's rules. It did it by looking at what MS and all its other competitors weren't* doing, or weren't doing well, in order to meet consumers wants and needs, then devising a cunning plan to do a complete end-run around the lot of them: redefining the entire game to suit their own strengths and allow them to define their own rules. Even if it meant burning their own traditional platform to get there. It was an absolute masterstroke, and a prime reminder that if you want to understand how this game is really played, you don't read Slashdot, you read Sun Tzu.
TL;DR: Windows didn't kill the Linux desktop and neither did OS X. The Linux desktop killed itself, by playing on their terms instead of its own. The best thing it can do now - once denial and recrimination are done with - is turn the killing process itself into a virtue, and slice not only the DE/application mess but also the cultural one right back down to the bone and start rebuilding from there.
Good luck, and apologies for length.
Yet years passed and we in FLOSS world seem to be stuck in the same place. We're creating more and more overbloated-I-do-it-all-better software than to improve with small drop in solutions. We can see that the only integration efforts are done by replacement of small good tools with crappy rewrite inclusions. Not compilation and redistribution of original small but good software following good old UNIX pipeline philosophy.
Sure, the are projects like suckless keeping up the good work but there is no connection with more mainstream solutions like Ubuntu or KDE. Which instead of serving with experience about UX and stuff do their own rewrites according to their own APIs.
Writing independent GUI applications becomes more and more of a chore. So many different ways of doing simple things to support. Like multimedia keys or even a tray icon. Try to do it for multiple operating ststems: you do macOS, Windows and when it comes to Linux: Unity, Gnome, KDE and there is I think still at least standard X-window way of doing things for others which should work quite fine for other UNIX based open operating systems.
One of the key features of Linux is the way it was always supposed to run noticeably better than Windows on much older and/or lesser hardware.
If everyone involved had at least prioritized this one feature without compromise (I know, infiltration of open source by those who felt the need to kill this advantage), that would still be part of the playing field that other OS's would have to contend with instead.
Ironically, the only "distro" that has a real chance of success is Chrome OS, because everything is moving to the web, but also because Google made it ultra simple, secure and zero maintenance. It can also run Android apps, so that's interesting.
Google can replace it by something else and they won't notice.
This is just a Pyrrhic victory, but geeks haven't yet realized it seems.