DeployQt4 will take an executable and any specified Qt plugins and install and setup all the linked dependencies.

DeployQt4 does this by using e.g. otool, ldd or depends.exe to find the linked libraries, installing a qt.conf file (if needed) to ensure the correct Qt is used and install any specified Qt plugins to the default Qt application plugin path. On OSX it will also use install_name_tool to make sure your application is linked directly to the libraries inside its bundle.

For example an OSX application bundle before DeployQt4 might look like:

and afterwards like:

The most commonly used DeployQt4 function is INSTALL_QT4_EXECUTABLE function. For example:
INSTALL_QT4_EXECUTABLE(${EXECUTABLE_PATH} qsqlite)

If you wanted to do this in a CMake script rather than at install time (i.e. for an already compiled executable) you could instead call:
FIXUP_QT4_EXECUTABLE(${EXECUTABLE_PATH} qsqlite)

Other DeployQt4 options include manually specifying libraries or non-Qt plugins to install their linked dependencies, additional directories to check for linked dependencies (the Qt directories are added by default), override the default plugin installation directory, override whether a qt.conf file is installed and the use of CMake INSTALL components.

You can see an example of using DeployQt4 (combined with CPack to generate installers) in the CMakeLists.txt file for my Fabula project.

For more information read the DeployQt4 section of the official CMake documentation, read the DeployQt4 source code or post a question in the comments.

If you want the same functionality for non-Qt projects I suggest you investigate the BundleUtilities module in CMake. Despite the confusing name this installs linked dependencies on Windows, Mac and Linux. DeployQt4 extends this functionality to improve the API and add some Qt-specific deployment help.

If you want the same functionality for Mac-only non-CMake projects I suggest you investigate the Mac deployment tool (macdeployqt) that is bundled with Qt. It lacks the DeployQt4 added features of automatic installation of any linked dependencies, CMake/CPack integration and support for Windows and Linux but will install the Qt libraries correctly.

By default there is a problem with QGtkStyle which stops it correctly picking up the GTK theme as XFCE does not save it in the usual place.

To fix this we can use a simple script:

#!/bin/sh
DEFAULT_XFCE_THEME=greybird
XFCE_THEME=$(xfconf-query -c xsettings -p /Net/ThemeName 2>/dev/null)
GTK2_RC_FILES=$HOME/.config/xfce4/gtkrc
[ -z "$XFCE_THEME" ] && XFCE_THEME=$DEFAULT_XFCE_THEME
echo gtk-theme-name = $XFCE_THEME > $GTK2_RC_FILES
unset DEFAULT_XFCE_THEME
unset XFCE_THEME
export GTK2_RC_FILES
. /etc/xdg/xfce4/xinitrc

Put this script into $HOME/.config/xfce4/xinitrc and ensure it is executable by running chmod +x $HOME/.config/xfce4/xinitrc.

A friend sent me a link to an interesting review that I was writing a long response to but thought I’d turn it into a blog post instead. The review is fantastically written by Zadie Smith but there’s a few glaring holes in it that frustrated this post into existence.

Smith, like many mainstream journalists and writers, seems to fundamentally understand what makes people like us excited about programming. I’ll respond to some choice quotes from the review.

No doubt the filmmakers considered this option, but you can see their dilemma: how to convey the pleasure of programming—if such a pleasure exists—in a way that is both cinematic and comprehensible?

If such a pleasure exists? Really? She mentions in the review she talked to a “software expert” but she must have avoided this topic of discussion. The pleasure in coding combines creativity (like creating art, no-one will ever write a program the same way as you), building to try to simplify the lives of others and mathematical problem solving. I think the film communicates this fairly well but it’s one of these things that’s pretty much impossible to hide the elements of programming that immediately turn some people off it. Some people find the idea that I sit at my computer typing for most of the day fundamentally boring and there’s not much you can do to argue against this viewpoint other than display the great things that can result from it.

E Pluribus Unum—that’s the point. Here’s my guess: he wants to be like everybody else. He wants to be liked.

It’s a shame that for anyone who is or was ever considered “nerdy” that we fall victim to such poor pop psychology. Just because we weren’t all deemed “cool” in high school doesn’t mean our entire careers are driven by this reductionist need to over-compensate for what others thing we missed out on. Zuckerberg I’d imagine, like most software engineers wants to build something that everyone will think “how did I manage before this came along” and, even if they don’t know he made it, he’ll know that he’s simplified the lives of a lot of people. This is why we do it and this is why we love it.

The fact that Zuckerberg open-sourced his earlier applications (not just gave it away for not monetary value, her review misses this) shows this; he values the pleasure of people using his tool over the monetary return that he could have instead. This also points to why Facebook didn’t take the many chances to sell out to large companies earlier in its existence.

