It creates a whole copy of your music library, just with a smaller bitrate.

More information about its use as well as the code it at github.

The downside is that I cannot do anything with the original JPEG images any more, and I did not keep those. Luckily, there is a nice tool called pdfimages.

Since I like my files to be numbered with an +1, +2, and so forth, I wrote a script that unwraps the image files from the PDF and numbers them for me.

More information and the script is at github.

In case you have some chat logs from the Mac OS X chat client Adium that you want to convert into format of the multi platform Pidgin client, this tool might be handy for you.

The code and more information can be found at github.

One could join them into a single PDF file, but I'd rather have the original files since images in PDF usually look blurrier. With text, it makes it harder to read.

Browsing through multiple images is not a problem with programs like Gwenview or Eye of Gnome. The only thing is that they display them fitting to the window. If you zoom, they will center. This might be natural for pictures, but not for a document.

Opening a single picture in Okular yields what I need: Fit to page width, starting at the top of the image. Unfortunately, Okular does not support multiple image files, and that is not going to change either.

This is a little script that generates a HTML page which combines all those images. A web browser starts at the top of the screen and is able to fit images to width of the window.

Usage

It assumes that your images are numbered like this:

physik111-03-korrigiert+1.jpg
physik111-03-korrigiert+2.jpg
physik111-03-korrigiert+3.jpg
physik111-03-korrigiert+4.jpg
physik111-03-korrigiert+5.jpg
physik111-03-korrigiert+6.jpg

They have to have the exact same name, just differ by the number behind the + sign.

Call it with any of the images, it will figure out the whole sequence.

multiimage physik111-03-korrigiert+5.jpg

Download

The code is at github.

Example

And this is what it looks like:

Those files are all over my hard drive. Some of them already have a PDF exported, some do not. In order to find those, that still need a PDF exported, I wrote a little Python script you can find at GitHub.

It searches through the current directory (or any folders you specify on the command line) an searches for files that are not easy to open on Linux.

Say you have presentation.odp but want to have a corresponding PDF to it. The script will check for a presentation.odp.pdf. In case that is not there, it will resort to presentation.pdf and rename it to presentation.odp.pdf to make clear that it is exported.

It will now only use the tags that are in your current branch. If you have two branches for two versions of your program, like v2-series and v3-series, you do not want the versions that start with a 3 to show up in your other changelog.

In case you want them all, there is an --all option now.

And if you want more control, you can specify a regex with the --filter option. But as always: Using a regex often creates more problems than it solves. ;-)

The unibn setup script will help you configure the VPN client on a Ubuntu or Fedora installation. It will also install emacs, LaTeX and gnuplot and at your option also set the ROOT statistics package up for you.

To use this script, open a terminal, either via CTRL+ALT+T or Menu -> Accessories -> Terminal.

Then these commands will download and execute the script.

wget http://martin-ueding.de/download/unibn_setup
bash unibn_setup

Please read the on screen instructions, the script asks a couple questions :-)

The script is published under the Modified BSD License, feel free to redistribute or change it as long as you mention that I created it initially.

I always thought that a function is cleaner than an include file which inherits all your variables and changes them without you noticing by chance. A function is encapsulated so that this would not happen. Recursion should be out of the question with include files, or at least it seems very cumbersome to me.

Anyway, one of the things that I learned from Steve McConnel's books is that you should not "optimize" something unless you can show that it is really faster or better than before. In order to be fair I put together a little test case for the claim regarding include files.

It basically has a very simple code snipped that I wrapped up into a simple include file foo.php, a similar snippet that I wrapped up in a function (foo2.php). Then there is the test.php which does the magic.

test.php

<?php
# Copyright (c) 2011 Martin Ueding <dev@martin-ueding.de>

$count = 10000;

# Start with including the code snippet $count times.
$start = microtime(true);
for ($i = 0; $i < $count; ++$i) {
    include('foo.php');
}
$duration_include = microtime(true)-$start;
# End include part.

# ------------------------------------------------------

# Begin function part.
$middle = microtime(true);

# Define the function.
require_once('foo2.php');

# Call the function.
$second = microtime(true);
for ($i = 0; $i < $count; ++$i) {
    foo($i);
}

$duration_function = microtime(true)-$second;
$duration_function_and_require = microtime(true)-$middle;
# End function part.

# ------------------------------------------------------

# Print the report.
print "include:\t\t".$duration_include."s\n";
print "function:\t\t".$duration_function."s\n";
print "function+require_once:\t".$duration_function_and_require."s\n";
print "\n";
print "The include method is "
    .($duration_function_and_require/$duration_include)." times faster.\n";
print "The function method is "
    .($duration_include/$duration_function_and_require)." times faster.\n";

foo.php

<?php
$k = 1;
$y = 2*$k;
?>

foo2.php

<?php
function foo($i) {
    $y = 2*$i;
}
?>

Results

This is what my machine came up with:

include:                0.3787100315094s
function:               0.026961803436279s
function+require_once:  0.027056932449341s

The include method is 0.071444984811999 times faster.
The function method is 13.99678371591 times faster.

Conclusion

