Category: Coding

Google Summer of Code 2008 is up…

…and neither guitone nor monotone will be a part of it.

Google just put the list of mentoring organizations online and our direct competitors, namely git and Mercurial, of course got slots. On #gsoc on Freenode a Google employee told the crowd about a total of 505 applications this year, where only 20 or so have been spam, so it seemed to be a rather hard selection on Google’s side as well, because in the end only 175 organizations could be accepted, mainly for organizational reasons.

Now while I was almost sure that my application with guitone would not be accepted (this was kind of already written in the FAQ), it is surely a shame that we couldn’t bring up some ressources for a proper application for monotone.

Sure, no application is better than a half-baked application, which, in the end, may create bad karma and reputation for the project itself, but still, I’m feeling a bit depressed right now.

Maybe next year… in the meantime I hope people are at least willing to work on a successful European Monotone Summit…

Summer Of Code 2008 / guitone Status Update

I’ve just read on Slashdot that applications for this year’s edition of Google’s Summer Of Code start in early March. I’m thinking about pushing this a little more this year for the monotone project, since we kind of “missed” it last year (we sent in our application too late). And I’m positive to also place at least one possible project for guitone there. While it certainly makes a lot of fun to code with Qt, it would make even more fun if somebody could team up and help out here and there…

In the other news: monotone 0.39 has been released yesterday and I’m once again astonished how easy openSUSE’s build service makes it to create rpms for a great variety of distributions and architectures. I’m currently using it to build openSUSE rpms for monotone and guitone there and its really easy and fun to do that.

I’m also pretty actively hacking on guitone at the moment, fixing bugs and implementing new features there. There are still some things on my TODO list before 0.8 is ready to release, amongst fixing bugs, f.e.

  • make the filesystem watcher implementation usable and working properly, so guitone updates the workspace view in the background if changes happen to the underlying filesystem
  • implement some of the workspace commands with native calls (i.e. add, drop), rename / move will be slightly harder, also wrt to view updates, maybe I’ll implement simple filename renames at first

The following things already have been implemented and are definitely part of 0.8:

  • restricted commit (right-click on any file/folder and hit commit!)
  • diff possibility for patched files in the commit and changeset dialogs
  • a new panel to view, add, edit and drop database variables
  • improved, more user friendly startup dialog which now also contains possibilities to edit the preferences and load recent databases and / or workspaces
  • improved loading times for huge workspaces, f.e. loading the complete org.openembedded.dev should run a couple of times faster now
  • and much more…

guitone 0.8 will also be the first version of guitone to be released under GNU GPLv3. Now that the Trolls released Qt 4.3.4 recently which allows licensing the library under the very same license, I’m positive that this change will not introduce too many headaches to distributors. Otherwise, drop me a note via private mail and we’ll work out a solution.

Based on my current workload and other activities (Chemnitzer LinuxTage, anyone?) I hope to get a stable version out mid march. No promises on this, though 😉

guitone 0.7 released

guitone 0.7, my Qt-based monotone GUI, has just been released today. Most of the changes over the past 9+ months since the latest major version are under the hood, so there are only a few “new” things you can actually see (most notably the
file history browser, a new icon set and numerous other improvements in existing dialogs).
The main reason for all the internal overhaul is however, that guitone should now run much smoother, faster and less crash/error prone than previous versions. It also includes better mtn error detection and fixed some of the outstanding platform bugs on Mac OS X and Windows.

A complete overview of all the changes can be found – as always – in the
NEWS file. Make sure you grab your copy here.

If you encounter any problems, have suggestions or anything else, drop
me a note or open a new task in the task tracker.

And here is finally the mandatory screenshot – click to see more screens:

guitone changeset browser

Zen Master of Programming

I started with computers pretty late, around 1997, at the age of 15. I was totally ignorant about them before back in the day. I had a pretty good typewriter with which I did all my homeworks and I was satisfied with it. On the other hand many of my classmates had a computer, but they mainly used theirs for gaming. Yeah, gaming… I thought “why on earth should I pay several thousands of Marks [the old currency in Germany] just to waste time and… play?!”. I thought, if I ever get a computer, I want to do something creative with it…

