So here is a very quick and simple plugin; it simply puts a button on the toolbar that you can click when you want to stop playback after the current song. I based the toolbar button code on Alexandre Rosenfeld’s lastfm-queue plugin, since I had no idea where to start with that

Download it here, and put it into ~/.gnome2/rhythmbox/plugins/stop_after_song/. Activate it in Rhythmbox’s plugin dialog.

• I ran into this bug (here’s the fix)
• ATi’s dual monitor setup is still too hard (here’s how to do it)
• ATi’s drivers can’t do compiz and video at the same time (Install the latest drivers to fix it)

David R. MacIver has recently written this blog post about cleaning up a set of tags. This blog post, on the other hand, is about a nice old Unix tool called ‘awk’.

Awk is one of those programs that is often overlooked. It is really a small domain-specific language for processing text. In some ways it resembles sed, but it is more powerful, and it especially excels at processing line- and field-structured input.

Processing cite-u-like’s data

First of all, before we begin I want to say this this isn’t a criticism of David’s work. Using a general-purpose language like Ruby to process data comes with several benefits. This post is to explain the benefits of awk and what it excels at doing.

Now, cite-u-like’s tag data comes in a pipe-separated format, so we have input like this:

42|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:25:05.373798+00|ecoli
42|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:25:05.373798+00|metabolism
42|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:25:05.373798+00|barabasi
42|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:25:05.373798+00|networks
43|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:25:51.839281+00|control
43|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:25:51.839281+00|engineering
43|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:25:51.839281+00|robustness
44|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:26:33.156319+00|networks
44|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:26:33.156319+00|strogatz
44|61baaeba8de136d9c1aa9c18ec3860e8|2004-11-04 02:26:33.156319+00|survey

From now on, whenever you see x-separated data, I want you to scream ‘USE AWK!’

Awk scripts look something like this:

pattern { expression }

pattern is used to match against a record, and if successful, the action in the braces (expression) will be carried out. But what is a record? Awk allows you to define what a line is using the variable RS (short for ‘record separator’). By default it is set to \n (so that each line is a record), which is what we want here.

Within the expression you can refer to fields of the current record, using the syntax $n. $0 refers to the whole record, while $1,$2… refer to individual fields.

Awk also allows you to define what the field separator will be via the variable FS.

So how do we set these variables? Awk has two special patterns BEGIN and END, which run before and after everything else. In this case, we want the fields to be separated by |, so we use the pattern:

BEGIN { FS = "|" }

This is rather long-winded, so mawk (an implementation of awk) also allows you to set FS via a command-line option -F.

For this application, we want the last field of the record (we could hard-code it as $4, but we’re exploring awk!). Awk provides the number of fields in the record as the variable NF (number of fields), so we want to access this field. We do so using the record syntax $ and the variable NF.

So to put all this together, what we want is the command:

awk -F "|" '{ print $NF }'

We set the field separator to “|”, and write an awk expression to print the last field of each record. Since we left the pattern empty, this expression is evaluated on every record.

Awk vs. Ruby

So what good is learning all this, anyway? There are a couple of reasons:

• awk is standard on *nix operating systems. In order to use David’s code I had to install Ruby; with awk you can generally count on it being there.
• awk is fast (I should say at least in the interpreter ‘mawk’ which is the standard for Ubuntu). On my machine the awk version completes in under a third of the time that it takes for David’s Ruby version to complete. An interesting thing was that the awk version didn’t even max out the CPU, indicating that it is IO-bound and would go faster if I had faster disks (I’m currently on a laptop).
• Awk is ideal for record- and field-based input, as I hope this post will show you

Filtering data with awk

After the above we use sort and uniq the same as David does to get the results in the following form:

 212595 bibtex-import
 157136 no-tag
  27926 elegans
  27887 celegans
  27825 c_elegans
  27795 nematode
  27738 wormbase
  27736 caenorhabditis_elegans
  18933 review
  15280 all-articles

David uses the following to filter out lines with no alphabetical content:

ruby -ne 'puts $_ if !($_ =~ /^[^a-z]+$/)'

We can use awk’s patterns to do the same thing:

$0 ~ /[a-zA-Z]/

