Fancy New Keyboard

So, after years of tweaking my keyboards in software, and even getting Shaggy to model-paint over the key-caps for me on an El Cheapo USB keyboard, I’m finally ordering a mechanical, custom-printed specialty keyboard.

As much of my life as is spent on the keys, it’s about time to make a little investment in a real quality tool, right?

So, here’s the final revised file: (if you click a couple of times you’ll get the full-life-size version)wasd-105-brpocock-space-cadet-redux-final


The key colours underlaying that image are blurry and just for show.

Notably, the key caps on the black arrow keys will be white ink.

The white Super key is the one that brings up the Activities Overview in Gnome and is a modifier key for some desktop-wide things; e.g. Super+N to bring up the Notifications area.

The red keys are all “panic” buttons: Escape, Stop/Pause (Break), Delete left and right, Lock, and System Request.

The green keys are Return and Enter.

The grey keys are navigation or action keys.

The orange keys are media controls.

The blue keys are all “shift” (modifier) keys.

The typewriter is light beige; it’s laid out in a modified Dvorak style, which saves on finger travel while typing.

The purple key is Hyper, because it’s all mine.

Compose and AltGr

The keys with four graphics on them, the second (right-hand) set are accessed by AltGr (alternate graphic) and AltGr+Shift. E.G. AltGr+1 → ☠ (skull & cross-bones). The Control and Meta (Alt, Option) keys work as you’d expect. The Compose key is a Linux thing; it lets me type “complex” letter-like symbols by typing two other keys after it. EG: Compose, o, c → ©; Compose, -, > makes the → sign; Compose, c, / → ¢. In particular, it does accents for e.g. Spanish: Compose, e, (apostrophe) → é; or old English (Compose d – → đ; Compose t h → þ) or some useful punctuation like “left and right quotes” (Compose ” < & Compose ” >) or not-equal-to (Compose / = → ≠)


The movement keys are laid out in ways that make more sense to me. The main Delete key is on the left, because it deletes to the left; the lesser Delete key is down below Return, on the right, because it deletes to the right. The big key above Return is used for Tab, because it usually moves to the right, and you use it in filling out forms similar to Return.

The other navigation keys: Home and End are beside one another, because they move left and right usually. Insert is down below, because it’s rarely used. The Clear key is where it might be on a calculator. The Prior and Next keys are right where they usually are; they make sense like that.

Hyper key

The purple Hyper key is used for personalization on-the-fly; among other things, I can set up temporary keyboard macros or bookmarks with it. (The other day, I recorded myself correcting a typo in some machine-generated code once, then replayed the same macro 1,000 times while I went to bed.) Its main benefit is that no program is supposed to ever come with a keyboard shortcut of its own that uses Hyper, so Hyper+anything is “guaranteed” to be “all mine” for whatever I want to do with it.

Function Keys row

The function keys are actually set up for real functions that I use; with AltGr, I get the “F1, F2…” keys on the first 12 keys.

The first four are “browsing” functions. Help is pretty obvious, I hope, with the life-preserver symbol. Properties is used to edit things. Back is the same as the browser tool button. History brings up things like bookmarks or history files; e.g. in my editor it brings up the set of files that I’m working-on.

The next four are “programmer” functions. The Build key is usually used to recompile a program or re-export a graphic or document (e.g. “save as PDF”). The Inspect key is used to “look into” an object; I use it a lot in debugging programs, to show me what the current internal state of an object looks like. The Execute key does things like evaluate program code or start a program. The REPL is the Read-Eval-Print-Loop where I interact with the compiler directly.

The last four are “desktop” functions. The Camera key is mostly tied to screenshots and screencasts (taking photos or videos of my screen). The Menu key is the same one that’s usually wasting space down under the right Shift key. The Lock key is used to lock my screen or to “lock down” files and windows in my editor.

The last three are a mixed-bag. The orange keys are media controls; the left one is Play/Pause, or with Control and Meta, it’s also skip-back and skip-ahead. The other one is Mute when pressed alone (because it’s important to be able to shut the computer up quickly, sometimes) and Volume Down/Up with Control and Meta. Finally, I know, only programmers and system admins use System Request; it’s an emergency interrupt to the kernel when pressed with Meta; but I can also use it in debugging desktop applications. (e.g. Meta+System Request+s means for the kernel to make sure all my disc drives are synced up, because I’m about to say “Watch this!” and I don’t want to lose any files.)