In the two upper years in grammar school I chosed Information Science as optional course. I was somehow interested in the topic, because the media more and more grabbed up the whole computer/internet topic and I just thought “a little knowledge in this area surely doesn’t hurt”. I knew that it would be quite useless to attend this course without having a computer at home, a place where I could actually try out what I’ve learned. So, shortly after I expressed my interest in attending this course, my father and I bought my first PC: a Pentium MMX with 200MHz, 32MB RAM, a Matrox Mystique 4MB graphics card, a 15 inch monitor and a 4GB hard disk. And it was expensive, I can’t remember the exact price, but damn, it was a lot of money.

The following years had their ups and downs. I learned a lot by playing around with the operating system (don’t tell me how often I had to re-install Windows 95/98 because I messed with the config and registry) and I took my first steps into the programming world: Turbo Pascal! This was the language they taught us in the information science course and it immediately became clear who was really interested in this course and who not: Those who just attended to browse the internet for free received bad grades and mostly couldn’t follow. But there were also a few people (amongst them my pal Stefan and I) who stepped into the topic and hacked like mad. He was into game programming (vga, 4bit color DOS games, anyone?) and I was, umm, more this kind of early application developer. As much as I appreciated his work, I was just too uncreative to do game development. Anyways, these times were fun, because we exchanged our knowledge and tried to outperform each other by using and implementing stuff the teacher hadn’t even told us.

In my last year in grammar school we switched away from Pascal to Prolog – and I hated it right from the start. My main appeal to do programmaing at all was to see something appear on the screen, see that some nice algorithm worked, but not to hack definitions into a command prompt and wait for the overly astonishing result “x is a cat” to return. I was probably too much of a greenhorn at that time, because from today’s perspective this language and the concepts sound pretty nice. Anyways, disappointed by Prolog I started MFC programming with C++ in Visual Studio 6 in my spare time (don’t ask me where I got this, you know, there have been these sources, …). One of my first projects has been a Paint application which even made it to a “PC Games” CD (yes, obviously even I played sometimes on computers…). These CDs contained (amongst demos from new and upcoming games) also a section where users could send in their small, self-developed programs. Usually some of them were nice (some even let you “wao”), but most of them just sucked. They were simple, dead boring text adventures mostly written in BASIC. So, I was quite impressed that my little program deserved real honor, they teasered it as “pretty solid paint application”, and not just as “another nice text adventure”. I was so proud!

Anyways, the rest is history. After school I decided to study information sciences, discovered the internet, learnt even more about computers, operating systems and programming languages, and started gaining my first working experiences. I mainly started with working because I wanted to learn more than my study could provide me. Programming is crafting, and you will never get all the tricks in university. A real hacker from which you can learn stuff is absolutely invaluable! So I was looking for some kind of mentor, a “grand master” which could tell me the missing bits, with whom I could hook up and gather indefinite knowledge.

I sadly never found such a person, wherever I worked. Either people asked me how to do things or I had to tell them how to do stuff. At most I had colleagues, “senior developers”, which knew what they did, but were not too fond to let me participate on their knowledge. Though, none of them was what I would call a “Zen Master of Programming”.

I have to say that I still feel bad – even today – that I never had such a person. My time is limited nowadays, by my daily job and my family, and I have neither the opportunity to study again nor am able to revive my hack sessions which sometimes kept me awake all night in the early days of my bachelor study. The work I do on free software projects like monotone or my own project guitone is therefor limited as well, and the distance between the other developers (from which a few of them certainly have “Zen Master” status) doesn’t make it easy to create a real relationship which I’d like to have. In an ideal world, I could just hook up with them, sit with them in front of a computer, staring at code and hack like mad!

In an ideal world…

Step by step

Over the last few months I’ve worked on a new monotone interface for guitone from time to time. This new interface supersedes the old one in a couple of aspects; the most important one is that it runs the monotone processes in separate QThreads instead of the main GUI thread. I hope this will make many unexplainable locking problems on Mac OS X and Win32 vanish, which especially pop up when starting the application up or – weird enough – when the application is run as non-root user (Win32).

Rewriting something so important almost from the scratch is very tedious. Since it basically affects the whole application, the head of the net.venge.monotone.guitone branch has been and probably will be broken for a while. This is actually the first time I appreciated the fact that you can compile single source files step by step with make, just by triggering `make target_dir/filename.o`, so I’m kind of proud to say that I already have the actual thread class, a task item and a thread manager working (i.e. they compile ;)) – and I just finished the new utility class which supports synchronous queries to the thread (with the help of QEventLoop), which otherwise has a pure async i/o.

