The implied conclusion is that we should all switch to Theora, since that is unencumbered with patents. Well guess what — pretty much every algorithm used in modern video compression is patented. And there are only so many ways you can slice and 2D-DCT a macroblock. There is no reason to believe that Theora is somehow designed “around” all those patents. It might very well be impossible to create a video codec that doesn’t infringe on something. This article has a much more realistic approach to the issue at hand.

The game to play is to either abolish the patent system altogether (it has outlived its usefulness), or to make patent claims on algorithms void and unenforceable. Simply avoiding H.264 just because the licensing situation there is sorted out won’t get us anywhere. We’ll end up adopting something else (be it Theora or On2 VPwhatever) and finding out about patent claims years later, once the codec becomes popular.

Other issues aside, I don’t understand why supporting a proprietary Flash plugin from a single vendor is better than opening support for a standardized (albeit similarly patent-encumbered) video format with open-source implementations.

Key takeaway points, so that I can remember them and so that people googling for answers may find them:

• If you’re looking for the PSRLB (parallel shift right logical bytes) SSE instruction, it isn’t there. But there are two ways around it: you can either shift words using PSRLW and then mask out the higher bits, or for shifts with a count of one, use (xmm14 contains 1 in every byte and xmm15 is 0):

   psubusb xmm0, xmm14
   pavgb xmm0, xmm15

• If you need to “horizontally” sum 16 bytes in an XMM register, you will find that the PHADDB instruction doesn’t exist, either. There is PHADDW and you could use that in combination with PMADDUBSW (multiply-add bytes to words), but the resulting sequence of instructions is far from optimal. Fortunately, there is a trick: use PSADBW. This computes the sum of absolute differences, which if you use 0 as the source parameter will correspond to your sum, and stores it in two quadwords, which gets you halfway there. In my case, I simply accumulated the results using two quadwords per register, and combined them at the end.

• There is a nice PMOVMSKB instruction which converts a byte mask to a bit mask. But why, oh why isn’t there an instruction which does the opposite? Extracting a 16-bit mask to a 16-byte register turns out to be painful.

• The last time I programmed in x86 assembly was using a Pentium 4 with the infamous NetBurst architecture. It was an ugly, unpredictable beast, where a mispredicted branch could cost you a fortune in performance terms. It seems that with the newer Nehalem chips Intel really got things right — latencies for most instructions are small and predictable and overall performance is more consistent across the board. There are fewer traps. And unaligned data accesses aren’t penalized as badly as before!

• LOOP is slower than

   sub rcx, 1
   jnz .loop

Go figure.

• Thank God and AMD for FINALLY adding registers. Back in the P4 days it was ridiculous: having a 3GHz processor with only 6 usable general-purpose registers and 8 SIMD ones sounded like a joke.

And the final observation: just as several years ago, the state of x86 assemblers is a sad, sad affair. To use a construction industry metaphor, an average x86 assembler has the complexity and usefulness of a hammer, while the DSP world is using high-speed mag-rail blast-o-matic nail guns with automatic feeders and superconducting magnets. I mean, seriously, do I really have to manually track register allocations?! Manually reorder instructions and measure performance to see which arrangement is faster (hoping not to break any dependencies)? Manually update stack pointer offsets after pushing something onto the stack? Write prologs and epilogs for C-linkable functions myself?

If anybody is thinking about writing or improving an x86 assembler, take a look at what Texas Instruments provides for their DSPs. See how you can write “linear assembly” and have your compiler schedule VLIW execution units for you. See how you don’t need a piece of paper with a huge table detailing which registers are used in which part of your code.

I find it ridiculous that the most popular computing platform in the world does not have a decent assembler. What’s even worse, from the discussions I’ve seen on the net, people are mostly interested in how fast the assembler is (?!) rather than how much time it saves the programmer.

Anyway, the net result of this encounter is a function that is about 600x faster than the original C implementation. It is about 4x slower than the theoretical limit (calculated assuming only arithmetic ops, no overhead, no memory accesses, and 16 ops per cycle), which I’m very happy with.

x86 assembly, see you in several years!

UPDATE (22.12.2009): I wrote this post hoping that it will help people searching for the non-existing PSRLB instruction — and it worked — I can already see it in the logs!