Cut and Paste. Since ZXCV aren’t in a row the bottom-left corner of the keyboard, I’ve duplicated the usual cut-and-paste controls also. The shift functions on Back → Undo; History → Paste; Build → Cut, Inspect → Copy, and REPL → Execute. Technically, Shift+Properties = Options, but that’s practically a synonym.

Stop. Usually, the key is Pause, with Control → Break, and with Meta/Alt → System Request, and half the time it’s missing altogether on laptops, but it’s really useful for programmers, at least. Having a big Stop key there lets me abort terminal-mode programs (instead of hitting Control+C) and various actions in my editor (instead of hitting Control+G or Control+C twice), and I can shift it to get to the less-likely Pause action to e.g. pause a videogame or freeze a terminal-mode program (instead of the confusing Control+Z).

Punctuation and Symbols

The punctuation is arranged to match an English-speaker who happens to write a lot of Lisp and some other program code.

The unshifted graphics on those keys are the ones I use most often: ‘ , . / ; * + – ( )

The shifted graphics on the punctuation keys are ones I use fairly often: ” < > \ : @ = ~ [ ]

The shifted number keys are the ones I use less often: ! | # $ % _ & ? { }

(Tilde ~ and reverse-slash \ are more common because we use those in program code, and we do use things like # _ { } in program code, but not nearly as much as, say, () )

Some of the AltGr punctuation is there because it’s used often enough, but it made more sense to group it near the main key and isn’t quite as often used: ` (backwards apostrophe) for example, belongs with apostrophe but isn’t used nearly as often as ” (double-quote). Others are just really hard/annoying to type using Compose sequences, like – (dash); it’s Compose — (Compose and three hyphens), or just AltGr+- now.

It’s hard to see on the image, but the AltGr graphics are ☠ skull-and-crossbones; ∈ is-an-element-of; ∋ is-a-set-containing; “ballot X” (the opposite of check-mark); ♪ eighth note (eg, to mark “singing” in dialog); † footnote dagger; ∀ for-all-members-of-set; □ empty box; ƒ function symbol; ∞ infinity; – dash; ✝ Christian cross; ⁂ asterism; because sign; ` reverse apostrophe; √ square root radical; the shifted+AltGr number keys are the planetary signs, in order ☿♀⊕♂♃♄♅♆ – Mercury, Venus/female, Earth, Mars/male, Jupiter, Saturn, Uranus, Neptune; then moon and sun/centre sign; the other punctuation gets ^ caret, ≈ approximately-equal-to, ★ star/correction, ∴ therefore; ¬ not sign, «guilletmots accents», and ✓ check mark.

The swapping of + and = is dual-purposed. Not only do I type + more often, but also when I type Compose sequences, I’m more likely to not have to change shifting. Compose + – → ± vs. Compose = > → ≥ (since =, <, and > are all Shifted keys now). The only “loss” I’ve noticed so far is ≠ (Compose / =) requires hitting Shift for the = but not the /.

Notably, in Lisp, constants are usually named +with-plusses-around-then+ and dynamic variables are usually named *with-stars-called-earmuffs*, so having them unshifted is a big win. And, no, I don’t know what genius named *this-style* as “earmuffs.”

The () and {} swap is for much the same reason. Lisp uses () often (so often, that’s it’s practically the trademark of the language!); and even in languages like C or Perl that use {} and [] a lot, they tend to use () more often. There isn’t any AltGr defined on those keys, mostly out of symbolism 🙂 since those parentheses are practically my “tools of the trade.” However, Hyper+( starts recording a keyboard macro in Emacs, and Hyper+) ends it.

Moving _ up to 6 is a little funky. C and Perl use it a lot, since they don’t allow hyphens in the names of variables or functions, to_break_up_words, but it was a shifted key anyways, and now I can hit it with either hand comfortably, give or take.

? just lost out to \ for popularity by a small margin. Also, /\ being on one key seemed to make more sense.

Almost no-one ever types ^ except in regex patterns, where it’s used to mean “beginning” or “not,” depending on the context. Having it on the same key as the “not” sign seemed appropriate.

No Mode Locks

The CAPS LOCK, Numeric Lock, and Scroll Lock keys are “missing,” because I don’t use them. I never have to remember if they’re on or off to decide what the keyboard is going to do when I hit a key.

The Lights

I have a little utility function that re-uses the keyboard LED’s as indicators for my programs. I tweak it all the time, but at one point, I had one of the lights set up as “you’ve got important eMail,” one as an indicator that blinked “on” longer the busier the computer was (so it barely flickered when the CPU is busy, but barely turned off if it’s fully-loaded), and one I would use as an ad-hoc indicator that some long-running task or other had finished. That let me glance at the keyboard while the monitor is still asleep to tell if there was anything interesting happening.

I’m pondering hooking up one of them to the Notification Tray system in Gnome, so when the screen is locked (or asleep) and I have a Notification waiting, the light will come on.

Using keyboard lights to indicate “Work Complete”

I like the “job done” purpose; if you’re a Linux user, you can add an xset command after the command you’re waiting-on (with a ; semicolon) like this:

run some-slow-command ; xset led named 'Scroll Lock'

Then, to clear it, use -led (minus):

xset -led named 'Scroll Lock'

You can run “xset q” to get a list of possible LED names; they’re called “XKB Indicators” and appear near the top of the report, and while X will list like 10+ of them, you’ll have to experiment to see which one(s) actually light up your keyboard.

If you start a job, and then realize it’s going to take a while and you want it to notify you like this, then you can cheat a little; hit Control+Z to stop (not kill, just stop) the job, and you’ll get a shell response with its job number — usually #1 – in brackets:

[1]+   Stopped             my-slow-program

— then run (replace “1” with the job number in brackets):

fg 1 ; xset led named 'Scroll Lock'

Numeric (“Ten-Key”) Keypad

These keys are always numbers. I almost did away with the top row; maybe someday I’ll order replacement keys without the duplicated digits. Notably, the decimal point key + Shift → comma, to make it easier to type e.g. “5,264.24” or so; the keys around the keypad also have some useful symbols like the proper division sign ÷ and multiplication cross and dot × · as well as things like the ° degree sign, ℵ infinite ordinal, and the macron (¯) used in Latin or Japanese. (It’s way over there not because it has to do with math, but because I very rarely need it, but it’s hard to type “Amō, amās, amāt” without having it on a key, somewhere.)

Fractions. Hard to tell, but the division key also has the special fraction slash ∕ which is a little different than /. For ½, ⅓’s, ¼’s, and ⅛’s I can get the single-char equivalents by Compose 1 2 → ½, Compose 5 8 → ⅝, but for things like ⁹∕₁₆ the only way to type it properly is to use the whole long sequence: ( Compose ^ 9 ∕ Compose _ 1 Compose _ 6 ).

Other Great Keyboards

The Space Cadet

Keyboard fans loved the Space Cadet keyboard. This is one of those classic 1970’s keyboards that people have wired up new control circuits just to be able to use it on modern computers.

The beige and blue keys are an homage to the Space Cadet, as well as (somewhat) the clustering of Shift, Control, and Meta keys. Unix keyboards owe the existence of Meta (Alt), Super, and Hyper keys to the Space Cadet.

You’ll notice the leftwards Delete (RUB OUT) key was to the left of the centre row, like on my keyboard. The Any key replaces the TOP and GREEK keys in the lower-left: the TOP key provided the symbol on the letter keys, like the ∞ sign on the I; the GREEK key gave the Greek equivalent letter, which was printed on the front of the key. The STOP OUTPUT, HOLD OUTPUT, ABORT, and BREAK across the top are all summed up by my one Stop/Pause key; and I almost used the funny thumb and finger signs for the cursor keys before giving in to modern “tradition” and using the usual arrows.

The Space Cadet keyboard

The Space Cadet keyboard

Blast from the Commodore Past

I almost moved Home over to where Stop is, but I really wanted to have an oversized Red Stop key there. On my Commodore 64, the Stop key was where Delete is, sharing space with Shift Lock.

I have not-entirely-un-fond memories of doing something stupid and reaching to the left to smack the STOP key in a panic.

For serious panics, you had to hold STOP and hit the RESTORE key on the right … it’s the analog of hitting CONTROL + RESET on an Apple II, which turned into Control + Open-Apple + Reset on the Apple IIe, which seems to have inspired Control + Alt + DEL on the IBM PC. Last time I checked, Control + Command (Apple) + Power still would put a Macintosh into a panic, and Control + Alt + Backspace is the default (often disabled) key sequence for “kill every program I have running on my desktop and return me to the login screen right now” on Linux systems.

Hitting Stop + System Request is probably going to end up being my keyboard shortcut for “murder my desktop now”. Maybe Meta + Stop + System Request. There’s a reason I put a bomb on that key.

The Commodore 64 didn’t have an Escape key, but its ← key was sometimes used that way. I moved Escape “back down” to where the wasteful `~ key is on a typical keyboard to reproduce that a bit.

You’ll note that * and @ both had their own keys back then (so did £ and Î; and Shift+up-arrow got you ¶), but apostrophe was on the 7 and double-quotes on the 2. The | character on the 2 key is actually used in Lisp for “quoting” symbols whose names have spaces or strange punctuation in them (e.g. if I named a variable |Mary’s little lamb| instead of marys-little-lamb, I have to use the |bars| to “quote” it), so that’s a bit of a throwback reference also. Missing from this keyboard were {}, ~, `, and \, making it difficult to write C-language programs.

Note that the Control (CTRL) key was up where I put Stop, and the C= (Commodore logo) key was used as a shortcut key like Meta or Super. (EG: In the graphical interface, C=+X was Cut, C=+C for Copy, C=+V for Paste)

For a real space-saver, the arrow keys move only down and to the right; to move up and left, you had to hit Shift. I didn’t got that far with my space-saving.

Commodore 64 keyboard layout

Commodore 64 keyboard layout

C on funky keyboards

Machines that weren’t designed with all of the symbols found on the IBM PC keyboard made it difficult to enter programs in the C programming language. In order to enter these marks, instead, you have to type two or three characters in a row. As a result, even today, a C programmer has to be careful about their punctuation, because they occasionally will accidentally type one of these sequences. In the Commodore 64’s case, _ { } | \ ~ were all missing from they keyboard, but ~ isn’t used often in C, and the ← symbol was used interchangeably for _ in separating words, which looks really funky:

eg. C code:

int add_two_figures (int a, int b)
    int c;

    c = a + b;
    printf (" | %d + %d = %d | \n", a, b, c);

    return c;

/* the same C code written by a Commodore user */
int add←two←figures (int a, int b)
    int c;

    c = a + b;
    printf (" ??! %d + %d = %d ??! ??/n", a, b, c);

    return c;
<: [
:> ]
<% {
%> }
%: #
??= #
??/ \
??' ^
??( [
??) ]
??! |
??< {
??> }
??- ~

Your keyboard’s ancestor

OK, I’m assuming you’re looking at something like the “standard” 104- or 105-key layout that IBM foisted upon the world in the 80’s …

IBM PC keyboard

IBM PC keyboard

Thing is, there’s a few keys “out of place” there, aren’t there?

Control used to be on the left, where it maybe made more sense (easier to hit). There was only one Alt key, and Caps Lock was down on the right. The * key for multiplication was doubled up with Print Screen, and Num Lock and Scroll Lock were huge (and both of them modified the same keys, of course; you hit Num Lock to enter numbers, Scroll Lock to scroll the screen, or neither to move the cursor.) There wasn’t even an Enter key on the numeric keypad, the `~ key was up in the middle of things, and Escape was right where it belonged, within easy reach.

It wasn’t as good as the Commodore keyboard for typing human things, but it did have the numeric keyboard (which Commodore added with the 128). It was still a huge improvement over the otherwise-superior Apple II machine, whose craptastic excuse for a keyboard was this:

Apple II

Apple II

See that @ sign on the P key? Guess how you typed it …? SHIFT. Really. There were no lower-case letters, so Shift+P → @ and Shift + N → ^. The ESC key was down a row, the CTRL key was left of A, and the top-right key isn’t Delete, it’s RESET.

“Wait,” you say; “where’s Delete?”

It’s right there, next to the ;+ key. It’s labeled ←.

“And the key after that, labeled →? What could that be?”

It’s undo-delete. Since the delete key didn’t actually delete anything, it just moved the cursor over the letters, and if you hit Return before you were at the end of a line, it would then delete them.

And if you were thinking you might accidentally hit the Power key, don’t worry, it’s just a really awkward light there, not a key.