Sure, there is still a lot of work left and this work could be done faster if I wouldn’t be the only one right now hacking on this project (*wink*, *wink*, want to join?) – but at least I have the feeling that I’m getting somewhere now. And maybe I get even more impressions how to do things _better_ if I come back from the Trolltech Developer Days 2007 in Munich (16th and 17th October), whose attendance is sponsored by my company and Trolltech themselves.

Yes, thats right, they invited me to go there for free; a normal entry would have cost me nearly 600 Euro! And all this just because I develop this nice little Open Source application named guitone – isn’t that great?!

guitone 0.6.4 released

This is mainly a compatibility release so that guitone 0.6.x keeps working with newer monotone versions like the recently released 0.36. There are no new features or bug fixes included.

Please note that it won’t be possible to use monotone 0.34 or monotone 0.35 with this version of guitone due to a incompatible change in the monotone interface. Use guitone 0.6.3 or earlier for that purpose.

Grab your copy of guitone 0.6.4 here.

The work on 0.7 still goes slowly after having decided to completly redo the internals with QThread support. However I’m always open for help ;).

Taking appcasts to the next level

Appcasts are RSS feeds which make use of the <enclosure> tag which links to a binary file (usually a software package) somewhere on the internet. Sparkle, a library drop-in for Objective-C/Cocoa Mac OS X development, implements and expands this format to use it as transport description for application updates. With this, Sparkle makes it possible to automatically trigger application updates in a well-defined, consistent way. It downloads, unpacks and replaces the original binary and afterwards restarts the updated application.

I’m sure most of the Mac users out there have already seen it; many popular programs support self-updates through appcasts and Sparkle (hell, even guitone has an appcast after I managed to hack Sparkle support into this Qt project), it makes the whole process of updating non-Apple applications on a Mac so much easier and fun. With the advent of AppFresh, which aggregates all the registered appcasts from all locally installed applications and then updates them all-at-once, appcasts become an interesting idea for software distribution at a larger scale.

Now, GNU/Linux users will probably laugh at me when I tell them from this “superior” technique, because appcasting is a well-known technique in the free software world: A software update (if not automatically triggered) is usually done in the background by modern Linux distributions through yum or apt, with full support for version and dependency checking, mirror localisation and much more. Interestingly, these software distribution systems never made the jump to other operating systems – and yes, I know of MacPorts and Fink, but both are different story, because they distribute mostly GNU software.

There is one thing which distinguishs appcasts from GNU/Linux distribution systems, and this is rooted in the way software is developed on both platforms. GNU/Linux software projects usually just provide the sources, which are then build for the specific distribution and platform by so-called packagers. These packagers have not necessarily anything to do with the actual project. Because there are so many distros out there, a software gets quite a lot repackaged, even if some of these packages basically serve the same platform and architecture.

Mac OS X software (and Windows software as well) is usually distributed directly in binary form, ready to use for the defined platform. The “packager” role is here an internal role of the software creator and the distribution – if not done through the software creators home page – usually happens via big download sites like macupdate.com, cnet.com and others. All these websites are isolated “applications”, meaning that they use different internal data formats, are usually closed and don’t work together in most cases.

So, the new hype, not only in content creation branch, is syndication. And that is exactly what appcasts are about: Based on RSS 2.0 they provide a general format to describe software updates. Platforms like iusethis.com use the feed and provide additional services, f.e. a global “usage counter” for a particular software package. However the problem with the current appcast format pushed by Sparkle is, that it is itself an isolated application, because it can only provide “some package with some version to download somewhere” and includes no information about other platforms, architectures or download locations. This may be ok as long as you either have different appcasts for all these different platforms or only target one platform (in case of Sparkle Mac OS X).

But what if you create an application which should run on all major platforms? You certainly want to provide your users the same look’n’feel and features on all these platforms, and this is where my proposal drops in. My aim is to create a cross-platform format for software updates which is suitable to distribute update information for any platform through one single stream of information. Based on this format people could create those kind of library drop ins like Sparkle not only for Mac OS X, but for multi platform toolkits like Qt, wxWidgets, even for .NET. Software developers would then simply add those in their projects, provide the syndicated format on a webserver, and are done.

