Older blog entries for pfremy (starting at number 22)


I was pointed to a Gnome blog where it is said that the KDE name has been dragged into mud by the reaction on the UserLinux list.

I agree that there have been overreactions on the UserLinux list, from some KDE people. However, I find the blog unfair in the sense that it only talks about the bad aspects of KDE, those overheated discussions on UserLinux. We took a great time to prepare a clear, argumented and constructive proposition: http://desktop.kdenews.org/strategy.html

But it seems that nobody has taken care to read it or to take it into account when they talk about KDE and UserLinux. There has also been a lot of argumented postings, not only from KDE people, whose concerns about UserLinux have still not been answered.

I think the reaction on UserLinux are strong because, like many free software developers, we are passionate at what we do and UserLinux sounded like an exciting project. However, the rules were not written in the original paper. What sounded like a community based project where choices would be dabeted and argumented turned out to be a dictatorship project. Bruce said that some part of the project would be community-based, but I have the feeling that the only community-based decision ever accepted will be the one that follow the opinion of Bruce.

I am expecting more frustration on the UserLinux list. For example, people are debating about a name, but I expect Bruce to come back and said that he never intended to change the name, so all the people who have voted can all go home.

I would love to be surprised though.

After discussing a bit on UserLinux's mailing list, it turns out that Bruce does not want to discuss any of the choices made for the distribution.

So, what started as a probably community distribution toward the enterprise turns out to be a dictatorship distribution where choices are made without any rationale. What an irony for a distribution that is based the debian, the community driven distribution.

The particular subject of discord is the fact that the distribution will be Gnome centric, to the point where KDE is not recommended (but still included). The arguments supporting a distribution based on both KDE and Gnome have been ditched away with a "the decision is already taken", without bothering to give any explanation on the choice of excluding KDE.

Forget that KDE had a very significant impact on the fact that Linux can now afford to be an enterprise desktop. Forget that in Europe, the standard is KDE and you won't sell an enterprise distro if it is not based on KDE. Forget that many ISV already have chosen Qt despite the licensing price.

UserLinux is actually BrucePersensLinux. For those that doubted it, Bruce said it clearly. Don't expect any democraty there.

KDE/Qt - Gnome/Gtk

