Qt 4th edition, feature pack 7

Published Thursday September 3rd, 2009
44 Comments on Qt 4th edition, feature pack 7
Posted in Git, Qt

(a.k.a., Qt 4.7)

Borrowing the term from our Symbian / S60 friends, who have stopped using this naming scheme already, I’d like to point out that the Qt 4.6 and master branches in our Gitoriuous repository have diverged.

What does this mean? Well, if you build master now, Qt will tell you that it’s version 4.7.0, not 4.6.0. For example:

$ qmake -v
QMake version 2.01a
Using Qt version 4.7.0 in /home/tmacieir/obj/troll/qt-main/lib
$ moc -v
Qt Meta Object Compiler version 62 (Qt 4.7.0)
$ $QTDIR/lib/libQtCore.so
This is the QtCore library version 4.7.0
Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
Contact: Nokia Corporation (qt-info@nokia.com)

Build key:           i386 linux g++-4 full-config
Installation prefix: /home/tmacieir/obj/troll/qt-main
Library path:        /home/tmacieir/obj/troll/qt-main/lib
Include path:        /home/tmacieir/obj/troll/qt-main/include

And if you’re following Qt development using Git, it might be time to start tracking the 4.6 branch instead:

git branch 4.6 origin/4.6
git checkout 4.6

That’s about it. We haven’t started merging 4.7 features yet. We don’t know yet when it will be released, nor much about what’s going to be in it. (Ok, we have some opinions on date and content…)

And before anyone panicks, no, we’re not adopting the naming scheme either. This was just to write a longer title than two letters, two digits and one punctuation πŸ™‚

We’ve managed to keep a very boringstrict numbering scheme for Qt for years. I remember when we released Qt 4.4 and our Chief Troll was interviewed by a Norwegian newspaper. After he had listed the new features coming in, the reporter commented something like, “4.4? You should call that release 13 or something!”

Other products have had a more, erm… relaxed numbering:

  • Windows: 3.0, 3.1, 3.11, NT 3.5, 95, NT 4, 98, 98 SE, 2000, ME, XP, Server 2003, Vista, Server 2008, 7
  • Solaris: started as Unix 6, 7, III, IV, V, V R2, V R3, V R3.2, V R4; merging with SunOS: 4 BSD, 4.1 BSD, SunOS 1.0, 2.0, 3.0, 4.0; resulting in: Solaris 2.0, 2.5, 7, 8, 9, 10

What’s your take on what Qt’s sequence numbering should be? Give your reply how Qt past releases should be numbered and how we should go from here. Be creative!

Do you like this? Share it
Share on LinkedInGoogle+Share on FacebookTweet about this on Twitter

Posted in Git, Qt


bastibense says:

How about Qt 2009 Release 2 Service Pack 4 Hotfix 7 ?
Especially putting the year into the release name is “trendy”. I really prefer traditional version numbering, since that allows you to compare to previous version rather easily and prevents something like “Uhh, was 2009 Release 6 before or after 4.6?”.

Cyrille Berger says:

Qt ${random}.${random} πŸ˜‰

Adrian says:

Don’t change anything!

bastibense says:

Oh wait, just give it the SHA-1 of the most recent Git commit before release:

Qt fc45fe509245d4f6d083dd2c4949a328a3ad4722

lulzfish says:

Year.month is fine, and works great for Ubuntu.
Just don’t cause any Y2010 problems by using single digits:

Ubuntu way (incorrect): 9.9
Qt way (correct): 2009.09

Nils says:

Qt Lobster Ultimate (SP2)

hugo says:

Don’t change what does not need to be changed !!

Keep the current Qt’s sequence numbering.

Tim says:

You forgot another versioning disaster: Java! http://en.wikipedia.org/wiki/Java_version_history

I actually quite like the 2009.09 type naming scheme. Another similar alternative that matlab uses is to sequentially version within a year, e.g. 2009a, 2009b, 2009c, 2010a, etc.

However Qt version numbers are nice and simple, I say keep them.

James says:

Qt 4.6 bytecode edition

becrux says:

Qt The Last One

Nils says:

The x.y.z scheme is good.

z changes => usually everything will continue to work (minor surprises only)
y changes => should do a lot of testing before a release
x changes => might have to rewrite application πŸ˜‰

The scheme shouldn’t be changed, it reflects quite well what you can expect having to do.

Fazer says:

If it ain’t broken, don’t fix it. The current naming scheme is very easy to understand and maintain, at least from a developer’s perspective. I surmise incrementing only the decimal fraction of the number doesn’t render a huge quantity of changes commited since last version – from a marketing point of view.

Using a YEAR.MONTH naming convention brings a danger of misinformation – a person has to know and remember when particular versions have been released. Was it in March? Or maybe in November?

It looks like every method has its advantages and disadvantages. Not to spread confusion, I suggest you stay with the current naming.

NoName says:

The only thing i think what could be better, is to rename the name of the shared libraries:


and so on… or something similar

Thiago Macieira says:

A couple of people have asked us not to change.

Rest assured, we won’t change. This is not a poll asking what scheme we should use.

This is just an exercise in creativity. Give us some funny ideas for a numbering sequence. (Where “sequence” stands for “more than 1”)

chris says:

Please don’t change Qt’s sequence numbering.

Anon says:

Qt3.1415926… etc, of course! πŸ™‚

Kollum says:

Hi. I’dd suggest to use an infamous mathematical sequence. Fibbonacci is too famous, anyone would understand. But looking at fractals or chaos theory, I’m sure you can switch naming shame without too much discountinuity ( taking eg. 4.7 last of x.y.z sheme, and as first of chaos sheme ) and you manage to loose even your release managers ! yey

ris says:

Should be based on a maximal length linear feedback shift register sequence.

