Last week, CORBA-lover Michael Meeks released some slides that caused something of a stir amongst some in the KDE community. In his slide, Michael Meeks attempted to make the case for GNOME as the only viable desktop on Unix by directing the heat of his argument at the cost of Trolltech's Qt -- the wonderful cross-platform toolkit on which KDE is based -- for proprietary development. Rising up to the challenge, George Staikos has written a nice article that compares the cost of Qt vs GTK in the real world.

George successfully makes his case independent of the specifics, but there are few things in particular about Michael's slide that bother me. For one, Michael seems to be making a skewed comparison of GNOME to Qt as opposed to comparing GNOME/GTK to KDE/Qt. If comparing KDE to GNOME, then certainly two of the three points in favour of GNOME count for KDE.

Other than the points George makes in Qt's favour (check out the dirt on the new tab widget!), and the fact that KDE more or less maintains a copy of Qt in CVS, KDE has a very open development model, and I would even argue that in many ways KDE development is more open and accommodating to contributors than the GNOME development model which is heavily influenced by the commercial powers behind the GNOME Foundation. Personally, I have also seen a lot of whining about how closely-controlled (by Red Hat) GTK development is. And, of course, the ABI/API stability Michael claims for GNOME certainly applies just as equally to KDE/Qt.

Another thing that puzzles me are the prices Michael quotes for proprietary Qt development. He is talking about proprietary development on Unix, and yet he quotes the prices for Qt on three platforms (Mac/Windows/X11) which is twice the price of Qt for X11 alone. And if he does that, he really ought to take into account the state of GTK on Windows and Mac (ports of which do indeed exist). But these quibbles are sort of besides the point, since indeed Qt does cost something for proprietary development whereas GTK is gratis up front.

So, by all means, read George's article carefully, then tell us what you think about this whole matter. Have you used Qt for free or proprietary development? If so, what have been your experiences?

