This is an attempt to format the subversion log of a one-month period in the following way:

• Beautiful HTML output.
• Compact representation of lots of information
• Usable with a not-so color rich beamer.
• Fully automatic.

Usage

1. Install Ruby (both 1.8 or 1.9 should work).
2. Download svn-shortlog.rb.
3. Open svn-shortlog.rb with your favourite text editor, and configure the config section according to your needs.
4. Doubleclick svn-shortlog.rb
5. Open the generated changelog_....html file with your favourite browser.

Sample Output

Here is a sample output of one month of boost commits into trunk, taken from the public repository. The output is quite information dense, a quick description is in the screenshot:

Issues

Ideas, suggestions, problems? Please post them as a comment here, at the bug tracker.

Credits

This tool is based on the idea from my colleague Christoph Heindl and inspired by Linus’ Kernel shortlog and Gmail.

Once installed, you basically use one click to get a video preview and then a prompt with the filename to save the file. The script works by looking into the newest flash files in your /tmp folder, and creates a hardlink to the save destination. When the video has fully loaded, you can close the browser window. The temp file will get deleted, and the linked copy will remain.

Installing flashrip

Open a terminal like gnome-terminal or konsole, and run these commands:

wget http://martin.ankerl.com/wp-content/uploads/2009/11/flashrip.sh
chmod 755 flashrip.sh
sudo mv flashrip.sh /usr/local/bin

Now all thats left to do is to create a link in your gnome panel for ease of use: Right click the gnome panel, “Add to panel…”, choose “Custom Application Launcher…”. Choose a proper name, and a command like this:

/usr/local/bin/flashrip.sh /home/manker/Videos

For the command, replace the second parameter with the default location where you want to save the ripped videos (you have to use the full path here!)

I have tested this in Ubuntu, but it should work on any linux where gnome is installed.

Have fun!

Thanks to Johan Kivinemi I have just found out how to bring back the excellent legacy subpixel hinting engine. This has a much more crisp hinting, and uses subpixels only where it really is an improvement:

Just open these files in your home directory, and copy the content into them:

~/.fonts.conf

<?xml version='1.0'?>
<!DOCTYPE fontconfig SYSTEM 'fonts.dtd'>
<fontconfig>
  <match target="font">
    <edit name="antialias" mode="assign">
      <bool>true</bool>
    </edit>
    <edit name="hinting" mode="assign">
      <bool>true</bool>
    </edit>
    <edit name="hintstyle" mode="assign">
      <const>hintfull</const>
    </edit>
    <edit name="lcdfilter" mode="assign">
      <const>lcdlegacy</const>
    </edit>
    <edit name="rgba" mode="assign">
      <const>rgb</const>
    </edit>
  </match>
</fontconfig>

~/.Xresources

Xft.antialias:  true
Xft.hinting:    true
Xft.hintstyle:  hintfull
Xft.lcdfilter:  lcdlegacy
Xft.rgba:       rgb

This should work in Ubuntu 8.04, 8.10, and 9.04 too, and makes all fonts much more crisp. Of course, your mileage may vary.

UPDATE: Comparison Screenshots

As promised on reddit, I got back from an awesome snowboard trip so I am able to put up extensive comparison screenshots of the two subpixel hinting engines. Move your mouse over the following images to see the differences. Watch especially out for letters like “m” where the spacing between the lines is very small. You might have to wait a bit for the image to load.

I have used all of the most important fonts that I usually use, and just for fun I have added “Dijkstra”, which just looks cool.

Sans Fonts

Mouse to see the same fonts with the legacy hinter.

Mono Fonts

Mouse to see the same fonts with the legacy hinter.

Zoomed Comparison Screenhots

Here is an excerpt with 400% magnifications. Mouse over the pictures to see the legacy hinter.

Zoomed Sans

Zoomed Mono

Imagine you have some Java code that does lots and lots of computation. All the time intensive calculations is performed by the class SlowCalculator which implements the interface Calculator:

public static interface Calculator {
    public String calculate(int a, String b);
}

public static void main(String[] args) {
    Calculator c = new SlowCalculator();
    // call c.calculate() a lot of times here...
}

