% create a matrix with random values:
>> noise = 2 * rand(90 * 60 * 44100, 2, 'double') - 1;

% write the wav file with a sample frequency o 44.1kHz
>> wavwrite(noise, 44100, 16, 'noise.wav');

This process takes a while and it consumes quite some of your system RAM.

More efficient, in bash:

$ dd if=/dev/urandom count=5400 bs=176400 | sox -s -c 2 -r 44100 -t raw -w - noise.wav

This took only 2 minutes!

#!/bin/bash
# rd - remove dupliactes

# find the files using the specified 'find arguments'
find "$@" -type f -print0 |

# calculate checksum for each file
xargs -0 -n1 md5sum |

# sort on the checksum
sort --key=1,32 |

# show remove command for each duplicate file
awk 'dup[$1]++{print "rm -f " $2}'

exit 0

The script is safe to use, it is not able to actually delete files itself. Instead, it generates a script that does the risky stuff.

Usage
To see what files are marked as duplicate in the current working directory:

$ rd .
rm -f ./config_backup_2008-11-06_11.30.01.tar.bz2
rm -f ./config_backup_2008-11-07_11.30.01.tar.bz2
rm -f ./config_backup_2008-11-08_11.30.01.tar.bz2

If you like the result, you can execute the generated commands. This can by piping the output to the shell:

$ rd . | sh

Processing the rd command might take some time. So you can also copy and paste the output in the terminal when there are a lot of (big) files.
Since the script passes all arguments to the find command. It’s also possible to fine tune the find command. For example, you only want to remove duplicates in the current directory, without searching in sub directories:

#  rd . -maxdepth 1

I’m using the script to remove duplicate backup sets.

#!/bin/sh

source=$1
dest=$2

echo copying virtual machine
cp -rv $source $dest

vmxsourcefile=`ls $source/*.vmx`
vmxdestfile=`ls $dest/*.vmx`

grep -v displayName $vmxsourcefile > $vmxdestfile
echo displayName = \"$dest\" >> $vmxdestfile

exit 0

One of the things that has been bothering me is the fact that thumbnails are not only generated during import, but also during the first visit of the new albums. Especially on my very slow web host, it can take up to minutes to view a single picture that hasn’t been processed before.

A solution is a shell script that finds out what pages to download after adding a new set of pictures. It will then download those pages, forcing Plogger to generate all the necessary cache files. The script should be executed form the web server itself. It requires 3 lines (upper part of the script) of configuration: the url and filesystem path to the plogger installation and a log file that keeps track of the url’s already downloaded. If you want to redo the downloading, just remove this log file.

#!/bin/bash

# A small example program for using the new getopt(1) program.
# This program will only work with bash(1)
# An similar program using the tcsh(1) script language can be found
# as parse.tcsh

# Example input and output (from the bash prompt):
# ./parse.bash -a par1 'another arg' --c-long 'wow!*\?' -cmore -b " very long "
# Option a
# Option c, no argument
# Option c, argument `more'
# Option b, argument ` very long '
# Remaining arguments:
# --> `par1'
# --> `another arg'
# --> `wow!*\?'

# Note that we use `"$@"' to let each command-line parameter expand to a
# separate word. The quotes around `$@' are essential!
# We need TEMP as the `eval set --' would nuke the return value of getopt.
TEMP=`getopt -o ab:c:: --long a-long,b-long:,c-long:: \
     -n 'example.bash' -- "$@"`

if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi

# Note the quotes around `$TEMP': they are essential!
eval set -- "$TEMP"

while true ; do
        case "$1" in
                -a|--a-long) echo "Option a" ; shift ;;
                -b|--b-long) echo "Option b, argument \`$2'" ; shift 2 ;;
                -c|--c-long)
                        # c has an optional argument. As we are in quoted mode,
                        # an empty parameter will be generated if its optional
                        # argument is not found.
                        case "$2" in
                                "") echo "Option c, no argument"; shift 2 ;;
                                *)  echo "Option c, argument \`$2'" ; shift 2 ;;
                        esac ;;
                --) shift ; break ;;
                *) echo "Internal error!" ; exit 1 ;;
        esac
done
echo "Remaining arguments:"
for arg do echo '--> '"\`$arg'" ; done

$ sudo apt-get install mysql-server

Then you might think that you need this command for removal:

$ sudo apt-get remove mysql-server

However, this is not the case. The mysql-server package is a sort of meta-package that makes sure that the latest (and greatest) available mysql server version will be installed. Currently, this means that you actually installed mysql-server version 5.0. Above command will only remove the meta-package, while mysql server 5 happily continues running on your system. To de-install the mysql-server, remove the package, the meta package pulled in:

$ sudo apt-get remove mysql-server-5.0

To also remove the configuration and the binary data, use instead:

$ sudo apt-get remove --purge mysql-server-5.0
# and for ubuntu Gutsy:
$ sudo apt-get purge mysql-server-5.0

Now that mysql server is ‘really’ gone, you can start over and install the mysql-server package:

$ sudo apt-get install mysql-server

HOSTCOLOR="31m"
PS1="\u@\[\e[${HOSTCOLOR}\]\h\[\e[0m\]:\w\n\[\e[33m\]\!\[\e[0m\] \$ "

It will print out the current working directory on the first line and the actual bash prompt on the second line. Making it less likely that your command will wrap lines after the first few typed characters.
It changes the command prompt from:

….into:

The login prompt now shows the following info:

• username
• hostname in red (in my bash script, it will print red for one group of servers and blue for other servers)
• current working directory
• command history number, ie: use !520 to execute the previous command

#!/bin/bash

xcffile=$1

layers=`xcfinfo $xcffile  | awk '{ print $NF }'`

destdir=`dirname $xcffile`/layers
mkdir $destdir

for layer in $layers
do
        echo saving $layer to $destdir/$layer.png
        xcf2png -o $destdir/$layer.png $xcffile $layer
done

exit 0

$ for i in `ls *.bmp` ; do echo convert $i ${i%.*}.png ;done
convert screendump_01.bmp screendump_01.png
convert screendump_02.bmp screendump_02.png
convert screendump_03.bmp screendump_03.png

When you’re satisfied with the result, have it executed by the shell:

$ for i in `ls *.bmp` ; do echo convert $i ${i%.*}.png ;done | sh

; wait for tightvnc window
WinWaitActive("New TightVNC Connection")
; send hostname and port number
Send($hostname & ":" & $displaynumber)

This makes sure that the keystrokes actually end up in the right window. Mouse coordinates can be specified relative to the application window. Using these features allows you to write ‘reasonably’ robust code. But don’t expect your AutoIt script to run flawlessly on other PC’s. There are a lot of dependencies, like dialogs that look different in another version. Internationalization might cause the window title to read “Nieuwe TightVNC Verbinding” (Dutch) and the above code snippet will fail. Even user preferences like font sizes, window themes and screen resolution might result in unexpected behavior.

Anyway, it’s just fun to figure out which sequences to send to an application and let it process a batch of documents!
Ok, this works pretty nice under windows. But what about my favorite platform?

I thought it couldn’t be difficult manipulating mouse clicks and keystrokes with the Penguin…
Well, the most difficult task was collecting the required tools! I ended up with vnc and rfbplaymacro.
Let me explain . VNC uses the RFB (Remote FrameBuffer) protocol to remotely control another computer. While vncviewer (vnc client) is an interactive application (you interact with the remote computer as if you where sitting behind it), rfbplaymacro is ‘headless’. It allows you to send over the keystrokes and mouse clicks, but it doesn’t show you what happens. Instead of actually using your mouse and keyboard, rfbplaymacro expects a macro fed into stdin. The macro is a plain text list of mouse and keyboard events. The demo macro that is supplied with the rfbplaymacro source code displays an xclock for 10 seconds:

RFM 001.000
password "mypasswd123"
pointer 100 20 delay 1s
type "xclock -geometry +400+200 &"
press Return
type "xkill"
press Return
pointer 410 210 delay 10s
click 0

The first line tells the parser which of the possible macro versions is used. I’ve only seen just one version. The password statement is optional, it’s also possible to specify the password when playing the macro, see the next code snippet. This script assumes the remote desktop runs an xterminal in the upper left of the screen. By moving the mouse to the upper left (pointer 100 20), the xterm gets the input focus (depending on the window manager). After the mouse movement, the macro pauses for one second, specified by delay. Then the xclock is started in the background, by typing the xclock command and hitting return. Xkill is fired up in the same fashion. The mouse pointer is transformed in a deadly weapon! Another pointer instruction moves the cursor to xclock. The dangling ‘Sword of Damocles` is hanging for the full 10 seconds before final and deadly mouse click is sent.

To play back this rather useless, but illustrating macro, use:

$ rfbplaymacro --server=linuxbox:9 < test.rfm

This will connect to a running vncserver (desktop :9) on ‘linuxbox’ and sends over the mouse and keyboard events specified in the marcro test.rfm. Connect a vncviewer to the same desktop and you will see it happen!