10 developers cost 60.000$ per year (75.000$ is pretty the top for paying developers).
That's 1.200.000$ for a 2 year project.
Getting the most out of Qt one needs "Qt Enterprise Edition TrioPack".
That's 37.200$ for the first,11.500$ for the second year and 48.700$ for the whole project.
In this calculation Qt costs 4% the developers cost (and maybe 3% of the project costs).
For gaining any benefit for using Qt one has to finish the development one month earlier. Which is possible by using Qt (as it's a damn good tool). Than one saves 50.000$. But saving development time is very much dependend of the project, and Qt may only be used for a few parts of the project and won't save any more than 1% of the time.
Additional benefit is maintainance, as Qt usually needs less code than MFC, GTK,... and is very easy to learn.
One more on Qt 50.000$ cost. It's nearly one additional developer for one year!

Conclusion:
Qt is a pretty good tool. But as any tool, one has to know which tool to use when. Qt is _not_ the solution for every (GUI) problem.

What? Of course MS Office Format is the standard.... _but_:
It is _a lot_ better to save your documents in OO's own format. From what my experience is I can say that once a document is a bit corrupted most of the work can be restored with OO's file format whereas this is seldom possible with MS format... funny thing though that OO does a better job in restoring corrupted documents than MS itself... MS file format is a lot more complicated with a hell lot more of cross referencing pointers inside the format than OO's format.

Note:
OO's file format is superiour to MS file format from a technical point of view.

Advice:
Use MS file format where you have to, but don't rely on it for storing and backing up your work.

o You don't have to send MS files to make others read your documents (please use the de-facto standard Adobe pdf), plus you don't have to trust everybody to not change the content of your docs before forwarding your documents (maybe with your companys high-quality logo embedded) to somebody else.

o If you want to exchange editable documents where somebody else has to modify or copy-and-paste your work: use MS office format.

Oh, but XML and open-standard do count. XML = more easily repairable in case of corruption (important in an ever-more networked world), and open-standard means more easily convertible and more easily accessible by secondary tools.

MS Office Format may be the standard, meaning most of the world is using it.

But the MS Office format isn't open, or is it? Using a format that is analysed / reversed engineered isn't that wise. Especially IMPORTING e.g. a MS Word file always looks different in OpenOffice / StarOffice Writer than it does in MS Word.

I don't agree that pdf is a good way to get the file not changed, it is only a bit harder to do. The advantage of pdf is the wide spread of readers and the hardware independence of the displayed content. But to protect the content aginst changes there is only the way to sign the document with cryptographic methods.

How on earth can you claim that 10% less 'lines of code' results in 10% less costs? I doubt that. If a programmer has to think for an hour to write a certain function in 100 lines of code, it's not very likely he will do it in 90 lines of code in 54 minutes. Probably the time needed is more or less the same and very dependent on the quality of the programmers. But then again who cares. KDE and Gnome should bash eachother less. There is no need for either of them to bash another product, both being brilliant...

It is difficult to summarise in a small article all the gain of Qt over Gtk. This is why George has taken conservative numbers like 30% less line codes means 10% faster. However, if you really want to dig into it, there is a huge difference of productivity between Gtk and Qt, whichi in my opinion, is closer to the 50% productivity boost than 10%.

The heart of the difference is that you can have a better, as more versatile, more reusable, architecture with Qt than with Gtk. With Gtk, you spend also a lot of your coding time in writing structs and type-unsafe MACROS because Gtk re-invents the OO programming in C. The fact that C++ is OO in the language saves a lot of time and catches a lot of mistakes at compile time.

You appear to be ignoring the existance of GTKmm, which produces similar looking code to Qt (but without a preprocessor and using the STL).

I think Michael Meeks was a bit off base with focusing on the costs, I think the issue of control is far more important here, but to claim that GTK is "less productive" than Qt because you can, if you wish, write more LOC in C, sounds extremely suspect. Like most decent toolkits today, GTK has bindings into all kinds of languages. There's no need to write in C, not even if you wish to create new widgets.

I am aware of gtkmm. I have even discussed with some people who program in Gtk and C++. You should wonder why the use the C binding and not the C++ one. They told me that gtkmm it is too complicated and that you have better support for the native C.

You don't need C to program in Gtk only from a short-sighted point of view :
- If you want to use gnome, you need C because most bindings don't bind gnome or are very late in doing it, and usually don't do it completely. So you need the C binding to take advantage of the interesting technologies.
- If you want people to join and contribute to your project, you need C too because most people don't program in exotic language. Would you code a feature for a project like unison which uses gtk and OCaml ? (by the way, it is a pity that they can't use gnome, it would make the project much more interesting and usable).
- If you want help and support from the community when you have a problem, it is better to use the native binding.
- The tutorial are in C, the books about Gtk are about C programming.

For all these reasons, you end up with 95% of the applications written for gnome/gtk in C.

While the emphasis may appear on the LOC, the problem of gtk is that it is a lot more complicated to do simple things.

Honestly, which one is more complicated ? Where do you have more chances of making a mistake ? Remember that the Gtk version is macro-based, so a simple error may not be detected at all. For example, I have introduced an error in the code above which may create a strange compilation error one day. Have you noticed it ?

So the easy part is to day that in this example, the gtk example takes a lot more lines of code, but the rationale is that it is a lot more complicated. Hope you see my point now.

Hmm, so, you didn't actually _try_ GTKmm then, you just took some other peoples word for it that it's "too complicated" - in which case, why were they using it themselves?

I really think you should form your own judgements about this.

[ - If you want to use gnome, you need C because most bindings don't bind gnome or are very late in doing it, and usually don't do it completely. So you need the C binding to take advantage of the interesting technologies. ]

Not really. Almost everything 95% of apps use is bound to C++ at any rate, I think perhaps you can't define Bonobo objects in C++ yet (but very few apps do that anyway). Sure, some of the less popular bindings aren't complete, but that's not the case for the mm series.

