A large list of "harmful stuff" related to software development is presented on cat -v. Is Qt harmful? What would be the rationale for considering to Qt harmful? Why would Tcl/Tk be presented as a superior alternative?
That site is designed around the idea of simple implementations, rather than simple interfaces. This is referred to on that site as Unix style design vs MIT style design.
As such, Qt is "considered harmful" because it strives to offer as simple an interface as possible, whilst increasing internal complexity. For example,
QStrings share memory internally, under some circumstances, when copied. Tell me that's expected behavior and the simplest possible implementation. It's not. It's useful when you are storing large amounts of duplicate data in several
QStrings, however, so the developers added that feature. As the maintainer of that website states, not implementing features is hard (paper).
Looking at the list of "harmful" software at http://harmful.cat-v.org/software/ shows this is a common pattern: The author prefers software that is simple in implementation, does one thing, and does it well. Whether or not the author is correct in their assumptions about complex software is up to the reader, and many would disagree.
Personally, I attempt to remove unnecessary complexity from programs I write when possible. However, in order to write useful software, you, as a programmer, often need to deal with such complexity as a matter of course. Your job, as said programmer, is to add the requested features with a minimal addition of complexity.
The question, at least to me, is not why it is harmful, but whether it is or isn't. I think not, actually. It is a great toolkit. Toolkits are only harmful as you won't have to learn how the stuff which goes on underneath them, but even if they exist, you are still free to do so, and you should do so. You should also use toolkits when available (most of the time, they are). This wasn't specific to Qt though, and the author listed Tcl/Tk (toolkit) as a better option, so it doesn't seem like the author is against toolkits themselves.
It might be the license (Tcl/Tk uses a much more liberal BSD license, and much of the software he bashes is under some variant of the GPL), or it might just be the author's personal preference (and he seems not be able to see anything good in other things).
The author doesn't list any points as to why he thinks Qt would be bad, and thus you can only speculate, and I can't see why Qt would be harmful. Many things on that site also raises the general question: "is the author serious, or is he just joking/trolling?". I think it is the second.
I would consider Qt harmful for its implementation.
My favorite pick is the lack of smart pointers. Memory is handled manually, and the ownership is unclear.
This lack of clear memory ownership semantics/convention in the API is harmful -- you need to read the doc... and we know every developer scrupulously read it, don't we ? and never make a mistake either, of course
A proper use of C++ idioms:
- use smart pointers in the interface when taking ownership
- use references when the object need be alive longer than the method call/object being built and will not be owned
would make for a less error-prone API, and ultimately software of better quality would be built upon it.
Apart from that, it seems the author of this site has a wry sense of humor.