I am dreaming of a Web that caters to a kind of person who no longer exists. A private person, a person who is a mystery, to the world and—which is more important—to herself.

The type of web (and person) she mentions already existed and still exists: you can use private email, private Facebook messages, protected Twitter accounts and use other services that guarantee privacy, even relying on end-to-end encryption so only the sender and receiver can see any content. Arguably, this was the first web, the one many of us were using 10 or 15 years ago. The problem is that she fails to see the flip side of her argument: what about those of us who are very public people, how could we share things with the world without relying on a gatekeeper or third-party before the internet and, arguably, before Web 2.0′s concepts became mainstream?

This is why she’s writing her review in the New York Review and not by monetizing a personal blog. She seems to believe in the gatekeeper, the Web 1.0 (or Person 1.0 from her article) and the tight separation of career and personal life, of the private persona that lives their life and the public persona that does their work (or perhaps I’m the one who is spouting pop psychology now).

As said, this was a brilliantly written review even although I disagree with many of the arguments in it. The Social Network (and indeed Facebook itself) is a great advertisement for the beauty and power of software: that someone can produce something that will change the world from their university dorm room with scarce resources, no corporate sponsors, some programming experience and a lot of hard work. It’s the antithesis of programs like X Factor and other reality TV that spouts the lie to society that success comes from being lucky enough to be picked by a corporation and that fame itself is the thing worth striving for.

Start showing films like The Social Network in schools. Get high school kids writing software rather than the letters in Word. Teach them how to write Facebook and mobile applications, programs that they and their friends will use outside of school. Let us, as software engineers, rekindle the passion that got us into this field in the first place and let’s see a return to late-night coding binges and building useful stuff for fun. Let’s see the youth of tomorrow look at our field and think “wow, that’s cool, I want to do that too”.

I’m a software engineer and I like writing code. I don’t mind doing sysadmin, I did it at my previous employer and do it on this server but my main love with computers will always be programming. Moving to OSX gave me a system that “Just Works” and resulted in me having more time to work on interesting coding projects and wasting less time trying to make my computer do what it is meant to.

I think the reason people become so passionate about Apple’s products is that they really focus on not bothering the user unless they have to through making sensible design decisions rather than worrying about edge cases (an unfortunate affliction for software engineers). A great example of this is the suspend behaviour. Firstly, suspend and resume on Mac is 100% reliable, I’ve never had my machine not come up after suspending. It’s quick, it occurs on you putting the lid down and it quickly becomes second nature to do so. Another great example of Apple’s design focus is what happens when your battery runs out after you’ve already put your lid down and suspended (UPDATE: This feature is know as Safe Sleep and combines hibernate and sleep. This is possible on Linux but isn’t default on any distribution I’ve ever used). On Windows (on older versions at least, haven’t tested this on 7) and on Linux: sucks, you shouldn’t have let your battery run out, you’ve lost all your work. On OSX: it hibernates automatically some time before the battery runs out so your work is saved.

I explained this to my wife and she asked “Why doesn’t everyone do it that way?”. I didn’t know. I suspect because it’s a hard problem and it doesn’t affect many people. The problem is that, although an edge case, when it does affect you it’s mindblowingly frustrating. When I use an Apple product it feels like they care about you enjoying your experience. They care if you lose work so they try and stop you doing so. On Linux, it just felt that whatever went wrong it was my fault for not RTFM. This came across from the OS itself and the developers and users I would ask for help.

Even if you use Linux or Windows, I encourage you to be influenced by Apple when you design your software: do the most sensible thing for the user at all times and don’t bother them. Don’t worry so much about edge cases and just try and transparently help the user without bothering them. This is why people pay a premium for Apple products. Better to make something that’s great at doing a few things in a way the user will love than possible to do everything if the user tries hard enough.

UPDATE: I didn’t mention the distribution I’ve used because the above applied to every one I had used at the stage I left. Even on well supported Dell hardware (Latitude D620) I never had 100% reliable suspend on Fedora, Debian, Kubuntu, OpenSUSE, Arch Linux or Gentoo. I bought the laptop for Linux as a friend had a Macbook; it was really well supported and worked great and he’s a kernel hacker so I thought it was a good bet. Turns out the newer version I bought had the above mentioned kernel bugs causing only one core to be usable (ACPI bug).

I’ve managed to emulate this functionality in Windows by using the login scripts. This script should work in Windows 2000 or any later version but the setup instructions may vary.