[ - If you want people to join and contribute to your project, you need C too because most people don't program in exotic language. ]

C++ is hardly exotic, but OK, point taken. How does this not apply to KDE/Qt though, esp as Qt extends C++ and redefines a lot of stuff in the STL.

[ Would you code a feature for a project like unison which uses gtk and OCaml ? ]

Er, probably not, unless it was really cool. That's the tradeoff with using any language though, it's got nothing to do with the widget toolkit used.

[ - If you want help and support from the community when you have a problem, it is better to use the native binding. ]

That's rather subjective, perhaps it contains a grain of truth but all the major bindings for GTK have thriving communities and mailing lists.

[ - The tutorial are in C, the books about Gtk are about C programming. ]

That's about the only point that makes sense. But if you can read C++ you can read C, and reading C does not force you to write in it.

Yes, I'm quite aware of GObject thanks. It is indeed rather ugly and verbose, but the reason it's used is to make it easier to create and use bindings! There's no way you can credibly claim that GTK is more complex unless you use the same language to compare, and actually *have* experience of both, as opposed to going on random stuff people have told you or first impressions from looking at the code. Take a look at this example (and it doesn't even use glade remember):

I have tried gtkmm recently, and it didn't work out. Nice interface, but when you need to debug something you're screwed when you have to wade through all the fugly gtk muck of C code that has to do all kinds of backflips to achieve what QT does more natively, and concisely.

The only good thing I got out of it was the nice sig/slot library, which is separated, thank goodness. Also if you want to do any serious work on the internals of GNOME you're pretty much stuck with their spaghetti maze of interdependant libraries and weak interfaces.

Another thing, is that the way problems are idiomatically solved in C and C++ are quite different these days. Someone who learned C++ first and now programs heavily with a functional/OO style can't necessarily just "read" (translation: follow just as well) C just because it's mostly a sub-language.

The OP was also making remarks about a QT and gtk comparison, and gtk != gtkmm, so there isn't any "ignoring" going on here. On the contrary, you just decided to butt in some snide, unrelated remarks.

And finally, the "thriving communities" of gtk bindings is mythic bullshit. I've got several non-C programs with strange bugs right now that magically appear and dissappear between releases.

To be perfectly honest, you sound like a well-indoctrinated GTK/GNOME fanboy. It would be nice if instead of regurgitating the line you're fed from others, you'd constrain yourself to things of your own knowledge and experience.

OK, so you tried GTKmm and didn't like it, that's fine by me, I don't have any problem with people using Qt in their apps. Some posters here appear(ed) to be unaware of its existance though.

I don't agree that gtk != gtkmm, GTK is a widget toolkit, bindings are just different ways of accessing the same thing. So saying, "GTK sucks because C is more verbose than C++" is like say, oh, I dunno, Qt sucks because C++ multiple inheritance is confusing (or whatever). C++ is just the means of accessing Qt, it doesn't seem very relevant.

By "thriving community" I meant there are active (busy) mailing lists for the major bindings, those being C++ and Python. Bugs happen, we all know that, I don't see how that's relevant to my comment on communities either.

[ To be perfectly honest, you sound like a well-indoctrinated GTK/GNOME fanboy. It would be nice if instead of regurgitating the line you're fed from others, you'd constrain yourself to things of your own knowledge and experience. ]

Well, I would if others did the same, the reason I am posting here tonight is because I clicked "Read more" and saw lots of fanboys repeating stuff they'd been told by others (presumably) or stuff that was just plain wrong about GTK/GNOME. I'm hardly a GNOME fanboy, there are parts of GNOME that suck and I'm happy to talk about them without getting rude about it. Defending GTK against inaccuracies and FUD doesn't make me a fanboy (or rather, shouldn't).

> So saying, "GTK sucks because C is more verbose than C++" is like say, oh, I dunno, Qt sucks because C++ multiple inheritance is confusing (or whatever).

No, it's not. You have to *write* all those lines, and to write them correctly, and then to maintain them. Even though the general idea when it comes to languages is that "all languages are equal, use what you like", it is simply not true in practice. The more you have to write, the harder it is, period. It's purely a statistic game, more lines of code => more bug. There's no way around it. Perl and C are both two ways to access the kernel functions, would you agree that both are equal ? It doesn't make sense.

As for being a "fanboy", a google of name and a look at my homepage should be enough to prove you that I know what I'm talking about.

There's a reason why, in about 5 years of existence, only a handful of programs are based on gtkmm, and even some reverted from that to plain GTK+ or even Qt. It's not just because it's "in C++" that it's equal to Qt. I learned that the hard way :-).