I had this though for a long time. Although I believe Qt is superior to Gtk, there seem to be more innovative projects done using Gtk: there was no equilvalent to gimp, GnomeMeeting, AbiWord, Gnu Cash, Gnu Spread or sodipodi before they were started. And all in Gtk or Gnome. There is also the CD burning app (don't remember the name).

Apart from a few very ambitious applications, like KOffice and Konqueror, KDE seem to have tackled common applications. KMail and Konqueror for example are very good but we already had a mail client and a browser before. All vector drawing program (Karbon14, Krita) seem to have a hard time becoming usable.

However, there seem to be more and more applications that are better than the original one they were copying. Maybe it is just a subjective impression but it is mine.

5 Oct 2003 (updated 25 Apr 2006 at 11:20 UTC) »
Gnome Wrapping

I just found this link on the Gnome website, which I find very funny: http://developer.gnome.org/doc/guides/wrapper-friendly-api-guidelines/wrapper_friendly_api.html

Basically, if you want your code in Gnome to be easy to wrap, you should write C++. Maybe that is why we never had this issue in KDE.

Some more reflections about writing a wrapper for Qt/KDE or Gnome/Gtk:

  • Every language has some libraries to access C code. So wrapping C code for another language is easy. Wrapping C++ is more complicated. That's why there were so many Gnome wrappers and so few KDE wrappers
  • While producing a wrapper is quite easy for C, maintaining it is very burdensome, because every maintainer must add manually all the wrapping code. As gnome and gtk evolves, this turns out to be quite painful. This why many wrapper only do gtk and/or wrap old versions of Gtk or Gnome.
  • While producing a wrapper for C++ is initially harder, once you have done it, you can automate most of the task. That's why KDE wrappers are quite up to date, as comparisons to Gnome's. The paper also points out why it is difficult to automate the wrapping of Gtk/Gnome widgets: because the intent of the programmer is not expressed in the language. Is this member public or protected ? Macros break everything but Macro are part of the gnome type system.
  • Since KDE is written in a higher language than Gnome, there is less need to program in another easier to use language.
15 Sep 2003 (updated 25 Apr 2006 at 11:22 UTC) »
Python is so cool. It is the first time I can use it that much in a project and I really enjoy it. The big difference with C++ comes in small things, like when you almost have what you want but you need to parse a small file, or transform a small expression.

I had the sudden need of managing a .ini style file, to store keys for the card. 10 lines of RegExp and 20 lines of tests solved my problem in 15 minutes. Then few days later, I need to change the file in place. Just 10 mores lines of tests, 5 mores lines of python and I'm done. I know I would have spent a lot of time in C++ do handle this crap.

The real problem with python is that you can not dispense with the tests. I tried yesterday. Then today, my code broke on an exception. You really have to run the code through all the possible case because your program can simply stop on unexpected exceptions.

I see the defenders of Java advertising their safe exception handling. Java is probably suited for big projects does not make it for middle size or small projects. And the safer way of handling exceptions does not remove the need to write tests. So, all in all, you write the same code, but it is more painful in Java.

I made a 75 minutes interview with Eirik Eng, CEO of Trolltech. The problem is now to transcript it into text. Transcripting 5 minutes of interview takes 1 hour. So I have 15 hours of work ahead of me. I don't think I will be able to publish it anytime soon.

Anyone willing to help ? I have some 5 minutes ogg vorbis files ready to be sent.

Gnome 2.4
I read some people really enthusiasts about the fact that Gnome 2.4 is compliant with the HIG (Human Interface Guildelines), some people citing it as a core improvement. If I were them, I wouldn't insist too much on that. It means than for 4 years, Gnome was not that much compliant with its HIG, nothing to be proud of.

On the other side, KDE has always been compliant with its HIG. The only thing that was a problem is that the HIG would recommand SDI while some applications (Kate and KDevelop) use MDI. I think the SDI recommandation has been removed now.

Wonder why KDE had no problem with this ? Because 98% of the HIG compliance is achieved by the KDE Libraries. In Gnome libraries, this same number used to be very low, which means that programmers had to achieve compliance manually, all of them in their slightly incompatible way. Actually, one of the improvement of Gnome 2.4 (if I understand correctly) is that HIG compliance will be made easier because some stuff finally enter the library. It's never to late for Gnome to catch on KDE. :-0

Hopefully, there are real improvements in Gnome 2.4 but I always enjoy nitpicking.

diff is unintuitive

diff is a tool you use without even thinking about it. Given its age, you assume it to be robust and to use the best algorithm. However, reading the documentation about python diff library, I discover that it produces unintuitive set of changes.

Let me show you.

This is a1.c :

if (a) {
	// x
} else {
	// y

This is b1.c:

if (a) {
	// z

if (a) { // x } else { // y }

How would you intuitively go from a1.c to b1.c ? Obviously, one has added a new statement "if (a) { // z }" in before the existing one.

However, if you pass it through diff, you will get:

--- a1.c 2003-04-29 13:28:15.000000000 +0200 +++ b1.c 2003-04-29 13:28:30.000000000 +0200 @@ -1,5 +1,9 @@

if (a) { + // z +} + +if (a) { // x } else { // y

According to diff, you have modified the inside of the then statement of the test by adding some content, which contains half of the new then statement, an end of statement and a new test.

Both results are correct. But one is more intuitive to the programmer than the other.

The diff library of python would produce the intuitive result. How come ?. The algorithm of the diff python library is to find repeatedly the Longest Common Subsequence (LCS) of both files, until all the common parts have been found. When there is no LCS left, everything remaining are differences. The common code "if (a) { // x } else { // y }" gets identified as common and the rest gets identified properly as difference.

The algorithm of diff is different. Basically, it scans the file as a stream for common lines. When it encounters a difference, it looks forward to find the next common lines. Everything in the middle is a difference. This is why diff has hooked the first "if (a) {" as common to both file and had included in its difference everything until the next common line.

So, don't trust your tools blindly. Although they may be old and respected and robust, someone can still do better. Anyone wants to rewrite to diff so that it produces the most intuitive result ? Given the importance of diffing in producing software, producing more intuitive diff is an issue.

Philippe Fremy

Qt and murrayc
I read your flame/debate with Guillaume.

You are at least obviously wrong about one thing. You stated multiple time that Trolltech would prevent you from porting Qt to windows or MacOs X.

Qt is released under GPL so there is no way Trolltech can prevent you from doing anything with it. You can twist the code the way you want as long as you stay GPL. And in fact, Qt is being ported on windows and Trolltech is aware of it. See: kde-cygwin.sf.net

Right now, the project require cygwin and X11 server. But there are plans to port Qt to native win32. I remember a project one year ago where a Mac hacker said he had the GPL Qt running on MacOs X in one day, and was planning to port it on MacOs 9 since it was so easy. Seems like he did not do it.

So you could prefectely wrap Qt using libsig++ instead of their signal/slot system :-)

Another thing that many people seem to miss is that Qt is GPL but if Trolltech does not release a new version in two years, it becomes BSD-licensed (see the FreeQt foundation) so you can use it in any kind of commercial close-source product . You get the same protection against 'what happens if the company goes bankrupt' as for any open source project.

A final point: I agree that you have no true development list for Qt as for other project. But their direct support is very good and they even provided it to me although I had no license (at that time). Some of my feature-requests have been taken into account and many of KDE's requests/problems are dealt with by Qt.

So the development is not as open as you could with but it does not prevent you from benefitting of the result. In fact, I would be ready to trade some openness of many open source projects for more stability/quality (with the source still fully available and modifiable of course).

Random thought
One thing cool with C code (and probably an advantage of native Gtk over Qt) is that compiles fast. Damn fast in comparison of C++ code. Add ccache power to that, you it compiles at the speed of printf.

13 older entries...

New Advogato Features

New HTML Parser: The long-awaited libxml2 based HTML parser code is live. It needs further work but already handles most markup better than the original parser.

Keep up with the latest Advogato features by reading the Advogato status blog.

If you're a C programmer with some spare time, take a look at the mod_virgule project page and help us with one of the tasks on the ToDo list!