I thought I'd do a little analysis of my own comparing keyboard layouts, so I wrote a little program that assigned weightings to each key and penalties for having the same finger typing consecutive letters. Of course, how much to weight these things is subjective, but it seemed like a starting point. So I gave weightings of between 5 and 50 for each key, where 5= good, 50 = bad. Then I had a 60 point penalty for using the same finger twice in a row.

Analysing a bunch of English literature I got these scores:

Qwerty:   84119043 fing: 430274
Dvorak:   74657489 fing: 295600
Colemak: 74334483 fing: 267198

The first number is the overall score, where a low score is good. The second number is the number of times the same finger had to type two consecutive letters. And we see that Colemak is the winner here. But when I put some Java computer code through the program I got this:

Qwerty:   93699673 fing: 795548
Dvorak:   81284609 fing: 588235
Colemak: 83264953 fing: 621636

Now Dvorak is beating Colemak. Now I'm wondering if the reason is something specific to the Java language. So I decided to try some Eiffel source code, since that language is a lot more "wordy" than Java, and has less symbols, and I got this:

Qwerty:  1587789 fing: 12316
Dvorak:  1402223 fing: 11260
Colemak: 1535469 fing: 11444

And still Dvorak wins in both categories. The scores might be partly explained by my giving very slightly worse scores for bottom row keys than top row, and thus dvorak's use of top row punctuation. But Dvorak's winning in the finger jump category is a surprise.

So then I tried some Cobol:
Qwerty:  9440707 fing: 80423
Dvorak:  9085586 fing: 78546
Colemak: 9309487 fing: 78236

Here Dvorak wins on points, but Colemak edges a win in finger jumping.

For completeness I tried  the C language too:
Qwerty:   231977372 fing: 1728116
Dvorak:   196325018 fing: 1458932
Colemak: 218228432 fing: 1498967

Which unsurprisingly gives the same result as Java.

One thing my program doesn't measure is "hand jumping" as defined on the Colemak FAQ. But its not clear to me why hand jumping is particularly bad. Finger jumping is bad, but hand jumping? With MINIMUM on qwerty, the last MUM is obviously bad, but is there anything enormously wrong with the row jumping of MINIM?

It's hard to fully understand why Colemak loses to Dvorak in computer languages, but I can make some guesses.  Firstly the minus key ranks as the 6th most important key compared to 26th in English literature. However, even in English the minus (dash) easily edges out the semi-colon, slash, J, X, Q and Z. This suggests that the minus (dash) deserves a better spot than Qwerty (Colemak) gives it.

Another problem is that the #6 digraph in C programming is "-." (minus period). This is a REALLY bad combo under both Qwerty and Colemak. Under Dvorak it is a very easy combo. And there's quite a few other problematic digraphs involving minus.

The next point is how highly comma and semi-colon rank in Java code, being ahead of twelve regular letters. This suggests to me the better Dvorak positions are going to make a difference.

But also the parethesis ranked very highly in Java code, being ahead of eleven of the letters. Even in English writing the parethesis were ahead of all punctuation except quote, period, dash, semi-colon, slash, exclamation and asterisk. This suggests that maybe parethesis deserve the position traditionally held by square brackets.

>Did you filter repeated characters in your analysis? Strings like ------------- will score much worse
>on Colemak if you didn't.

No I didn't, but the Java code I tested at least doesn't have anything like that.

>Did you give a bigger penalty to the keys in the B/Y QWERTY positions (difficult reach)?

Yes I did. These were my weightings where the top row qwerty TY is 45/45. GH is 20/20  and B is 40. Everything on the numerical row gets 50.

    static final int sctop[] = {45, 35, 30, 25, 30, 45, 45, 30, 25, 30, 35, 40, 45, 50};
    static final int scmid[] = {15, 15,  5, 10, 20, 20, 10,  5, 15, 15, 35, 45 };
    static final int scbot[] = {40, 40, 35, 35, 40, 35, 35, 40, 40, 45 };

>Emacs hotkeys can be remapped, so I don't see the Emacs hotkeys as an issue.

True, but it depends how much time one wants to invest in relearning everything, as you recognize from retaining the qwerty ZXCVB.

>Here's a possible variation of the layout with Dvorakish punctuation

That variant wins in all categories, in both code and literature. In fact it wins by a much greater margin in regular literature than code.

Here's a better variant based on the new Colemak:

`12345 67890[] 
 QWFPG JLUY;/=\
 ARSTD HNEIO'  
 ZXCVB KM,.-

It really depends on what things you use often, and it really doesn't make that much of a difference IMO.
e.g. in this forum BBCode uses a lot of [], MediaWiki also uses lots of [], and I use the / key all the time in Firefox and Vim for searching, and it's used in HTML for closing tags, and all those keys []/ move to worse positions. And in most programming languages the {} are used very often. Since most applications are designed with QWERTY in mind, it makes sense to leave everything in its QWERTY positions. Since the punctuation keys are not used very often they take longer to relearn.
I've left all the punctuation on the right hand so you can use the Ctrl+X/C/V shortcuts with the left hand.

The Q (and/or Z) can be exchanged with the ; (or any of the other punctuation keys) to avoid the ;+Enter combo.
The Arensito layout places all the punctuation keys with AltGr hotkeys, but that's not very comfortable with normal keyboards.

It doesn't seem like a very logical layout.
The Ctrl+Z hotkey can't be used with the mouse on the right hand.
And the 'O' and 'K' cause a somewhat frequent same-finger digraph on the pinky finger, which is best to avoid.
I don't think it makes sense to put the [ in a better position than -

`12345 67890[] 
 ;WFPG JLUYQ/=\
 ARSTD HNEIO'
 ZXCVB KM,.-