EDIT: fixed a bug! Results should be good now :) Damn, why did I forget to run the tests :p
Computer keyboards are fucking stupid, especially for programmers.
They fuck everyone too: QWERTY is so we don't jam the machinery. Even dvorak keyboards have staggered keys so the MECHANICAL arms can reach them.
However, as programmers, we use all sorts of symbols not in the ken of mere mortals (like *). And for most, you have to press shift just to get at them.
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
The solution: design a programmer keyboard!
First off, we need some numbers so it can be known which keys are most often pressed. To do this I wrote a key frequency program*. I then used it to find the key frequencies of the source files of a number of different programs, in various languages. These are:
linux - C
adagide - ada
axiom - c#
django - python
ghc - haskell
go - go
irrlicht - c++
limewire - java
phpbb3 - php
prototype and jquery - javascript
rails - ruby
regexkit - objective c
racket - racket
To simplify things, I only considered characters ASCII characters between horizontal tab (ASCII 9) and '~' (ASCII 126). These are usually the ones I type, at least.
My hypothesis is that many symbols are going to be more popular than letters. This would prove a need for these symbols to have their OWN FUCKING KEYS instead of being the hangers on and miscreants of the keyboard world.
Here are the results of my analysis. The character is on the left, the fraction of the whole is on the right. They are presented in descending order of popularity.
' ': 0.12601734868442382
'e': 5.672758827442585e-2
't': 4.506425247731305e-2
'i': 3.6282361484752744e-2
'r': 3.5587647133639044e-2
'\t': 3.52634742130502e-2
'\n': 3.45691915152049e-2
'_': 3.438222642926237e-2
's': 3.201379627014596e-2
'n': 3.0954960014858875e-2
'a': 3.058217872499613e-2
'o': 2.6776405034843204e-2
'c': 2.3632039961301494e-2
'd': 2.329124049378265e-2
'l': 1.9319481645750994e-2
'u': 1.761928496254444e-2
'0': 1.737397825253189e-2
'p': 1.6228575776688497e-2
'f': 1.5556196850182672e-2
',': 1.4572080038859849e-2
'*': 1.3460275453084754e-2
'm': 1.2857509828221805e-2
')': 1.2389877996691128e-2
'(': 1.2383996720909098e-2
';': 1.140731013627353e-2
'h': 1.0710680981789305e-2
'-': 1.0232090684508581e-2
'x': 1.0086694597923173e-2
'g': 9.400323788643899e-3
'b': 8.972889667733516e-3
'E': 8.898045202243342e-3
'=': 8.357994322825149e-3
'v': 7.983041606459754e-3
'S': 7.407318795659219e-3
'T': 7.301129459599258e-3
'R': 7.1601262346295165e-3
'/': 7.1380145327522146e-3
'A': 7.117130673860958e-3
'I': 7.099489478546994e-3
'C': 6.66979575805779e-3
'>': 6.316573098911656e-3
'.': 5.726058267571846e-3
'1': 5.685534184968124e-3
'N': 5.413383379318554e-3
'D': 5.24449377399052e-3
'P': 5.0353985619458206e-3
'L': 5.008180717747133e-3
'O': 5.000104327173332e-3
'k': 4.9537792457673745e-3
'w': 4.742584988103445e-3
'y': 4.725471515230428e-3
'2': 4.638324931590688e-3
'M': 4.5006262229531635e-3
'"': 3.800355652024797e-3
'F': 3.764420517430011e-3
'U': 3.1530152471186336e-3
'{': 3.055959062530431e-3
'}': 3.0551233923309254e-3
'B': 3.0211399095564015e-3
'3': 2.9180155749053346e-3
'G': 2.7770136659516554e-3
'4': 2.5617397584948654e-3
'8': 2.3449629606950287e-3
'#': 2.2478633475767726e-3
'&': 2.2210126718594423e-3
'6': 2.162497333669207e-3
':': 1.9414777000847955e-3
'H': 1.8788563917804559e-3
'q': 1.8209240487057808e-3
'<': 1.6977541573950867e-3
'5': 1.6778586265665519e-3
'V': 1.665461755260506e-3
'\\': 1.5621847627462226e-3
'X': 1.4939677541453535e-3
'[': 1.4782940028443977e-3
']': 1.4776491549739134e-3
'+': 1.4496245929290891e-3
'9': 1.3384093915275372e-3
'7': 1.3184046313658388e-3
'W': 1.2953598741004282e-3
'K': 1.2184137309589008e-3
'z': 1.2113717290099994e-3
'\r': 1.143696919026762e-3
'\'': 1.0093106228178275e-3
'Y': 9.986745810030226e-4
'|': 9.358519222411643e-4
'%': 8.897926760797742e-4
'!': 7.546115061692628e-4
'j': 6.665502913662852e-4
'Q': 4.7705713856824653e-4
'Z': 3.924557299928266e-4
'@': 3.550282331834911e-4
'?': 1.816549611314985e-4
'$': 1.7383124564164268e-4
'J': 1.5937875724642036e-4
'~': 1.2080895849508404e-4
'^': 3.6191757726917574e-5
'`': 3.1301442039734356e-5
'\f': 3.8032864197953453e-7
'\ESC': 5.264064248851689e-9
Total characters: 759869145
You suck \ESC. No one loves you!
Note that the total does not reflect the number of characters I ignored ala the last paragraph.
It's interesting to observe that _ is a rather popular character for programmers indeed! Also it is interesting that * and , are both more popular than m.
By far the most interesting thing to note is that '(' is more popular than ')'. Don't they come in pairs?
The next step is to design a keyboard layout which makes it easy for people to type the more popular characters. I think I will do this by experimentation - how easy it it to type various phrases? Some research is available on the topic, but a lot of things are easy to get, eg:
Most people are right handed.
Your index fingers are stronger than your pinkies.
Hence, you're gonna want the most used keys in the middle-right of the keyboard.
The last step is to actually make the bastarding thing.
I'm not exactly sure on the best way to actually create a keyboard. With enough time, I could design a program which would run on a microcontroller, interface with the keyboard matrix and communicate with the pc over PS/2.
However, that sounds complicated. Perhaps I shall just move the keys around (but how to put enter and tab in the middle?), and see if I can make it work under Xorg and the terminal.
* The program is split into two parts.
frequency.hs:
-- Copyright John Morrice 2010.
-- Distributed under the terms of the GNU General Public License v 3
{-# LANGUAGE BangPatterns #-}
module Main
(freq_test
,file_test
,main) where
-- | GHC haskell key frequency program
import Control.Monad
import qualified Data.ByteString.Lazy.Char8 as Z
import qualified Data.ByteString.Char8 as B
import Data.Array.MArray
import Data.Array.IO
import Data.List
import System.IO
import System.Posix.Process
import System.Environment
import GHC.Int
main :: IO ()
main = do
as <- getArgs
if length as /= 1
then
error "Usage: frequency DIR"
else do
let dir = head as
prgs <- find_prgs dir program_exts
contents <- fmap Z.concat $ mapM strict_read prgs
(freq, total) <- frequency contents
format_frequency freq
putStrLn $ "Total characters: " ++ show total
strict_read :: FilePath -> IO Z.ByteString
strict_read fp = do
contents <- B.readFile fp
return $ Z.fromChunks [contents]
format_frequency :: IOArray Char Double -> IO ()
format_frequency ma = do
as <- getAssocs ma
let sorted = reverse $ sortBy (\(_,fr1) (_,fr2) -> fr1 `compare` fr2) as
mapM_ (\ (ch,fr) -> putStrLn $ (show ch) ++ ": " ++ show fr) sorted
freq_test :: IO Bool
freq_test = do
d <- freq_data >>= getAssocs
roccs <- new_occs
right <- mapArray fromIntegral roccs
writeArray right 'e' 0.5
writeArray right 'd' (3/8)
writeArray right 'a' (1/8)
rightl <- getAssocs right
return $ d == rightl
freq_data :: IO (IOArray Char Double)
freq_data =
fmap fst $ frequency freq_input
freq_input :: Z.ByteString
freq_input = Z.pack "eeeeddda"
file_test :: IO Bool
file_test = do
files <- fmap sort $ find_prgs "test_files" ["c", "rb"]
putStrLn "Found:"
print files
let expected = sort (actual "test_files/")
putStrLn "Expected"
print expected
return $ files == expected
where
actual dir = map (dir ++) ["a.c", "b.c", "c.rb", "d.rb"]
-- | Determine the frequency of characters in a bytestring as a fraction of the whole
frequency :: Z.ByteString -> IO (IOArray Char Double, Int64)
frequency by = do
fr <- occur by >>= mapArray (\o -> fromIntegral o / fromIntegral total)
return (fr, total)
where
total = Z.length by
new_occs :: IO (IOArray Char Int64)
new_occs =
newListArray (min_char, max_char) (repeat 0)
min_char :: Char
min_char = '\9'
max_char :: Char
max_char = '\126'
occur :: Z.ByteString -> IO (IOArray Char Int64)
occur bz = do
occs <- new_occs
zfoldrM increase occs bz
where
increase :: Char -> IOArray Char Int64 -> IO ()
increase ch oc =
if ch >= min_char && ch <= max_char
then do
count <- readArray oc ch
let n = count + 1
n `seq` writeArray oc ch n
else
return ()
zfoldrM :: (Char -> IOArray Char Int64 -> IO ()) -> IOArray Char Int64 -> Z.ByteString -> IO (IOArray Char Int64)
zfoldrM f ar bz =
if Z.null bz
then return ar
else do
f (Z.head bz) ar
zfoldrM f ar (Z.tail bz)
program_exts :: [String]
program_exts =
["bas", -- basic
"java", -- java
"hs", -- haskell
"rb", -- ruby
"py", -- python
"php", -- php
"m", -- objective c
"c", "h", -- c
"cs", -- c#
"js", -- javascript
"ads", "adb", -- ada
"cxx", "cpp", "c++", -- c++
"scm", -- scheme, racket
"pas", -- pascal, delphi
"go" -- go
]
-- | A regular expression which matches files with the given extension
extension_regex :: String -> String
extension_regex = (".+\\." ++)
-- | Find program files in the given directory matching the given extensions
find_prgs :: String -> [String] -> IO [String]
find_prgs dir exts = do
writeFile "result" ""
mapM_ (find_prg dir) exts
fmap lines $ readFile "result"
--- | Find program files in the given directory matching the given extension
find_prg :: String -> String -> IO ()
find_prg dir ext = do
pid <- forkProcess $
executeFile "./finder.sh" False [dir, "-regex", extension_regex ext] Nothing
getProcessStatus True True pid
return ()
-- Source ends with this line
finder.sh
# Source begins with this line
#! /bin/bash
find $* >> result
# Source ends with this line
