Mike McQuaid

Deploying Qt applications with DeployQt4

2012-01-04T00:00:00+00:00

CMake 2.8.7 has been released and includes the DeployQt4 module I created.

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.

Make Qt use the GTK Style on XFCE or Xubuntu

2011-12-01T00:00:00+00:00

I’m a Qt developer and use Xubuntu in my Linux VMs as it is lighter than KDE and doesn’t get in my way (unlike Unity).

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.

The Social Network: A Defence of Programming

2010-11-11T00:00:00+00:00

I recently saw The Social Network, a dramatisation of the creation of Facebook. It was a thoroughly enjoyable film with brilliant direction, casting (Eisenberg and Timberlake in particular) and writing. It also had an incredibly realistic hacking scene (using wget and perl scripts) and featured KDE on the desktop of most of the programmers in the film. I highly recommend seeing it, regardless of your thoughts on Facebook.

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”.

Why I Left Linux and went to Apple

2010-09-21T00:00:00+01:00

I originally bought a MacBook to use as a nice Linux laptop and for some iPhone and Qt OSX development. Shortly afterwards I got engaged which made me think about the future and how I spent my time a bit more. Linux is great for many use-cases but I just kept finding myself getting increasingly fed up with trying to use it on the desktop. My problems included having DVD playback not work quite correctly, having to manually edit configuration files in a text editor just to get some piece of hardware that worked instantly in OSX and Windows working and various other issues that wasted my time. Due to a kernel bug in Linux affecting my MacBook, I found myself using OSX more and more for work and finally moved across completely to my MacBook and also removing Linux from my desktop to relegate it to a Windows-only games machine. I’m now only running Linux on my NAS, this server, TV and phone.

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 known 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 incredibly 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).

Windows Autologin Lock Screen

2010-09-19T00:00:00+01:00

Something I miss when I used Windows is the nice autologin feature from KDE’s login manager (KDM). Autologin always struck me as a bit insecure; why have a password if you are going to bypass it completely? KDM’s solution was pretty nice, it allowed you to be logged in automatically (so that everything that runs on startup started loading) and lock the desktop before it appeared so that when you turned on your computer you would still get a password prompt but would unlock it to find that all your applications had already loaded.

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:

KDE - Blog from KOrganizer HOWTO

2008-09-27T00:00:00+01:00

Blog from KOrganizer? What kind of madness is this? Apparently some crazy fool decided to give you the ability to post journals from KOrganizer to your blog. Let’s learn how to do it!

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.

Using .asoundrc to remap ALSA channels for Audacity

2008-07-17T00:00:00+01:00

My sound card (a Creative Sound Blaster Audigy 2) has got lots of inputs, especially with the nice drive bay expansion port.

Unfortunately, the default ALSA device seems to have no way to access the “Line 2/Mic 2” channel on the front drive-bay expansion which I use for recording due to it seemingly being the lowest-noise channel.

If you point JACK’s “Input Device” to “hw:0,2” then it will pick up the 16 channel inputs and you can connect them nicely to be able to access this port (channels 9 and 10) in JACK-enabled applications.

I’m currently working on some voice acting for The Nameless Mod (which is looking like it’s going to be spectacular, check it out) and the best program I’ve found to do this recording in is Audacity. Audacity however seems to stubbornly refuse to let me use its JACK support (which is apparently buggy beyond use currently anyway).

I found that if I point Audacity to record 16 channels from “hw:0,2” then I can access all the Audigy’s input channels (as JACK does) but unfortunately this means that every time I record I get all 16 channels (a PortAudio limitation from what I can tell from the source). This isn’t ideal as it means, to record a bunch of lines in rapid succession, I need to spend huge amounts of time deleting the unwanted 15 other channels. As it’s not possible to select the channels to record from Audacity I needed to get a little more creative and ended up with this:

pcm.mic2 {
    type plug
    slave.pcm "hw:0,2"
    slave.channels 16
    ttable.0.8 1
    ttable.1.9 1
    ttable.8.0 1
    ttable.9.1 1
}

If you add the above to your “~/.asoundrc” or “/etc/asound.conf” then you will find that in Audacity’s “Recoding” dropdown you will now have the option “ALSA: mic2”. This is simply the same as “hw:0,2” but with the 9th channel swapped with the 1st and the 10th swapped with the second, thus allowing you to select “2: Stereo” or “1: Mono” from the “Channels” dropdown and get the Line/Mic 2 input(s) in Audacity without the need to constantly delete unwanted tracks.

Enjoy!

Note: You probably also want to ensure that Audacity records at the Audigy 2’s native rate of 48000Hz and use a 16-bit sample format.

Konqueror with latest Adobe Flash HOWTO (Outdated)

2007-12-30T00:00:00+00:00

This page is outdated. In KDE4 Konqueror will work with the latest Adobe Flash plugin and there is now a 64-bit version of Flash available for Linux. I highly recommend you use one of these instead of the guide below but I’m leaving it here in case you need to use it for another reason.

I agree with Lubos. Flash sucks. However, most of us have or want to use it for things like YouTube or watching badgers.

As you may be aware the latest versions of Flash depend on XEmbed support which Konqueror lacks without various patches to KDELibs and KDEBase which haven’t been applied by my distribution and I couldn’t get working even when I manually patched the necessary parts of KDE myself. I was using the older versions but it appears they have outstanding and actively exploited security holes that they have only fixed in the XEmbed-supporting versions.

