Windows Phone got updated, but still not as perfect as Apple's simultaneous updates for all phones.
Pre-7.5 updates were significantly delayed (for several months), 7.5 went much better. But still AT&T Samsung Focus rev1.4 got Mango about a month later and all AT&T Samsung Focus phones didn't get internet sharing - even though it's fully supported by hardware and can be enabled with a simple registry hack! Considering how seriously Windows Phone is behind iOS and Android feature-wise, Microsoft can't afford wasting time on catching up with their competitors.

But still this is much better than Google's "leave updates to manufacturers/carriers" approach.

Nexus One was a nice phone, but still not perfect:
- After unlocking the bootloader, you can't lock it back. This may be useful if you've done playing with custom roms and want to sell the phone, or want to secure the phone. An unlocked bootloader allows someone with a USB cable to dump all the data without knowing the unlock pin or password.
- Gingerbread was released late, about two months after Nexus S.
- It has some preinstalled apps taking up space on the system partition - like Facebook and Twitter. These versions are usually outdated and if you install the update, the same app will be installed twice! Installing them on the /data partition with the possibility to remove them would be much more useful.
- Finally, as people already mentioned, it's not getting ICS.
In addition, the phone has serious limitations, such as a crappy digitizer (no pinch-rotate, onscreen joysticks cannot be on the same line) and too little flash memory so that mandatory updates for Market, Google Music and other system apps take up all the space.

This is Microsoft. Windows development will cost less, but license prices will remain unchanged - all the money saved will go to management bonuses and marketing. And of course upper management will remain in the US.

You do understand that Nokia Siemens Networks makes telco equipment such as antennas and switches? None of which runs Windows, except for (perhaps) monitoring software.

Microsoft was also productive in the early 2000-s. Windows 2000 was a great OS, making NT ready for the desktop, and a major step in finally fixing the constant bluescreens and crashes of the 9x line. Unlike Windows XP, 2000 had no activation crap and had everything needed for everyday tasks. XP just added desktop themes, entertainment apps and Windows Restore.
Visual Studio .NET/2003 and the introduction of .NET were also major steps, this probably killed Borland because Borland couldn't create a competitively priced products or offer something better than Visual Studio. VS2005 was also a great IDE, with powerful refactoring tools and a really helpful debugger. Plus, it also introduced the free Express editions.

It seems that the whole "rewrite longhorn from scratch" thing and the failure of VIsta put Microsoft (at least the Windows team) back a few years and made them more pragmatic, instead technological advances (promises for WinFS, making everything .NET, vector graphics to make UI resolution-independent just to name a few) they're preferring to make GUI tweaks. I'm very interested to see if Windows 8 finally manages to introduce something new.

Okay, found the example in my code archives:

CFileDialog fDlg( TRUE, NULL, NULL,
        OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_EXPLORER,
        NULL, this );
DWORD MAXFILE = 2562;
fDlg.m_ofn.nMaxFile = MAXFILE;
fDlg.m_ofn.lpstrFile = new wchar_t[MAXFILE];
fDlg.m_ofn.lpstrFile[0] = NULL;
fDlg.m_ofn.lpstrFilter = L"Images\0*.bmp;*.jpg;*.jpeg;*.png;*.tif;*.tiff\0"
        L"All files\0*.*\0";

#ifdef NDEBUG
fDlg.m_ofn.Flags&= ~OFN_ENABLEHOOK; //Vista style support
#endif // Display the Open dialog box.
if (fDlg.DoModal()==IDOK){
        for (POSITION pos = fDlg.GetStartPosition();pos != NULL;)
        {
                CString fname= fDlg.GetNextPathName(pos);//here's the filename!
        }
}

More or less the same stuff in Qt:

QFileDialog dialog(this);
dialog.setFileMode(QFileDialog::ExistingFiles);
dialog.setNameFilter(trUtf8("Splits (*.000 *.001)"));
QStringList fileNames;
if (dialog.exec())
        fileNames = dialog.selectedFiles();//List of files is returned

The WinAPI version required a lot of trial and error to get the input parameters correct. Plus, there's no way of stating "allocate as much memory as required for output", so you have to pre-allocate memory and hope the user doesn't select too many files. This issue turns a "lots of boilerplate code pasted from MSDN" inconvenience into a real problem with no solution except for displaying an error message.

"7500 songs" is just as bad as that Libraries of Congress shit. Some songs last 3-4 minutes, some run for 7-9. Bitrate can also change the total count significantly. What's more, users usually don't know how many songs they have. A better measurement would be a "74-minute CD", but it still depends on the bitrate.

