Submitted by After many months of designing, coding, reviewing, testing and documenting, Qt 4.7.0 is finally ready for the big time. Although it’s a little more than nine months since Qt’s last feature release (4.6.0 on December 1, 2009), the seeds of some of the new stuff in 4.7 were sown much earlier. Indeed, many of the ideas behind the biggest new feature in Qt 4.7.0, Qt Quick, were born more than two years ago, not long after Qt 4.4 was released
As some of you might know, programming isn’t exactly my cup of coffee so I’ll do my best not to sound too much like an idiot running down the list of new features in this latest Qt release.
Qt Quick is the biggest new thing in this release. “Qt Quick, the Qt UI Creation Kit, enables the creation of dynamic user interfaces, easier and more effective than possible with existing UI technologies.” It consists of three core technologies: QML, QtDeclarative, and the venerable Qt Creator.
- QML is a declarative language oriented on JavaScript that utilizes Qt’s Meta-Object capabilities to enable designers and developers to collaborate tightly and create animated and fluid user experiences, using existing knowledge in script language and design.
- QtDeclarative is a C++ library that provides the underlying engine, which translates the declarative description of the UI in QML into items on a QGraphicsScene. The library also provides APIs to bind custom C++ types and elements to QML, and to connect the QML UI with the underlying application logic written in C++.
- Qt Creator has been improved to support interactive editing of QML UIs through drag-and-drop. The text editor supports the QML syntax and provides authoring assistance such as auto-completion, error lookup, help lookup and easy preview of QML UI’s. The Qt Quick features in Qt Creator will be released with Qt Creator 2.1
A lot of work has gone into further improving QtWebKit and its performance. For instance, QGraphicsWebView has a new tiled backing store which should improve scrolling and zooming performance. There’s also a new feature in QtWebKit called frame flattening, which will resize frames to make sure no scrollbars are displayed. The performance improvements are paying off: compared to Qt 4.6.0, scrolling performance has improved 350%, page loading 16%, and CSS animation 31% thanks to accelerated compositing.
Performance improvements were a focus across the board. The newly introduced QStaticText class improves text rendering performance, Qt gets a new widget implementation which improves performance of applications with complicated UIs on Mac OS X, and the JavaScript engine has been improved.
There’s a lot more stuff in there, so go take a look.
QML seems nice, it’s like JavaFX, but with less fail.
As well as XUL, MXML etc.
yes and no, even if the “end result” could look similar to animations done in flash or javafx, the fundamentals of the language are pretty peculiar: it’s quite heavily based on the declarative description of a state machine. that allows to do cool animations in the ui leaving the codebase pretty simple and elegant (and still human, and non coder readable)
the only thing as far i’m aware that shares a good degree of similarity with it (as a general paradigm, not implementation) is the efl framework from Enlightenment
rekonq uses qtwebkit(ships with qt) and it is very crash happy. Hope the crashes are coming from qtwebkit and they are fixed in this release. I like the browser but i switched back to firefox because it was crashing waaay too often.
qtwebkit also uses phonon to handle html5 media elements and hence should be able to handle all codecs phonon backend media player can handle. I use xine backend and xine can play h.264 so i have support for the codec but rekonq simply wouldnt play html5/h.264 videos. It played theora just fine. Hope the fix is in this release too. On my way to compile it and test.
webkit is mature code. rekonq is development code. In the upcoming Kubuntu 10.10 (maverick meercat), rekonq has been made the default browser, even though it is only version 0.6.
Happily this version is far more stable than earlier versions, but be warned (as the version number should tell you), this is still development code, it is not yet stable.
Given that qtwebkit is mature code, and also given that rekonq isn’t mature code, one would presume that any crashes you are experiencing are more likely to be due to reconq that to be due to qtwebkit.
Yeah, Ubuntu have that annoying habit of pushing forward alpha-quality software… PulseAudio, early releases of KDE4, rekonq…
It’s the same with Fedora, Opensuse, Mandriva…
Well, Ubuntu and Fedora are a bit worse in that they push things forward. On Mandriva, alpha-quality features are introduced cautiously (pulseaudio can be easily disabled if it does not work, compiz was not automatically enabled last time I checked). On openSUSE, they were generally more serious about adding new features at all, except for incomplete open-source drivers.
QtWebKit from Qt 4.6 is not mature. In 4.7 it’s way better but there are still a few issues, especially related to text fields (no spell check, weird theming at least with Qxygen, and a few other relatively minor issues).
Still, QtWebKit became a fine rendering engine in Qt 4.7.
Edited 2010-09-22 12:48 UTC
^
|
This. Why I no longer use Linux.
Orly?
You no longer use Linux because one desktop (which is not even the main desktop for that distribution) changed the default browser?
My, yor smart, aintchya.
BTW, it is dead easy to un-install the browser and change the default, and you are given a choice of at least four fine, free, freedom browsers that you can install. You don’t even need a browser installed in order to be able to install another.
Sheesh.
think he means distros that release software that’s not ready for mass consumption yet. Granted he could choose a less cutting edge distro but I guess if you want the latest and greatest, you have to be ready to deal with some bugs/unstability.
Are you seriously too blind too realize that the post is not about rekonq specifically but about the ever present attitude amongst linux developers thinking that putting alpha quality software as the default is a good idea?
Things like PulseAudio, rekonq and oss graphics drivers are introduced as the defaults before they are ready and then people wonder why average people can’t get their computer working properly or find linux hard to use. This incessant “it will work eventually” attitude might work in an imaginary ideal world, but here in the real world, people have shit they need to do on their computers, today. Not in three years when your new fangled software finally reaches maturity, but today.
Man, you confuse “linux developers” with Ubuntu developers. (Or Fedora, or whatever cutting edge distro)
Use a good distro and the problem is gone.
Try Red Hat, Slackware, Debian stable or whatever.
Edited 2010-09-23 15:19 UTC
You want to see real horror with qtwebkit, try using the java bindings. To be fair, they ditched those to the community for support. But it’s still amazing just how slow that is. While I look at it embedded in C++ based browsers, and it flies.
I’m not sure why that should be. I wouldn’t expect the language bindings to be involved much when a web page is being rendered.
QT Quick, as I understand it, intends to make non-programmer user interface specialists first-class citizens of the development team. Great goal, and it looks good so far.
QT supports cross-platform development for newer Symbian phones (including the N8) and MeeGo phones, tablets, netbooks, TVs, In-Vehicle, … well, MeeGo kinda gets around. QT apps also run on my N900, and of course on Windows and Linux computers – and it’s the default framework for KDE 4.
I’m very happy to see that 4.7 is now official.
I think the more important goal is that QML allows your UI to kick ass.
It’s very easy to create a UI with the “old” stuff (QWidgets – basically the same as visual basic/winforms/delphi/whatever), but doing something “impressive” in terms of glorious animations is hard. QML makes it easy.
Problem with QML has been that a graphical designer has been necessary to get stuff done. The answer to this is “Qt Components”:
http://labs.qt.nokia.com/2010/09/10/building-the-future-reintroduci…
the graphical designer helps but is not necessary, the syntax is really simple.
the problem is that it provides only primitives, so developers would have to write their own “widget set” to be reused (or reuse an already existing one, either QWidget or QGraphicsWidget based, it works just fine)
what qt quick wil do is to provide a basic widget set, written in QML itself and themed with the particular platform style it’s running in.
so a layer for the coherency without sacrificing the expressivity.
That’s what I meant by requiring a graphics designer – as a developer I can’t draw widgets that look tolerable.
eheh, so true
I suspect that it is easier to get things done by using the text editor.
I hope that qt quick becomes as powerful as xaml and qt creator rivals expression blend.
Haven’t tried it yet but I doubt it as anywhere as easy to create awesome animations as it is in expression blend.
Is Qt 4.7 currently required to compile KDE4, or is it still using Qt 4.6?
kde 4.5.1 on my box was compiled with Qt 4.6
Which is of course entirely sensible, since KDE 4.5.1 was released prior to Qt 4.7.
August 31st, 2010
http://www.kde.org/announcements/announce-4.5.1.php
September 21st, 2010
http://labs.qt.nokia.com/2010/09/21/qt-4-7-0-now-available/
It depends on who compiled your KDE and with which QT version. It can be compiled with 4.7 or earlier versions.
the 4.5 branch will require Qt 4.6 forever.
trunk (what will be the KDE 4.6 platform) will require Qt 4.7 in about 2 weeks
Qt has become extremely bloated…furthermore, it is no longer a c++ library. It’s a collection of libraries, tools and and programming languages that one needs to master.
I think it’s time for a new simple c++ GUI library.
Since you can choose which modules you enable for your application, the fact that there are lots of features doesn’t actually add any overhead.
Just use GTK then. I don’t think we really need yet another GUI library.
Let’s see. Is there a c++ GUI library that:
1) does not have proprietary language extensions?
2) does not depend on external tools?
3) is only about GUI?
4) follows object-oriented principles cleanly?
5) reuses the STL or STL-like principles?
6) reuses the native widgets?
Let’s take one library at a time:
a) Qt fails at #1 and #2 and #3 and #5 and #6.
b) GTK is C, not C++; GTKMM has some serious problems (even the authors say don’t use the latest version, it contains serious regressions).
c) MFC fails at #3, #4 and #5.
d) ATL/WTL fails at #4 and #5.
e) wxWidgets fail at #4 and #5.
Edited 2010-09-23 13:18 UTC
Use .NET or Java. Let’s not continue to waste time with C++ as it’s a horrible language and for most GUI apps, you don’t need the “speed” it provides.
I think you are horrible.
C first appeared in 1972, C++ in 1983. They’re in use today, and will be for the next 40 years.
You will not survive until that, C/C++ will. Neither Java/.NET will.
So who is the horrible here?
That’s also true for COBOL and FORTRAN and MS Windows. Good company, eh? I mean, to be honest, that’s really a terrible argument. Christianity as been around for a long time, as has prostitution and murder. Does age really mean anything? Not really. Just because C++ has been around does not mean it’s the be-all, end-all.
Look, C++ is not a well-designed, well-implemented language. It’s not good for RAD or business apps. It has its pluses, but mostly in the metaprogramming, performance-computing and research arena. For writing business apps, it just doesn’t make sense. You have to do so much work, deal with slow and difficult compilers and work around semantics problems in the language. Why bother when you just need to make some forms and DB connections? Just use .NET or Java for that.
True, but that does ignore one important fact: there’s no true replacement for C++ available. If I’m writing a game/compiler/hpc code I am forced to use C++. I may not like it, but there is no other option for code that needs to run as fast as possible and with as little memory overhead as possible.
Get me a language that can do that (and with a decent ide) and I’ll be a happy camper.
It’s like people don’t even read my post. Yeah, I know that C++ is really good at some things. But for throwing together GUI apps, business apps, webapps, etc. it really is not useful (and those are the kind of apps we are talking about, after all, since the topic of conversation is Qt, not general C++ usage). It’s better to use .NET or Java.
Interestingly enough, both of those languages are quite suitable for writing compilers and indeed the compilers for languages on those platforms are generally written in C# or Java. And guess what? They are much faster than C++ compilers. Memory usage is definitely worse, though, but with the exception of some embedded platforms, that’s not an issue.
Qt is not just GUI. It is actually suitable for low level programming in embedded systems in your car, in your phone and in your fridge. Java requires lots of memory and an energy sucking processor.
Anyway, I do business apps in Qt because I need to deploy easily on a large number of computers with different setups. I can not afford to ask my clients to install a virtual machine. I deploy the static binary and it just works.
http://en.wikipedia.org/wiki/D_%28programming_language%29
http://www.digitalmars.com/d/
If you don’t need OO:
http://en.wikipedia.org/wiki/Google_go
Will either of those suit?
Neither D or Go is a C++ replacement. D requires a garbage collector, and so does C++.
Go is more like C, D is more like C++. Unlike C++, and like .NET, both D and Go include a garbage collector, so that you don’t have to write one yourself.
http://en.wikipedia.org/wiki/D_%28programming_language%29
http://en.wikipedia.org/wiki/Go_language
Edited 2010-09-24 12:17 UTC
I am C programmer for over 20 years and never had any of the problems you mentioned above.\
The difficults that novice programmers encounter are because they don’t know computing at all.
That’s why they makes mistakes.
That’s why they can’t develop in C/C++.
A real programmer must know, MUST KNOW, the machine he is operating.
Otherwise, they keep themselves in ignorance and use .NET, Java or SomeOtherManagedAndEasyLanguage.
Edited 2010-09-23 19:19 UTC
Read the C++ FQA. It’s not just beginner mistakes. The language is fundamentally *nasty*.
I’ve also done C for quite some time. I’ve done assembly. I even wrote my own assembler and my own virtual machine. I’ve done C++, Java, Perl, PHP, C# and, sigh, even VBA. I have books on operating system kernels and how the computer works on a low-level. I’ve taken classes in that stuff. Believe me, I’m not just saying this because I don’t get pointers. I get pointers. I can deal with C++, but it’s such a fscking pain and the more I use other languages, the more I find them to be considerably superior except in the performance/memory-usage department. Better, though, is to write most of your app in a managed language and write the performance critical core in C++ or another unmanaged language.
C/C++ aren’t nasty. They are flexible.
Programmers who can’t stand flexibility, should never try C/C++, so they would never say that C is horrible or difficult.
People often say that something is horrible or not feasible when they do not understand.
We, C/C++ programmers, are very happy with our language. It’s flexible, blazing fast, cientific and fantastic.
I do business programming for living too. And I code in C++.
C/C++. They fits our needs.
Please don’t lump C in with C++. C is a small, relatively clean, efficient and well-defined language. C++ is an ungodly monster of hacks, special cases, unclear or non-decidable semantics, weird parse requirements and non-obvious syntax.
Why waste time on going back and forth between two languages? it’s counter productive.
Using a managed language when it’s not required it’s also a waste of resources.
It’s entirely the opposite of counter-productive. I know Java’s JNI isn’t the cleanest, but in .NET, you have to do almost nothing to have managed code call unmanaged code. The framework does all the work for you. Furthermore, it’s equivalent to using assembly to write your inner loops inside an otherwise C or C++ program. That’s considerably more tedious, yet I doubt you’d complain.
Using C++, and its ridiculous semantics, manual memory management and long compile times is also a waste of resources (especially programmer resources) when you can use a managed language that has learned from the mistakes of C++. They really aren’t slow (they are JITted) and they don’t actually use that much memory. Unless you are doing embedded programming, the cost is pretty minimal.
You should work on English before any programming language so you don’t sound like Skwisgaar Skwigelf.
RealCarpentersDontUseNailGuns.
You seem to not realize that lot of C# programmers have a C++ background. A big reason why MS used C syntax was to make it appealing to programmers with existing C/C++ experience.
Sometimes it makes sense to use managed code, sometimes it doesn’t. But being completely dismissive of managed languages doesn’t make any sense at all.
Watch out for those pointers, don’t want to leave yet another buffer overflow exploit.
English is not my native language and I don’t care.
Esperanto Estos la cefa lingvo de la mondo.
Those who choose C# are lazy. Sorry, but that’s the truth.
Programmers must work hard EVERY TIME. That’s my oppinion.
awesome!
Lets just not do anything.
Why have a car ? People should walk everywhere. Why fly across the atlantic it is perfectly doable by ship…NO;better swim…
That has to be one of the stupidest justifications I’ve heard all month
Edited 2010-09-24 18:10 UTC
You should use ASM then and never copy from existing code.
Write all your own libraries too.
Neither language you propose have a good quality GUI library. Swing is very tedious to program, Windows Forms is tied to Windows.
Furthermore, I program real time applications for a living, and I don’t think that both languages are suitable for me.
Guess what, a lot of people use Windows.
the fact that none of those toolkits fulfill all your criteria should say something.
Maybe YOU can be the genius that designs a library that fits your very specific needs?
1) it’s pure and simple c++, really
languages like the xml formt for layouts (.ui files) or QML are just to -help- since creating the gui layout directly in the code is plain ugly. in any language.
as for the bloated.. Qt is not -one- library, it’s a set of libraries, each one pretty simple. you always use and link -only- to the ones you need/use.
it you link only to QtCore for instance you don’t even have any gui-related functions, only pure event loop, QObjects with signals and slots.. and that’s it.
Hey, don’t let facts get in the way of a good, ill-informed rant.
It’s not. The Signals And Slots mechanism requires the MOC.
that is in turn pure c++
now one can debate if auto generated code is a good thing or not, but if you open a moc file you’ll find nothing but perfectly valid c++
You didn’t get it. Qt is not pure C++ because it requires an external tool other than the compiler itself.
No, mart is right. All code necessary for Qt applications are pure C++, compilable with basically all C++ compilers available today.
It also comes with a set of tools that allow developers to automate certain tasks or avoid having to write boilerplate code again and again.
These code generators, e.g. qmake, moc or uic, take an input file which is easier to write, read and maintain than the code which is actually required.
qmake takes a simple text based project file and generates platform specific makefiles or even IDE project files. While writing Makefiles might still be possible manually (or writing shell scripts that contain all compiler invocations), this would be pretty difficult for IDE project files.
moc doesn’t require an additional input file, it gets its input from the usual source and header files and generates C++ code. Again these can obviously also be written manually, but that would be quite boring.
uic takes XML bases files which describe UI forms and, again generates C++ code. Doing that manually is again possible, but doing UI visually is gives a developer an early impression on how it will look like and even allows non-developers (e.g. designers) to work on UI parts.
Tools that help development by generating code of some sort are quite common. Almost no build is done manually but through a build system with an easier input format (aside from qmake, e.g. cmake, autotools, ant/maven).
My guess is that this is why developers usually don’t talk about compilers as stand alone entities but as part of their tool chain.
Because it is just so common that more than one tool is involved in building software
Edit: trying to fix quoting
Edited 2010-09-24 13:06 UTC
Let me ask you a question: can you define new signals and slots in Qt with only using the C++ compiler and linker?
Yes you can. Go look at what MOC generates. It just generates some tables and a few boilerplate methods. It’s all there, in C++. There’s no special tricks that only MOC can do. You can write it manually if you want. It’s just tedious and pointless because MOC does it automatically and with more readable C++. Same reason why people use macros and templates instead of tediously writing out the same code over and over again. Or why people use C and C++ instead of assembly. And so on.
Ok, rephrase: can you define new signals and slots with reasonable effort using only the c++ compiler and linker?
Does it matter? For God’s sake, just use MOC. Either that, or use a language that can actually do reflection so we don’t need tools like MOC.
Yes, it matters a lot. For example, we have to maintain 5 year old apps, written in Qt 3.0. Moving the apps to Visual Studio 2008 is not possible because there is no support for the Qt 3.0 MOC for VS9. We don’t want to spend time manually configuring each file in the project for using the MOC, nor we have time to even look this up, at the moment.
Edited 2010-09-24 15:47 UTC
You didn’t get it. Qt is not pure C++ because it requires an external tool other than the compiler itself. [/q]
Since you are not requred to use MOC to utilize the Qt libraries, it’s by your own reasoning pure C++. Since nothing stops you from manually write the pure C++ code that MOC generates, rather than having MOC generate it for you. That it would be a totally stupid and pointless thing to do, is another issue altogheter. Much like arguing against Qt on grounds of it not being “pure” C++.
How is it pure C++, when it requires me to alter the way I work? with pure C++, you only need a text editor and the compiler.
As I already have written, you do not have to use MOC. Nothing stops you from manually write the pure C++ code that MOC generates.
Edited 2010-09-24 14:03 UTC
From a practical point of view, what you say is impossible. No one is going to write the huge boilerplate code required for Qt to work manually.
So, Qt actually requires using the MOC.
It is quite straightforward to create everything the moc creates at runtime.
For instance, the qml environment creates QMetaObjects at runtime, as do most of the Qt language bindings. All the moc mostly does is generate code for QMetaObjects, and so you can do everything the moc does at runtime pretty much.
If qt was basic on statically typed signals and slots like Boost signals, then you wouldn’t be able to do that sort of thing. Which would be a big loss. Nor would KDE KParts work and a lot of other features which depend on the *dynamic* runtime that the moc based features of Qt provide.
Oh yeah? please show me the relevant Qt documentation that allows one to do the same job himself.
(psst…don’t bother, there is no documentation. Qt does not encourage that, and I don’t want to have to support many versions of the Qt internals that might change from version to version).
There is nothing that stops a statically typed signals and slots system to be connected at runtime via text files. All that is required is the appropriate interfaces in the code.
I didn’t me ‘easy’ in the sense that it is something a normal applications programmer would want to do. I meant ‘easy’ in the sense of it allowing systems programmers to make use of the dynamic runtime. I agree there is no documentation and you do need to read and understand the code that the moc generates and how QMetaObjects work at runtime.
Of course that is something that an applications programmer would not want to, and nor would they want to keep track of internal apis. But the fact is using statically typed Boost signals is much, much harder for language bindings and other dynamic language features like properties in Qt Designer.
What is the ‘text files’ technique that you are talking about? It is a new one on me. What do these ‘text files’ look like? How would Boost signals work with ‘text files’? Is there a tool to autogenerate them?
Stick to making console apps. It seems to me that you want the impossible.
Do you really call gcc manually always, or do you use makefiles? If you use makefiles, like any sane person, then your workflow is not altered by using MOC.
Of course, it sounds like you’re one of those people who wants to take a dumbass stand on an issue of insignificance as you try to get people to convince you that what already makes sense (MOC) isn’t unreasonable.
I don’t use makefiles. Your assumption is wrong.
I let the IDE take that tedious job, like any sane person will do.
Wow there. A whole lot of invalid assumptions from your part.
Here is the deal…
Fact 1 : developing anything worthwhile without an IDE is near to impossible.
Fact 2 : the MOC works with only specific IDEs.
Fact 3 : if your favorite IDE is not supported by Qt, you are screwed.
So, in reality, the MOC is a real problem.
What IDE do you use, then? I know Visual Studio, Qt Creator, KDevelop all support MOC. You can probably hack it into the build system of any other IDE unless it’s a total piece of shit.
True in many cases, but not all. Depends on the language and platform.
Not true. If the IDE supports any type of custom building at all, then you can have it shell out to MOC.
Then use an IDE for Qt. This isn’t hard. Use the right tool for the job. Qt already supports all the major IDEs. If you want to use some backwater IDE that nobody knows about, you must deal with the fact that a lot of things won’t work with it. Sorry.
Not for people who don’t have ridiculous personal requirements about their workflow.
I use Visual Studio…right now, VS is supported, but not some years ago.
What about XEmacs? I know you can hack XEmacs to support it, but still, it’s extra work, someone has to do it.
It’s not a ridiculous requirement to not have to do more work than it should be required.
Just use make. Seriously. Get over yourself. This isn’t hard.
I know that Microsoft’s development tools can be weird at times (like not supporting parallel builds properly), but I am pretty sure that even several years old VS had the ability to create new projects based on existing makefiles.
It definitely works in VS2008, just tried it.
And it really doesn’t care Qt3’s or Qt4’s qmake (or any other generator for that matter) created them.
Is this really a new feature in VS2008?
requiring a tool to generate code and being another language is a tad different.
everything that the programmer writes validates perfectly, and that for me closes it.
If you’re so dead set against using tools why don’t you program in assembler?
Is there any Decent and modern gui toolkit that does not use external tools to create boilerplate code?
Seriously what is the point? Boilerplate code is always the same.
I use tools, but I don’t want to use more tools than what is actually required. The MOC is not really necessary in order to have signals and slots: any other signals and slots system does not use an external tool.
Nope. That’s what I said.
MOC really is required for Qt, so you have to use it. End of story. Just deal with it. I mean, what are you gaining by taking this ridiculous stance about MOC? It’s not that hard. It costs pretty much nothing. It’s fairly automatic if you use any type of build system at all. Stop bitching about something that almost nobody else cares about and just get your job done. Really isn’t that hard. People like you make me weep for the programming community.
A lot of other toolkits actually do use autogenerated code. Some Java frameworks do it. .NET does it. It makes things easier because you can avoid the tedium of building your GUI in pure code.
As I said in another comment, if C++ had proper reflection, MOC wouldn’t be needed. Yet another reason why C++ is actually a poor language for building GUIs (among other things).
Nope, sorry, the attritude of ‘just deal with it’ is not acceptable for me.
I guess you never had to manually setup the MOC for each file you created, because there was no support for the MOC in the IDE of your choice. It happened to me, in the context of the project at work, and it was not pretty.
You seriously can’t use qmake like other sane people? I mean, if you want to use weirdo setups that are incompatible with the tools you are using, then you will have to deal with the mess. A whole bunch of other people get by just fine without any problem at all because they don’t try to create giant piles of problems by intentionally doing things wrong.
Did you know that using Qt requires a C++ compiler? Yeah, what a fscking pain! My weirdo IDE only supports C and INTERCAL. Clearly, Qt is not usable at all.
I don’t want to use a nail gun if it means I can’t load nails that I forged myself.
Let me know when they make a nail gun that doesn’t require specialized nails.
Possibly what I should have added:
Is there any other way to automatically create boilerplate code short of creating a new language (that probably will do so behind the scenes anyway)?
That is unless you’re a masochist that enjoys writing boilerplate code just to keep purity in the language (of which c++ isn’t already)?
Personally I prefer to make applications quickly instead of writing reams of code that are exact copies of that produced by machines. My time is pretty valuable to me.
Edited 2010-09-24 16:11 UTC
It doesn’t matter what Oracle does at this point, Java will never be as clean and Qt isn’t tied to a single language.
Java on the server isn’t safe either.
People like Shuttleworth need to get over their attachment to GTK and Gnome. Qt and KDE have better teams and better plans for the future.
Qt just has to hit the tipping point where it rivals Apple’s native toolkits. A Qt port is in development for Android as well.
And how often is Java used for GUI apps? Sure, it happens often enough (presumably Android apps done in Java are typically GUI apps), but a lot of the stuff that Java is used for has nothing to do with GUIs (especially since swing looks so ugly, though many Java GUI apps use SWT, which looks much better). Java is not the language of choice for GUI apps and never has been.
So, while a more powerful Qt might make doing certain stuff in C++ easier, it’s not like it’s going to do in Java. Even Oracle’s stupidity won’t kill it, since it’s been open sourced. Now, Oracle’s stupity may very well seriously reduce how much Java is used, but it won’t kill it.
A better Qt may whittle away at Java’s user base, but it isn’t going to kill it.
It will in the consumer software sphere which is what I was referring to. Java is still used once in a while for cross-platform consumer applications but Qt will eliminate Java as even a consideration.
Just because something is open sourced does not mean that it will progress. OpenOffice was also open sourced and yet over 90% of the commits were from Sun. Giant codebases like Java and OO require a team of paid developers. Open source does not guarantee success, just look at the HURD.
Shuttleworth is/was using KDE SC on his desktop.
Read interview – http://derstandard.at/3413801/Shuttleworth-Apple-is-driving-the-inn…
So? What he personally uses and what he pushes are two different things. I’m sure he runs OSX half the time anyways.