Mike needs his YouTube fix without haxors running rife on his box. Who can save him?

KMPlayer to the rescue!

KMPlayer is my media player of choice as it allows you to trivially switch between XINE, MPlayer and GStreamer backends and, as of version 0.10.0, has a nifty backend that allows you to use XEmbed-supporting plugins, including Adobe’s Flash plugin, which can then be embedded in Konqueror to allow Flash to work trivially.

Install KMPlayer (version 0.10.0c or higher). It is included in all the major distributions I’ve ever used. Ensure it is installed/compiled with the “NPP” backend enabled which allows the playback of Netscape XEmbed plugins (this depends on your distribution).
Run KMPlayer so it creates its config file. Close it. (This step probably isn’t necessary but it won’t do any harm)
Run the following commands:

kwriteconfig --file kmplayerrc \
    --group "application/x-shockwave-flash" --key player npp
kwriteconfig --file kmplayerrc \
    --group "application/x-shockwave-flash" --key plugin \
    /usr/lib/flashplugin-nonfree/libflashplayer.so

Change the “libflashplayer.so” section depending on where the Adobe Flash plugin was installed on your distribution. The above example is where it is installed on Gentoo. (People have replied below with where it is stored on various systems. If you can’t find yours, you probably have a locate program installed so trying running “locate libflashplayer.so” for an idea).
Open Konqueror and click “Settings > Configure Konqueror…”. In the new window navigate to “File Associations” in the left-hand panel and select “application/x-shockwave-flash”. Click the “Embedding” tab and click “Add…”. Select “Embedded MPlayer for KDE” from the new window. If it is not there then you may need to restart KDE or run “kbuildsycoca” from a terminal. Close all the opened windows.
Enjoy a working Flash in Konqueror!

What is wrong? You’re running a x86_64 machine (like me) so the above doesn’t work? Never fear! If you manage to get a 32-bit version of “knpplayer” (the small program that runs the plugins) and install that in your $PATH before the 64-bit version then it will all just work like magic! Note that you’ll need 32-bit versions of the various dependent libraries also (it seems just to be GTK, Cairo, X11 and DBus stuff).

IBM Cell SDK/SDK for Multicore Acceleration on Debian/Ubuntu HOWTO

2007-12-15T00:00:00+00:00

Today I battled with trying to get IBM’s Cell SDK 3.0 (now known as the SDK for Multicore Acceleration) installed on my Debian AMD64 machine. This would cause slight grief even with a regular Debian machine as IBM only formally supports Fedora and RHEL so only provides RPMs. This is worsened by the fact that a bunch of the packages aren’t even available from IBM but require perusal of some provided yum configuration files to find.

Firstly I recommend you download the CellSDK-Devel-Fedora_3.0.0.1.0.iso and CellSDK-Extras-Fedora_3.0.0.1.0.iso (current at time of writing) from here.

Then when you have downloaded them mount them somewhere on your filesystem.

mount -o loop $HOME/CellSDK-Devel-Fedora_3.0.0.1.0.iso \
    /tmp/CellSDK-Devel-Fedora/
mount -o loop $HOME/CellSDK-Extras-Fedora_3.0.0.1.0.iso \
    /tmp/CellSDK-Extras-Fedora/

We’ve downloaded the two RPMs by IBM. If you install these on Fedora they will provide you with some yum repositories for the Barcelona Supercomputing Centre. These will need to be downloaded manually as we aren’t on a RPM-based system.

If you are running Ubuntu Gutsy on x86_64 or x86 run:

apt-get install ppu-gcc ppu-gdb spu-g++ \
    spu-gdb cell-programming-primer

If you are running Ubuntu Gutsy on the Cell run:

apt-get install cell-sdk

Otherwise run the following:

apt-get install wget #Install wget if it is not already
mkdir openrpm
cd openrpm
wget -l 1 -c -np -nd -r http://www.bsc.es/projects/deepcomputing/linuxoncell/cellsimulator/ -A .rpm

The above assumes you are on an x86_64 machine. If you are using the Cell, a regular x86 or a PPC 64-bit machine change the ‘x86_64’ to ‘cbea’, ‘x86’ or ‘ppc64’ accordingly.

The following instructions apply regardless of your Debian/Ubuntu variant or architecture.

Next, if we are on x86_64, we want to create a nice little script to handily convert the i386 architecture files to amd64 so they will install nicely when we convert them to debs. This is safe as all the stuff these packages install gets chucked into /opt/.

I recommend we name it “fixcelldebsarch.sh” and stick it in your $HOME. This is only necessary if you are on x86_64 not x86 and (probably) won’t work on the Cell or another PPC64.

#!/bin/bash
#~/fixcelldebsarch.sh
OWD=`pwd`
for i in `ls -d */`
do
    cd $i
    sed -ie 's/Architecture: i386/Architecture: amd64/' \
        debian/control
    dpkg-buildpackage
    cd "$OWD"
    rm -r */ *.gz *.changes *.dsc
done

(Thanks to Jon for the fix to avoid mess when using symbolic links.)

Next we want to convert the various RPMs into DEBs for our Debian system so the dependencies are nicely handled and they can be uninstalled. Install the ‘alien’ package if you have not already.