Folder Actions now attempts to delay calling “files added” actions on files until they are done being copied. Previous versions called “files added” actions on new files as soon as they appeared in the file system. This was a problem for files that were being copied into place: if the file was sufficiently large or coming over a slow server link, the file might appear several seconds before it was done being copied, and running the folder action before it finished copying would behave badly. Folder Actions now watches if the file is changing size: if it stays the same size for more than three seconds, it is deemed “done”, and the action is called.

My experience with folder actions was that they are one big race condition waiting to bite you. It’s something all the tutorials conveniently glossed over. I kept wondering why Apple kept them if they are so obviously unreliable.

Hopefully that change, while far from correct, will make them usable.

Because, with Adobe apps, everything from installation through activation through re-activation through software updates through more re-re-reactivations through (HEY! more updates!) is like a giant rectal exam. That I paid for.

Couldn’t have phrased it better myself.

This is to explain why I will “steal” music using BitTorrent, eDonkey and any other easily available means.

I will not do it because I want to save money or because I’m cheap. Far from it. My 600-or-so CD collection packaged into boxes and stored in my basement should attest to it.

I’ve been trying to pay for music online. I really have. I wanted to use the iTunes store, but it doesn’t sell music or movies in my country. I tried to register as a US customer, but a US-based credit card is required to do that.

I managed to buy several albums from Amazon MP3 right when it opened, before it told me my money was not welcome (“Please note that AmazonMP3.com is currently only available to US customers”). Hulu told me its video library can only be streamed from within the United States.

I own a Sonos system, so I tried to get a Rhapsody subscription. But they didn’t want my money (“The Rhapsody MP3 Store is currently only available inside the United States”). Pandora didn’t want me either (“We are deeply, deeply sorry to say that due to licensing constraints, we can no longer allow access to Pandora for listeners located outside of the U.S.”).

Spotify was a glimmer of hope (it isn’t in the US!), until it told me that “Unfortunately, due to licensing restrictions we are not yet available in your country.”

So, in spite of my best efforts over the past several years, I have been unable to pay for music online. And frankly, I’m tired of trying. What difference does it make which country I’m in? Is my credit card any different from any other one? Are my dollars/euros of lesser value?

You have been playing your silly regional games and you think you can keep playing them forever. Make these people wait. Release the album here, see if it gets traction, then price it higher there. Regionalize DVDs to control releases and pricing. Well, the game is over.

From now on, I will have no qualms about downloading digital music. I will continue to buy from sources that want my money (Magnatune, artists like Ronald Jenkees). For everything else, I will just download it. It only takes a couple of minutes anyway.

So, next time you wonder about why your sales and profits are declining, remember — it’s because you didn’t want my money. And perhaps instead of complaining about P2P, hiring hordes of lawyers or buying expensive ad campaigns it is easier to simply start SELLING your stuff to people who want to pay for it.

Since I used all major GTD apps on the Mac extensively (e.g. I moved my entire life into each of them in turn), I think I’m qualified to form an opinion.

There are three major contenders in the Mac OS native application GTD arena:
* OmniFocus
* Things
* The Hit List

There used to be iGTD as well — but it has been discontinued now that its developer joined Cultured Code and works on Things. I used iGTD a long time ago, but found it too heavy on features and too crash-prone.

I should also probably mention TaskPaper, which while cool, isn’t really a full-blown GTD app.

Let’s go through each of the three in turn.

OmniFocus (The Omni Group) is the most mature of the apps. It was clearly developed with lots of user feedback. It is quite complex, with lots of user interface. However, I found that I’m spending lots of time on the mechanics of managing tasks instead of actually doing stuff. There is lots of clicking, tabbing and cursoring around to be had in OmniFocus. Plus there is that ubuquitous Omni inspector thing, which some people love and some people hate. I fall in the second category. I don’t like multiple window apps.

