Community Hub0 Subscribers
Community hub
Backspace
View on Wikipediafrom Wikipedia
Backspace (← Backspace, ⌫) is the keyboard key that in typewriters originally pushed the carriage one position backwards. In modern computer systems, it typically moves the display cursor one position backwards,[a] deletes the character at that position, and shifts back any text after[b] that position by one character.
Nomenclature
[edit]
Although the term "backspace" is the traditional name of the key which steps the carriage back and/or[c] deletes the previous character, the actual key may be labeled in a variety of ways—for example delete,[1] erase,[d] or with a left pointing arrow.[3] Some very early typewriters labeled this key the backspacer key. A dedicated symbol for "backspace" exists as U+232B ⌫ ERASE TO THE LEFT but its use as a keyboard label is not universal.
Backspace is distinct from the delete key, which in a teletypewriter would punch out all the holes in punched paper tape to strike out a character, and in modern computers deletes text at or following the cursor position. Also, the delete key often works as a generic command to remove an object (such as an image inside a document, or a file in a file manager), while backspace usually does not.[4][5] Full-size Mac keyboards have two keys labeled delete; a key that functions as a backspace key, and a key that functions as a delete key. Smaller Mac keyboards, such as laptop keyboards, have only a key that functions as a backspace key.[6] Full-size PC keyboards have a backspace key (in the main section) and two delete keys (in the extended area).
Combining characters
[edit]With some typewriters,[e] a typist would, for example, type a lowercase letter A with acute accent (á) by typing a lowercase letter A, backspace, and then the acute accent key. This technique (also known as overstrike) is the basis for such spacing modifiers in computer character sets such as the ASCII caret (^, for the circumflex accent). Backspace composition no longer works with typical modern digital displays or typesetting systems.[f] It has to some degree been replaced with the combining diacritical marks mechanism of Unicode, though such characters do not work well with many computer fonts, and precomposed characters continue to be used. (Some software like TeX or Microsoft Windows use the opposite method to apply a diacritical mark, namely typing the accent first, and then the base letter to be accented.)
Use in computing
[edit]Common use
[edit]In modern systems, the backspace key is often mapped to the delete character (12710, 7f16, DEL in ASCII), although the backspace key's function of deleting the character before the cursor remains.[3] In computers, backspace can also delete a preceding newline character, something generally inapplicable to typewriters.
| Esc | F1 | F2 | F3 | F4 | F5 | F6 | F7 | F8 | F9 | F10 | F11 | F12 | PrtScn/ SysRq |
Scroll Lock |
Pause/ Break |
|||||||||
 |