On the following lines replace the occurrences of ‘/x86_64/’ with ‘/cbea/’, ‘/x86/’ or ‘/ppc64/’ using the same criteria as above.

cd open
for i in ../openrpm/*.rpm
    do alien --scripts $i
done
~/fixcelldebsarch.sh #Only needed on x86_64
dpkg -i *.deb

cd devel
for i in /tmp/CellSDK-Devel-Fedora/x86_64/*.rpm
    do alien --scripts $i
done
~/fixcelldebsarch.sh #Only needed on x86_64
dpkg -i *.deb

cd extras
for i in /tmp/CellSDK-Extras-Fedora/x86_64/*.rpm
    do alien --scripts $i
done
~/fixcelldebsarch.sh #Only needed on x86_64
dpkg -i *.deb

It should have been fairly obvious what was going on above. This should have installed all the necessary packages for the Cell SDK without breaking your system and allowing Debian/Ubuntu packages to override these versions.

I hope this all works; if anyone spots any typos, has any suggestions or needs any help then give me a shout!

Updated: Added Gutsy information. Thanks Bart!

Community Driven Software Development

2007-06-01T00:00:00+01:00

Abstract

Some people have suggested that the future of E-Commerce will be shaped by various kinds of “communities” (both online and offline); other are more sceptical about the potential. This report analyses the competing argument, focusing on the key actors and using Free and Open Source Software (FOSS) as a case-study to analyse the effects of online communities.

Introduction

The future of E-Commerce is shaped largely by technological and sociological developments in the field and within society. On the technological front, one of the backbones allowing Internet-based E-Commerce to be possible is Free and Open Source Software (FOSS). Many Email, CMS systems, databases and web servers are FOSS and CRM systems and the majority of other enterprise applications will be running on a FOSS operating system.

As a result, the development and shaping of these technologies is crucial in the development of E-Commerce and the community-based software model has moved out of the universities and into the data-centres, with large corporations such as Sun, IBM, HP and Novell relying and heavily contributing to FOSS and steadily more companies making use of FOSS components.

FOSS shows some promise but there are also possible issues that may need to be addressed before it could ever replace traditional proprietary software.

Key Events

In the late 1950s when mainframes started to appear in academic institutions the software available to perform tasks was freely shared by programmers within these institutions, similarly to how academic research is shared in other fields. As mainframes found their way into the business world in the late 1970s, the programmers and academic institutions realised the ability to obtain monetary reward for their software or wished to keep the intricacies of what they were doing secret. As time went on more software was being sold, frequently with prohibitive license agreements, preventing unauthorised duplication and/or restricting access to the source code used in creating the software.

In 1983 a programmer at MIT named Richard Stallman created the GNU project with the goal of designing an operating system with an approach closer to that adopted in the 1950s-70s: the free sharing of information. In 1985 he founded the Free Software Foundation (FSF) whose goal was to promote and support his new “free software” movement. The key foundation in this was the creation of the GNU General Public License (GPL), a license for the new software allowing any user of the software access to the source code and the rights to modify and redistribute any changed version. This software does not necessarily have to be provided monetarily free but frequently is [Stallman, 2002].

In 1989 the University of California, Berkeley released Networking Release 1, a version of their Unix operating system where all the proprietary AT&T Unix code had been rewritten, allowing use by non-licensees of AT&T code and was redistributable under the BSD license. This license was even more permissive than the GPL, allowing proprietary commercial use and modified versions to be used in proprietary software. BSD code has been notably used in the networking layer of Microsoft Windows and heavily used in Apple’s Mac OS X operating system’s core.

In 1991 Linus Torvalds, a student at the University of Helsinki, decided to create a kernel to better learn about computer hardware. He publicly released this under the GPL license. This is now the core of the Linux operating system, now an important part of many businesses such as Google, Novell, HP, Red Hat (the first company to sell the Linux operating system) and IBM. The projected income for this “free” operating system’s software, servers and desktop is predicted to be worth $40 billion by 2010 and is currently worth $18 billion in a study by IDC analysts.

Since Linux was created companies have been open-sourcing previously proprietary solutions. Two large examples of this was Sun releasing the code for StarOffice, which became OpenOffice.org and Netscape releasing the source for Netscape Communicator, which became Mozilla’s Firefox and other projects.

Linux is used across computing in embedded devices, servers, supercomputers, mainframes and desktop machines. It is seeing increased use in governments such as South Korea and Germany and in schemes such as the One Laptop Per Child scheme, delivering a low-cost laptop computer to children in developing nations, using FOSS to allow sale at $100.

Key Actors

IBM announced support for Linux in 1999, providing applications, support and working with the open-source community to provide support for it’s hardware. Today IBM employs more than 300 full-time staff to work on Linux. IBM also releases code under FOSS licenses, such as Eclipse (a software development tool) and Apache Derby (a high performance database). IBM is also currently engaged in a lawsuit with SCO over the intellectual property of the Linux operating system.

HP supports the open-source community through employees with open-source job responsibilities and sell Linux workstations.

Apple Inc. made extensive use of open-source software in the development of Mac OS X, and make use of large open-source projects such as CUPS and Samba in providing print and networking services respectively.

Novell sells the Linux operating system for servers and desktops, acquiring major open-source companies Ximian and SUSE in 2003. In 2006 Novell reached a joint patent agreement with Microsoft, agreeing to collaborate on increasing interoperability between Windows and Linux each party agreeing not to sue the other for patent violations. This caused a rift in the FOSS development community; the collaboration implying that non-Novell Linux users could be sued by Microsoft. Jeremy Allison, a member of the Samba team and employee of Novell resigned in protest. The GPLv3 license is subject to debate on whether it will ban the rights on Novell to continue to develop Linux or prevent similar deals from occurring in the future.

Microsoft was ruled by the US DOJ to hold a monopoly in the operating systems market so the development of open-source operating systems (such as Linux) or operating systems based on open-source software (such as Mac OS X) threatens their market share. As a result, Microsoft have a “Get the facts” campaign, comparing the total cost of ownership of Linux and Microsoft operating systems. As previously mentioned, they have recently agreed to collaborate with Novell. Steve Ballmer, the CEO of Microsoft said, when speaking about the Novell deal that Linux “uses our intellectual property”.

Sun Microsystems supports Linux on its systems and open-sourced major pieces of software such as StarOffice, Java and its Solaris operating system. This makes them the largest commercial contributor of FOSS, at an estimated 312 million euros worth of programmer time by the EU-commission study “Economic impact of open source software on innovation and the competitiveness of the Information and Communication Technologies (ICT) sector in the EU”. The FSF own the copyright on most GNU software and some non-GNU FOSS. They actively campaign against DRM, software patents and user interface copyright.

Potentials

Raymond argues that the proverb “Necessity is the mother of invention” is especially relevant in the software world and the that “Every good work of software starts by scratching a developer’s personal itch” [Raymond, 2001]. He claims that the reason the quality of software in the FOSS is so high is that developers tend to work on software that benefits them personally and that they enjoy working on. Another point is that “Great [programmers] know what to … reuse”, highlighting that time is frequently wasted in software development solving a common problem but, in the case of proprietary-software, existing “encumbered” code is not or cannot be reused. Microsoft and Apple made use of existing BSD code in their development of their respective platform operating systems but cannot use any GPL code. However, all GPL applications can reuse this code in applications.

Madanmohan and Deapos reveal some of the benefits of this reuse of FOSS, such as the open disclosure of bugs and performance details, frequent updates, documentation and the ability to modify the existing code, allowing a firm to aid their competitive position by reducing development costs and increasing development speed of new products [Madanmohan and Deapos, 2004]. They highlight the popularity of the BSD license over the GPL in companies, due to the ability to keep the modified source private and include only an attribution to the original source.

Von Hippel and Lakhani discuss “field support” for Apache, a popular FOSS web server and the most widely used web server on the Internet. Despite the official developers claiming no “official” support availability for Apache, questions posted on a Usenet forum tend to receive helpful responses from other users. In a referenced poll by Serverwatch in the paper, Apache is ranked 4.5/5 for technical support compared to Netscape’s 4/5 and Microsoft’s 4/5 [Lakhani and von Hippel, 2003] These results are discussed to be motivated by reciprocity within the community, a desire to “help the cause”, to gain reputation and intrinsic personal rewards. Another advantage highlighted of the community-support mechanism is the rapid response time and lack of financial cost.

Castells raises the concept of a network society and states that electronic communication systems, such as the internet, give the flexibility of distribution without sacrificing performance and “because of their superior performing capacity [they], through competition, are gradually eliminating centred, hierarchical forms of organisation in their specific realm of activity”[Castells, 2000]. This argument was used in the justification of the network enterprise, but illustrates the reasoning that open-source software, although frequently created by developers across vast geological differences and little face-to-face contact, can be seen as another form of “the networked enterprise”, and operates similarly to a traditional business, albeit usually without same financial system. Castells claims his book “The Internet Galaxy” was produced “in the spirit of ‘open source’ that is the root of the Internet world”, referring to the networked system of researchers and experts across fields contributing to a single project [Castells, 2001].

O'Reilly provides an explanation for why open-source communities are secure, despite a frequent lack of financial transactions [O'Reilly, 1999]. He claims that the “heart of many open-source communities is the social compact between the software developer and [their] users, in which both agree to cooperate under certain rules that are beneficial to both parties”. He highlights that this is the “glue” that holds these communities together, rather than financial transactions in proprietary software. This is also strengthened by the fact that frequently, as mentioned previously, developers of FOSS are frequently part of the user-base. Within this article Ousterhout argued that open-source and commercial development complement each other with FOSS providing the “raw material” which can be “further refined and extended by commercial development”.

Bitzer et al. argue that FOSS is “a public good” due to “non-rivalry in consumption … and non-excludability”, the latter due to the GPL license [Bitzer et al., 2004]. They expand on Raymond’s focus on personal benefit from programming, such as his so-named “scratching an itch”, and creates a “family” model, where members of the FOSS community see the community as kin and will therefore be willing to do something that may not benefit them directly but may benefit the community. This justifies why FOSS code frequently is very well documented, when the writer of the documentation will obviously not need to use it. This requires time investment more than simply writing code and provides no direct benefit to the documenter, but bolsters the community development attitude whilst requiring more effort than simply releasing the code to the software and licensing it under a suitable FOSS license.

Gabriel and Goldman argue that the ideals and seeming effectiveness of FOSS practises arose from the optimum use resources, highlighting past distributed community efforts such as the original Oxford English Dictionary and, less directly, literature [Gabriel and Goldman]. They raise this comparison by saying:

“It is as if all writers had their own private companies and only people in the Melville company could read ‘Moby Dick’ and only those in Hemingway’s could read ‘The Sun Also Rises’. And we expect people to learn to program in this exact context?”

Issues and Tensions

Castells claims that the next frontier of FOSS development is “user-orientated commercialisation”, raising the lack of interested of computer programmers in developing user-friendly software to directly try and attack Microsoft’s market share [Castells, 2001]. Since this paper was written, there has been some advancement, with projects such Ubuntu Linux aiming to be easy to use and “not made any more complex than absolutely necessary”. Another major project is OpenUsability, a project aiming to coordinate usability experts to analyse and improve open-source software.

Nichols and Twidale further elaborate on this problem, showing that software developers are not suitable at designing user interfaces for non-technical users [Nichols and Twidale, 2003]. To fix this imbalance, software firms hire usability experts but open-source suffers in this area. As previously mentioned, there are some usability experts contributing to open-source software, but there are far fewer than needed working with FOSS. They also highlight that, due to the frequently self-motivated functionality improvements, technical users may be less likely to work on features for novice users. This difference in motivation is a major difference between FOSS and commercial development, with commercial developers focusing on user satisfaction as the primary goal whereas with FOSS this may be secondary to nonexistent.

Some promise in this area is highlighted by Benson et al.[Benson et al., 2004], employees of Sun Microsystems. They agree that there are poor user interfaces in FOSS, due to being created “by engineers for engineers”, and they discuss their work in usability on three major FOSS projects. Sun Microsystems' business model increasingly relies on open-source software so, although there is little lack in professional developers for large projects, Sun can pay usability specialists to work on this software, providing free consultancy and as a result aiming for these projects to see wider use.

Software communities tend to have a gender bias (only 28% women), the FOSS has an even more dramatic bias with around 1.5% of FOSS community members being female. Deliverable claims that “women are actively (if unconsciously) excluded rather than passively disinterested” [Deliverable, 2006]. He explains this is due to a decreasing proportion of women in ICT professions and that women in FOSS projects tend to do graphics, usability and documentation rather than the more “prestigious” software development. This points back to the lack of usability specialists and other non-programmers in FOSS.

Shirky claims that groups are reinforced by an external enemy and in the case of FOSS this enemy is, correctly or incorrectly, viewed as Microsoft[Shirky, 2003]. He also claims that this group ethos can contain elements of “religious veneration” with people failing to admit flaws or faults in a certain icon or tenets; something becoming “beyond critique”. The accusation could be made that this is sometimes applicable to FOSS communities, failing to accept seeming gestures of cooperation from Microsoft, such as the deal with Novell. He also raises the importance of sometimes have a core group with higher rights or greater vetoing power than the majority of users. This example applies nicely to the management of FOSS. These projects sometimes suffer from lack of organisation or a clear set of goals. As a result, it’s unusual to find projects where the users dictate the roadmap for a piece of software, but is instead decided by the main core developers or a so-called “Benevolent Dictator”. In the case of the Linux kernel, this dictator is the original creator, Linus Torvalds. He decides on the inclusion or rejection of new features or modifications to existing features. This power is occasionally criticised, but the dictatorship is supported by the masses as, due to the GPL, the project could be “forked”, that is modified and continued along a different path with a different development/leadership team. This model is indirectly endorsed by Shirky who claims that you need “barriers to participation”, which the “dictatorship” provides and a way to separate the group from scale, also helped by the model with one sole voice making final decisions.

Lerner and Tirole perform some further analysis of the possible dangers of “forking” in FOSS projects [Lerner and Tirole, 2002]. They present the example of Sendmail FOSS which was “forked”, which each version being “enhanced” in various conflicting ways, resulting in incompatible versions. This problem was solved when the initial creator of Sendmail returned and performed a rewrite, adding the desired features and causing the incompatible versions to be abandoned. They point to the need for a powerful, directed leadership model with clear goals and support from the other developers in order to prevent “forking”.

Hein shows another example of a “fork”, this time illustrating the benefit of the ability to “fork”. They discuss the X.org “fork” from XFree86, caused by a disagreement amongst the development team over a license change [Hein, 2006]. X.org is now the dominant version used and the “fork” has spurred more interest in development with new developers and new technologies appearing since the “fork”, despite a slight stagnation prior. Hein also raises another important point; the open nature of the FOSS community may appear more argumentative and conflicting, but this is common inside many proprietary software companies but just not viewable to the public at large.

Conclusion

FOSS community projects have influenced many areas from food (e.g. OpenCola) to movie production (e.g. Elephants Dream) and encyclopedias (e.g. Wikipedia). Governments around the world are starting to recognise the importance in open standards, with the EU recently fining Microsoft and enforcing them to release interoperation documentation and various countries demanding the use of OpenDocument for their external documents. Clearly there is a rising demand for transparency and openness, something FOSS inherently provides.

FOSS may never fully replace traditional proprietary software but it has certainly made an impact and highlighted the benefits of leveraging geographically distant communities to work together and solve problems. Community-based support and development have always been commonplace on the Internet and with the rise of Web 2.0 (the focus on a community-driven Web) more businesses are seeing online communities as a way to remain competitive in an ever-changing field.

References

C. Benson, M. Muller-Prove, and J. Mzourek. Professional usability in open source projects: GNOME, OpenOffice. org, NetBeans. Conference on Human Factors in Computing Systems, pages 1083-1084, 2004.
J. Bitzer, W. Schrettl, and P.J.H. Schröder. Intrinsic Motivation in Open Source Software Development. Freie Univ, 2004.
M. Castells. Materials for an exploratory theory of the network society. British Journal of Sociology, 51(1):5-24, 2000.
M. Castells. The Internet Galaxy: reflections on the internet, business, and society. Oxford University Press, 2001.
D. Deliverable. Free/Libre and Open Source Software: Policy Support. March 2006.
R.P. Gabriel and R. Goldman. Mob Software: The Erotic Life of Code. Proc. ACM Conf. Object-Oriented Programming, Systems, Languages, and Applications.
G. Hein. Open Source Software: Risks and Rewards. mar 2006.
K.R. Lakhani and E. von Hippel. How open source software works:“ free” user-to-user assistance. Research Policy, 32(6):923-943, 2003.
J. Lerner and J. Tirole. Some Simple Economics of Open Source. Journal of Industrial Economics, 50(2):197-234, 2002.
TR Madanmohan and R. Deapos. Open source reuse in commercial firms. Software, IEEE, 21(6): 62-69, 2004.
D.M. Nichols and M.B. Twidale. The Usability of Open Source Software. First Monday, 8(1): 59-67, 2003.
T. O'Reilly. Lessons from open-source software development. Communications of the ACM, 42 (4):32-37, 1999.
E.S. Raymond. The Cathedral and the Bazaar: Musings on Linux and Open Source by an Accidental Revolutionary. O'Reilly, 2001.
C. Shirky. A Group Is Its Own Worst Enemy. Economics & Culture, Media & Community, Open Source, 2003.
R. Stallman. What is Free Software. Free Society: Selected Essays of Richard M, 2002.

Making Dizzy Shine With Ajax

2007-02-27T00:00:00+00:00

Abstract

“Ajax applications can provide a more effective user interface than those of GUI desktop or classic Web applications with fewer drawbacks than either individual approach.”

In this report, the preceding hypothesis was evaluated by developing an Ajax Web application for the Dizzy chemical kinetics stochastic simulator [2] and analysing the benefits and drawbacks compared with the existing Dizzy classic Web application and Dizzy GUI desktop application. Among the benefits were those of a more responsive interface, less bandwidth usage and allowing logic to be output to the client. The drawbacks included the challenge of ensuring cross-browser compatibility, unfamiliarity to the user, JavaScript debugging issues and the time-consuming nature of re-engineering an existing Web application.

Download PDF

Digital Rights Management and Operating Systems

2005-12-17T00:00:00+00:00

“Sony has recalled many millions of its music CDs, because they contain ‘copy protection software’ that may damage computers. Describe and explain this story; compare Sony’s approach with other attempts to achieve copy protection, and discuss the future for digital rights management in operating systems design.”

In August 2000, the Vice President of Sony Pictures Entertainment announced to the Americas Conference on Information Systems “The industry will take whatever steps it needs to protect itself and protect its revenue streams… It will not lose that revenue stream, no matter what… Sony is going to take aggressive steps to stop this. We will develop technology that transcends the individual user. We will firewall Napster at source – we will block it at your cable company, we will block it at your phone company, we will block it at your [ISP]. We will firewall it at your PC… These strategies are being aggressively pursued because there is simply too much at stake.” This was one of the first times many in the technical field saw and predicted the rise of DRM-like technologies. This issue has been invisible to many non-Internet news sources until fairly recently, but, on the infinite discussion of many Internet forums and newsgroups, changes have been noticed and protection has been found and cracked. A notable early example of this was the Content-Scrambling System (CSS) used on some DVDs, introduced around 1996, and integrated into many DVD drives, players and DVD media. However, in 1999 the algorithm was cracked by Johan Johansen, known as “DVD Jon” and a program to decrypt the content, named DeCSS, was released anonymously, possible by DVD Jon.

The most recent example of DRM controversy hitting the mainstream news all started when a man named Mark Russinovich, Chief Software Architect and co-founder of Winternals Software, was testing his new version of “RootkitRevealer”, and was surprised to find that he, according to his software had a rootkit. Rootkits are defined by TeCrime International as “A collection of tools that allows a hacker to provide a back-door into a system, collect information on other systems on the network, mask the fact that the system is compromised…”. In this case, Mark found files, an application and registry keys that had been hidden by the operating system, preventing them from being detected from the Windows API. Due to Mark being a security expert, and him writing security tools such as the aforementioned RootkitRevealer, he was somewhat surprised to hear he had picked up a rootkit on his machine.

Traditionally, to have got a rootkit on your machine, you either need to have run, as a root on UNIX based systems or Administrator on Windows based machines, an executable that will install the rootkit on your machine. Another possible method is remote execution through security holes in software (recently, commonly holes in PHP web applications such as PHP Nuke), allowing the executable installing the rootkit file to be downloaded and run. Virus checkers and only running files from trusted sources can normally stop the first method, and a good software or hardware firewall (or being behind a router or proxy with closed ports) can normally prevent the second. As a Windows expert, Mark was likely to be using both of these methods, hence leading to his surprise.

Windows rootkits traditionally patch the Windows APIs to prevent their files being found. Using this knowledge, Mark dumped the contents of the service table, looking for entries that pointed outside of the Windows kernel. Finding two of these, he found a link to one of the files masked by the API modification. Examining this file, he found that it was hiding any file with the prefix “$sys$”. Further examining the DLL files, he found that they had been signed by a company named “First 4 Internet”, who sold a DRM software named XCP. He also found that they had produced software for several record companies, including Sony, to implement copy-protection methods on CDs. He then traced this back to a copy-protected CD he had bought. Sure enough, when he played the media from the bundled player on the disk, the DRM manager’s CPU increased. The DRM manager was also running as a Windows service, with the subtle name of “Plug and Play Device Manager”. This, even at a stretch, is a complete lie, with the DRM manager having very little to nothing do do with Plug and Play, but instead being about protecting digital content. This naming was, presumably, to stop a normal or even slightly technical user from spotting anything being amiss if examining their Windows Services.

With this knowledge in hand, Mark went about attempting to remove the rootkit. This resulting in him finding out that the installed DRM files had installed themselves as a filter under his CD-ROM device drivers, resulting in his CD drive no longer working when he removed them. He managed to eventually restore things to working order, but this raises some important questions in the future of DRM. This software was, by the opinion of a man who Microsoft have awarded a “Microsoft Most Valuable Professional” certification, shoddily written, had no visible removal method, and used CPU time even when the DRM media was not present.

This scandal, initially posted on Mark’s blog, grew from technical to mainstream news, and seen many differing reactions. Spyware and antivirus companies released updates to remove it and prevent its installation, unnecessary now, as in the last week, Microsoft have released a patch to remove it. The fears of the rootkit hiding new viruses and hacks has been released for World of Warcraft, a popular MMORPG (massively multilayer on-line role playing game), using this rootkit to avoid detection of the hacks. Legally, the States of California, New York and Texas have initiated lawsuits against Sony, with the New York suit seeking damages for all those affected throughout the United States. Italy has also filed lawsuits against Sony over the rootkit. However, removal of the software, before these suits pass, could be claimed to violate the Digital Millennium Copyright Act in the United States. Also, ironically, a researcher named “Muzzy” has identified code from the LAME MP3 encoder inside the rootkit code, presumably to pattern match and prevent the protected CD’s from being encoded. However, the LAME software is licensed under the open-source LGPL, which requires disclosure of any modifications as well as the credit being given to the copyright holder. To quote “Muzzy”, “this is certainly copyright infringement”. This means Sony and First 4 Internet are both liable for distributing copyrighted software.

Sony has tried to clean up from the mess of media exposure around the scandal, finally releasing a removal tool on their website. Initially, however, the President of Sony BMG’s global digital business division was recorded on a US public radio program saying “Most people, I think, don’t even know what a rootkit is, so why should they care about it?”, further claiming, “component is not malicious and does not compromise security”. The claim the product is not malicious is justified, however, I believe it is apparent from the evidence above that the product has already been used, in the case of the WOW hackers, to compromise security. In addition, Sony’s removal tool uses ActiveX, meaning it is not usable on alternative browsers such as Firefox or Opera, and ActiveX frequently finds itself disabled by security-conscious users, due to the spyware infestations and malicious programs that frequently accompany it. This may be seen as excessively paranoid, but in this case it would be justified, as it has been reported by “Muzzy” that the ActiveX control has 2 methods called “RebootMachine” and “ExecuteCode”, the prior, unsurprisingly, but amazingly insecurely, reboots the machine, and the latter remains untested, but presumably allows remote code execution. These methods could, technically, be called by any website that uses the ActiveX API, without prompting the user, simply be calling the already installed ActiveX control. Additionally, even when the removal control is run, several scriptable methods are left behind, still allowing the ability to reboot the machine remotely, using only a web browser. Quoting Muzzy “Considering anyone can reboot the computer using these, I suspect security wasn’t thought about for even a second during development of this thing. Virus writers and such would be very interested in analysing what these methods do, as some of them are remotely exploitable… by design.” Recently, a new standalone installer was released, which seems to properly remove the software. Sony announced, on November 11, 2005, that they will stop producing CDs using First 4 Internet’s XCP DRM software. According to the New York Times, 4.7 million CDs have been shipped and 2.1 million sold that use this technology, and although Sony is initiating a recall, is is likely at the start of 2006 there will still be machines compromised by this system, and, according to the New York Times, there are still at least 2 Internet borne worms that take advantage of the rootkit. Other methods of DRM have been in use for years. As previously mentioned, the CSS method of protecting DVDs will shortly be coming to its 10th birthday. Other notable methods are the Apple Fairplay DRM used on their iTunes MP3s and the Microsoft NSC format encoding, both cracked by DVD Jon, DivX, which required a phone line in order to view its video disks. Other methods of content protection seen recently have been the phone or Internet activation requirements of Office and Windows XP, digital watermarking and Valve’s Steam software. Steam is an interesting move in the world of content protection and many, myself included, applaud it as a move in the right direction of both content protection and software publishing. Steam, instead of requiring traditional purchase and then activation, requires you to download their client program, register an account, and either register existing pre-Steam products, or buy products directly from their Steam program. It is interesting, as it does not require an Internet connection to play Steam games off-line, as long as they have been activated on the Internet at least once. The Steam distribution platform also automatically updates software with patches, and creates a directory of on-line servers for playing Steam games, allowing them to be quickly found and connected to, using the Steam browser. Initially, this platform was only used by Valve, the creators and developers of Half-Life, but, after the Half-Life 2 release proved the platform to be valid and powerful, we have seen a release of a few more games such as Pirates!, Rag Doll Kung Fu and Darwinia.

Unfortunately, bright stars such as Steam seem to be few and far between in the ever-progressing field of DRM. The previously mentioned Digital Millennium Copyright Act was passed in 1998 and signed into law in the United States. One of the key parts of the DMCA is the content on Circumvention of Technological Measures, prohibiting devices or services that are primarily designed to circumvent, had limited commercially significant purpose or use other than to circumvent or are marketing for use in circumventing copyright measures such as DRM. Understandably this and other similar legislation brings crackers such as DVD Jon under fire, who was arrested for “computer hacking” in 2002. He was, however, acquitted without charge in January 7, 2003, after argument from the defence that any copy protection he circumvented was for DVDs he already owned, and under Norwegian law it is legal to make personal copies of data such as DVDs for personal use.

Legislation, such as that previously mentioned, is meeting operating system design with the emergence of the Next-Generation Secure Computing Base (NGSCB), formerly know as Palladium. This is a software architecture designed by Microsoft to implement trusted computing on future versions, post-Vista, of the Windows operating system. Trusted computing refers to the design of systems or software designed to perform the way they “should”, potentially allowing computer manufacturers and software authors to increase their control over how the computer systems are used by their users. This could result in users no longer being able to change their software, control information they receive, control their own created data and could removes anonymity options from the Internet. The trusted computing methods require a next generation processor, which could be designed by AMD or Intel, as both have stated they will integrate trusted computing into future processors, which protects memory and data from hardware on the chip. This could, potentially, make methods such as DeCSS and other cracking of encryption and DRM physically impossible, as it would require overrides on the hardware level, rather than a software modification. In the first version of trusted computing, tested by Microsoft, it was possible to delete pirate software remotely, due to remote detection. This could also be used to blacklist data from, say, Office 2000 in Office 2006, forcing the user to upgrade rather than being able to use old software. This could also require remote-activation, secured on a hardware level, and the operating system requiring said hardware, making piracy physically impossible. Microsoft claims that trusted computing won’t suddenly stop anything from working, but the long term goals are to prevent piracy and removal of protection methods.

This method of protection will work with a chip on the CPU, known as a Nexus chip. This chip will be implemented onto the motherboard, and communicates with a feature in the CPU to prevent memory access from one program to another’s area of memory, a bridge in the operating system kernel, known as the Nexus, and individual application security components (NCAs). This will all produce information and communicate with on-line security servers maintained by both hardware and software vendors, removing authorisation capabilities from the users machine. This memory protection means that DVD players could prevent their area of memory, used to actually play the DVD, from allowing external access to rippers to obtain the content. Trusted computing, in a privative form, is already available in Windows Server 2003, for protecting confidential documents and automatic document destruction.

The long-term effects and, some might say, goals of trusted computing are darker than they might at first appear. Many, including Microsoft and Sony, would claim they are just trying to prevent their copyrights being broken. “Trusted computing can be turned off!” they may say. However, as a user of an alternate operating system, trusted computing could may well affect me in negative ways. Due to the requirement of most of my software to be open source, potentially, my computer no longer would be able to digitally create MP3s or videos, and I could be unable to open trusted computing protected documents. If studying at a university that protected their course materials in this way, this could force me to use a Microsoft operating system in order to do my work. Also, the music industry, due to the huge force and costs behind DRM, could well see smaller, independent record labels die out, unable to afford to protect their media. This type of protection undermines the GPL and other open source products. IBM and HP have already started work on a TC-enhanced version of Linux, but this code may need to be propriety, and therefore may need to cost money to use.

Trusted computing is a deceptive title. It moves the trust of computing from the administrator to the developers of software and to the owners of media. This requires a radically different approach in operating system design, as at all levels, from hardware to memory management to software, everything must be managed and authenticated by a third party, potentially crippling the system if and when this authentication suffers from bugs or is not available. It also poses dire consequences for kernel hackers everywhere, and people who use operating systems such as Linux and like modifying the deepest internals of there systems to work the way that they want.

The future of DRM is clouded, but it seems almost inevitable that it will feature heavily on future Microsoft operating systems. However, many users who value freedom of data and fair use of software and media, especially those who currently use Linux due to these freedoms, are unlikely to lie down and take the new measures without a fight. Whether this fight is fought by cracking protections, hacking servers, boycotting Microsoft in favour of Linux or other operating systems, or taking legal action under “Fair Use” law, remains to be seen, but, personally, I will not simply accept the new DRM measures forced upon us, and if I can help others through programming for the Linux operating system to obtain a system that allows these freedoms, I will.