Here we use the ~ (match) operator to write a pattern that matches only the records with an alphabetical character in them. (Remember that $0 refers to the entire record.) Notice also that we can leave off the expression after the pattern, because it defaults to { print }, which is exactly what we want.

In this case, awk really shines. On my machine it outperforms the Ruby version by a factor of 8–9.

Programming with awk

The third task that David does is to consolidate all tags which are differentiated only by hyphens or underscores. That is, ‘a-tag’, ‘atag’, and ‘a_tag’ should all be considered the same. We choose which one to put into the output by whichever one is used the most times (and then we normalize the tag by replacing ‘-’ with ‘_’ so there are only underscores in the output).

Here is David’s code to do the job:

tag_counts = {}
STDIN.lines.each{|l| c, t = l.split; tag_counts[t.strip] = c.to_i }
duplicates = Hash.new{|h, k| h[k] = []}
tag_counts.keys.each{|k| duplicates[k.gsub(/-|_/, "")] << k }
duplicates.values.each{|vs| vs.sort!{|x, y| tag_counts[y] <=> tag_counts[x]} }
 
new_tag_counts = {}
duplicates.values.each{|vs| new_tag_counts[vs[0].gsub(/(_|-)+/, "_")] = vs.map{|v| tag_counts[v]}.inject(0, &:+)}
puts new_tag_counts.to_a.sort{|x, y| y[1] <=> x[1]}.map{|t, c| " #{c} #{t}" }

I’m not going to explain it here, because that’s not the point of the post

Here’s my awk script:

{ tag_counts[$2] = $1 }
END {
	for (tag in tag_counts)
	{
		normtag=tag
		gsub(/-|_/,"",normtag)
 
		count=tag_counts[tag]
		sum[normtag]+=count
 
		if (count > max[normtag])
		{
			names[normtag]=tag
			max[normtag]=count
		}
	}
 
	for (tag in names)
	{
		finaltag=names[tag]
		gsub(/(-|_)+/,"_",finaltag)
		print " " sum[tag] " " finaltag
	}
}

That’s right, you can use awk to do some ordinary programming tasks! Arrays are used using the usual syntax, and awk even has a foreach-style loop for looping over them. I’ll walk through the rest of the script slowly.

First we apply an expression to each record, creating an array of tags and their counts:

{ tag_counts[$2] = $1 }

Then, once everything has finished (the END pattern), we process this array. For each tag, we do the following:

1. Normalize the tag (the gsub function overwrites the variable, so we have to make a copy):

   normtag=tag
   gsub(/-|_/,"",normtag)

   (Notice the similarity between this and Ruby’s equivalent normtag.gsub!(/-|_/, "")!)

2. Get the count for that tag and add it to the count for the normalized version:

   count=tag_counts[tag]
   sum[normtag]+=count

   Like in PHP and Perl, if a value is not present in an array it is automatically added with a default value.

3. Next we check to see if the current tag is the commonest version of the normalized tag, and if so we save its name and count in two other arrays:

   if (count > max[normtag])
   {
   	names[normtag]=tag
   	max[normtag]=count
   }

   Notice again the usefulness of a default value for nonexistent keys: count > max[normtag] will be true if max[normtag] doesn’t exist.

Now we have all we need to print out the answer. For each tag we normalize it to the final version (remembering to make a copy):

finaltag=names[tag]
gsub(/(-|_)+/,"_",finaltag)

Then we print out the line (concatenation is done by simply juxtaposing variables or strings):

print " " sum[tag] " " finaltag

If you’ve been watching closely you’ll notice there is a small difference between the awk and the Ruby scripts; Ruby sorts before outputting, while the awk version will come out in a non-defined order. This is fine! We can use the standard *nix tool ‘sort’ to sort the lines;

awk -f consolidate_tags.awk < tags | sort -nr > fixed_tags

(Note that this fits in with the *nix philosophy of ‘do one thing well’ and reusing small components.)

Again, the awk version outperforms the Ruby by a factor of 3–4.

Reading external commands and files

Unfortunately there doesn’t seem to be a command-line stemming program (a quick Perl script would suffice but it isn’t what we’re here for!), so I’ll skip that stage (here’s one of the aforementioned weaknesses of a non-general-purpose language). Instead we’ll go straight to implementing stopwords.

Here’s David’s Ruby code again:

require "set"
 