Insert | Home | PgUp | Num Lock |
∕ | ∗ | − | |||||||||||||||||
| Delete | End | PgDn | 7 | 8 | 9 | + | ||||||||||||||||||
| 4 | 5 | 6 | ||||||||||||||||||||||
| ↑ | 1 | 2 | 3 | Enter | ||||||||||||||||||||
| ← | ↓ | → | 0 Ins |
. Del | ||||||||||||||||||||
^H
[edit]Pressing the backspace key on a computer terminal would generate code 0810, the ASCII control code BS (Backspace), which would delete the preceding character. That control code could also be accessed by pressing Control+H, as H is the eighth letter of the Latin alphabet. Terminals which did not have the backspace code mapped to the function of moving the cursor backwards and deleting the preceding character would display the symbols ^H (caret, H) when the backspace key was pressed. Even if a terminal did interpret backspace by deleting the preceding character, the system receiving the text might not. Then, the sender's screen would show a message without the supposedly deleted text, while that text, and the deletion codes, would be visible to the recipient. This sequence is still used humorously for epanorthosis by computer literates, denoting the deletion of a pretended blunder, much like a strikethrough; in this case, however, the ^H symbol is faked by typing a regular '^' followed by typing a regular 'H'. For example:
- Be nice to this fool^H^H^H^Hgentleman; he's visiting from corporate HQ.[7]
Related sequences
[edit]In some contexts, ^W is used as a shortcut to delete the previous word, such as in the Berkeley Unix terminal line discipline. This shortcut has also made it into the insert mode of the Vi text editor and its clone Vim.[8]
Similarly, ^U deletes a line.[9]
Notes
[edit]- ^ The meaning of "backwards" depends on the direction of the text, and could get complicated in text involving several bidirectional categories.
- ^ "after" here implies on the same logical line of text
- ^ in some correcting typewriters it did both<
- ^ for example in One Laptop Per Child[2]
- ^ Many typewriters don't advance the carriage when an accent character is typed, thus no backspace is needed where the accent is typed ahead of the letter it is to be combined with. However, even with such machines, the backspace is still used to produce certain other characters, e.g. for combining "o" with "/" to make "ø".
- ^ There is no reason why a digital display or typesetting system could not be designed to allow backspace composition, a.k.a. overstrike, if an engineer chose to do that. As most contemporary computer display and typesetting systems are raster graphics-based rather than character-based (as of 2012), they make overstrike actually quite easy to implement. However, the use of proportional-width rather than fixed-width (monospaced) fonts makes the practical implementation of overstrike more complicated, and the original physical motivation for the technique is not present in digital computer systems.
References
[edit]
Look up backspace in Wiktionary, the free dictionary.
Wikimedia Commons has media related to Backspace.
- ^ "User Mistakes or Mac Mistakes?, Backspace vs. Delete, and It's Too Easy to Zap an Icon in the Dock". 2007.
- ^ OLPC Wiki. "OLPC Human Interface Guidelines/The Sugar Interface/Input Systems". Archived from the original on 18 January 2008. Retrieved 2008-01-15.
- ^ a b "9.8 Keyboard configuration". Debian Policy Manual. Archived from the original on 2016-03-10. Retrieved 2007-07-24.
- ^ "Windows keyboard shortcuts overview". Microsoft. Retrieved 2016-02-09.
- ^ "Keyboard shortcuts for PCmanFM-QT [bug]/[Missing feature]". GitHub. Retrieved 2016-02-09.
- ^ Pogue, David. "Keyboard Differences". Switching to the Mac: The Missing Manual, Mavericks Edition.
- ^ Chapter 5. Hacker Writing Style, The Jargon File, version 4.4.7
- ^ "VIM USER MANUAL". FreeBSD. November 2, 2013. Retrieved May 14, 2016.
- ^ "FreeBSD Man Pages; vi". Vimonline. March 9, 2002. Retrieved May 14, 2016.
Backspace
View on Grokipediafrom Grokipedia
Origins and History
Typewriter Development
The backspace key originated in the late 19th century as a mechanical feature on typewriters, designed to move the carriage one position backward without imprinting a character, thereby facilitating overtyping for basic corrections. The Densmore No. 4, introduced in 1897, is recognized as the first typewriter to incorporate a backspace key.[8] The Hammond Typewriter Company is credited with introducing one of the earliest backspace options around 1898 on its models, marking a significant advancement in manual editing capabilities.[9] The term "backspace" itself entered usage in 1899, derived from "back" and "space," specifically denoting this typewriter function.[10] Early typewriter models, such as the Remington Standard No. 2 introduced in 1878, lacked a dedicated backspace key, relying instead on manual repositioning of the carriage for any adjustments. Corrections on these machines typically involved physical methods like scraping ink with a knife or using a rubber eraser to remove errors before retyping, a labor-intensive process prone to damaging the paper. Later Remington models incorporated the backspace for precise positioning, allowing typists to overtype mistakes, though this still required manual erasure or opaque covering for clean results. A major improvement in correction techniques came with the invention of correction fluid in 1951 by Bette Nesmith Graham, a Texas-based secretary who formulated "Mistake Out" (later marketed as Liquid Paper) using household ingredients to cover errors without scraping.[11] This innovation became widely adopted, enabling quicker fixes on manual typewriters by painting over incorrect characters before overtyping. The shift to electric typewriters in the mid-20th century enhanced the backspace's utility through motorized mechanisms. The IBM Selectric, launched in 1961, featured a single-element printing head that rotated and tilted for character selection, with backspace enabling smooth carriage reversal.[12] True erasing functionality arrived with the IBM Correcting Selectric II in 1973, which integrated a correction tape to lift ink from the paper upon backspacing and re-striking the erroneous character, eliminating the need for separate fluids or erasers.[12] Throughout the 20th century, such electric innovations allowed for precise, non-destructive character removal, streamlining professional typing workflows. This mechanical foundation influenced the backspace's integration into computing keyboards during the 1960s.Adoption in Early Computing
The adoption of the backspace function in early computing closely mirrored its mechanical role on typewriters, where it repositioned the carriage leftward to enable corrections through overtyping rather than true erasure. Early computer systems in the 1960s, drawing from typewriter layouts, incorporated backspace keys on terminals to facilitate similar editing during data entry and output on punch tapes and printers. For instance, the IBM 1050 Data Communications System, introduced in 1963, featured a backspace key on its 1052 Printer-Keyboard that moved the print-element carrier one space to the left, allowing operators to correct errors on punched paper tape by switching to a "BKSP" mode for silent repositioning, followed by overprinting with delete codes in normal mode.[13] This adaptation supported offline data preparation for punch cards and tapes, emphasizing precision in batch-oriented environments without immediate deletion capabilities.[13] By 1964, supercomputer terminals began integrating backspace keys in layouts reminiscent of typewriters, as seen on the CDC 6600's keyboard, where the key was positioned to the left of the alphanumeric section alongside the carriage return. In these setups, backspace primarily shifted the cursor or print head left without inherently deleting characters, relying on overstriking for corrections, which aligned with the era's hardware limitations in interactive computing. Teletypewriters, such as the Model 33 used in early ARPANET connections, further entrenched this function by employing backspace codes to enable overstriking on continuous paper rolls, producing effects like bold text or error fixes through repeated character printing at the same position. This was particularly valuable in line printers and early terminals, where backspace (ASCII code 08) allowed typographic enhancements beyond plain text, influencing data transmission protocols in networked systems. As computing shifted toward interactive video terminals in the 1970s, the backspace function evolved within systems like the DEC VT series, starting with the VT52 in 1975, where it transmitted a backspace code to move the cursor left on the screen, supporting real-time editing without physical overstriking. However, early challenges arose from inconsistencies between batch processing environments—where backspace often only repositioned without erasing, as in punch card systems—and emerging interactive terminals that demanded more dynamic deletion. These discrepancies, evident in teletype-based setups versus CRT displays, prompted the formal distinction between backspace (for leftward movement and overstrike) and a separate delete function (for forward erasure) by the mid-1970s, standardizing behaviors in terminals like the VT100 to accommodate both legacy print emulation and screen-based interaction.[14][15]Technical Specifications
Control Characters and Encoding
The backspace control character, denoted as BS, was defined in the American Standard Code for Information Interchange (ASCII) standardized in 1963 as code 08 decimal (0x08 hexadecimal, binary 00001000), serving as a format effector to move the print head one position backward on mechanical printing devices such as teletypes without advancing the paper or deleting content.[16] This functionality originated from teletypewriter requirements, where BS enabled precise carriage control for error correction or formatting on impact printers.[15] Unlike the delete control character (DEL, code 127 decimal or 0x7F hexadecimal), which was designed as a "pad" or filler character—punching all holes on paper tape to render positions unusable without performing any action on receiving devices—BS actively repositions the cursor or print head to facilitate overprinting or erasure when followed by another character.[15] In practice, applications often combine BS with a space or DEL to achieve deletion, but BS itself does not erase; DEL, by contrast, had no printing or movement effect and was primarily a tape utility.[15] In Unicode, backspace is encoded as the control character U+0008Keyboard Implementation
On standard QWERTY keyboards adhering to the ANSI layout, the backspace key is positioned in the top-right of the main alphanumeric section, typically as a 2-unit wide horizontal key directly above the Enter key.[20] In compact layouts, such as those on laptop chiclet keyboards, the backspace key may be reduced in size or functionally merged with the Delete key, often requiring a function (Fn) modifier to toggle between backspace and forward-delete operations.[21] Electrically, the backspace key is implemented through standardized protocols for keyboard communication. In USB Human Interface Device (HID) specifications, it is assigned usage code 0x2A within the Keyboard/Keypad usage page (0x07).[22] For legacy PS/2 interfaces, the make scan code is 0x0E in scan code set 1, with the break code 0x8E.[23] Keyboard controllers, such as the buckling spring capacitive-based unit in the IBM Model M from the 1980s, process key presses via matrix scanning and output these scan codes over the interface, enabling reliable detection by the host system.[24] Hardware variations affect the tactile and durability aspects of the backspace key. Mechanical keyboards employ individual switches like Cherry MX series, which use a stem-and-spring mechanism for precise actuation with a lifespan exceeding 50 million cycles per switch.[25] In contrast, membrane keyboards rely on rubber domes over a conductive membrane for cost-effective implementation, though they offer shorter durability typically around 5-10 million actuations. On mobile devices, the backspace function is rendered as a virtual icon—often a left-pointing arrow—on touch-screen keyboards, integrated into the operating system's input method editor.[26] Accessibility implementations enhance usability for the backspace key in on-screen keyboards. Features include resizable keyboard panels to provide larger touch targets, reducing accidental presses for users with motor impairments, as seen in macOS Accessibility Keyboard options.[27] Sticky Keys mode, while primarily for modifiers, can indirectly aid sequential input involving backspace in combination with other keys. The key's hardware signal corresponds briefly to the ASCII control character BS (code 8).[28]Primary Uses in Computing
Text Input and Editing
In graphical user interfaces (GUIs), the Backspace key primarily functions to delete the character immediately to the left of the text cursor (insertion point) and then moves the cursor one position to the left, facilitating precise editing in left-to-right text flows.[29] This behavior is a core feature of text input systems, allowing users to correct typos or refine content incrementally without disrupting the overall document structure. In applications supporting multi-line editing, such as word processors, Backspace navigates across lines seamlessly, deleting the preceding character regardless of line boundaries.[30] In popular GUI applications like Microsoft Word and Google Docs, Backspace integrates with modifier keys to enhance efficiency; for instance, pressing Ctrl+Backspace deletes an entire word to the left of the cursor, respecting word boundaries defined by spaces or punctuation.[29] These deletions are fully reversible through the application's undo mechanism, typically invoked via Ctrl+Z, ensuring users can restore content without data loss. Such functionality supports fluid text manipulation in documents of varying complexity, from simple notes to formatted reports. Cross-platform consistency in Backspace handling is achieved through established GUI frameworks and standards. On Linux systems using the GTK toolkit, the Backspace key emits a dedicated ::backspace signal in text views, triggering deletion of the preceding character or grapheme cluster.[31] Similarly, on macOS, Apple's Cocoa framework processes Backspace via key-binding defaults in the text system, mapping it to backward deletion actions in NSTextView instances.[32] These implementations ensure predictable behavior across diverse environments, abstracting low-level keyboard events into high-level text field operations. Edge cases demonstrate Backspace's adaptability in specialized contexts. In password fields, such as HTML elements or equivalent native controls, Backspace deletes the obscured character (visually represented as a bullet or asterisk) without revealing the underlying text, maintaining security while allowing corrections. When text is selected—highlighted by dragging or keyboard shortcuts—Backspace deletes the entire selection in lieu of a single character, streamlining bulk edits in GUI text editors.[29]Terminal and Command-Line Behavior
In Unix-like operating systems, the Backspace key in terminal emulators such as xterm and GNOME Terminal typically sends either the ASCII backspace control character (BS, code 8, represented as ^H) or the delete character (DEL, code 127, ^?), depending on the emulator's configuration and the terminal's terminfo database entry for the "kb" (key backspace) capability. This character is processed by the kernel's tty line discipline to erase the previous character from the input buffer in canonical (cooked) mode, where line editing features like erasure are enabled. The specific erase character can be configured using thestty utility; for instance, the default is often ^? (DEL), but it can be set to ^H with stty erase ^H, allowing the terminal to rub out the last typed character by echoing ^H followed by a space and another ^H in some display modes.[33][34][35]
Historically, the backspace character has been used for overstriking in text-based output, particularly in legacy terminal rendering for effects like bolding and underlining in man pages generated by tools such as groff's grotty driver. In this technique, a character is printed, followed by a backspace (^H), and then another character or underscore; for example, underlining a letter "c" is achieved by outputting "_" followed by ^H and then "c", while bolding uses "c" ^H "c". This method, rooted in typewriter-era formatting and nroff/troff systems, allows combining characters on low-capability printers or terminals without native support for attributes, though modern terminals often convert such sequences to ANSI escape codes for better rendering. The -u option in grotty suppresses overstriking other than for bold and/or underlined characters when the legacy output format is in use.[36]
Terminal emulators exhibit variations in backspace handling; for example, in the Windows Command Prompt, the key erases the previous character in the command line buffer before execution, emulating a left-arrow movement combined with deletion rather than strictly sending a control character like ^H, which aligns with the console host's input processing model. In Unix shells like bash and zsh, which use the GNU Readline library for line editing, backspace behavior can be customized via the ~/.inputrc file to support advanced deletions, such as binding Ctrl-Backspace (often ^_) to unix-word-rubout or backward-kill-word for erasing the previous word: "\C-_": unix-word-rubout. This allows users to override defaults, where standard backspace performs single-character deletion, extending functionality across Readline-based applications.[37]
Common troubleshooting issues arise from mismatches in the TERM environment variable, such as when a client sets TERM=xterm-256color but the remote system lacks a corresponding terminfo entry, causing backspace to produce literal ^? or ^H characters on screen instead of erasure—often manifesting as spaces or no effect. This can be resolved by exporting TERM=xterm or TERM=ansi to match available definitions, ensuring the "kb" capability sends the expected sequence (typically ^H for xterm variants), or by running stty sane to reset tty settings. Such discrepancies are frequent in SSH sessions or when switching between emulators like GNOME Terminal and xterm, where termcap/terminfo databases define differing key mappings.[34]
Alternatives and Variations
Delete Key Comparison
The backspace key deletes the character immediately to the left of the cursor, effectively moving the cursor backward while removing text.[38] In contrast, the delete key removes the character to the right of the cursor, allowing forward deletion without shifting the cursor position.[38] This directional distinction stems from their respective origins: backspace evolved from typewriter mechanisms that repositioned the carriage for manual overwriting or correction, while delete draws from early computing control characters designed to erase the current or upcoming position.[3][39] Early computer keyboards were heavily influenced by typewriter designs, which featured backspace for backward erasure and overtyping. As text editing needs evolved, a separate delete key was introduced for forward deletion to maintain compatibility with established backspace behavior.[40] The divergence into separate keys became prominent in the late 1970s and 1980s as terminals and personal computers adopted distinct functions; for instance, the ASCII DEL character (0x7F) was repurposed for forward deletion in editing environments, separate from the backspace (0x08) for backward movement.[39] By the IBM PC era in 1981, standard keyboards included dedicated backspace and delete keys to support these differentiated behaviors in text processing.[40] In modern operating systems, these distinctions persist with platform-specific implementations. On macOS, the delete key (often labeled simply "delete") functions as backward deletion like backspace, while forward deletion requires pressing Fn + Delete.[41] Windows, however, uses the Del key consistently for forward deletion across applications, maintaining separation from the backspace key's backward action.[38] Common use cases highlight their complementary roles: backspace is typically employed for correcting recent typos during input by erasing immediately behind the cursor, whereas delete facilitates removing anticipated or selected content ahead, such as clearing cells in spreadsheets without shifting surrounding data.[38] This separation enhances editing efficiency in text-based and graphical interfaces.[40]Specialized Functions in Software
In integrated development environments (IDEs) like Vim, the backspace key's behavior in insert mode is governed by the 'backspace' option, which can be set to "indent,eol,start," allowing it to delete across automatically inserted indentation, end-of-line breaks (joining lines), and the start of the current insertion.[42] This configuration enables backspace to function as a motion-like command for multi-line editing, such as removing indentation or merging lines without additional commands, enhancing efficiency in code navigation and refactoring.[42] In Emacs, the backspace key (often mapped to DEL) executesdelete-backward-char to remove the character preceding the cursor, but in terminal environments, it may default to generating C-h, which invokes the help system; users typically remap it via normal-erase-is-backspace-mode to ensure consistent backward deletion across buffers and modes.[43][44]
In web browsers and development contexts, the backspace key historically triggered backward navigation in the browsing history when no text field was focused, a feature present in early versions of Chrome but disabled starting with Chrome 52 in 2016 to mitigate accidental page reloads and data loss during form input, citing user reports of frustration from unintended navigation. Google later released an official extension, "Go Back With Backspace," to optionally restore this functionality while exempting text fields.[45] Within HTML forms, backspace interacts standardly with <input type="text"> elements by deleting the preceding character, as defined in the HTML specification, supporting real-time editing in web applications without triggering browser-level actions when the field is active.
In gaming and simulations, particularly text-based adventures like Zork from the 1970s, backspace serves for correcting input commands during gameplay, allowing players to edit typed actions (e.g., erasing errors in movement or object manipulation phrases) before submission, as noted in the game's original documentation which recommends using the delete/backspace equivalent to revise lines of text up to two full lines long.[46]
Custom keybinding tools enable programmable extensions of backspace for specialized macros, such as in AutoHotkey scripts where it can be remapped to delete entire lines in editors like Notepad++ by simulating Home, Shift+End, and Delete sequences, streamlining bulk text removal in scripting workflows.[47] Similarly, Karabiner-Elements on macOS supports complex remappings, like assigning backspace to forward delete or combining it with modifiers (e.g., Option+Backspace for word-level backward deletion), allowing users to tailor it for domain-specific tasks such as code debugging or UI prototyping.[48][49]