Things is carefully designed to look nice, which scores it a lot of marketing points. It also seems simple to use. I jumped onto it with enthusiasm, also buying the Things Touch iPhone app. But after several weeks problems became apparent. First, Things forces a structure upon you and that structure isn’t very well designed. There are projects, areas and „focuses”, which don’t really complement each other. In theory, Projects are for ordered, sequential lists of tasks, Areas for single-shot tasks and Focuses cut across them, letting you see which tasks you have to do immediately and which can wait. But if this is so, why can’t I schedule a task in a project to be done in the future?

The biggest problem with Things might seem inconsequential unless you realize this happens dozens of times a day. Let’s say I have a task in my Inbox. I know it belongs to a project and I need to start it today. I can either drag it to a project or drag it to „Today”, but in either case the task will disappear from my Inbox. I then have to hunt it down again, searching for it. This is a complete showstopper problem.

Until very recently Things also had no keyboard support at all — even the tabbing order seemed wrong. This has been improved in recent versions, but it is clear the developers never use the app without a mouse.

Things Touch was nice until I filled it with tasks. Then it became so slow that it was virtually useless. Unreliable syncing didn’t help either.

I then tried The Hit List — and after an hour moved my life into it and never looked back. It isn’t perfect, but it gets most things right. Here’s what I really like about the app, all of this is in contrast to the others:
* In the Inbox, you can drag things to „Today” and they still remain in the Inbox, which lets you then assign them to projects,
* There are lists and folders. You can use these lists as projects, areas, shopping lists, anything you want. No artificial distinction into „Areas” and „Projects”.
* Smart Folders let you organize tasks your own way (I have a „Stale tasks” smart folder that picks up untouched stale things for review).
* Insanely great keyboard support. Navigate to a task, press „F”, and then type several letters from any of your project names, press enter and your task gets moved. Similarly for jumping to projects, use „G” and type any subsequence of characters of your project’s name. I wish all apps had this nailed down so well.
* Great interface for repeating tasks. Press „Cmd-R” on a task, type „every week” and the task becomes a repeating one.
* Tabs that let you keep frequently used views easily accessible.
* Auto-suggested tags that really work (surprisingly).

Overall feeling after several weeks of usage was that I was on top of things. I could manage my tasks easily without spending too much time on the mechanics of it.

The Hit List seems to contain everything I wanted from OmniFocus, but with a much better interface. I just hope the author will keep improving it very carefully, without implementing every feature people ask for. In GTD apps, streamlined interface and usability are more important than features!

Roughly quoting Merlin Mann (43Folders.com): „asking which GTD app is better is like asking if mustard is better than ketchup”. Those are subjective choices, hence my subjective review.

First of all, I am amazed at how readable and concise the code turns out to be. As an example, take a look at this function:

(defn choose-reproducing-parents [individuals]
  (take 2 
    (sort-by :fitness > 
      (select-randomly 5 individuals))))

It doesn’t get more readable than this!

But the real joy came when I started to parallelize my code. Normally, the process would involve extra libraries, lots of fussing around with locks, and hours spent debugging deadlocks. So let’s look at an example function I needed to parallelize. Generating random code takes quite a bit of CPU time, especially if one needs to generate code for thousands of individuals. There is a function for that:

(defn create-random-individuals [number code-generator]
  (map create-individual-from-code (take number (repeatedly code-generator))))

And here’s the reworked parallel version:

(defn create-random-individuals [number code-generator]
  (pmap create-individual-from-code (take number (repeatedly code-generator))))

Can you spot the difference? Yes, that’s it. The little letter ‘p’ is all it takes for the work to be spread among all of my CPU cores.

Other functions required more work (again, notice how concise and readable the code is):

(defn produce-offspring [population number]
  (take number
	(repeatedly #(reproduce
		      (choose-reproducing-parents population)))))

For those unfamiliar with Clojure, repeatedly produces a lazy sequence whose elements are produced by the function (in this case an anonymous function) supplied as the argument. take simply takes the first number elements of a sequence.

And now for the parallel version:

(defn produce-offspring [population number]
  (pmap reproduce
	(take number
	      (repeatedly #(choose-reproducing-parents population)))))

Encouraged by this, I then moved on to parallelize the most time-consuming step of all GP programs: fitness evaluations. I’ll spare you the boring details of extended parallelization work I did on the function (but see examples above). The result was:

(defn test-generation [population fitness-function]
  (pmap #(set-fitness % (fitness-function %)) population))

After fitness was evaluated for all individuals, the next generation was produced and the fitness evaluations were run in parallel again.

This worked fine, but I thought there should be a better way. pmap limits me to a single multicore machine. This is fine for now, but in the future I plan to move to a distributed cluster, where the synchronous nature of map would be limiting. So I tried to write an asynchronous implementation.

First, I defined my pool: a collection where individuals are gathered once their fitness is evaluated:

(def pool (agent (vector)))

The pool is a Clojure agent. Agents are a synchronization primitive: you can send them actions (functions), which will be queued and executed in order.

As you can see, the pool initially starts as an empty vector. So how do individuals get to the pool? Their fitness needs to be evaluated, and then they need to be added to the pool. It all starts with this function:

(defn run-individuals [individuals]
  (dorun
   (map #(send % test-individual *fitness-function*)
	(map #(add-watcher (agent %) :send pool fitness-tested) individuals))))

First, we make each individual an agent, so that we can add a watcher to it. Watchers are a cool Clojure feature — they let you watch for state changes. Using add-watcher we add a watcher to each individual, telling it to send a fitness-tested action to the pool (which is also an agent, remember?). Then, once we’ve set up watching for state changes, we send a test-individual action to each individual, giving it the fitness function as a parameter. test-individual is a really simple function, all it does is call the fitness evaluation function and return the new state of the individual.

The dorun is necessary, because we’re dealing with lazy sequences and discarding the result (sending agent actions is a side effect). If the dorun wasn’t there, the entire sequence would never get evaluated and actions would never get sent.

Let’s see what happens once the pool is notified of a state change in an individual:

(defn fitness-tested [watched-population individual]
  (let [population (conj watched-population @individual)]
    (if (>= (count population) target-population-size)
      (let [new-population (prune-population population)]
	(run-individuals
	 (produce-offspring new-population
			    (- target-population-size (count new-population))))
	new-population)
      population)))

First, we add the new individual to the pool. If we haven’t gathered enough individuals, we simply return the pool with the individual added — this updates the global pool.

The fun part begins when we have enough individuals to produce the next generation. Then, we prune the population, deleting the poorest individuals and produce a new batch of individuals, letting them go using the previously described run-individuals.

If you’ve done any parallel programming, you’ll probably worry about multiple threads modifying (pruning) the population simultaneously. Not to worry — Clojure agents are monitors, you are guaranteed that only one action will execute at a time.

We now have a fully asynchronous parallel GP implementation. Notice how there aren’t any queues, locks, thread pools to manage. All we have is a single global variable and a couple of simple functions. We don’t need any new data structures! The beauty of this solution is that because we’re using agents and watchers, Clojure does the queueing for us. Look, ma, no queues!

I am very happy with how easy and clean this solution turned out to be. I can now see why people keep raving about Clojure. Somebody finally did some serious thinking and implemented a new approach to parallel programming, not just a rehash of old ideas.

In less than an hour I went from a sequential implementation to a parallel asynchronous one. I’d say that’s impressive. And most importantly, the same code still runs on a single-cpu machine, with minimal performance impact. I am very impressed.

First, something which came to me as a surprise: the single biggest performance jump I got with my application was achieved by switching from Java 5 to Java 6 (64-bit, Mac OS X). The jump was huge — from interpreting around 850,000 instructions per second right up to 1,300,000 instr/s. That’s a nearly 60% improvement that required ZERO work on my part. Two clicks in Java Preferences.

Invoking a function is expensive. I am back to old Common Lisp techniques of using macros instead of functions in many places.

Watch out for var lookups (yes, I mentioned this before, but this is important).

The other things I did were application-specific, so there isn’t much point in describing them here.

And if you’re interested in how the JIT performs, here’s a sample run of the application. As you can see, it takes almost 20 runs until the times stabilize at around 1.5 million interpreted instructions per second. The improvement is dramatic: 276% from the first run to the last one.

Executed 616154 instructions in 1.543867 seconds, instruction rate: 399097.84 inst/s
Executed 616154 instructions in 0.653465 seconds, instruction rate: 942902.9 inst/s
Executed 616154 instructions in 0.522443 seconds, instruction rate: 1179370.8 inst/s
Executed 616154 instructions in 0.492671 seconds, instruction rate: 1250639.9 inst/s
Executed 616154 instructions in 0.482119 seconds, instruction rate: 1278012.2 inst/s
Executed 616154 instructions in 0.424934 seconds, instruction rate: 1449999.2 inst/s
Executed 616154 instructions in 0.424169 seconds, instruction rate: 1452614.4 inst/s
Executed 616154 instructions in 0.416273 seconds, instruction rate: 1480168.1 inst/s
Executed 616154 instructions in 0.420429 seconds, instruction rate: 1465536.4 inst/s
Executed 616154 instructions in 0.421797 seconds, instruction rate: 1460783.2 inst/s
Executed 616154 instructions in 0.421114 seconds, instruction rate: 1463152.5 inst/s
Executed 616154 instructions in 0.4115 seconds, instruction rate: 1497336.5 inst/s
Executed 616154 instructions in 0.410837 seconds, instruction rate: 1499753.0 inst/s
Executed 616154 instructions in 0.411064 seconds, instruction rate: 1498924.8 inst/s
Executed 616154 instructions in 0.410936 seconds, instruction rate: 1499391.6 inst/s
Executed 616154 instructions in 0.410301 seconds, instruction rate: 1501712.1 inst/s
Executed 616154 instructions in 0.410638 seconds, instruction rate: 1500479.8 inst/s
Executed 616154 instructions in 0.408832 seconds, instruction rate: 1507108.0 inst/s
Executed 616154 instructions in 0.410466 seconds, instruction rate: 1501108.5 inst/s
Executed 616154 instructions in 0.410113 seconds, instruction rate: 1502400.5 inst/s
Executed 616154 instructions in 0.409741 seconds, instruction rate: 1503764.5 inst/s

1. You really should know the difference between a seq and a list. If you use any of the seq functions (such as drop or take), your list will no longer have an O(1) count operation. Instead, it will become a LazySeq and count will become O(n). If count is something you call frequently (I do), you will want to avoid this. In my case, my stacks were implemented as lists and count gets called very frequently, so this was a serious and surprising problem. Surprising, because most tutorials skim over the difference, only emphasizing how general seqs are. So if your count performance takes a dive, see if you can replace (drop 2 mylist) with (pop (pop mylist)). The latter will keep the PersistentList structure.
2. I implemented my stacks as both lists and vectors. There was almost no performance difference between the two (lists were actually slightly faster). I found this to be a surprising result, I expected vectors to be faster. I still think vectors might have lower memory requirements, but I don’t know how to check.
3. For vector access, (v n) is faster than (nth v n) which is faster than (get v n). This is not something I expected. I think this will get ironed out in the future, as Clojure matures.
4. Attempts to replace Clojure vectors containing integers with primitive Java int arrays produced no performance gains. In fact, they managed to hurt performance because of some necessary conversions.
5. As expected, there are very few places where type declarations improve performance. But if you have loops that get executed a lot, you might want to check. Always measure, as the results might be unexpected, and remember that less is more.
6. When measuring anything running on top of the JVM, let it run for a while before you draw any conclusions. The Hotspot JIT compiler does really cool things with the code, but it does them after a while. In my case, I run code for at least 10-20 seconds and watch the results. I take them into account only after they stabilize. It is common to see a 2x improvement between the first run and the last one.
7. Accessing vars costs cycles. Clojure has no constants, so many people use *global-parameters*. This is not a good idea in performance-sensitive code. There are two ways around it:
   1. Define macros that expand to constants:
      (defmacro global-parameter [] *global-parameter*)
      and use (global-parameter) in your code.
   2. Enclose your function definitions in let forms, rebinding global constants to lexical variables:
      (let [global-parameter *global-parameter*] (defn my-function [] ...))

As for profiling tools, the old and tried method of actually measuring wall time worked best. I tried the YourKit profiler, but wasn’t impressed, at at $499 it is way overpriced. If they come out with a Clojure edition (drop some features) at $79, I’ll consider. I also tried JVisualVM, but it turned out that it is buggy on a Mac and the profiler doesn’t work. I hope this will be fixed in the future.