• Text over the colored background should be easily readable
• Colors should be very distinct
• The number of required colors is not initially known

Naïve Approach

The first and simplest approach is to create random colors by simply using a random number between [0, 256[ for the R, G, B values. I have created a little Ruby script to generate sample HTML code:

# generates HTML code for 26 background colors given R, G, B values.
def gen_html
  ('A'..'Z').each do |c|
    r, g, b = yield
    printf "<span style=\"background-color:#%02x%02x%02x; padding:5px; -moz-border-radius:3px; -webkit-border-radius:3px;\">#{c}</span> ", r, g, b
  end
end

# naive approach: generate purely random colors
gen_html { [rand(256), rand(256), rand(256)] }

The generated output looks like this:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

As you can see this is quite suboptimal. Some letters are hard to read because the background is too dark (B, Q, S), other colors look very similar (F, R).

Using HSV Color Space

Let's fix the too dark / too bright problem first. A convenient way to do this is to not use the RGB color space, but HSV (Hue, Saturation, Value). Here you get equally bright and colorful colors by using a fixed value for saturation and value, and just modifying the hue.

Based on the description provided by the wikipedia article on conversion from HSV to RGB I have implemented a converter:

# HSV values in [0..1[
# returns [r, g, b] values from 0 to 255
def hsv_to_rgb(h, s, v)
  h_i = (h*6).to_i
  f = h*6 - h_i
  p = v * (1 - s)
  q = v * (1 - f*s)
  t = v * (1 - (1 - f) * s)
  r, g, b = v, t, p if h_i==0
  r, g, b = q, v, p if h_i==1
  r, g, b = p, v, t if h_i==2
  r, g, b = p, q, v if h_i==3
  r, g, b = t, p, v if h_i==4
  r, g, b = v, p, q if h_i==5
  [(r*256).to_i, (g*256).to_i, (b*256).to_i]
end

Using the generator and fixed values for saturation and value:

# using HSV with variable hue
gen_html { hsv_to_rgb(rand, 0.5, 0.95) }

returns something like this:

Golden Ratio

Using just rand() to choose different values for hue does not lead to a good use of the whole color spectrum, it simply is too random.

Here I have generated 2, 4, 8, 16, and 32 random values and printed them all on a scale. Its easy to see that some values are very tightly packed together, which we do not want.

Lo and behold, some mathematician has discovered the Golden Ratio more than 2400 years ago. It has lots of interesting properties, but for us only one is interesting:

[...] Furthermore, it is a property of the golden ratio, Φ, that each subsequent hash value divides the interval into which it falls according to the golden ratio!
-- Bruno R. Preiss, P.Eng.

Using the golden ratio as the spacing, the generated values look like this:

Much better! The values are very evenly distributed, regardless how many values are used. Also, the algorithm for this is extremly simple. Just add 1/Φ and modulo 1 for each subsequent color.

# use golden ratio
golden_ratio_conjugate = 0.618033988749895
h = rand # use random start value
gen_html {
  h += golden_ratio_conjugate
  h %= 1
  hsv_to_rgb(h, 0.5, 0.95)
}

The final result:

You can see that the first few values are very different, and the difference decreases as more colors are added (Z and E are already quite similar). Anyways, this is good enough for me.

And because it is so beautiful, here are some more colors
s=0.99, v=0.99, s=0.25, h=0.8, and s=0.3, v=0.99

Have fun!
Martin

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

10. Top 10 Eclipse Hotkeys

Ironically, this list starts with another top 10 list, namely Top 10 Eclipse Hotkeys. This article from 2006 has just made it onto this top list. With 3,302 pageviews it seems that these keys are still relevant.

9. Human Compact Themes for Ubuntu 8.10

Number 9 is a modification of the Ubuntu’s default theme that is optimized for small screens. With the recent rise of netbooks this becomes more and more wanted.

8. Logical Volume Manager Cheatsheet

sudo pvcreate /dev/sdg1
sudo vgcreate ext_vg /dev/sdg1
sudo lvcreate -L 450G -n ext ext_vg
sudo mkfs.ext3 -m 0 /dev/ext_vg/ext

A compact little cheat sheet that explains how to easily combine two harddisks into one large volume. I have used this to combine two 500GB disks into one large 1TB filesystem.

7. Comprehensive Linux Terminal Performance Comparison

In this highly controversial article I have compared how long several different terminals (xterm, gnome-terminal, etc.) take when displaying one large textfile. I still believe this is relevant, especially when compiling stuff and text flies by. You don’t want your terminal be the limiting factor for your compile speed! I would perform the test yourself, as this seems to be highly dependent on the graphics card driver.

6. Howto Create MANIFEST.MF Classpath from Ant

<!-- name of the output .jar file -->
<property name="jar.name" value="ourjarfile.jar" />

This HOWTO describes a simple way to create the classpath in a MANIFEST.MF file automatically from the libraries available on the harddisk. I have been using this since 2005, and it has never failed me.

5. Human Compact Gnome Theme (for Ubuntu 8.04)

Another Compact theme has made it on the list, this time for 8.04. I have used this theme for quite a while, even on a large 1680×1050 monitor because it really saves a lot of screen space. For everybody still using Ubuntu 8.04, this is the best choice to use a compact layout while still having the default Human look.

4. Optimized pow() approximation for Java, C / C++, and C#

public static double pow(final double a, final double b) {
    final int x = (int) (Double.doubleToLongBits(a) >> 32);
    final int y = (int) (b * (x - 1072632447) + 1072632447);
    return Double.longBitsToDouble(((long) y) << 32);
}

Through some funny floating point representation tricks it is possible to create an approximative calculation of the pow() operator, that is a hell of a lot faster than the standard calculation which has to be extremely precise. This might be useful for games, Artificial Intelligence applications, and everywhere else where performance is an issue and not precision.

3. Ajax Dojo Comet Tutorial

One of the most often seen article contains 3 buzzwords at once: Ajax, Dojo, Comet. This page was linked several times, and it is getting quite a bit of attention. The article was written by an intern at my workplace and he allowed me to put it up here.

2. Clearlooks Compact Gnome Theme

Yet another theme! This startet it all. The Clearlooks Compact Theme was the first compact theme I have created. It is just a modification of the original Clearlooks theme, with tighter spacing. This has been linked quite a lot of time and I get a continuous stream of visitors who are in the need for a compact theme.

1. How to get Enough Sleep Despite StumbleUpon With Ubuntu

This post about me struggling with getting enough sleep despite StumbleUpon was by far the most viewed article on the blog, it has received more than 4 times as much visits as the second best. I guess I hit some nerve with it in the large Linux using StumbleUpon crowd. The article is almost a year old, and I still get lots of visitors each and every day. Happy stumbling!

Thank you everybody for coming to this site and posting your thoughts. I appreciate each and every feedback. Happy christmas and happy new year!

1. Create a file ~/.mplayer/mencoder.conf with default compression settings. I use this, with encoding quality settings I have from mplayer’s x264 examples:

   o=out.avi
   ovc=x264=yes
   oac=mp3lame=yes
   
   #lameopts=preset=medium
   lameopts=aq=2:vbr=4
   #lameopts=preset=voice
   
   # the lower crf, the better
   # 20: very good
   # 22: Medium Quality DVD rips
   # 23: quite ok
   # 25: so-so
   # 30: acceptable
   # 40: my eyes hurt
   # 50: my eyes bleed
   x264encopts=threads=auto:crf=20:subq=7:partitions=all:8x8dct:me=umh:frameref=5:bframes=3:b_pyramid:weight_b
   
   # deinterlace
   # vf=yadif
   
   # slight denoise
   # vf=hqdn3d=3:2:3:3
   
   # turbo encoding (low quality!)
   #x264encopts=threads=auto:crf=23:turbo=2:subq=1:frameref=1
   

2. I use constant quality setting. The advantage is that it requires only one pass, and you get, well, constant quality In the config file find the crf=20 section and change it to your desire.
3. Find out which DVD chapter you want to rip, starting with 1 up (e.g. mplayer dvd://1).
4. If the DVD has black borders, find out their sizes with

   mplayer dvd://2 -vf cropdetect

   Fast forward a bit into the movie so that the ratio can be trusted.
   WARNING Some DVDs like Natural Born Killers are shot with multiple different films, so the border changes! Take care not to crop anything important away. Copy the -crop printouts into the clipboard.

5. Open another console window, run mplayer dvd://2 -identify, and quit. Now scroll up, there is some important information about the tracks which you need in the next step. I have extraced the important information here:

   ID_AUDIO_ID=128
   ID_AID_128_LANG=de
   ...
   ID_AUDIO_ID=129
   ID_AID_129_LANG=ja
   ...
   subtitle ( sid ): 0 language: de
   ...
   subtitle ( sid ): 1 language: de
   

   So there is audio language de and ja, and 2 subtitles for de. Mplayer the DVD and press J to find out which subtitles you want to have. (mplayer shows the ID, like (0) de).

6. I have chosen AID 129 and sid 1. In the other window, start ripping the movie:

   mencoder dvd://2 -vf crop=704:432:0:72 -aid 129 -o Yojimbo.avi -vobsubout subs -vobsuboutindex 0 -sid 1

   This will get you 3 files: Yojimbo.avi with Japanese audio and x264 encoded movie video, and subs.idx and subs.sub with the subtitles. Play the movie to check everything works as it should.

7. Rip additional sound tracks now, if you want them. You can rip one additional subtitle at the same time. To do this, increase the vobsuboutindex by one, or choose another filename. I choose to rip the german audio and another subtitle track:

   mencoder dvd://2 -aid 128 -ovc frameno -o de.avi -vobsubout out -vobsuboutindex 0 -sid 1
   

   The -ovc frameno part is important, because this skips video encoding. Encoding is much faster this way because we already have the video anyways.

8. Merge everything together with mmg, this is a GUI interface for mkvmerge which you get via sudo apt-get install mkvtoolnix. Select the correct languages for the audio and subtitle tracks.

I think that’s about it. This way you will get very high quality, multi language rips with subtitles. Oh, some other interesting points to note:

• I always encode with the same resolution as the source, no rescaling. Rescaling is very bad, I much prefer that quality is reduced by the codec and not preemptively through scaling down. Even a HDTV ripped to 700MB gets you a much better quality when not rescaled than a DVD ripped to 700MB. The x264 does an awesome job at preserving quality where it is important.
• I only rip with variable bitrate VBR. It has very good quality, but it is not surround sound.

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!

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

Well, it is a bit difficult to create a step-by-step tutorial, but I will try anyways. Prepare to fiddle around with your configuration and try it out several times until you get the desired results.

1. All your Gnome themes are located under /usr/share/themes. Find the theme of which you want to create a compact one, and copy it into your home directory with e.g.

   cp -r /usr/share/themes/Human ~/.themes/Human-Compact

2. If there is a file index.theme, open it and change all the names (e.g. add “Compact” where appropriate). This file is necessary if you want to directly choose the theme from the Appearance Preferences; if it is not available you have to choose a theme and select “customize” to select the compact controls for it.
3. Now to the fiddling part. Open gtk-2.0/gtkrc, and change lots of thickness and width settings… When you do this, always check how your changes work visibly, e.g. if the application still have usable borders etc. To help with the fiddling, I have added a diff of the Human vs. the Compact theme, you might be able to reuse some of the settings there.
4. Once you are satisfied with your theme, you can create a .tar.bz2 distribution for backup or to be used by others, e.g. with this command:

   cd ~/.themes
   tar cjvf ~/Human-Compact.tar.bz2 Human-Compact

5. That’s it. Have fun with your theme!

Diff between “Human” and “Human Compact”

--- /usr/share/themes/Human/gtk-2.0/gtkrc	2008-07-03 18:13:20.000000000 +0200
+++ .themes/Human Compact/gtk-2.0/gtkrc	2008-05-22 21:11:07.000000000 +0200
@@ -10,29 +10,61 @@

 gtk_color_scheme = "fg_color:#101010\nbg_color:#EFEBE7\nbase_color:#FFF\ntext_color:#000\nselected_bg_color:#FFD799\nselected_fg_color:#000\ntooltip_bg_color:#F5F5B5\ntooltip_fg_color:#000\norange_color:#FF6D0C\nmetacity_frame_color:#CC863E\nextra_view_widgets_color:#F5C07F"

-gtk-icon-sizes = "panel-menu=24,24"
+gtk-icon-sizes = "panel-menu=16,16 : gtk-menu=16,16 : gtk-button=16,16 : gtk-small-toolbar=16,16 : gtk-large-toolbar=16,16 : gtk-dialog=32,32 : gtk-dnd=32,32"

 style "ubuntulooks-default"
 {
-	GtkButton      ::default_border    = { 0, 0, 0, 0 }
+	# base class for everything
+        # setting this to 0 has *very* tight packing. 1-2 looks better.
+	GtkWidget      ::focus_padding        = 0
+
+	GtkButton      ::child-displacement-x = 1
+	GtkButton      ::child-displacement-y = 1
+	GtkButton      ::default-border       = { 0, 0, 0, 0 }
+	GtkButton      ::default-outside-border={ 0, 0, 0, 0 }
+
+	GtkButtonBox   ::child_min_width      = 0
+	GtkButtonBox   ::child_min_heigth     = 0
+	GtkButtonBox   ::child_internal_pad_x = 0
+	GtkButtonBox   ::child_internal_pad_y = 0
+
+	GtkPaned       ::handle_size       = 4
+
 	GtkRange       ::trough_border     = 0
-	GtkPaned       ::handle_size       = 6
-	GtkRange       ::slider_width      = 15
+	GtkRange       ::slider_width      = 14
 	GtkRange       ::stepper_size      = 15
+	GtkRange       ::stepper_spacing   = 0

-	GtkScrollbar   ::min_slider_length = 35
+	GtkScrollbar   ::min_slider_length = 30
+	GtkScrolledWindow::scrollbar_spacing = 0
 	GtkCheckButton ::indicator_size    = 14
 	GtkMenuBar     ::internal-padding  = 0
-	GtkTreeView    ::expander_size     = 14
-	GtkExpander    ::expander_size     = 16
-	GtkScale       ::slider-length     = 31
+
+	GtkMenu        ::horizontal-padding   = 0
+	GtkMenu        ::vertical-padding     = 0
+
+	GtkOptionMenu  ::indicator_size       = 0
+	GtkOptionMenu  ::indicator_spacing    = 0
+
+
+	GtkTreeView    ::expander_size     = 11
+	GtkTreeView    ::expander_spacing  = 0
+	GtkTreeView    ::vertical-separator = 0
+	GtkTreeView    ::horizontal-separator = 0
+
+	GtkExpander    ::expander_size     = 11
+	GtkExpander    ::expander_spacing  = 0
+	GtkScale       ::slider-length     = 23
+	GtkScale       ::value_spacing     = 0
+
+	GtkToolbar     ::internal-padding  = 0
+	GtkToolbar     ::space-size        = 10
+
 	# GtkToolbar     ::button-relief     = GTK_RELIEF_NORMAL
 	# GtkMenuBar     ::shadow-type       = GTK_SHADOW_OUT
 	# GtkScrollbar   ::has-secondary-forward-stepper = 1
 	# GtkScrollbar   ::has-secondary-backward-stepper = 1

-	GtkButton      ::child-displacement-x = 0
-	GtkButton      ::child-displacement-y = 0

 	xthickness = 1
 	ythickness = 1
@@ -92,8 +124,8 @@

 style "ubuntulooks-wide" = "ubuntulooks-default"
 {
-	xthickness = 2
-	ythickness = 2
+	xthickness = 0
+	ythickness = 0
 }

 style "ubuntulooks-wide-orange" = "ubuntulooks-wide"
@@ -104,7 +136,7 @@
 style "ubuntulooks-wider" = "ubuntulooks-default"
 {
 	xthickness = 3
-	ythickness = 3
+	ythickness = 2
 }

 style "ubuntulooks-wider-orange" = "ubuntulooks-wider"
@@ -114,12 +146,18 @@

 style "ubuntulooks-button" = "ubuntulooks-wider-orange"
 {
+	xthickness   = 0
+	ythickness   = 0
+
 	bg[PRELIGHT] = shade (1.02, @bg_color)
 	bg[ACTIVE]   = shade (0.90, @bg_color)
 }

 style "ubuntulooks-notebook" = "ubuntulooks-wide-orange"
 {
+	xthickness = 0
+	ythickness = 0
+
 	bg[NORMAL]      = shade (0.99, @bg_color)
 	bg[ACTIVE]      = shade (0.85, @bg_color)
 	bg[INSENSITIVE] = shade (0.99, @bg_color)
@@ -127,14 +165,14 @@

 style "ubuntulooks-tasklist" = "ubuntulooks-default"
 {
-	xthickness = 5
-	ythickness = 3
+	xthickness = 0
+	ythickness = 0
 }

 style "ubuntulooks-menu" = "ubuntulooks-default"
 {
-	xthickness = 2
-	ythickness = 1
+	xthickness = 0
+	ythickness = 0
 	bg[NORMAL] = shade (1.04, @bg_color)
 }

@@ -145,8 +183,9 @@

 style "ubuntulooks-menu-item" = "ubuntulooks-default"
 {
-	xthickness     = 2
-	ythickness     = 3
+	xthickness     = 1
+	ythickness     = 1
+
 	bg[SELECTED]   = @selected_bg_color
 	fg[PRELIGHT]   = @selected_fg_color
 	text[PRELIGHT] = @text_color
@@ -171,19 +210,26 @@

 style "ubuntulooks-progressbar" = "ubuntulooks-wide-orange"
 {
-	xthickness    = 2
-	ythickness    = 2
+	xthickness    = 0
+	ythickness    = 0
 	fg[PRELIGHT]  = @base_color
 }

 style "ubuntulooks-treeview" = "ubuntulooks-wide-orange"
 {
-	xthickness    = 2
-	ythickness    = 2
+	xthickness    = 0
+	ythickness    = 0
 	fg[NORMAL]  = @text_color
 	fg[SELECTED]  = @base_color
 }

+# style are overriden again.
+style "ubuntulooks-treeview-header" = "ubuntulooks-default"
+{
+	xthickness = 0
+	ythickness = 0
+}
+
 style "ubuntulooks-combo" = "ubuntulooks-button"
 {
 }

Any questions, comments?

I followed the excellent LVM Tutorial, and was surprised how easy everything goes. Here is a short cheat sheet of the important commands (take care to exchange the partition/volume names if you use this):

Installation

I use Ubuntu, so this is a piece of cake:

sudo apt-get install lvm2

There is also a GUI available, but I found the command line tools are very easy to use so there is no real need. I wouldn’t use EVMS as it is not supported in Ubuntu 7.10 and may cause problems.

Create a New Filesystem

First I create the physical volume on the partition sdg1, create a new volume group ext_vg that contains this physical volume, and create a new logical volume of size 450GB within the volume group. Finally create the filesystem (disabled reservation space, see Get More Space Out of Your ext3 Partition).

sudo pvcreate /dev/sdg1
sudo vgcreate ext_vg /dev/sdg1
sudo lvcreate -L 450G -n ext ext_vg
sudo mkfs.ext3 -m 0 /dev/ext_vg/ext

Show Status

Each LVM layer has its corresponding command to get information about the metadata:

sudo pvdisplay
sudo vgdisplay
sudo lvdisplay
sudo pvs
sudo vgs
sudo lvs

Mount via fstab

I use the filesystem mainly for data, so allowing just rw is enough (no executables allowed). noatime allows quicker access.

sudo mkdir /media/mega
/dev/ext_vg/ext /media/mega     ext3    rw,noatime,user 0       2
mount /media/mega

Resize

It is even possible to do an online resize of the system, wohoo This extends the logical volume by 200MB.

sudo lvextend -L +200 /dev/ext_vg/ext
sudo resize2fs -p /dev/ext_vg/ext

You can watch the resize process going on with df -h.

Add Another Partition to the Logical Volume

To add another partition and use up all the available space in the logical volume, first add the physical volume to the volume group, then use pvdisplay to find out the total available number of free PE (add the numbers from the physical volumes), then use lvextend to use up all this available space.

sudo pvcreate /dev/sdb1
sudo vgextend ext_vg /dev/sdb1
sudo pvdisplay
sudo lvextend -l +63602 /dev/ext_vg/ext
sudo resize2fs /dev/ext_vg/ext

That’s it! Any questions? please post.

I am a long-term StumbleUpon user, which means that I don’t get much sleep. Now, after almost 4 years of stumbling, I have decided to get my life back. Well, at least some sleep!

What does this do?

Every night when I have to work on the next day (Sunday night to Thursday night ), at 23:25 my computer shows me this little warning message:

I use this little trick with Ubuntu, but it should work anywhere where Gnome is installed.

How?

Thanks to the power of Linux, this is not difficult to do for yourself, and configure it however you want it to behave:

1. Open /etc/crontab with your favourite text editor (no need for crontab -e since this is the system wide crontab), e.g.

   sudo gedit /etc/crontab

2. Add the following lines (replace manker with your username!)

   25 23 * * 0-4   manker  /usr/bin/zenity --display :0 --warning --text="Shutdown in 5 minutes. Go to bed."
   25 23 * * 0-4   root    shutdown -h +5

3. The first part of both lines 25 23 * * 0-4 means that the commands are executed at 23:25, but only Sunday (day 0) to Thursday (day 4). Read man 5 crontab for a detailed description of that format.
4. The first command uses zenity to show a warning message. You have to execute this as the same user that you use for working, or you will not see the message, so change manker to your username (root does not work either).
5. The second command shutdown -h +5 means that the computer will halt in 5 minutes. This has to be run as root, and it also shows nice warning messages in all your open terminals so you can’t really miss it.
6. Save the file, and stumble until it is 23:25.

Sweet dreams!

Markus Holzmann, an intern at Profactor of my fellow colleague Philipp Hartl, had the opportunity to experiment with Ajax during his job. He wrote a tutorial about how to push events from the server to the client. For example, display popup messages on all browsers at the same time (see screencast in full resolution here):

Cometd Hello World

I’ve read Chris Bucchere’s Say Hello World to Comet and built an application based on this using a more current version of Jetty (version 6.1.5) which I embedded into a Tomcat v5.5 Server. For the developing I used Eclipse 3.2.

Start your Engines

At first you have to get the server running. As I mentioned I embedded Jetty into a Tomcat server. Therefore you have configure the libraries:

1. Add the packages org.mortbay.cometd and dojox.cometd to your source folder and delete the client package in the org.mortbay.cometd package.
2. Add jetty-util-6.1.5.jar, jetty-6.1.5.jar and servlet-api-2.5-6.1.5.jar to your build path.
3. Copy the jetty-util-6.1.5.jar file into the /lib folder in the WEB-INF directory.

Replace the existing servlets in your web.xml – file in the WEB-INF – folder with the following servlets:

<servlet>
  <servlet-name>cometd</servlet-name>
  <servlet-class>org.mortbay.cometd.continuation.ContinuationCometdServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>cometd</servlet-name>
  <url-pattern>/cometd/*</url-pattern>
 </servlet-mapping>

For the project I used the dojo toolkit (version 0.4.3) which has an integrated COMETd class that makes it easy to build comet projects. Download it and add it to your WebContent folder.

When you’ve done all this, the hardest piece of work for this program is already done.

Hack the Code

Now you can implement the code for the client side: You need a HTML file with a button on it. The code for this looks like this (download):

<html>
  <head>
    <script type="text/javascript" src="../dojo.js"></script>
    <script type="text/javascript">
      dojo.require("dojo.io.cometd");

      cometd.init({}, "cometd");

      cometd.subscribe("/hello/world", false, "publishHandler");

      publishHandler = function(msg) {
        alert(msg.data.test);
      }
    </script>
  </head>
  <body>
    <input type="button"
       onclick="cometd.publish('/hello/world', { test: 'hello world' } )"
       value="Click Me!">
  </body>
</html>

Line by line, the above bold code works like this:

1. In the line

   <script type="text/javascript" src="../dojo.js"></script>

   you integrate the dojo toolkit into the project.

2. To activate the cometd class of dojo:

   dojo.require("dojo.io.cometd");

3. Connect the server with the client:

   cometd.init({}, "cometd");

4. Here we say what to do when there is a subscribe event:

   cometd.subscribe("/hello/world", false, "publishHandler");

5. Last but not least, the publishHandler function serves as the callback function, which uses alert to show a simple message box:

   publishHandler = function(msg) {
     alert(msg.data.test);
   }

Give it a Try

When you load the HTML file now, you can click on the button and an alert box saying hello world will appear:

The reason for this is that when you click the code

cometd.publish('/hello/world', { test: 'hello world' } )

is executed which publishes a text on the channel with the id /hello/world.

The funny thing is that this is able to run on any number of browsers. Everytime when a client clicks the button, on all browsers that view this page the alert box is shown. (See screencast above).

Pushing Data from Server to Client

You can also add serverside code to trigger an event. I wrote a JSP file with the following code:

<%@page import="java.util.*"%>
<%@page import="dojox.cometd.*" %>
<%
Bayeux b = (Bayeux)getServletContext().getAttribute(Bayeux.DOJOX_COMETD_BAYEUX);
Channel c = b.getChannel("/hello/world",false);

Map<String,Object> message = new HashMap<String,Object>();
message.put("test", "jsp: hello world");

c.publish(b.newClient("server_user",null),message, "new server message");
%>

When this page is loaded, an alert popup appears at the page saying jsp: hello world.

That’s it. Happy hacking!