I would say that it does not make too much sense to avoid functions just to save a couple of lines of code. Abstraction comes with a penalty, but I think that it is worth it.

In order to generate a changelog file, I had to tinker a little. As it seems, there was no easy way to get all the tags together with their descriptions. I created a script called git-changelog which takes all the tags, reverses them and gets their descriptions:

#!/bin/bash
# Copyright (c) 2011 Martin Ueding <dev@martin-ueding.de>

set -e
set -u

for tag in $(git tag | tac)
do
    if [[ $tag =~ v?[0-9]+(\.[0-9]+)* ]]
    then
        git show $tag | parse_tag_object
    fi
done

Each tag description is passed through the parse_tag_object script, which strips all the irrelevant git information (the commit id, the whole patch, time and author) as well as the GnuPG signature and generates a clean changelog:

#!/usr/bin/python
# -*- coding: utf-8 -*-

# Copyright (c) 2011 Martin Ueding <dev@martin-ueding.de>

import sys
import itertools

def main():
    for line, i in zip(sys.stdin, itertools.count()):
        if line == "-----BEGIN PGP SIGNATURE-----\n":
            sys.exit(0)

        if i >= 4:
            print "\t"+line,
        elif i == 0:
            print line[4:-1]


if __name__ == "__main__":
    main()

This assumes that all your numeric tags are indeed version numbers and that you have signed all of your tags.

The generated changelog contains this:

v1.5.3
    * Add Java Webstart.
    * Create extensive manual page.
    - Fix drawing dots (broken since v1.5.2).
    - Allow movements with extra mouse buttons (enable in config).
    - Add config option to disable eraser.

That was extracted from the output of git show v1.5.3:

tag v1.5.3
Tagger: Martin Ueding <dev@martin-ueding.de>
Date:   Sun Sep 25 12:46:31 2011 +0200

* Add Java Webstart.
* Create extensive manual page.
- Fix drawing dots (broken since v1.5.2).
- Allow movements with extra mouse buttons (enable in config).
- Add config option to disable eraser.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.11 (GNU/Linux)

iQEcBAABAgAGBQJOfwaJAAoJEB64QqUqUa0tDCQH/AxpYUD4UZg5wFR/6tAhEDrr
VQGrBEYoQ3IN2mnHHH9SO/sDvyFa90j3uR57gfNgE1R+i5nC1c6r90nujedAJum7
…

To use this, download the tarball and put both files in your path. You need Bash and Python and obviously git.

Since most of the paper that I write is not read after a day or so, I tried to come up with a better way. Text on the computer can be easily deleted if you do not need it any more, but you cannot erase pen from paper too easily.

My idea is that your computer can easily serve as an almost infinite notebook. If you save pictures with the resolution of your screen, you can store millions of pages. And they do not weigh anything. Ideally, you do not need to bring paper to do your math homework, following a lecture or sketch something.

Since you cannot seriously draw with a mouse, you need to have something like a pen tablet or a touch screen to make this work well.

You might say that using a graphics tablet is nothing new. Sure, there is plenty of drawing software out there. But I just did not find one where you cannot click on anything that makes your page disappear and can create a reasonable number of images (i.e. pages) with little effort.

So my software goes full screen on a netbook with 1024x600 pixels of resolution. You can only control it with your keyboard. That way, you can draw freely with your pen without worrying about accidentally clicking something.

If you have filled the whole screen, just press the arrow keys (or space bar or enter) to advance in your virtual notebook. If you are at the end of it, at new page is instantly created. That way, you will never run out of (virtual) paper.

You can organize your notesheets in notebooks that can individually hold as many pages as you like. On startup you can choose the notebook that you want to work in:

If you just need paper for scribbling, you can just enter the "scribble" mode. You can go back and forth in this, but when you close it, it disposes all the sheets.

In case you are interested in the program, please send me an Email. I'll be happy to send you a copy. You can also download the program and sources here.

These are taken from the "Wunderwelt" miniture world:

There are redirections from the old pages to the new ones, so you should be fine, even with the RSS feed except that every old post is doubled now.

There is nothing done on the server, it just serves generated webpages that are generated with a set of makefiles, bash scripts, PHP and markdown. So this should load a little faster than the five to seven seconds that WordPress took before.

Olympia Park

BMW World

Schloss Nympfenburg

Jet d'eau

Horloge fleurie

This is the ATLAS Control Building and its control room:

There is also a pretty newly built “globe” where one can explore the world of particle physics.

It looks very nice at night.

