If Microsoft "gets it", they will sponsor an open source GNU C# compiler front-end. If the implementation is good, it has a chance of catching on. If they just do a C# compiler for Visual C++, I think it won't go anywhere.
"synchronized" promised to simplify multithreaded programming, but I think it hasn't worked out well in practice. Java programs end up locking much more than necessary, and despite that, many common locking operations are still a nuisance to implement in Java. C# has locks. While we can live with "synchronized", in hindsight, I think traditional locks would probably have been overall better even for Java.
A number of languages combine GC, traced references/pointers, and untraced references/pointers. Among them, Modula-3.
If you screw up the manual storage management, your program may crash. However, you don't have to use manual storage management or any other unsafe feature. In Modula-3, unsafe constructs can only be used in modules explicitly marked "unsafe". It's really no different from loading a C extension into the JVM, except that even "unsafe" Modula-3 modules are a lot safer than C.
The Modula-3 definition of safe/unsafe modules and untraced pointers seems to work well in practice. The C# definition seems incomplete and unfinished...
As I understand it, primitive types like int aren't objects in C#, they are simply converted on demand. That's a subtle but important distinction. It can be a useful feature, but the implications aren't entirely clear to me. Java could implement it without changes to the VM.
Here are my first impressions from looking at the document (I may have overlooked/misinterpreted a lot...). I use Java as the baseline for comparison:
garbage collection (like Java)
no multiple inheritance
no genericity/templates
IEEE compliance required (kind of like Java)
"delegates" (non-MS folks call them "bound methods")
by-value structures
"foreach" syntax
automatic boxing/unboxing (e.g., conversion between "int" and "java.lang.Integer")
true multidimensional arrays
multiple classes per source file
checked/unchecked statements for arithmetic
overloading of operator[]
get/set methods (methods that look like instance variables)
C-like conditional compilation but no macro substitution
"decimal" type
"finalizers" are (confusingly) called "destructors"
users can define "class attributes" (superfluous and unnecessarily complex; use static variables instead)
little support for reflection
no libraries
some support for call-by-reference (would have much rather had tuples/multiple return values)
apparent intent to support of untraced pointers minimally
unclear how it will connect to C/C++ APIs; this is clearly in their interest (Win32 APIs), but not well defined in their document
no mention of Java that I could see (certainly not in the references); coincidence?
On the whole, Microsoft seems to have taken Java, added many of the things people were asking for, and called it C#. Barring any big blunders, it's not a bad language. It's "give the customer what they want", but whether that is prudent language design is another question.
But, then, Java is evolving. And that's the crucial point: it's fairly easy to write a language description. It's much more difficult to implement it, work out the gotchas and bugs in it over years of practical use, and actually deliver a high performance, robust implementation with as many features as they stuffed into C#. Java may yet end up incorporating many of those features before C# even sees the light of day (if ever).
What should Java take to heart from this list? My favorites are: by-value structures, foreach syntax, automatic boxed/unboxed conversions, true multidimensional arrays, multiple classes per source files, checked/unchecked arithmetic, get/set methods, and conditional compilation. I think Java also ought to get a generic tuple type. All of those could be implemented without any changes to the JVM (by-value structures would require a new class attribute to actually make a difference in terms of performance). In fact, there are a number of extended Java compilers that do just that.
So, C# is a reasonable idea, but when it comes down to it, it's just like many other Microsoft "me too" announcements. Microsoft just can't seem to let anybody else define or lead an effort. But I don't think they'll be able to take over the world with this one. Java is pretty good, it's quite mature, and it's adding new features at a reasonable pace. Java will get most of C#'s features sooner or later, without changes to its VM. And Java has a big edge over C# when it comes to libraries. Even if Microsoft ever figures out technically how to hook up the Win32 API to C# (and doing that well is tricky), I doubt the result will be anywhere near as comfortable, complete, and safe as the Java APIs.
Please check the reference that I gave before speculating. Non-lossy wavelet representations for editing are straightforward, and they are fast and useful. (They are also very different from having multiple layers at different resolutions, the strawman you shoot down.)
I find your notion that everybody should buy and use Microsoft Word in order to further the success of non-Microsoft software absurd. The more entrenched Word format gets, the more difficult it will be to use anything else.
But that's not behind the refusal of many people to read Microsoft Word documents they receive. The reason is much simpler: it's a nuisance and it's expensive.
At work, we have a site license for Word, but maintaining a separate computer just to read mail containing Word files is a lot of work and money. For private correspondence, I would have to buy my own copy of Word, which is more expensive than my whole computer. In addition to all that, I would have to spend time learning how to use Word, and I would have to live with the risk of computer viruses.
I consider sending Word documents around a sign of bad manners or ignorance on the part of the sender. It's roughly the equivalent of giving me a set of Porsche hub cabs for my birthday and expecting me to buy the Porsche to go with it.
I respond to such messages politely that I am sorry, but I cannot read them. Nothing more needs to be said; it's none of the sender's business why I can't read them, nor do I lecture them on Microsoft, Linux, or open source. I suggest plain text, HTML, or uncompressed PDF as alternatives that I can read. It's then up to the sender to decide whether they want to resend the message or not. If they don't, it can't have been that important.
I don't see why the New York Times should be in a privileged position to receive information with national security implications. The NYT is merely a private, for-profit organization. If anything, because they are considered "media", they have more freedom and fewer liabilities when publishing information than other non-governmental entities, meaning that they should actually have less access to potentially dangerous information.
What this comes down to is:
If this information is actually of national security importance, the NYT should not have obtained it. Both the provider and the recipient of the information then effectively engaged in espionage.
If this information is not of national security importance, it should be available to everybody openly and freely. In that case, the "redacting" by the NYT can have one of two meanings. Either it is a publicity stunt, deliberately intended to mislead the public to believe that the NYT has access to privileged information that other media and individuals do not have. Or, it is merely arrogance on the part of the editors; they actually believe themselves to be privileged in some way.
But, clearly, in some circles, there is some belief that the NYT is some impartial, competent institution that is in a privileged position to receive confidential information. For the reasons given above, I think this attitude is wrong. However, even if we admit the premise of a special status for the NYT, I think this blunder suggests that the NYT simply isn't competent to work responsibly in the on-line media.
As for me, I stopped reading the NYT for its informational content a few years ago. In the areas I know about, I found their articles to be too often poorly researched, factually inaccurate, and logically inconsistent, and I had to conclude that this was likely to be true for their articles in areas that I didn't know about.
But the NYT is clearly still of enormous influence in US society because of its readership, the access it is given in some circles, and the beliefs many people seem to have about the quality and integrity of their reporting. So, from that point of view, it is useful to have a rough idea of what they are writing. For accurate information and insightful analysis, however, I'd recommend going elsewhere.
(For some history of the media, including the NYT, I found the book "Life the Movie" by Neil Gabler very interesting.)
The "gated community model" fails to address one of the major concerns that drives people to open source in the first place: what do I do when the vendor goes away? Under a "gated" model, the end user or the community still has no rights to take over development of the system themselves. Of course, the obvious economic imbalance, users contribute and the company profits, will also discourage many contributions.
Still, for an essential piece of software, if there are no alternatives, this is better than nothing. People will contribute bug fixes for problems that absolutely need to get fixed now. If the license is reasonable (no "contamination"), it will speed up the development of compatible libraries. And if programmers get paid for work on such a project, it also seems preferable to working on a project that is completely closed source.
This isn't some obscure limitations, it is something everybody should know. Sun has in the past insisted that downloading their source code "contaminates" you, i.e., that the presumption is that any Java implementation you work on afterwards must contain stuff that they hold the copyright to. In fact, Sun is hardly alone in this view; other source releases have similar restrictions. Whether they are legally valid is an open question, but if you ignore them, that will affect your employability and your ability to contribute to open source projects.
Java is a pretty good language, and Sun's implementation of it is reasonably nice. I think it's good if people use Java more, even on open source projects. Truly free implementations of it are becoming available.
But the only people who might want to download source code to Sun's Java implementation are people who work on implementation-related issues, and those are just the kind of people who we need to fix bugs in Kaffe or the other open source VMs. If they become "contaminated", that's bad. Besides, there isn't much point looking at Sun's Java source code--Sun is very unlikely to incorporate any bugfix you come up with, even if it fixes a long-standing bug. They are simply too busy.
It seems to me Modula-3 (http://www.m3.org/) is functionally equivalent to Ada and otherwise a much better choice. Like Ada, it has generics, modules, threads, objects, dynamic typing, static typing, and explicitly unsafe modules, but it is a much simpler language than Ada. There are multiple free and commercial implementations, listed at the m3.org site.
Reference counting leaks circular references. Reference counting is also inefficient compared to a good garbage collector. And reference counting in C++ fails to give you the runtime safety that a system based on garbage collection gives you. Essentially, there is no way to write portable memory management code in C++ that works as efficiently, reliably, and safely as built-in garbage collection.
Java has not one but two "real destructor" constructs: "try... finally" and finalization. However, they are needed much less in Java than destructors are in C++, because memory is freed automatically.
People have found all sorts of uses for C++ constructors/destructors, but when it comes down to it, C++ is the oddball language there, and destructors in C++ cause all sorts of problems.
We already have a number of efficient, clean, simple systems programming languages:
Oberon
Modula-3
Limbo (from Bell Labs)
Sather
real-time Java
It's too bad Microsoft needs to reinvent the wheel, again. But, I suppose, except for Java, those things don't use enough braces, and RT Java wasn't an option for them.
Well, if they manage to come up with a language definition that is as decent, efficient, and simple as Oberon or Modula-3 and they manage to make it successful, that's still a big win for everybody. For systems programming, C really needs to be replaced by something that is a bit safer without being a lot more complex. But given Microsoft's track record on language design, I won't hold my breath.
"Hybrid" methods of the form proposed in the article are not exactly news. Many pattern recognition and statistical methods combine "digital" selection and "analog" amplification and gain control.
Sadly, work on neural networks still sometimes relies a lot on buzz. Nature, as a journal, seems particularly susceptible to this kind of science: what they publish has to be short and pithy.
If you give corporations the right of free speech and license to market massively everywhere from schools to streets to public airwaves, you shouldn't be surprised if the population makes less than intelligent choices. There are few or no public service messages that balance the consumerist corporate messages and encourage people to spend within their means, not take out loans, and to live happily with what they have. In fact, spreading such messages would likely be considered un-American by many.
Blaming the victims of marketing and consumerism for their poor choices is adding insult to injury. We know marketing works, so if you permit it to occur without constraints, people will make poor choices. If you want to get people to make good economic choices, all you need to do is to change the messages they see in the media.
Mickey Mouse, Windows shortcuts, the Beach Boys, and all the other successful copyrighted works have become part of our culture. We have learned to interact with copyrighted programs and use copyrighted stories and images as symbols in our communication. By giving companies nearly perpetual ownership of these artifacts, we are essentially giving them ownership to parts of our language and our thoughts.
The original copyright terms of 14 years seemed entirely appropriate. They give authors and creators more than enough time to be amply rewarded.
But, absent a legislative remedy, we need a social one, one everybody can adopt. And that's actually not that hard: just avoid using or referring to proprietary artifacts, images, and symbols as much as possible. Avoiding reliance on such proprietary cultural artifacts has many advantages, foremost that the non-proprietary alternatives usually don't come bundled with an agenda to make you or your kids buy more or eat more. And the destiny of the non-proprietary cultural artifacts is determined ultimately by its users.
So, say "no" to Power Rangers, Disney, and Microsoft software. Arabian Nights, Greek Mythology, Grimm's Fairy Tales, and GNU Software are better, more interesting alternatives anyway.
Menus that you don't have to look at are a good idea; linear menus are not the best choice--circular menus are. And people can even make selections pretty reliably in multilevel circular menus.
With ever increasing image resolutions, I think the GIMP needs wavelet or multiresolution drawing support.
That is, images are represented at multiple resolutions. When you edit it at low resolution (zoomed out), only the low resolution representation needs to be modified. When you zoom in and edit details, only a small part of the high resolution representation needs to be modified. Global color adjustements and many kinds of other global image processing operations can also be done very fast.
This kind of representation would allow the GIMP to work fast for nearly arbitrarily large images and arbitrarily fine detail, since processing speed is determined by the part of the image that is actually displayed and being modified. It is also a good match to the upcoming JPEG2000 standard.
But this kind of support needs to be built in from the ground up, since filters and tools need to be coded differently.
A good introduction to the subject is the book "Wavelets for Computer Graphics" by Stollnitz, DeRose, and Salesin.
Quake runs plenty fast on Windows and Linux as well.
Now, if BeOS were open and had some compelling technical features, maybe it would be more interesting. But merely doing what everybody else is doing a little faster and more cleanly isn't good enough for me.
Laptops are generally much less noisy, and they also consume less power. APM allows you to suspend them quickly. And with Firewire and USB, you can expand them almost as much as a desktop.
That's a common but incorrect belief: except for million copy shrink-wrap products or death-march efforts, that is a lot of money for development tools. In particular, these days, it's a lot of money for R&D labs, the very places that bring new tools and libraries into an organization.
In any case, you should compare what you get for $1500 with Qt vs. other offerings. For less money, you get the complete Microsoft development suite (enterprise level, including compilers, GUI designers, VB, and database stuff), Microsoft-compatible cross platform libraries for Linux, an Eiffel system, a variety of Java implementations with GUI designers, or a variety of other GUI toolkits. Qt wouldn't even be on the radar screen if KDE hadn't popularized it.
I see, Microsoft == Evil, so DOC must be created to obfusticate. Very smart of you. Why would a company with the smartest people in the world make life more difficult on themselves by making their own formats hard to read?
I think it's an expedient combination: using object serialization for I/O makes it both easy for Microsoft to read/write data, it makes it difficult for competitors to do anything with the format on other platforms, and it forces users to upgrade their copies of Office with every new release.
This is, in fact, at the heart of what people are complaining about Microsoft: Microsoft adopts strategies that give them a quick time-to-market, lock users into upgrade paths, and that are also effectively exclusionary. I wouldn't necessarily call that deliberately "evil". I'm sure many people at Microsoft view it as the natural way of doing software development, and they view everybody else in the industry who bothers with standardized or well-documented formats as people who foolishly waste time and money.
DOC isn't going to be very important in a few years anyway, Microsoft are moving to XML based everything. Serialization of com services will be XML based rather binary based as they are today as well.
While it may help a little, serializing objects in XML format will not necessarily result in formats that are significantly more readable, accessible, or backwards compatible. To make sense of a big and complex XML model, you still need a formal definition of what it is.
This is really an issue for users and customers: users should insist that their data is in well-documented formats that remain constant and compatible across releases. That's why many government offices have insisted on using SGML in the past.
Using serialization for document storage is simply poor engineering, whether it is done by Sun or by Microsoft or by anybody else. Skipping the step of formally defining a storage format is expedient to the company but harmful to users. In the long run, users have too much invested in their content to store it in such an ephemeral format.
While the QPL is written in a rather roundabout way, it comes down to this: if you use Qt under the QPL to start developing any software, that software must become free/open source software. Troll Tech may agree to let you opt out of such a requirement by buying the commercial version later, but they are not obligated to do so, and the negotiations might turn out to be interesting as well ("how many developers on the project?" etc).
What this means in real life is that if you are considering using Qt at a company or university, you should evaluate it like any other commercial, proprietary toolkit, including its cost. Whether employee or student, your institution can probably not afford to commit to making all their GUI code free or open source up-front (even if a lot of their code may end up open source later).
And even with all the free effort KDE developers have put into enhancing Qt for Troll Tech, at $1500-$2400/developer, I don't think it's very competitive compared to other proprietary or free toolkits. But that's something you have to evaluate for yourself.
There are several companies working on handhelds with official Linux support: the Yopy (some big Japanese company), VTech, and Royal.
Those are likely to be cheaper and less hassle to install and use. And if you buy the iPAQ now, you'll just contribute to Microsoft's Windows CE sales figures and pay extra for software you won't use. I'd recommend waiting for true Linux PDAs.
Meanwhile, you can always send mail to Compaq expressing your interest in a version of the iPAQ without an OS or with Linux preinstalled.
Slashdot Mirror
If Microsoft "gets it", they will sponsor an open source GNU C# compiler front-end. If the implementation is good, it has a chance of catching on. If they just do a C# compiler for Visual C++, I think it won't go anywhere.
"synchronized" promised to simplify multithreaded programming, but I think it hasn't worked out well in practice. Java programs end up locking much more than necessary, and despite that, many common locking operations are still a nuisance to implement in Java. C# has locks. While we can live with "synchronized", in hindsight, I think traditional locks would probably have been overall better even for Java.
If you screw up the manual storage management, your program may crash. However, you don't have to use manual storage management or any other unsafe feature. In Modula-3, unsafe constructs can only be used in modules explicitly marked "unsafe". It's really no different from loading a C extension into the JVM, except that even "unsafe" Modula-3 modules are a lot safer than C.
The Modula-3 definition of safe/unsafe modules and untraced pointers seems to work well in practice. The C# definition seems incomplete and unfinished...
As I understand it, primitive types like int aren't objects in C#, they are simply converted on demand. That's a subtle but important distinction. It can be a useful feature, but the implications aren't entirely clear to me. Java could implement it without changes to the VM.
On the whole, Microsoft seems to have taken Java, added many of the things people were asking for, and called it C#. Barring any big blunders, it's not a bad language. It's "give the customer what they want", but whether that is prudent language design is another question.
But, then, Java is evolving. And that's the crucial point: it's fairly easy to write a language description. It's much more difficult to implement it, work out the gotchas and bugs in it over years of practical use, and actually deliver a high performance, robust implementation with as many features as they stuffed into C#. Java may yet end up incorporating many of those features before C# even sees the light of day (if ever).
What should Java take to heart from this list? My favorites are: by-value structures, foreach syntax, automatic boxed/unboxed conversions, true multidimensional arrays, multiple classes per source files, checked/unchecked arithmetic, get/set methods, and conditional compilation. I think Java also ought to get a generic tuple type. All of those could be implemented without any changes to the JVM (by-value structures would require a new class attribute to actually make a difference in terms of performance). In fact, there are a number of extended Java compilers that do just that.
So, C# is a reasonable idea, but when it comes down to it, it's just like many other Microsoft "me too" announcements. Microsoft just can't seem to let anybody else define or lead an effort. But I don't think they'll be able to take over the world with this one. Java is pretty good, it's quite mature, and it's adding new features at a reasonable pace. Java will get most of C#'s features sooner or later, without changes to its VM. And Java has a big edge over C# when it comes to libraries. Even if Microsoft ever figures out technically how to hook up the Win32 API to C# (and doing that well is tricky), I doubt the result will be anywhere near as comfortable, complete, and safe as the Java APIs.
Please check the reference that I gave before speculating. Non-lossy wavelet representations for editing are straightforward, and they are fast and useful. (They are also very different from having multiple layers at different resolutions, the strawman you shoot down.)
But that's not behind the refusal of many people to read Microsoft Word documents they receive. The reason is much simpler: it's a nuisance and it's expensive.
At work, we have a site license for Word, but maintaining a separate computer just to read mail containing Word files is a lot of work and money. For private correspondence, I would have to buy my own copy of Word, which is more expensive than my whole computer. In addition to all that, I would have to spend time learning how to use Word, and I would have to live with the risk of computer viruses.
I consider sending Word documents around a sign of bad manners or ignorance on the part of the sender. It's roughly the equivalent of giving me a set of Porsche hub cabs for my birthday and expecting me to buy the Porsche to go with it.
I respond to such messages politely that I am sorry, but I cannot read them. Nothing more needs to be said; it's none of the sender's business why I can't read them, nor do I lecture them on Microsoft, Linux, or open source. I suggest plain text, HTML, or uncompressed PDF as alternatives that I can read. It's then up to the sender to decide whether they want to resend the message or not. If they don't, it can't have been that important.
What this comes down to is:
But, clearly, in some circles, there is some belief that the NYT is some impartial, competent institution that is in a privileged position to receive confidential information. For the reasons given above, I think this attitude is wrong. However, even if we admit the premise of a special status for the NYT, I think this blunder suggests that the NYT simply isn't competent to work responsibly in the on-line media.
As for me, I stopped reading the NYT for its informational content a few years ago. In the areas I know about, I found their articles to be too often poorly researched, factually inaccurate, and logically inconsistent, and I had to conclude that this was likely to be true for their articles in areas that I didn't know about.
But the NYT is clearly still of enormous influence in US society because of its readership, the access it is given in some circles, and the beliefs many people seem to have about the quality and integrity of their reporting. So, from that point of view, it is useful to have a rough idea of what they are writing. For accurate information and insightful analysis, however, I'd recommend going elsewhere.
(For some history of the media, including the NYT, I found the book "Life the Movie" by Neil Gabler very interesting.)
Still, for an essential piece of software, if there are no alternatives, this is better than nothing. People will contribute bug fixes for problems that absolutely need to get fixed now. If the license is reasonable (no "contamination"), it will speed up the development of compatible libraries. And if programmers get paid for work on such a project, it also seems preferable to working on a project that is completely closed source.
Java is a pretty good language, and Sun's implementation of it is reasonably nice. I think it's good if people use Java more, even on open source projects. Truly free implementations of it are becoming available.
But the only people who might want to download source code to Sun's Java implementation are people who work on implementation-related issues, and those are just the kind of people who we need to fix bugs in Kaffe or the other open source VMs. If they become "contaminated", that's bad. Besides, there isn't much point looking at Sun's Java source code--Sun is very unlikely to incorporate any bugfix you come up with, even if it fixes a long-standing bug. They are simply too busy.
It seems to me Modula-3 (http://www.m3.org/) is functionally equivalent to Ada and otherwise a much better choice. Like Ada, it has generics, modules, threads, objects, dynamic typing, static typing, and explicitly unsafe modules, but it is a much simpler language than Ada. There are multiple free and commercial implementations, listed at the m3.org site.
Reference counting leaks circular references. Reference counting is also inefficient compared to a good garbage collector. And reference counting in C++ fails to give you the runtime safety that a system based on garbage collection gives you. Essentially, there is no way to write portable memory management code in C++ that works as efficiently, reliably, and safely as built-in garbage collection.
People have found all sorts of uses for C++ constructors/destructors, but when it comes down to it, C++ is the oddball language there, and destructors in C++ cause all sorts of problems.
- Oberon
- Modula-3
- Limbo (from Bell Labs)
- Sather
- real-time Java
It's too bad Microsoft needs to reinvent the wheel, again. But, I suppose, except for Java, those things don't use enough braces, and RT Java wasn't an option for them.Well, if they manage to come up with a language definition that is as decent, efficient, and simple as Oberon or Modula-3 and they manage to make it successful, that's still a big win for everybody. For systems programming, C really needs to be replaced by something that is a bit safer without being a lot more complex. But given Microsoft's track record on language design, I won't hold my breath.
Sadly, work on neural networks still sometimes relies a lot on buzz. Nature, as a journal, seems particularly susceptible to this kind of science: what they publish has to be short and pithy.
Blaming the victims of marketing and consumerism for their poor choices is adding insult to injury. We know marketing works, so if you permit it to occur without constraints, people will make poor choices. If you want to get people to make good economic choices, all you need to do is to change the messages they see in the media.
The original copyright terms of 14 years seemed entirely appropriate. They give authors and creators more than enough time to be amply rewarded.
But, absent a legislative remedy, we need a social one, one everybody can adopt. And that's actually not that hard: just avoid using or referring to proprietary artifacts, images, and symbols as much as possible. Avoiding reliance on such proprietary cultural artifacts has many advantages, foremost that the non-proprietary alternatives usually don't come bundled with an agenda to make you or your kids buy more or eat more. And the destiny of the non-proprietary cultural artifacts is determined ultimately by its users.
So, say "no" to Power Rangers, Disney, and Microsoft software. Arabian Nights, Greek Mythology, Grimm's Fairy Tales, and GNU Software are better, more interesting alternatives anyway.
Menus that you don't have to look at are a good idea; linear menus are not the best choice--circular menus are. And people can even make selections pretty reliably in multilevel circular menus.
That is, images are represented at multiple resolutions. When you edit it at low resolution (zoomed out), only the low resolution representation needs to be modified. When you zoom in and edit details, only a small part of the high resolution representation needs to be modified. Global color adjustements and many kinds of other global image processing operations can also be done very fast.
This kind of representation would allow the GIMP to work fast for nearly arbitrarily large images and arbitrarily fine detail, since processing speed is determined by the part of the image that is actually displayed and being modified. It is also a good match to the upcoming JPEG2000 standard.
But this kind of support needs to be built in from the ground up, since filters and tools need to be coded differently.
A good introduction to the subject is the book "Wavelets for Computer Graphics" by Stollnitz, DeRose, and Salesin.
Now, if BeOS were open and had some compelling technical features, maybe it would be more interesting. But merely doing what everybody else is doing a little faster and more cleanly isn't good enough for me.
Laptops are generally much less noisy, and they also consume less power. APM allows you to suspend them quickly. And with Firewire and USB, you can expand them almost as much as a desktop.
In any case, you should compare what you get for $1500 with Qt vs. other offerings. For less money, you get the complete Microsoft development suite (enterprise level, including compilers, GUI designers, VB, and database stuff), Microsoft-compatible cross platform libraries for Linux, an Eiffel system, a variety of Java implementations with GUI designers, or a variety of other GUI toolkits. Qt wouldn't even be on the radar screen if KDE hadn't popularized it.
I think it's an expedient combination: using object serialization for I/O makes it both easy for Microsoft to read/write data, it makes it difficult for competitors to do anything with the format on other platforms, and it forces users to upgrade their copies of Office with every new release.
This is, in fact, at the heart of what people are complaining about Microsoft: Microsoft adopts strategies that give them a quick time-to-market, lock users into upgrade paths, and that are also effectively exclusionary. I wouldn't necessarily call that deliberately "evil". I'm sure many people at Microsoft view it as the natural way of doing software development, and they view everybody else in the industry who bothers with standardized or well-documented formats as people who foolishly waste time and money.
DOC isn't going to be very important in a few years anyway, Microsoft are moving to XML based everything. Serialization of com services will be XML based rather binary based as they are today as well.
While it may help a little, serializing objects in XML format will not necessarily result in formats that are significantly more readable, accessible, or backwards compatible. To make sense of a big and complex XML model, you still need a formal definition of what it is.
This is really an issue for users and customers: users should insist that their data is in well-documented formats that remain constant and compatible across releases. That's why many government offices have insisted on using SGML in the past.
Using serialization for document storage is simply poor engineering, whether it is done by Sun or by Microsoft or by anybody else. Skipping the step of formally defining a storage format is expedient to the company but harmful to users. In the long run, users have too much invested in their content to store it in such an ephemeral format.
What this means in real life is that if you are considering using Qt at a company or university, you should evaluate it like any other commercial, proprietary toolkit, including its cost. Whether employee or student, your institution can probably not afford to commit to making all their GUI code free or open source up-front (even if a lot of their code may end up open source later).
And even with all the free effort KDE developers have put into enhancing Qt for Troll Tech, at $1500-$2400/developer, I don't think it's very competitive compared to other proprietary or free toolkits. But that's something you have to evaluate for yourself.
Those are likely to be cheaper and less hassle to install and use. And if you buy the iPAQ now, you'll just contribute to Microsoft's Windows CE sales figures and pay extra for software you won't use. I'd recommend waiting for true Linux PDAs.
Meanwhile, you can always send mail to Compaq expressing your interest in a version of the iPAQ without an OS or with Linux preinstalled.