So again, what are the advantages here?

  • Based on the specification, an application update would “feel” the same on every platform, maybe with slightly differences between the different toolkit implementations
  • The syndicated format, which extends RSS 2.0, could serve as common content feed in any feedreader and, at the same time, transport the needed update information for the application drop ins
  • The feeds are decentralized published; the power is taken back to the software creator as he determines how he publishes his software
  • Other services similar to iusethis.com could arise which would provide social functionality around software updates, caching, mirroring and more

Of course the whole proposal would probably make most sense for Windows and Mac OS X software creators, since, as I already mentioned, distribution in the GNU/Linux world happens quite differently (and these people usually don’t like to build binaries themselves, they let packagers from the different distros do this work). But why should efforts like AutoPackage not be supported, if they’re interested? And I think commercial Linux software distributors would be interested in that as well, just because it would strengthen their relationship with their customers quite a lot.

What follows is a quick effort how such a format could look like. It currently doesn’t contain the RSS part, because I think you all know how this would look alike, I plan to put one <software> node into each <item> which would then stand for an invididual software release. Below the software node, the following tree would be expanded (which should be mostly self-explanatory):


  2.2.3
  
    
      
        source
        application/x-compressed
        2928399933
        012346789ABCDEF012346789ABCDEF
      
      manual
      
        
        
      
    
    
      
        binary
        application/octet-stream
        2928399933
        012346789ABCDEF012346789ABCDEF
      
      app-replace
      
        
        
      
    
    
      
        binary
        application/octet-stream
        2928399933
        012346789ABCDEF012346789ABCDEF
      
      installer

Of course some concepts are stolen from Sparkle (f.e. hashs to check the data integrity of downloaded files), and one could put a lot more stuff in this. I once thought about adding support for “upgrade paths” into it, f.e. if a user skips a couple of versions, he should be notified if his current installation can be updated (using binary patches) or has to be upgraded (which requires a full installation), but I think bandwidth is cheap nowadays and it would make a first shot of this format and its implementation far too complex.

So, this is it, what do you think? I’d love to hear your feedback! I’m in contact with the developers of AppFresh and they signalled interest as well. Stay tuned for more news in the future!

Should Trolltech make their products support GPLv3?

Since the GNU General Public License v3 had been [released last week](http://gplv3.fsf.org/) I’m actively thinking about switching the license for some of my projects, f.e. [guitone](http://guitone.thomaskeller.biz), which are currently GPLv2 “or later”. The main reason for doing this for me personally is to protect my software even better from any possible [Tivoization](http://en.wikipedia.org/wiki/Tivoization), i.e. no patent restrictions, closed hardware, or anything else should hinder people to use, modify and distribute it further.

Looking more in detail at the license possibilities [Trolltech](http://www.trolltech.com) gives developers which use their Qt/Qtopia platform, upgrading Qt projects from GPLv2 to GPLv3 doesn’t seem to be possible: The problem is that even though Qt4 can be licensed under GPLv2, it does **not** contain the “… or – at your option – any later version” clause of the license, and since GPLv2 and GPLv3 are incompatible with each other, as Richard Stallman [told us here](http://gplv3.fsf.org/rms-why.html), you therefor can’t legally link GPLv3 code with those GPLv2 libraries:

> When we say that GPLv2 and GPLv3 are incompatible, it means there is no legal way to combine code under GPLv2 with code under GPLv3 in a single program. This is because both GPLv2 and GPLv3 are copyleft licenses: each of them says, If you include code under this license in a larger program, the larger program must be under this license too.? There is no way to make them compatible. We could add a GPLv2-compatibility clause to GPLv3, but it wouldn’t do the job, because GPLv2 would need a similar clause.

([Source](http://gplv3.fsf.org/rms-why.html))

There _might_ be a way out of this dilemma, in case Trolltech doesn’t want to put Qt/Qtopia directly under “GPLv2 or later”/GPLv3: There already seems to exist a “Trolltech GPL Exception version 1.0”, but the text is currently unavailable from the [Troll’s site](http://trolltech.com/products/qt/gplexception). A temporary copy of it can be found in the Subversion repository of the libqxt project. The Exception states that you can use a couple of other accepted Free Software Licenses in your project and still use the GPL version of Qt:

> […] 1) The right to use Open Source Licenses not compatible with the GNU General Public License: You may link software (hereafter referred to as “Your Software”) against the Licensed Software and/or distribute binaries of Your Software linked against the Licensed Software, provided that:

> A) Your Software is licensed under one of the following licenses: […]

and what follows is a list which includes licenses like the Apache Software License, the LGPL, the BSD license, the Mozilla Public License, to just name a few. Furthermore:

> […] B) You must, on request, make a complete package including the complete source code of Your Software (as defined in the GNU General Public License version 2, section 3, but excluding anything excluded by the special exception in the same section) available to Trolltech under the same license as that granted to other recipients of the source code of Your Software. […]

…this seems only fair…

> […] C) Your or any other contributor’s rights to:

> i) distribute the source code of Your Software to anyone for any purpose;