Paul says:

Resisting inflated number earns a project respect. Projects that release at version 2.0, instead of the more appropriate 0.1 are signalling to users that marketing matters more than technical honesty.

Qt should stick with it’s existing scheme.

For something more interesting, start at a large number and decrement so users know how long to wait for the perfect last release. Like a children’s story where people floated, their feet growing down to the ground. When they reached the ground, it was game over.

almostlabs says:

I suggest:
0 1 1 2 3 5 8 13 21 … and so on.

t says:

According to http://en.wikipedia.org/wiki/Qt the abbrevation QT also means Quarter, a unit of mass equal to 12.70058636 kg. So, taking TeX version numbering as an example, I’d suggest:

After the last number you will have to measure actual weight of one standard quarter with better accuracy to get more digits πŸ™‚

Tom says:

While Qt’s version numbering is nicely consistent, some parts of Qt seem to have an identity crisis. I’m looking at you, Qtopia. Or is it Qt Extended? How about Qt Embedded?

Thiago Macieira says:

Qt/Embedded -> QtopiaCore -> Qt for Embedded Linux -> Qt

anono says:

I think the following scheme should be applied:

This way we would have nice huge increases in the major version number, wild ups and downs in minor numbers and some flattening maintenance number.

Ariya Hidayat says:

Prime numbers! After 4.7, follows 4.11.

Andreas says:

Versioning numbers should be as incomprehensible as possible, in order to generate as many discussions as possible on forums about what version X is compared to Y. It’s important to give people something to spend significant time on!

So I support random numbers. πŸ˜‰ Then we can have a web page that you must register to use (with hm… how about a cut-throat NDA!), where you can submit the Qt version you want to query. The answer will then be sent by snail mail. Hm… and I suppose that site should be unavailable most of the time (five 9s unavailability!).

Troy says:

I for one favour a count-down. Then we can have conspiracy nuts trying to tell us that the world will end when Qt reaches 0.0.0. Hopefully that coincides with 2012 or whenever the doomsday people are currently claiming, otherwise the world would end twice πŸ˜›

Wizard Of says:

The number to use would be 42 :p

But seriously, the current scheme is perfectly ok. Don’t try to “spice it up” just because the marketing folks ask for it. Usually it just makes it taste bad for the engineers who get confused.

romulus says:

From Norse mythology

Moon’s Edition
Tyr’s Edition
Odin’s Edition
Thor’s Edition
Freyja’s Edition
Washing Edition
Sun’s Edition

Johannes says:

What about perfect numbers for the y-part. After 4.6 comes 4.28, 4.496, 4.8128, 4.33550336, etc.

girish says:

Just use the git sha-1 from which the packages were created πŸ™‚

Carina Denkmann says:

You could use even numbers (4.6, 4.8, 4.10 … ) for releases, and odd numbers for snapshots. For example, 4.6 branch says it is 4.6.0, but the API is probably not 100% frozen. So use 4.7.x for current master snapshots, and release that as 4.8.0 when it is final.

Philippe says:

KISS… hence 4.6

anono says:

The KISS approach could be extended:

Why not simply call it “Qt” and just forget about version numbers. They confuse most of the people anyway.
The mantra is: If it doesn’t work your “Qt” is too old.

You could pull a Drupal and go from 4.7.x to 5.x, 6.x, 7.x etc., breaking binary compatibility with every new release!

Blizzz says:

Instead of increasing, decreasding the version number would be something else and more exciting. I suggest to start with Qt 1337 and step down until Qt 42. From then on, just add a plus for each nur version, i.e. Qt 42+, Qt 42++, Qt 42+++ and so on.

Or, if increasing is the ne plus ultra, just add those nice Ε‚ chars, see how nice it can be: Qt Ε‚Ε‚Ε‚Ε‚Ε‚Ε‚

Thiago Macieira says:

Romulus: did I understand right that Saturday is the bath day in Norse mythology? πŸ™‚

arg0 says:

> QtCore_460_vs2005.dll
> QtCore_460_mingw.dll

Yes, it would be wonderfull! Binary incompatibility of different C++ compilers is a very sad fact.

And Norse mythology is a good idea! =) Qt 4.92 Odyn’s Edition sounds pretty good =)

Andre says:

The answer is obvious. To pay hommage to the Trolltech history, each version should have the name of a famous troll. If Apple can use big cats as names for their OSses, why not troll names for Qt versions?

silver says:

I’ve registered here just to say: please, don’t change your current version notation much! Probably, it would be better to increase major part more often (Qt 5.0, Qt 5.1, Qt 6.0…)

Peter says:

Because for a long time there is no Qt 5.x
and the progress is seen only in the decimals
marketing will maybe like following numbering:

Qt 4.30 -> Qt 300
Qt 4.40 -> Qt 400
Qt 4.52 -> Qt 520
Qt 4.66 -> Qt 660
Qt 4.70 -> Qt 700

Qt 5.0 -> Qt 1000
Qt 5.1 -> Qt 2000
Qt 5.21 -> Qt 3100

Qt 6.0 -> new numbering sheme because 10000 is too long

Don says:

The perfect version numbering system.
Looks familiar but incomprehensible at first glance.
Everybody thinks, but is not quite sure, that they understand it.
Subject to various interpretations leading to pointless discussions.

Kensai says:

I believe the best (serious) way is to use calendar dates. Dates are unique and incremental. They are no brainers, you can’t get them wrong.

So if Qt 4.7 is released in October 2009 consider something like Qt 2009.10, as stated above.

rae says:

I think we should look to the video card market for release names.

Insgtead of Qt 4.6, it should be Qt 9450 GTX Extreme Titanium Edition!

Commenting closed.

Get started today with Qt Download now