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!

Thats why I have created The Online Password Encrypter. Here users can enter their desired username and password, and the encrypted key is automatically generated online, without transmitting anything to any server.

Here is an iframe of the file. Click here for full screen.

The Online Password Encrypter is just one single HTML page, it does not depend on any other files. So it is easy to download it, modify and send it around. Feel free do whatever you want with it.

Have fun,
Martin

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

Sourcecode

I use floating point tricks based on my pow() approximation. Basically I just took the pow() formula and for a^b I substitued b with 0.5, then simplified this as much as possible. As it turns out the result is very simple and short. This initial approximation can be easily made more precise with Newton’s method:

    public static double sqrt(final double a) {
        final long x = Double.doubleToLongBits(a) >> 32;
        double y = Double.longBitsToDouble((x + 1072632448) << 31);

        // repeat the following line for more precision
        //y = (y + a / y) * 0.5;
        return y;
    }

Here is a comparison of the performance and accurancy versus the number of repetitions:

With 2 repetitions, the trouble is not worth the effort, as the approximation is already slower than the original Math.sqrt() which is more precise.

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!

Write a program that generates all two-word anagrams of the string “documenting”. Here’s a word list you might want to use: wordlist.zip.

When you’re done, send the results to selfdocumenting@hotmail.com.

Good luck!

So this caught my interest and i wrote a little entry in Ruby that is 23 lines long with whitespace and very nice to read. But I won’t show you this code until the contest is over, and this is not the reason for this post. The reason is, that the nice version takes about 2 seconds, and somebody else has coded a Python solution that takes only 1 second (I have no idea what his code looks like). This post is about a fast anagram finding algorithm, and how I developed this algorithm. The final result takes about 0.11 seconds.

Algorithm

The most basic algorithm has two phases:

1. Read in the file
2. Build all combinations of two words and compare the letter count with the query.

Building the combinations is usually done with two nested loops and takes O(n^2) runtime. This is slow, so I have added another step in between:

Idea #1: Filter out Candidate Words

The second step is really slow, but it would be a lot faster if it has to handle less words. So I wrote a little filtering step that lets only words through which are made out of the same letters as the query word.

For example when the query is documenting, the word men or go and even too are extracted, even if the number of letters might not match. But that’s not important, what is important is that the number of possible words are reduced a lot, and so the next phase is faster.

Idea #2: Use a Commutative Hashing Function

String comparisons are slow. To common way to find out if the strings coming with tuned is an anagram of the word documenting is to sort the letters and make a comparison, like this:

irb(main):003:0> "documenting".unpack("c*").sort.pack("c*")
=> "cdegimnnotu"
irb(main):004:0> ("coming" + "tuned").unpack("c*").sort.pack("c*")
=> "cdegimnnotu"

The strings are equal, so we have a match. But this comparison is terribly slow! What’s worse, the computations have to be redone for each match. It would be much better to just compare hash values, and find a hash function to quickly check if we might have a match, and only do the string comparison when the hash check matches. The hash has to be good enough that we don’t have too much false positives (hashes are equal but the real comparisons not) to get a speed advantage. So why not just sum up all the letters bytes?

irb(main):005:0> "documenting".sum
=> 1181
irb(main):006:0> "coming".sum + "tuned".sum
=> 1181

Ruby’s String#sum does exactly this. we can now precalculate the sum for each word, and to find a match we just add the two hashes and compare the result to the query’s hash:

irb(main):007:0> query="documenting"; first="coming"; second="tuned"
=> "tuned"
irb(main):008:0> first.sum + second.sum == query.sum
=> true

When this very quick check returns true, we have to do the string comparison to be absolutely sure it is a match. This considerably speeds up the whole program, but it is still O(n^2).

Idea #3: Reformulate Problem

Now here comes the trickiest and coolest part. Since Idea #2 the slowest part is matching the numbers, with still quadratic complexity. But the hard task is not anagram finding any more, we have reduced it to finding two hashes that combined have the same hash as the query. We can reformulate this problem into something completely detached from the anagram problem:

Given a list of numbers, find all combination of two numbers that add up to a given number

When we concentrate on just this problem and ignore the rest, we might come up with a better way of doing things.

I came up with a fast solution, described below. Somebody posted a better solution that is both faster and simpler, if you want just this final solution skip ahead to Idea #4 as the following description is outdated.

It clearly looks stupid to just try all combinations to add the numbers.
So lets sort them first. Quicksort is fast, especially with numbers, so no worries here. Now consider a list of numbers like this example:

1   3   7   10   10   12   17   20   22   23   24   24   25   26   30

Find all the combinations of two number that add up to 27. They are

• 1 + 26 = 27
• 3 + 24 = 27
• 7 + 20 = 27
• 10 + 17 = 27
• 10 + 17 = 27 (a second time)

You can detect a pattern here: the first number always increases, the second number always decreases! We can now formulate an algorithm for this:

We can have two pointers to the array, one starting from the left side, the other starting from the right side. When the numbers behind the pointers add up to a bigger result than the query (e.g. 1 + 30 = 31), we decrease the right pointer to find a smaller combination (1 + 26 = 27). When the sums are too small (1 + 25 = 26), we move the left pointer to the right (3 + 25 = 28).

This way we walk through the whole array in O(n) time and the sum of the pointers is always kept as close the the desired result as possible. When the pointers meet each other, we can stop the whole process or otherwise we would just reverse the words.

This algorithm gets a bit more complicated when you consider that we might have lots of numbers in it that are equal, whenever this happens you have to fall back into an O(n^2) matching algorithm for just this section.

Idea #4: Use Hash directly

UPDATE Scrap the implementation in idea #3. A blog post here from a reader of this article posted a way to do this really in O(n), without any sorting which is O(n*log(n)). The idea is to use a hashmap that maps from the hash key of the word to its matches:

M = {}
S = the target sum
for each element e in the list
      if M[S-e] exists? (e,S-e) is a pair
      add e to the M

Just use a Hashmap that maps from the cummulative hash of a word to a list of words that have the same hash. Whenever a new word is added, get the list of words that is stored under query.sum - current_word.sum. When the hashes are the same we just have to create a list of all the matches under this key, and check each of the matches sequentially for equality. This is just normal hash collision handling through a linked list. That’s very simple and works like a charm.

I have revised the code, it got both simpler and faster. That’s a win-win situation, wohoo!

The Sourcecode

I hope the code is understandable now with the above explanation. If you have any questions or ideas, please share them here!

#!/usr/bin/ruby

# created by Martin Ankerl http://martin.ankerl.com/

class String
	# creates an array of characters
	def letters
		unpack("c*")
	end
end

class Array
	# converts an array of letters back into a String
	def word
		pack("c*")
	end
end

query = "documenting"
query_letters_sorted = query.letters.sort
txt = File.read('wordlist.txt').downcase

# to quickly check if a letter is part of the query word
used_letters = Array.new(256, nil)
query_letters_sorted.each do |letter|
	used_letters[letter] = true
end

# Maps from cummulative hash of a word to a list of words that have this hash code.
hashToWords = Hash.new do |hash, key|
	hash[key] = Array.new
end

query_hash = query.sum

prev = 0
txt_size = txt.size
separator = 10
idx = txt.index(separator, prev)
while prev < txt_size

	letter_idx = prev

	# no need to check end of word because it is \n
	# which is not part of the word anyways
	while used_letters[txt[letter_idx]]
		letter_idx += 1
	end

	# ignore word if the above quick check fails
	if letter_idx == idx
		word = txt[prev, idx-prev]

		# check all key matches
		key = word.sum
		hashToWords[query_hash - key].each do |other_word|
			if (word.letters + other_word.letters).sort == query_letters_sorted
				puts "#{word} #{other_word}"
				puts "#{other_word} #{word}"
			end
		end

		# insert word
		hashToWords[key] << word
	end

	prev = idx + 1

	# no need to check end of file because we have to end with new line
	idx = txt.index(separator, prev)
end

When you rewrite the algorithm in C++ or Java or Python I am sure it will be faster than this one. But this is not the point of this post. The point is, “The Best Optimizer is between Your Ears” (Michael Abrash, Graphics Programming Black Book).

Have fun!

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!

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.

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

Comparison

Move your mouse over the image to see how the dialog looks like with clearlooks-compact. The buttons and spacing are smaller, which results in much more visible space for the actual content.

More Screenshots

Here are some more screenshots that I have taken with Clearlooks Compact enabled. Especially the Eclipse shot is great, there the theme really shines. It is even more compact than the Windows XP look.

If you are curious, I have used Tahoma, size 9 for the application font, and the MiscFixed for the sourcecode.

Download & Installation

Installation is extremely simple, in Ubuntu 7.10 (Gutsy Gibbon) you can do it this way:

1. Click System > Preferences > Appearance.
2. Drag & drop the link ClearlooksCompact-1.5.tar.bz2 into the Appearence window.

Beware that this is just definition of the Clearlooks control spacings. That means you have to have the clearlooks engine installed (which you most likely have, it is the default theme of Ubuntu). To change back, click on the currently active Theme, choose “Customize”, and select other controls instead of “Clearlooks Compact”.

History

I will regularly update this page when I update the theme with a new screenshot and the development history:

April 9th, 2009

Version 1.5: a bit smaller checkbox + selection box, less blurry and smaller progress bar.

April 5th, 2009

Version 1.4: added LGPL, index.theme, version number.

April 11th, 2008

Version 1.3: Small panel menu

November 11th, 2007

Version 1.2: Major update: Smaller handlers sizes, smaller scrollbars, no scrollbar spacing, less overall padding, and some more.

November 7th, 2007

Version 1.1: Now even more compact by reducing the default icon size to 16×16 pixels.

November 4th, 2007

Version 1.0: First release of Clearlooks Compact.