Thanks for sharing the info! Qt signals also have problems with passing non-Qt classes. If I recall correctly, in order for passing non-Qt classes, they have to be inherited from QObject, and have the QOBJECT macro defined in the class definition; also some code is required to declare the class at runtime (qRegisterMetaType). It's strange that Trolltech didn't use C++ templates instead of moc when they developed Qt4 and broke compatibility with earlier Qt versions.
But moc is still required, so Qt compilation may be tricky if you're using a non-standard toolchain (Intel's C++ compiler for example) and not using qmake to build the project.

GTK2 and GTK1.2 could run on the same machine with no problems. I think it's the same with GTK2 and GTK3, after all there's a huge library of GTK2 apps which aren't ported to GTK3.

Just a quick example: to create a thread in Boost, I need just one line of code, with relevant and understandable. A mutex takes one line (no parameters required) and a mutex locker is also a one-liner. Now in Windows, this stuff requires a lot more boilerplate code, with pointers and illogical function names such as WaitForSingleObject to lock a mutex.
I've created a simple image-viewing UI in win32 api and it took about 600 lines of code, 400 of which are related to scrollbars. In Qt the same application took about 50 lines of code and I didn't even have to write a single line of code for the scrollbars to work.
Another thing which kills me is poorly documented function parameters, some of which are even conflicting! It took me about 2 hours just to make a progress bar work.
If you learned Win32 API properly and have used it a lot, you probably are OK with it. But compared to modern toolkits/frameworks (Qt, Boost, .NET Framework, Java etc) it's much more difficult to use and writing an app in WinAPI feels like a waste of time.

Technically I was probably wrong - although some stuff in WinAPI looks like C++, such as
- pre-defined pointers (LPCWSTR etc.) are close to C++ references
- structs are used far more often than in C
- less memory tricks, such as pointer arithmetic
And MFC is C++, but most developers give up on using this monster, and instead implement their own C++ wrappers for making WinAPI usable.

Qt is an incredible toolkit. The only problem is that it looks "different" in Gnome, but about a year ago this problem seems to be solved.
Qt Creator is one of the highest-quality IDEs - very easy to use, powerful and not getting in the way.
Plus as a bonus Qt apps can be easily ported to Windows and MacOS, especially if they aren't using anything outside the Qt toolkit - many apps will simply compile and run with zero changes. Qt includes stuff like XML parsing, sockets, OpenGL etc. so you can probably will never need anything except Qt.
The only thing some people don't like about Qt is the need for a preprocessor and duplication of C++ stdlib stuff (like containers, I/O operatuins), which supposedly fragments C++ development. But I actually like this - no need to use use multiple library dependencies, everything is included in Qt SDK, along with great documentation and works out of the box.
There are concerns about Qt's future, since it no longer fits in Nokia's strategy. But it's quality definetly exceeds most toolkits like wxwidgets, gtk, mono and many others. Probably because the "boring" stuff like documenting and testing was done by full-time employees.

Oh, and Windows native C++ development is horrible. Just look at how you're supposed to display the standard "open files" dialog and get the selected file names.

Hehe, Nexus One is actually made by HTC. Samsung made Nexus S and the Galaxy Nexus :)

Nexus One currently has tons of bugs:
- Clock drift (as much as 5 minutes/week!)
- WiFI/network switchover. When I leave home, I have to enter airplane mode and turn it back off, or else my 2G/3G data will not work simply because the phone liked my home WiFI so much.
- Headphone jack sometimes goes nuts. If you get an incoming call while listening to music, there's no way of predicting if sound will go to headphones or the speaker. Once this resulted in all calls going to headphones, even when they were disconnected. I couldn't hear anything and lost an important call.
- Buggy car dock bluetooth, also no way of predicting if it will use the dock's or the phone's speaker.
- Ringtones sometimes change randomly. It may be *any* song or the "default" ringtone.
- The launcher becomes slow and unresponsive over time, crashes and after that works OK until the next slowdown and crash.
- Sometimes the screen locker stops responding. This looks like a touchscreen bug, however holding the power button reveals a menu which does work correctly. So this is not a frozen phone or hardware problem.
- The Gingerbread update was awful until 2.3.5 was released. Reboots and slowdowns every two days. 2.3.5 fixed reboots, but the pre-gingerbread bugs are still there.

This is just a few bugs!

Tapping icons existed 10 years before the iPhone, as seen on PalmPilot and (later) on Microsoft's Palm-size PC. From what I understand, Apple is unhappy about innovative stuff like the proximity sensor, multi-touch gestures, touch-friendly controls (instead of replicating the desktop UI) etc.