Input

/ˈspeɪs kædət ˈkiːbɔːrd/

n. "Baroque MIT Lisp-machine keyboard with enough modifier keys to make EMACS feel physically possible."

The Space-Cadet Keyboard is a now-legendary keyboard designed for MIT Lisp machines that became famous for its extreme number of modifier keys and symbols, directly influencing hacker jargon and the keybinding culture of EMACS. It evolved from the earlier Knight keyboard and was used on Lisp machines from systems like Symbolics and LMI, where dense, symbol-heavy, Lisp-centric editing was the norm.

Key characteristics of the Space-Cadet Keyboard include: seven modifier (“shift”) keys—four “bucky-bit” modifiers (Control, Meta, Super, Hyper) plus three shift-like keys (Shift, Top, Front) arranged for easy chording; keycaps with up to three legends each (e.g., a Latin letter and symbol on the top plus a Greek letter on the front); the ability to type thousands of distinct characters and single-keystroke commands via combinations of these modifiers. This design encouraged users to memorize vast sets of chords, helping shape the dense, modifier-heavy command style associated with EMACS and classic Lisp environments.

Conceptual example of Space-Cadet-style key use:

Example key legends (top/front) and chords:

G key:
  Top: "G" + ↑
  Front: γ (gamma)

L key:
  Top: "L" + ⇄  (two-way arrow)
  Front: λ (lambda)

Sample chords:
  Front + L            → λ
  Front + Shift + L    → Λ
  Top + L              → ⇄
  Control + Meta + λ   → complex editor command
  Control + Meta + Super + Hyper + X → extreme "quadruple-bucky" command

Conceptually, the Space-Cadet Keyboard turns the keyboard into a chorded instrument: one hand plays combinations of modifiers while the other taps symbol-rich keys, yielding an enormous command and character space without leaving home row. This excess of “bucky bits” birthed jokes about needing three or four hands, but also made it possible for Lisp hackers to treat the editor and environment—especially EMACS—as a highly tuned, keyboard-driven interface for code, math, and symbolic manipulation.

/dəˈrɛkt-ˈɪnˌpʊt/

n. “A Microsoft API within DirectX for handling input from keyboards, mice, game controllers, and other devices on Windows systems.”

DirectInput is a component of DirectX that provides low-level access to input devices, enabling developers to capture and process user input efficiently. It is commonly used in games and interactive applications where precise input handling, low latency, and support for multiple simultaneous devices are essential.

Key characteristics of DirectInput include:

• Low-Latency Input: Captures device input quickly, minimizing delay between user action and response.
• Multiple Device Support: Handles keyboards, mice, joysticks, gamepads, and other controllers.
• Force Feedback: Provides vibration and haptic feedback for supported devices.
• Integration with DirectX: Works seamlessly with Direct3D, Direct2D, and other multimedia components.
• Device Enumeration: Detects connected devices and allows querying of their capabilities.

Conceptual example of DirectInput usage:

// Capturing game controller input
Initialize DirectInput interface
Enumerate connected controllers
Acquire input from selected device
Read input state each frame
Process input in game logic

Conceptually, DirectInput acts like a translator between the hardware input devices and your application, ensuring fast, accurate, and responsive control in games and interactive software.