> and

> ii) publicly discuss the development project for Your Software and its goals in any form and in any forumare not prohibited by any legal instrument, including but not limited to contracts, non-disclosure agreements, and employee contracts. […]

… yes I hope so!

Now I’m unsure if this exception is granted to every (free) software project using Qt. Currently, GPLv3 is not on the list, but if this exception is valid for everyone (not just paid customers of Trolltech), maybe it could be expanded to allow GPLv3 as well and therefor serve the Open Source community

Whatever route Trolltech will go, I hope they at least notice that there is **a demand from the Open Source community** to clarify the licensing issues with respect to GPLv3, and I hope this happens in the near future…

Edit 2007-08-09

It seems as Trolltech put back the GPL Exception in place, though the GPLv3 is still not listed as a valid license. One Trolltech engineer said however recently in a comment on the Labs Blog:

… As for GPL v3, we are actively working on it. From what I understand, it is a bigger step and not something we can just provide with an Exception.

(Source)

So its good to know that they’re aware of it!

Projects, projects, projects!

Last week my copy of Anno 1701 for the Nintendo DS dropped in and I instantly remembered the happy days when I played the original version for the PC, Anno 1602. While the gameplay is pretty much the same, graphics have been improved a bit and the product circuits got less complex. While you may have needed two or three buildings to produce a certain good, now one or two are enough.
All in all its a worthwile game, which made me looking into alternatives and/or ports for the Mac OS. Sunflowers, the company behind the Anno series, never considered such a step (“market share too less significant”) and I don’t know of any other publisher, such as Aspyr Media, ever considered that either way. This is kind of sad, especially if you look at the gorgeous PC version of 1701 which was released last fall. Intel Macs now certainly have enough power to play those games, but even Steve itself doesn’t put the “almost no mainstream games for the Mac”-problem on a high agenda – which you may imagine if you look at the half-hearted try of Electronic Arts to support the Mac OS with games, which was, of course, vastly announced by Steve on the last MacWorld.

Now, one very interesting project which recently took my attention in this regard is OpenAnno. It seems that a couple of Anno-enthusiasts try to create a clone of the original 1602 version. The game is in very early stage, there is an editor written in Qt, and the game itself seems to be build upon SDL, making it suitable for cross platform gaming. However, like every Open Source game, the developer’s biggest problem is to find people who create kick-ass graphics and animations, and in general, get more attention by the community. I decided to give it a try and create some native mac binaries for the most recent version. This is not done in five minutes, given the fact that the SDL libs (they use SDL_image, SDL_mixer, SDL_gfx and SDL_ttf) aren’t installed on most user Macs and most of those libs are known to have other horrible dependencies. So instead of messing around with frameworks I’ll probably try and link all of them statically to the main application. PhysFS is another dependency, but this shouldn’t be too hard to integrate. Lets see how this goes, I’ll of course post news here if I get it done =)

Beside OpenAnno there are of course other projects which have my attention. At first guitone, where the development slowed down a bit recently, because I’m in the process of rebuilding the monotone wrapper in use again. Having the mtn process run in the main GUI thread seems to cause a lot of problems, sometimes it just doesn’t signal that output is available, so the GUI is stucked (this happens on my beloved win32 port). But I’m not saying that it works better on other platforms… OSX has similar problems. My current solution involves putting the QProcess in a separate thread which has a local task queue and which signals when a certain task has been finished. Thanks to the Trolls that signals and slots work across threads (they are enqueue in this case and are not executed directly), still, my new solution includes some ugly code parts, f.e. when I try to match the finished task to any of the signalled slots. Given a general signal like this