• Create a file named LockWorkStation.vbs with the contents: WScript.CreateObject("WScript.Shell").Run("rundll32 user32.dll,LockWorkStation")
• Access the hidden Advanced Users Control Panel by running “control.exe userpasswords2” from a Run dialog or command prompt.
• In the “Users” tab, uncheck “Users must enter a user name and password to use this computer”.
• UPDATE: Windows 7 Home Premium, Windows Vista Home Premium and Windows XP Home Edition don’t come with the necessary group policy editor so you can either Google for ways of using gpedit.msc (either downloading the needed files or editing the registry manually) or just put the above script in your Startup folder. The latter option will be less secure as someone could get access to your machine after the desktop loads but before the script does but it will still work.
• In the “Advanced” tab under “Advanced user management” click “Advanced”.
• Click “Users” in the left-hand pane of the “Local Users and Groups” window, right-click on the user you want to autologin from the right-hand pane and select “Properties”.
• In the “Profile” tab, enter “LockWorkstation.vbs” in the “Logon script:” box..
• Create a folder somewhere on disk (I recommend My Documents/Scripts) that you want to store the script in.
• Right-click on the folder and select “Properties”. From the “Sharing” tab, click “Advanced Sharing…”.
• Check “Share this folder” and enter “NetLogon” in the “Share name” box. Set the number of simultaneous users to 1.
• Click “Permissions” and ensure you are the only user listed and you have only “Read” access enabled.

You’re now done. When you next log in, you shouldn’t see the desktop at all (or incredibly briefly) and the screen should lock immediately and require your password to unlock while all your stuff happily loads in the background.

UPDATE: This was posted on Lifehacker and they made a video walkthrough for this post:

Outside of work my fiancee and I have been planning our wedding and bought a house for us to live in when we get married. It was worryingly easy to do the whole thing, it required minimal paperwork. It’s in Broughty Ferry (on the outskirts of Dundee) and the sea is 100m away and visible from my new study. It’s all very exciting and I’m counting down the days until we get married and I move in.

At work, I’ve been involved in some more fun Qt consultancy stuff. It’s all been enjoyable and varied, something that really suits my childlike attention-span. I work from home so I’ve been flying to various places (Germany, Sweden, Denmark so far and Iceland next week) in the course of my work. I like seeing new places but am a rubbish tourist so it’s been nice to be able to expand my horizons without much personal effort.

One of the nice things about working with Qt and other open-source projects is that I can get to contribute to them at work when a customer needs a feature/bugfix. One of my projects has involved a lot of QtScript and I used QtScriptGenerator for the bindings (wanted to try SMOKE but I couldn’t find enough of a solid internet presence to trust it fully yet). I’ve made a few fixes to support code written in C++ rather than Qt (handle exceptions better, do some automatic C++ standard library type conversion, support C-style single “void” parameter and bugfixing). This stuff is all merged upstream and part of QtScriptGenerator.

I can’t wait till KDE and more open-source projects move to Git (and Gitorious/GitHub). It’s so amazingly simple to get patches merged and retain your attribution and handle local work branches while tracking upstream, with merging normally being handled near-automagically. This requires so much time to do in Subversion that it really pains me to have to use it now.

Another interesting project I’ve been working on recently is Homebrew, a package manager for OSX that seeks to use system libraries, be fast and make contribution incredibly easy (things that MacPorts and Fink seem to fail at). It uses Git as the repository backing store so you just fork from mxcl’s repository, use “brew create $URL” to create a template package from the URL and archive name, modify it until it works and make a pull request on GitHub. mxcl then looks over your contribution and merges it if it looks good. So far I’ve tweaked Qt and started adding the necessary dependencies to get KDE in there too.

I really like this model. I trust mxcl as a benign dictator, he is a good guy and makes sensible decisions (such as buying me beer), and I feel this method of contribution really opens the project up to many more people than it would otherwise. It also has the Steve Jobs/Linus Torvalds-type figure that I think is essential for any piece of software to have a clear set of goals and maintain a certain quality level.

It’s been nice for me working mostly on my Macbook now. Everything just works that I need to and I can still run pretty much every open-source application I used on Linux. It’s nice to see the vibrant OSS ecosystem on OSX and the attention to detail in applications such as Adium, particularly in having an attractive and easily usable interface. Hopefully I’ll be able to apply this level of polish to some of the KDEPIM apps in the next while too, currently they work great but look a bit nasty on OSX.

Too much writing, back to the code!

I tried running Linux on it but due to some still unresolved issue it’s not really usable as a main operating system yet on this laptop so I’ve been forcing myself to use OSX for a while and trying to learn some lessons from it.