One could use a simple ls -A and check whether some .bzr or .git directory is present, but these are only in the root directory of your tree. You could enter git status and see the error message if you were wrong, but that does not help if you use Mercurial and Subversion on your machine as well.`

I added a small \$(~/bin/scmpromt.sh) into my prompt in my .bashrc. This causes the script to be executed each time the prompt is displayed. The script basically contains the following:

#!/bin/bash

CDIR=`pwd`

while [ "$CDIR" != "/" ]
do
    if [ -d "$CDIR/.bzr" ]
    then
        echo " bzr"
        exit 0
    fi

    # ... similar rules for .git, .hg, .svn ...

    CDIR=${CDIR%/*}
    if [ -z $CDIR ]
    then
        CDIR="/"
    fi
done

It basically checks for the .bzr directory (just as you would by hand) and then goes up in the directory tree until it finds a directory. If it finds one, it displays “bzr” which is then displayed right in the prompt:

martin@iMac:~/Code/scmpromt bzr $

That way, I know that I used git on this project, and then can use the appropriate commands. You could also beef the script up with some colors, I altered my prompt so that “git” show up in a dark yellow so that it does not draws too much attention. You can do this by wrapping the call to the prompt like this:

\[\033[00;33m\]\$(~/bin/scmpromt.sh)\[\033[00m\]

showing the status of the working tree

It would be really handy to know whether the current working tree had any uncommited changes in it. The quickest hack was just to count the number of lines in the status messages. Git only displays two or three lines for a clean tree, Bazaar does not print anything. The hack looks like this:

if [ "`git status | wc -l`" -le 3 ]
then
    echo " git✓"
else
    echo " git"
fi

It worked for me pretty good, but it is not safe at all since the output of git status could change any time or display other lines like that the branch it ahead of the origin. Another caveat is that this might take a lot of time, and your promt will not display until the script is done. Especially with Bazaar, you can wait around a second until the prompt shows up. Therefore, I do not use this any more but rather enter bzr st by hand.

This release features my database installer, it should be fairly easy to install the database with it.

One shortcoming in this version is that you cannot change the language on the website, you would have to dive into the PHP files and alter the language selection.

You will find the most current release on the Launchpad download page, you can even pull the current developer version if you like. You need Java 1.6 (sometimes referred to as “Java 6”) to play the game.

The interface is not really intuitive so far, so please take a minute and read the manual to the game.

I hope you like the game, feedback is appreciated!

There are certain things one would not write on a postcard. Like a password or some personal secret. But some people write those things in emails. I would like to show you how similar email and postcards are and how the messages could be read by strangers. After that, I will show you some ways to protect your emails.

Where Can Email Be Attacked?

A postcard can be read by everyone at any time. The mail man, somebody at the mail office or even your neighbor, if he looked into you mailbox. The path of an email is quite similar. It starts on your computer and is sent off to your email provider. On the way to the email provider, the email goes through your local network to your internet service provider (ISP). Then your email provider sends the email to another email provider, where it goes the same way backwards to the recipient.

As you can see, there are a lot of points on the way, and on each point the email could be read – in principle. It is rather difficult to spy on the way between the two email providers, but within your local network is quite easy. The email provider could also read your emails easily, since it stores them all for you.

How You Can Protect Your Emails

There are two concepts to protect your emails, one is used most of the time. It you trust your and the recipient’s email provider, this gives good security. If you access your emails via an encrypted connection, it means that the communication cannot be seen (I assume that the encryption works, that would be a whole different story) between you and the email provider. It is like putting your postcards in a portable vault supplied by the central mail office. Anyone in your local network and also your ISP will not be able to read the mails. In the office example, this would protect you from your desk (but not including it!) to the central mail office from the curious looks of co-workers or somebody at the mail office in your company. It offer good security against people spying in your network.

If the recipient uses the same, which is usually the case, the email should be pretty private. There is still the option that one of the computers is lost, and the emails can be read from it, since the email itself is not encrypted, just the way. Common names for this is SSL, TSL, IMAPS and POPS.

All the points and connections which are colored green are secured with the SSL approach:

The other method is to encrypt the email itself, like writing in a secret code on the postcard. Then you could even send the mail without any protection, since the email itself is encrypted. On your computer, the email is encrypted as well, so it does not really matter, if your computer should be lost. At least for the information in those emails.

The downside of this, it is implemented in PGP and S/MIME by the way, that both the sender, as well as the recipient have to have some sort of secret code. In PGP it is a secret key, in S/MIME it is a certificate you have to optain from some sort of certificate authority and it usually costs some money. With SSL, you just tick the “use encryption” checkbox, and you are done. In many web interfaces, you do not even notice that the connection is encrypted.

As always, you have to weigh security against comfort. Once PGP is properly set up, it is not any more work than a normal email. Before that, you have to exchange keys or certificates, confirm that they actually belong to the owner and so on. Your email provider already did all that for you with the SSL connection encryption, but it does not extend all the way to the recipient.

If you would like to try it out, you can install a free PGP implementation, namely GnuPG, generate a keypair and send me an encrypted email. You will find my key (0x2A51AD2D) on keyservers and also in the „Contact“ section to download.

Today, I wanted to start off blogging again, but I thought to blog in English, so that I could reach all my friends over the world. English might not be the best language to reach people in Germany, but I still think it is the best compromise.

The data is stored in a XML file a little buried in the user's library directory (~/Library/). The data points look like this:

<object type="SAVEDDATA" id="z102">
    <attribute name="date" type="string">2010-09-03</attribute>
    <attribute name="capacity" type="string">87 % (4742 mAh)</attribute>
</object>

Somebody asked whether there is a possibility to export them to CSV and I tried to write a little program that does this job.