Note that Phillip never said anything about gtkmm yet you felt the need to jump in and pump it up without really knowing anything about it?! Why should anyone listen to you when you freely admit that you don't understand C++? Here is a different perspective from someone involved in actually creating gtkmm:

I'm not sure if the above example is 100% correct (i don't even have any idea of what the original code does).
It's actually even less code than the Qt example, but the important part is that it is typesafe and it's genuine C++ (doesn't use a preprocessor like Qt). Gtk also uses modern C++ features (e.g. namespaces, STL) when appropriate.

Although gtkmm is much more up-to-date than it used to be, i do understand that many programmers would like to use a "pure" C++ toolkit, but overlooking gtkmm is a serious mistake when discussing gtk vs qt.

> but overlooking gtkmm is a serious mistake when discussing gtk vs qt.

This discussion is about commercial usage of gtk vs qt, and one thing that gtkmm lacks but that both gtk and qt have is: real usage, that is to say: both qt and gtk have been used successfully for large applications (open source or commercial).

gtkmm has not been used for large applications as far as I'm aware (if I'm mistaking feel free to correct me), and commercial developpers *hate* to be first movers because usually the first one gets to find the bugs, find that some parts miss documentation,etc..

So I'd say that for commercial development gtkmm is mostly irrelevent.

Say you developed a brand new spanking widget in gtkmm by deriving from a well defined base class? How can any gtk+ user benefit from your efforts?

The answer is they can't. So you are forced to implement your widget in gtk+ and then wrap it in gtkmm to be able to use it afterwards if you want others to benefit from your efforts. This is one point always overlooked by application development with toolkits such as Qt or gtk+. For others to be able to use your components the base development has to be done in the main implementation language which is C++ for Qt and C for gtk+.

The first is only a problem if you are into holy wars whereas the latter enforces doing things the hard way. If there were no C++ (or other OO-Language) then the approach to doing OO in C by hand wouldn't be as much frowned upon. When C++ wasn't up to the task (as it was about 6-8 years ago) there even was a soon-to-be-replacing-motif (back then motif still was the rage) development (Fresco) that used C++ and failed because there weren't any decent compilers that could handle it's compilation.

But I believe in the "choose the best tool for the job at hand"-rule and being a C programmer for more than 16 years I still decided that GUI programs are best written in OO fashion and learned C++ (after doing GUI design in C on windows for about 3 years and hating it). In our company we have two commercial licenses of Qt since three years and my own development speed has more than doubled compared to the bare bones (API and MFC) Windows-development and quadrupled when compared to previous X application development (where I used Xt and tried XView).

But only by prescribing that all languages have to use the same kind of interface at the lowest level - even if this means that the language can't be used to it's full extent or the implementation has to go through loops and hoops to be compatible. It all comes at a price. And the price for this is the lockin into the Windows platform which I am not willing to pay.

As far as the argument between Qt andt gtk+ is concerned: as long as you are willing to pay the price (here using the main implementation language of C++/C respectively) then the corresponding toolkit is ok. But even with my decade long experiences - or just because of these - with C I wouldn't pay the price to use gtk+.

No. .NET is not about being able to program is whatever language you like, this is totally wrong. It's about being able to reuse legacy code without too much trouble. If you start developing in .NET, you will do it in C#, period.

Actually, AFAIK you can use KParts written in Java (w/Qt bindings) just fine. Gideon/KDevelop even ship with a few, IIRC. Yeah, it needs some bolierplate factory code in C++, but it is still possible. IIRC, this works since in order to embed a component, you don't actually need access to all of its functionality, and just the functionality for the base class, and the basic KParts interfaces. Of course, the things one can do are somewhat limited to basically just feeding data to the widget for editting or display or such, but there are plenty of uses for that...

But you are stuck, if you'd want to extend the widget by deriving from it and changing the behaviour of it. As nice as the whole embedding is (and it's unusable if you want to be portable between platforms such as Linux, Mac and Windows) you still have to resort to the implementation language of the widget to enhance it to do whatever you need it to do if it doesn't fully meet your requirements.