void taskFinished(MonotoneTask & task);

and any amount of consumer classes which have a slot for this of course makes the need for code like this

void Consumer::taskFinished(MonotoneTask & task)
{
    // this is not our task...
    if (task.getTaskNumber() != rememberedTaskNumber) return;
}

if one uses a thread-global task number to identify each of them. I’ve looked into various other solutions for this; what I basically need is of course a callback or something which only functional languages provide: lambda notations. But this is Qt, this is C++, so without getting your hands very very dirty (or throwing in big dependencies like boost) there is no way of doing safe, reliable, non-intrusive, cross-thread callbacks. But hey, if you know something I don’t know, I’d be happy to hear from you!

There are two other projects which have my interest, but I guess I’ll tell you of those in my next post – this one got already far too long =)

Life and everything

So this was one of those mediocre days, you wake up far too early in the morning because your little son thinks its a good time to be awake. You do the usual things, like get awake yourself somehow in the bathroom, put on some clothes (while picking those ones which don’t smell that bad from the staple), take care about your son and your wife, eat something, later give each a hug, “love you, bye!” and go to work.

Well, work, this is probably what struggles me the most at the moment. Of course you can’t always do or like what you personally find good or bad, you’re bound to projects, internal processes and stuff. Work used to be fun because I had and have great colleques, but sometimes, like recently, this just doesn’t compare or outweight the actual project work which just annoys me.

Usually, there are several kinds of projects, and I’m solely speaking of software projects here. Two of these “types” are the reason for my current struggeling:

The “I knew that this would happen and break our neck”-project. Usually these projects are plainly brain dead, include immense code hacks to get something work or are just build upon the wrong /dysfunctional components. Of course its not an option to just cancel the project – they have to be kept alive most of the time for political and / or reputational reasons.

The “We have to use this whether or not it is sufficient”-project. This is something even more brain dead and normally applies to a component or software you need to build your own software upon. To make things even worse, the component or software is mostly closed source, meaning you or your customer had to pay a huge amount of money for it and by doing this you are solely dependent on this particular vendor. The whitepapers of those things always look great, but when it comes to the actual implementation details you may find out “woops, it doesn’t do what we want, now what?” – yeah, one could bug the vendor and beg him to implement the feature, and maybe he even does that (based on the amount of money you’ve spent before on licensing), but this doesn’t always work out and if it worked out for one missing feature, it might not work out for another one you may find later. So you sit there and try to hack it yourself, and obviously your “system” has something they’d call an “api”, this is badly documented, and of course any support call to the vendor costs either alot struggle or even worse $$$.

For me personally an even worse problem is recently, that even if some project finished successfully, I didn’t get much satisfaction from it. Maybe this was because I couldn’t use the tools or environment I’d like to have used (Windoze anyone?), maybe this was because the resulting code quality didn’t match my own expectations (if you do project work you almost never have much time to get your tools right, think about a proper and extensible architecture, aso.), and maybe this was because I couldn’t tell anyone of the project because of NDAs or other political issues. How should I be proud of something I cannot show and explain in detail to anybody?

So all this made me think a lot in the past. At first I decided to get my joy of work back by doing personal Open Source projects in my spare time. This worked for quite some time and still kind of works, but the obvious problem is time. If you work 8+ hours, have a family with a little child and then should find some time to get some serious hacking done, then this usually fucks up your sleeping rythmn because you start to shift your “personal” workload into evening and night sessions.

Shouldn’t it be somehow possible to get both, satisfaction and money, for something you create? I came to the conclusion that it should be possible, after all these people seemed to have a lot of fun with their day job. Is that, because they produce an Open Source software, which is not only licensed by many companies, but also free to use for anyone else? Is that, because their employer, Trolltech, not only allows, but encourage them to research personal interests and get in contact with the community?

I could be wrong, but I think the answers to the above questions are “yes”. Thats why I think my perfect job would be in a company which not only uses, but respects and lives Open Source. And thats why I recently applied for a job offer from the Trolls, now lets see how this one goes…