You notice that calculate() is often called with the same parameters which lead to the exact same result (SlowCalculator is stateless). This means it is possible to cache values so there’s no need to recompute. Using the generic CachingProxy™ described below, you can create a cached proxy for any class with just one single line of code:

// ...

public static void main(String[] args) {
    Calculator c = new SlowCalculator();
    c = CachedProxy.create(Calculator.class, c);
    // call c.calculate() a lot of times here...
}

That’s it, and the application is blazingly fast again.

UPDATE: Support for null values, transparently handles exceptions, better hash, nullpointer-bugfix.

UPDATE: Here is an article “Memoization in Java Using Dynamic Proxy Classes” that does (almost) exactly the same as this code.

How To Do This

All this sounds nice, but can you do this in java? Turns out you can and it is not that difficult either. The feature that makes it all possible is Dynamic Proxy. With it you can implement interfaces at runtime. You take an interface, create a proxy for it with Proxy.newProxyInstance(...), supply an InvocationHandler that implements the invoke() method, and you are done.

The code for the CachedProxy.create() method is this:

    /**
     * Creates an intermediate proxy object that uses cached results if
     * available, otherwise calls the given code.
     *
     * @param <T>
     *            Type of the class.
     * @param cl
     *            The interface for which the proxy should be created.
     * @param code
     *            The actual calculation code that should be cached.
     * @return The proxy.
     */
    @SuppressWarnings("unchecked")
    public static <T> T create(final Class<T> cl, final T code) {
        // create the cache
        final Map<Args, Object> argsToOutput = new HashMap<Args, Object>();

        // proxy for the interface T
        return (T) Proxy.newProxyInstance(cl.getClassLoader(), new Class<?>[] { cl }, new InvocationHandler() {

            @Override
            public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
                final Args input = new Args(method, args);
                Object result = argsToOutput.get(input);
                // check containsKey to support null values
                if (result == null && !argsToOutput.containsKey(input)) {
                    // make sure exceptions are handled transparently
                    try {
                        result = method.invoke(code, args);
                        argsToOutput.put(input, result);
                    } catch (InvocationTargetException e) {
                        throw e.getTargetException();
                    }
                }
                return result;
            }
        });
    }

1. First I create a HashMap that is the cache for the return values. I have written a class Args (omitted here) that is as the key to map from the method and the parameters to the cached output.
2. A Proxy is created for the interface cl, with an InvocationHandler that does all the magic.
3. The magic is actually very simple: If there is no cached result already available (line 25), perform the computation (line 26) and store the result in the map, then return the result.

Download

You can get the full code at my github repository:

• CachedProxy

Benchmarks

In my benchmark I can run about 8 million calls per secons via the cached proxy. That’s not too bad, given all the additional overhead with reflection and the HashMap.

Do you know of any way to improve this? Any ideas or suggestions are welcome!

I have now two versions of the theme: one with normal icon sizes, and one with the smaller 16×16 icons for even more compactness. Here is a comparison animation of the standard Human theme vs. the compact theme:

You can download the themes here:

• HumanCompact-8.10.tar.bz2
• HumanCompactSmallIcons-8.10.tar.bz2

Download and Installation

1. Save the theme to your computer.
2. Open the gnome’s appearence dialog with System > Preferences > Appearance.
3. Drag and drop the downloaded file into the Theme tab of the appearance dialog. If you get an error message “Can’t move directory over directory”, you have already installed a theme with the same name. To be able to reinstall it, remove the directory ~/.themes/Human Compact or ~/.themes/Human Compact Small Icons.
4. Choose “Apply new theme” in the popup dialog.

Most changes will occur immediately, but for e.g. the icon sizes it is best to log out and log in again. When you change the theme, you can get the Human Compact theme back by clicking on Customize, and then selecting Human Compact.

Any question, praise or flames? please post them!

Install for root (e.g. Synaptic)

Some readers asked how to get this to work for applications that run as root (e.g. synaptic), so here it is: simply copy the copy the theme file into the root’s home directory, like this (exchange username with your own name):

sudo cp /home/username/.themes/Human\ Compact/gtk-2.0/gtkrc /root/.gtkrc-2.0

Afterwards synaptic uses the human compact theme.

Older Themes

Here is some information about the original compact themes I have created:

• How to Make a Human Compact Theme
• Human Compact Theme (for Ubuntu 8.04)
• Clearlooks Compact Theme (for Ubuntu 8.04)

UPDATE: Human Compact Theme for Ubuntu 8.10 (Intrepid Ibex) is available!

Comparison

Move your mouse over the image to see the difference of a save dialog between Ubuntu’s 8.04 Human, and Human Compact. Buttons and spacing is much smaller which results in a lot more free space for the actual content. See for yourself:

Here are some other screenshots. The eclipse window uses 800×480 resolution, which is the same as the eee pc has.

Download and Installation

1. Save the file HumanCompact.tar.bz2 to your computer.
2. Open the gnome’s appearence dialog with System > Preferences > Appearance.
3. Drag and drop the downloaded file into the Theme tab of the appearance dialog.
4. Choose “Apply new theme” in the popup dialog.

Most changes will occur immediately, but for e.g. the icon sizes it is best to log out and log in again. When you change the theme, you can get the Human Compact theme back by clicking on Customize, and then selecting Human Compact.

Any question, praise or flames? please post them!

Install for root (e.g. Synaptic)

Some readers asked how to get this to work for applications that run as root (e.g. synaptic), so here it is: simply copy the copy the theme file into the root’s home directory, like this (exchange username with your own name):

sudo cp /home/username/.themes/Human\ Compact/gtk-2.0/gtkrc /root/.gtkrc-2.0

Afterwards synaptic uses the human compact theme.

Clearlooks Compact is a Gnome theme that tries to make use of the wasted screen space as much as possible. It is especially useful for small screens like on the Eee PC, or with intense applications like Eclipse.

This theme is picking up some steam lately:

• It is recommended from the EeeUser Installation manual (also available in many other languages, see translations to the top right).
• Somebody wrote an idea into Ubuntu’s Brainstorm, and it got 86 votes already
• I have written a bug report in Ubuntu’s launchpad a while ago, and somebody wrote an Eee PC blueprint
• There is an entry in Gnome-Look and Xfce-Look.
• And of course there are several blog postings.

I am using it on my 22″ monitor and like it here too.

Even though there is not much about this search, I have done quite a bit of user interface tweaks to make them easier to use. Here are the new features:

Remember Latest Selection

When you use e.g. the Open Source Search, the previously used operating system (selected by clicking on the button) is automatically used when you just enter the search term end press Return. The selection is highlighted with bold text.

Select Text On Click

Clicking into the text field automatically selects the whole text, so it is easier to reuse the textfield. I have also entered a default value, because from the webanalyzer logs I found out that many people just click on the buttons without entering any text, so now it should be more obvious how this thing works.

No Textfield Changes

The previous version added a text like more:Linux into the search box that was used by the custom search. This clutter is now hidden from the user.

I think the widgets are much more useful now. If you like them, add them to Netvibes, iGoogle, Apple Dashboard, Opera, Windows Live, or Windows Vista here:

• Open Source Software Search Widget
• Java Developer Kit Documentation Widget

I think the widgets are now much more useful. Post if you have any problems!

Try Them

For example, enter Word and click Linux to find open source alternatives for your favorite operating system. The widget remembers what your choice, and the next time you use the search you just have to enter the search term and press enter to search with the same operating system again.

Type concurrent and click 6.0 in the JDK search to find out about the concurrency package in JDK 1.6.0.

Add Them

You can add the engines to Netvibes, iGoogle, Apple Dashboard, Opera, Windows Live, or Windows Vista here:

• Open Source Software Search Widget
• Java Developer Kit Documentation Widget

Are the widgets useful to you? Please tell me!

tune2fs -m 0 /dev/sdf1

Replace sdf1 with your partition name. You don’t even have to unmount your disk. Voilá, 11.5 GB more space for free Here is the output of df -h as proof:

Before:

Filesystem            Size  Used Avail Use% Mounted on
/dev/sdf1             230G  193G   26G  89% /media/disk

After:

Filesystem            Size  Used Avail Use% Mounted on
/dev/sdf1             230G  193G   38G  84% /media/disk

If you like this, you might also be interested in How to change Ubuntu forced fsck.

Update: The free space limitation is also used to prevent fragmentation. So if you set the limit to zero and operate on a very full harddisk for a while, your filesystem might slow down.