As nice as both bonoboo and kparts may be to make the components interoperable, if you want to use the foundations provided by the toolkits to build something new - such as a whole application - you are best off using the primary implementation language for at least the generic widgets that might be of use to others when extended. Component models are really something to get bigger applications work together.

Language bindings though - however nice and complete they may be - are a cludge when compared to the real thing because you detach yourself from the main implementation and other people are barred from using your enhanced components by enhancing them themselves.

Not only I have to agree: In his book "The C++ programming language" Stroustrup showed the problems when using programming paradigm which weren't those of the programming language. IMHO its a good proof that OO is the best known paradigm for GUI-related stuff when GNOME tries to implement OO paradigm in a procedural language. There are cases where a procedural paradigm fits better (which Stroustroup pointed out too), but for big, long-life projects its nice to have the abstraction layer of objects - at least object-based programming, and for easy-to-understand-designs generalization is a great help too. The big advantage of C++ is that it provides the C subset for the lowest layers of a design, resulting in a best-fit approach (OO for the upper levels, dirty C for the lowest levels).
That's in short

Come on, you are talking only for initial development cost. What about the maintenance cost and bugfixes?! Also don't forget about that QT vs GTK, QT has very good OO advantage - which means that developer is strongly encouraged to reuse code!

In a big project bugfixes, later upgrades, maintenance, etc. strongly depends of amount and quality of the code, which on the other hand strongly depends of the quality of OO framework of your choice. I will not say anything more because one can guess, but QT is definite winner when talking about of efficient coding.

Why listening tools ? Well simple because if you compare the cost of development and development time then I better use a OO based foundation and know that I can develop apps with some lines of code rather than using a foundation written with C where I permanently stick into trouble and reinvent the wheels e.g. different Dialogs, Different Toolbars, Different Menu's, Different way of storing thumbnails etc. To solve all the existing issues in GNOME now will take them 3-4 times longer than using Objects which are programmed already and have them embedded into their own applications. I would say, let's wait another 2 years and compare back. While GNOME is still solving their heavy issues and talk what to adapt next KDE has stepped yet another way further into the right direction. All the applications are there (List above) they only need to get polished and enchanced but so far for business and real corporate this looks good.

> And, of course, the ABI/API stability Michael claims for GNOME

Such as multiple Toolbars and that herodic FileSelector ? GNOME has 5 Different really stable Toolbars and a stable FileSelector that hasn't changed since day 1.

I know my reply heatens this situation once again a tad more but I programmed long enough using GNOME libraries to know what I write about. Specially the rapid development of GNOME applications is worth to mention. Yes people really like to use the STABLE API/ABI of GNOME specially all the undocumented parts of the libraries and functions. I always celebrate the non-existing documentations for programmers.

What are you smoking? kdevelop counterpart is anjuta (in cvs I think, but gideon is not out yet either), quanta has bluefish, and I'm sure many others have counterparts (ie, I don't want to waste time searching).

I'm pretty sure you're smoking something now too. Both tools have a good feature set. I suspect though that you are suggesting Quanta is laughable as you're obviously trolling. I can tell you Quanta is a lot more popular. I can also tell you haven't looked at it for some time. As I am a gentleman I won't laugh at Bluefish for not being DTD driven with XML configuration files. Code folding? I won't laugh because we have a WYSIWYG part in CVS, have dropped below 4 reported bugs in KDE Bugzilla and off the KDE top 100 bugs list, have a number of new features... Quanta is integrating Kommander, a visual dialog editor for custom text manipulation and script control with our user programmable actions... Our full document parsers are incredibly fast...

It would be rude to laugh at another software project just because they were falling behind in these areas... Especially when they were in existance when Quanta was started and when most of the original development team left Quanta was largely undeveloped for a year. Hmmm?

Quanta takes a back seat to no web tool. Had we focused more on bells and whistles than our architecture prepping for being totally incomperable we could have been like other tools... but right now there is no tool open or closed source that is stacking up to Quanta's 3.2 feature set. That doesn't mean I will laugh at Dreamweaver either.

BTW your credibility here is pretty much zero with such ignorant statements.