As my first main contribution to the KDE Mac project I’ve been working at getting the packages easily buildable and distributable without MacPorts/Fink by using CPack (a cross-platform packaging tool that comes with CMake). This is the type of project that will probably be mostly committed in a oner into KDE Libs (post-review) and hopefully then available to basically any KDE project with a little configuration. I’m planning on starting with getting some basic packages without dependencies first (e.g. without KDELibs or DBus bundled) and then work up to an application bundle that contains all library and executable dependencies. If you’re interested what the result might look like then take a look at the Mendeley Desktop OSX package, built entirely using CPack that I produces while working at Mendeley.

Another thing I’ve found while building KDE for OSX is the need to build universal packages for all the KDE dependencies. This omits Fink unfortunately so I’ve ended up using MacPorts. Due to a decision I disagree with I’ve contributed to Harald Fernengel’s project for adding dummy versions of MacPorts packages that are already available on OSX Leopard. You can find this on gitorious.

For anyone interested, the current minimal dependencies for various packages in trunk are listed below:
kdelibs: pcre++, shared-mime-info, jpeg, giflib, libpng, dbus
akonadi: shared-mime-info, boost
kdepimlibs: gpgme, libical
kdepim: none

Once I’ve got a bit further I’ll get all this stuff on TechBase. Anyone interested in helping out or lending an opinion feel free to leave a comment.

Firstly open KOrganizer.

When it has opened right-click anywhere in the “Calendars” area in the bottom-left and select “Add…” from the drop-down menu that appears.

Select “Journal in a blog” from the “Resource Configuration” dialog.

Fill in the “Resource Configuration” dialog.

• Name: Choose a descriptive name for your resource, this is how KOrganizer will describe it to you in future. KOrganizer won’t reference this resource as being a blog again so you may want to choose something suffixed with “blog“.
• XML-RPC URL: This depends on your blog but for WordPress and Drupal this is the main URL followed by “/xmlrpc.php“, for Livejournal it is “http://www.livejournal.com/interface/blogger” and for Blogger it is “http://www.blogger.com/feeds/$YOUR_USER_ID/blogs“. For other blogs, consult their documentation or ask me for help and I’ll do my best to work it out.
• Username: This is the username you use to login and make blog posts.
  Password: This is the password you use to login with the above username and make blog posts.
• API: Use “(WordPress, Drupal <5.6 workarounds)” if you use either of those blogs. Otherwise it is MovableType for Drupal, Google Blogger Data for Blogger and Blogger for LiveJournal. The LiveJournal API is unlikely to work with LiveJournal as it isn’t yet complete. If you wish to implement the LiveJournal full API rather than using legacy Blogger one then please contact me.
• Blog: When you have chosen an API this list will be automatically populated using items from the server. If there is only one entry, it will be greyed out but the entry’s text shown and selected. If there are more than one (e.g. Drupal has one for pages and one for posts) they will be selectable. If there is nothing new displayed then one or more of your XML-RPC/username/password/API are probably incorrect.
• Posts to download: This chooses how many posts the API will download and sync. If you, like me, have made hundreds of posts then you probably want to keep this number reasonably low.
• Automatic Reload: This defines how often KOrganizer will download new blog posts from the server without notification.
• Automatic Save: This defines when KOrganizer will upload new blog posts to the server without notification. You probably don’t want to have this set to “On every change” unless you want it to be uploaded as soon as you hit “Save” in the next view.

You should now see your new blog resource displayed in the bottom-left corner. Let’s try making a new blog post. Activate the journal view by clicking the journal button.

We are now in the journal view and you can see on the left-hand pane that KOrganizer has successfully downloaded some of my blog posts. If we want to create a new one then click on the add journal button.

Fill in the “Edit Journal Entry” dialog.

• Title: You probably want to change the title of the blog post from the default.
• Date/Time: On most blogs selecting the date/time to somewhere in the future means the blog won’t publicly appear until then.
• Content: Write something about how I am awesome, like the pictured example.The rich-text should be displayed on your blog correctly (albeit with slightly nasty HTML).

• Select Categories: This list should have been populated with the ones from your blog and from the KOrganizer defaults. Sadly, I can’t seem to remove the latter and selecting them will do nothing unless they have been created on your blog.

When you click “OK” you may be prompted which resource you wish to save to. Select the resource we just created.

If you chose “on every change” for “Automatic Save” in the “Resource Configuration” dialog then your post has probably whizzed its way off to your blog already. If not, you can manually save it by right-clicking on your resource and selecting “Save” from the drop-down menu that appears.

I hope this was and is useful to some people. If you find any bugs, have any problems or want any other features then please let me know either by email, my posting on this blog or by filing a bug in the KDE bugtracker.

If anyone else has a good plugin for WordPress for avoiding spam then please let me know as being on the Planet seems to result in me being spammed to oblivion.

Also, if you had anything interesting to say about Spore, Phorm or Chrome then please excuse me being a noob and post comments!