stopwords = Set[*
  IO.read("smart.txt").lines.reject{|x| x =~ /^#/}.map(&:strip)
]
 
STDIN.lines.each do |l|
  c, t = l.split
  puts l unless stopwords.include? t.strip
end

And here’s my equivalent in awk:

BEGIN {
    while (getline < "smart.txt")
    { stopwords[$0] = 1 }
}
!($2 in stopwords)

Here I use the ‘getline’ function which does as its name suggests. We make an array of all the stopwords, with 1 as a placeholder value. The pattern is then short and simple: Print every record where the tag isn’t in the stopwords (again, we can leave off the expression to print the whole record).

Note: There is a discrepancy here: David claims this eliminated 46 tags, while I get a value of 368 for both my awk code and his Ruby code.

Again, the Ruby takes about 8 times as long to execute.

Conclusion

Here’s a couple of points:

• Record- or field-oriented data? Think awk.

• Don’t discount it just because it’s venerable. It is very well-suited to its task.

• pattern { expression } syntax is extremely flexible.

• Awk’s regular expressions are fast.

Nowadays everybody wanna talk
    like they got something to say
But nothing comes out
    when they move their lips
Just a bunch of gibberish
And motherf—kers act
    like they forgot about Awk

data Exp = Lit Int -- literal value
	| Call String Exp -- calling a function
	| Bin BinOp Exp Exp -- binary operations
	| Param -- the parameter
	deriving (Show,Eq)
 
data Function = Func String Exp -- a function has a name and expression
data BinOp = Add | Subtract | Multiply | Divide deriving(Show,Eq)
 
-- an instance to allow us to write nicer definitions
instance Num Exp where
	x * y = Bin Multiply x y
	x - y = Bin Subtract x y
	x + y = Bin Add x y
	fromInteger x = Lit (fromInteger x)
 
outFunc (Func name it) = name ++ -- output function name
	":\npush ebp\nmov ebp,esp\n" ++ -- save old stack frame
	output it ++ -- output function
	"pop eax\npop ebp\n" ++ -- restore old stack frame
	"ret 4\n\n" -- remove argument from stack and return
 
output (Bin op l r) = outBin op l r -- binary operations
output (Lit x) = "push dword " ++ show x ++ "\n" -- push literal
output (Param) = "push dword [ebp+8]\n" -- push parameter
output (Call name with) = output with ++
	"call " ++ name ++
	"\npush eax\n" -- put return value onto stack
 
outBin Add = outBinGen "add"
outBin Subtract = outBinGen "sub"
outBin Multiply = outBinGen "imul"
outBin Divide = outBinGen "idiv"
 
outBinGen op l r = output l ++ output r ++
	"pop ebx\npop eax\n" ++ op ++ " eax,ebx\npush eax\n"

And an example of using it:

main = putStr $ concatMap outFunc [double,quad]
double = Func "double" (Param * 2)
quad = Func "quad" (Call "double" (2*Param))

This example outputs:

double:
	push ebp
	mov ebp,esp
	push dword [ebp+8]
	push dword 2
	pop ebx
	pop eax
	imul eax,ebx
	push eax
	pop eax
	pop ebp
	ret 4
 
quad:
	push ebp
	mov ebp,esp
	push dword 2
	push dword [ebp+8]
	pop ebx
	pop eax
	imul eax,ebx
	push eax
	call double
	push eax
	pop eax
	pop ebp
	ret 4

Not the most efficient code in the world The calling convention is somewhat ad-hoc; the callee must remove its arguments from the stack and returns its value in eax.

1. Download the RT2500 Windows Drivers, and unzip them somewhere.
2. Ensure you have wireless-tools and ndiswrapper installed.
3. Open a terminal and browse to the folder where you unzipped the drivers.
4. sudo ndiswrapper -i rt2500.inf
5. Edit /etc/modules (as root) and add ‘ndiswrapper’.
6. Edit /etc/modprobe.d/blacklist (again as root) and add ‘blacklist rt2500’.
7. Restart, and you should now have a working card.

Oh, that reminds me… I should really contact some translators to ask for updates and release Gnome Specimen 0.2.

—Wouter Bolsterlee

The Gnome Specimen product is not set up for translation in Launchpad.

You might want to talk with Wouter Bolsterlee (uws), the project registrant, about using Rosetta.

—Launchpad

Done!

/etc/bind/named.conf.options

//Add this somewhere inside the options{}; section...
        forward only;
        forwarders {
                //OpenDNS
                208.67.222.222;
                208.67.220.220;
        };

Don’t use this method any more! I have a much easier way to do it in a more recent post.

But for posterity…

First install resolvconf and pdnsd: sudo apt-get install pdnsd resolvconf. Resolvconf handles the messy interaction between different programs fighting over the /etc/resolv.conf file, and pdnsd provides a persistent DNS daemon, which will cache the DNS lookups on your machine in order to make browsing faster.

Next, you just need to edit pdnsd’s configuration file, /etc/pdnsd.conf as root. Edit it to look like this:

global {
        perm_cache=512;
        cache_dir="/var/cache/pdnsd";
        max_ttl=604800;
        run_as="pdnsd";
        paranoid=on;
#       next setting allows ppp/ip-up update the name servers -- ABa / 20040213
        status_ctl=on;
        server_port=53;
        server_ip="127.0.0.1";
}

#Edit these to be your own servers if wished:
server {
        label = "OpenDNS";
        ip=208.67.222.222,208.67.220.220;
        proxy_only=on;
        timeout=10;
}

# if you installed resolvconf, and status_ctl=on
server {
    label="resolvconf";
}

source {
        ttl=86400;
        owner="localhost.";
#       serve_aliases=on;
        file="/etc/hosts";
}

And finally, restart pdnsd with sudo /etc/init.d/pdnsd restart to use the new settings. In the example above, I've used OpenDNS's servers, but you can change these to whatever you want. As far as actual results go:

~$ dig example.com

; <<>> DiG 9.3.2 <<>> example.com
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 17447
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0

;; QUESTION SECTION:
;example.com. IN A

;; ANSWER SECTION:
example.com. 172800 IN A 192.0.34.166

;; Query time: 513 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Thu Oct 5 15:24:19 2006
;; MSG SIZE rcvd: 45

$ dig example.com

; <<>> DiG 9.3.2 <<>> example.com
;; global options: printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 19338
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0

;; QUESTION SECTION:
;example.com. IN A

;; ANSWER SECTION:
example.com. 172799 IN A 192.0.34.166

;; Query time: 0 msec
;; SERVER: 127.0.0.1#53(127.0.0.1)
;; WHEN: Thu Oct 5 15:24:20 2006
;; MSG SIZE rcvd: 45


find . -type f -iname '*.mp3' -print0 | xargs -0 mp3gain -r -k

Unfortunately, this seems to have problems with very large collections (I suspect that the command line is being filled up), so here’s what I came up with:

find . -iname '*.mp3' -execdir mp3gain -r -k "{}" \; &

If you’d rather use album normalization (and you have your files separated by album such as “~/Music/David Bowie/Hunky Dory”/):

find . -iname '*.mp3' -execdir mp3gain -r -k -a "{}" + &

How to use it

Simply open a terminal, browse to your music directory (using cd), and type it in.

Break it down

What the command does:

1. find . -iname '*.mp3' finds all MP3 files in the current directory and all subdirectories.
2. -execdir mp3gain -r -k "{}" \; & executes “mp3gain -r -k” on each file (the filename goes where {} is found). The semi-colon indicates to execute the command once per file, but since ; is also a significant character for bash, you need to escape it with a backslash. The final ‘&’ tells bash to run the command in the background.

Promise

First of all I headed over to the Beagle site. It turns out that if you want to do more than handle a specific file-type (not an option in this case because the playlists are stored as .xml) you create not a “Filter” but a “Queryable”. Unfortunately the Queryable HowTo is still being written. Nevermind, I can always ask on the mailing list, and taking a look through the tutorial for Filters shows that the API for that is nice and clean and should be similar for the Queryables.

Next I try to find a reference for the C# DBus bindings. I install the Monodoc documentation for DBus, only to discover everything marked with “Documentation for this section has not yet been entered”—the default message for undocumented functions, classes, and so on. Nevertheless, I find a short tutorial on how to use Python with DBus to control Rhythmbox. The class names and functions seem to have similar titles in C#, so I figure this will map fairly directly.

Finding the DBus reference for Rhythmbox takes a fair bit more effort, trawling through mailing list archives on Google. Eventually I find the DBus APIs hiding in a couple of .xml files in the CVS repositories; org.gnome.Rhythmbox.PlaylistManager looks promising.

Misfortune

Unfortunately, I find a post by a last-exit hacker in which he states (my emphasis):

As I was told DBus C# bindings are unusable I went on about writing DBus# objects the hard way.

What? This can’t be right, I’ve already written a little test program:

using System;
using DBus;

namespace RhythmboxQuery
{
   class MainClass
   {
      public static void Main(string[] args)
      {
         Connection bus = Bus.GetSessionBus();
         try {
            Service rhythmbox = Service.Get(bus,"org.gnome.Rhythmbox");
         } catch (ApplicationException ex) {
            Console.WriteLine("Rhythmbox not started: " + ex);
            return;
         }
         Console.WriteLine("Found Rhythmbox.");
         /*

         Okay, so all I need to do now is to call `getPlaylists` on:
         /org/gnome/Rhythmbox/PlaylistManager

         */
         Console.WriteLine("Uhoh.");
      }
   }
}

Despite my valiant attempts to stave off the past through trivial C# programs, the DBus site confirms the aforementioned revelation:

They are schedualed to be removed from the core but has yet to find a maintainer. [sic]

Epilogue

As it turns out, what I had been planning to do would have been impossible anyway because the Rhythmbox DBus bindings lack a PlayPlaylist function in any of the three interfaces. Also, it seems that DBus under C# only plays nicely with C# objects that you have access to—but this could be just because I couldn’t find a single example of how to call methods on non-C# DBus applications.

Ah well, that Beagle Filter API did seem quite nice anyway, I wonder if there are any filetypes I could parse out there…

Attempting to fix this by forcing the install of the 32-bit version of uqm doesn’t work, because for some reason then apt won’t recognise that it is installed and complain that uqm-content has unmet dependencies. So here’s the official recommendation from me:

1. Install uqm normally with the package manager.
2. Download the i386 .debs, extract them and overwrite the binary files from uqm (there are two of them).
3. Install ia32-libs-sdl for the 32-bit versions of the libraries it depends on.

… and it should work perfectly. If you want voice-overs and music (yes!), head to the UQM download page, and download the second two files listed under “Content” (you already have the first). These are in fact just renamed zip files, so unzip them to /usr/share/games/uqm/content/ and you’re good to go.

And the game? Excellent. This is much better than the last game I bought—Civilization IV.

Install command-not-found then add this to your ~/.bashrc:

function command_not_found_handle {
        /usr/bin/command-not-found $1
        return $?
}

And you’re all done:

~$ ssed
The program 'ssed' is currently not installed, you can install it by typing:
sudo apt-get install ssed


This seen outside New World supermarket, Wellington, New Zealand. I’m not sure if the placement is some kind of metaphor.

The thing that’s nice about these Python applications is their extensibility, and not having to restart them for new plugins and suchlike. Now if only they’d automatically check for updates…

First of all, I created “simple.pg” according to his recipe:

grammar Simple::Grammar ;

token variable { [  | _ ] \w* }
token number { \d+ }

token addop { \+ | - }
token mulop { \* | / }

rule expression {  [   ] * }
rule addterm {  [   ] * }
rule multerm {  |  | \(  \) }

This looks all fine and dandy. Next, to compile: $ parrot pgc.pir simple.pg > simple.pir.

Error reading source file pgc.pir.

Huh? Well he didn’t say anything about that. Maybe I have a path wrong somewhere? A quick “locate” reveals it doesn’t lie anywhere on my computer. Next step is to check the downloaded source code to see if I wasn’t meant to delete it yet… ah, yes, it’s hiding under ./compilers/pge/. It looks like it will be easier to work from this directory, so I’ll move everything into there.

Unfortunately, pgc.pir won’t run straight away, and you’ll need to patch it up a bit:

@@ -49,7 +49,7 @@
     .param pmc args
     load_bytecode 'Getopt/Obj.pbc'
     load_bytecode 'dumper.pbc'
-    load_bytecode 'PGE/Dumper.pbc'
+    load_bytecode 'Data/Dumper.pbc'
     '__onload'()

     ##   create an option parser
@@ -153,8 +153,8 @@

 .sub '__onload' :load
     load_bytecode 'PGE.pbc'
-    load_bytecode 'PGE/Text.pbc'
-    load_bytecode 'PGE/Util.pbc'
+    load_bytecode 'PGE/Text.pir'
+    load_bytecode 'PGE/Util.pir'

     .local pmc p6regex
     p6regex = compreg 'PGE:6Regex'

Now it runs fine and generates the output file perfectly. Quite a bit of code in there! Next to use the parser on a real string, using the example:

.include 'simple.pir'

.sub 'foo'
  ...
  ##   get the parrot sub for parsing an expression
  parse = find_global 'Simple::Grammar', 'expression'

  ##   the expression to be parsed
  expr = '3 + 4 * (a-2)'

  ##   parse the expression
  match = parse(expr)

  ##   dump the parse tree
  '_dumper'(match)

That little ellipsis is really in there to let you know that you need to read quite a few more Parrot docs before you’re allowed to progress past this step.

In fact, you’ll be able to get up to speed in no time just by copying some of the example files. I found that I could get by with guessing a bit;

• .sub needed an .end,
• the main method needs to be marked :main to run automatically,
• the variables need to be declared… with appropriate types… you can’t just use pmc for everything,
• and the _dumper code needed to be loaded.

Here’s what it eventually looked like:

.include 'simple.pir'

.sub main :main
        .local pmc parse, match
        .local string expr
        ## get the parrot sub for parsing an expression
        parse = find_global 'Simple::Grammar', 'expression'
        ## the expression to be parsed
        expr = "3 + 4 * (a-2)"
        ## parse the expression
        match = parse(expr)
        ## dump the parse tree
        load_bytecode 'dumper.pbc'
        '_dumper'(match)
.end

But that’s not all, you’ll need to jump through the automagically-generated parser code to put in things that it forgot to. For brevity, here’s the diff:

@@ -1,6 +1,7 @@
       .sub '__onload' :load
           .local pmc optable
           ## namespace Simple::Grammar
+          load_bytecode 'PGE.pbc'
           $I0 = find_type 'Simple::Grammar'
           if $I0 != 0 goto onload_186
           $P0 = subclass 'PGE::Grammar', 'Simple::Grammar'
@@ -288,6 +289,7 @@
           .local string target    :unique_reg
           .local pmc mfrom, mpos  :unique_reg
           .local int cpos, iscont :unique_reg
+          load_bytecode 'PGE/Match.pir'
           $P0 = getclass 'PGE::Match'
           (mob, cpos, target, mfrom, mpos, iscont) = $P0.'new'(mob, adverbs :flat :named)           .local pmc ustack :unique_reg
@@ -321,6 +323,7 @@
           goto fail_cut
         R: # concat
         R147: # subrule ws
+          load_bytecode 'PGE/Regex.pir'
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos

And now, one and a half hours later, for the grand finale…

$ parrot simpleparse.pir
"VAR1" => PMC 'PGE::Match' { ... }

Voilà! My first excursion into Parrot. A bit fiddly, but I enjoyed myself

1. Download the version of Opera 9 for i386 Linux from the official site.
2. Go to the Ubuntu package site and download these packages (also for i386):
   • libqt3-mt
   • libaudio2
   • libxcursor1
   • libxft2
   • libxfixes3
3. Open each package in turn (don’t install!) and copy the libraries to the /lib32 folder as root. Open the package, then open “data.tar.gz”, then find the /lib folder. You don’t need to worry about copying anything under the /usr/share folder, these are just docs and some unneeded symlinks.
4. Install Opera by browsing to the folder where you downloaded it to and entering sudo dpkg -i --force-all opera*.deb.

All done!

Open up a terminal in the folder you saved it to:

sudo apt-get install ia32-libs
sudo dpkg -i --force-architecture wine*.deb

Next, head to the Ubuntu repository and download both libXx86dga1 and libXx86vm1 (for i386). Extract them (don’t install!) and then extract the data.tar.gz files inside of them. Browse to the /usr/lib32 subfolder, then copy both the symlink and the shared library to your /lib32 folder (you’ll need to do this as root). Make sure you do this for both these packages.

I’m currently testing this with the IEs for Linux script, and everything seems to be working so far. IE6 runs perfectly (it may not show up correctly the first time you open it but it’s fine after that).