Ed (text editor)

Short description: Line-oriented text editor for Unix

The `ed` text editor

Original author(s)| Ken Thompson
Developer(s)| AT&T Bell Laboratories
Initial release| 1973, 52-53 years ago
Written in| C
Operating system| Unix, Unix-like, Plan 9
Platform| Cross-platform
Type| Text editor
License| Plan 9: MIT License

ed (pronounced as distinct letters, /ˌiːˈdiː/)[1] is a line editor for Unix and Unix-like operating systems. It was one of the first parts of the Unix operating system that was developed, in August 1969.[2] It remains part of the POSIX and Open Group standards for Unix-based operating systems,[3] alongside the more sophisticated full-screen editor vi.

## Contents

* 1 History and influence
* 2 Features
* 3 Example
* 4 Cultural references
* 5 See also
* 6 References
* 7 External links

## History and influence

The ed text editor was one of the first three key elements of the Unix operating system—assembler, editor, and shell—developed by Ken Thompson in August 1969 on a PDP-7 at AT&T Bell Labs.[2] Many features of ed came from the qed text editor developed at Thompson's alma mater University of California, Berkeley.[4] Thompson was very familiar with qed, and had reimplemented it on the CTSS and Multics systems. Thompson's versions of qed were notable as the first to implement regular expressions. Regular expressions are also implemented in ed, though their implementation is considerably less general than that in qed.

Dennis M. Ritchie produced what Doug McIlroy later described as the "definitive" ed,[5] and aspects of ed went on to influence ex, which in turn spawned vi. The non-interactive Unix command grep was inspired by a common special use of qed and later ed, where the command `g/re/p` performs a global regular expression search and prints the lines containing matches. The Unix stream editor, sed implemented many of the scripting features of qed that were not supported by ed on Unix.[6][failed verification][7]

## Features

Features of ed include:

* available on essentially all Unix systems (and mandatory on systems conforming to the Single Unix Specification).
* support for regular expressions
* powerful automation can be achieved by feeding commands from standard input

(In)famous for its terseness, ed, compatible with teletype terminals like Teletype Model 33, gives almost no visual feedback,[8] and has been called (by Peter H. Salus) "the most user-hostile editor ever created", even when compared to the contemporary (and notoriously complex) TECO.[2] For example, the message that ed will produce in case of error, and when it wants to make sure the user wishes to quit without saving, is "?". It does not report the current filename or line number, or even display the results of a change to the text, unless requested. Older versions (c. 1981) did not even ask for confirmation when a quit command was issued without the user saving changes.[8] This terseness was appropriate in the early versions of Unix, when consoles were teletypes, modems were slow, and memory was precious. As computer technology improved and these constraints were loosened, editors with more visual feedback became the norm.

The man page for ed

In current practice, ed is rarely used interactively, but does find use in some shell scripts. For interactive use, ed was subsumed by the sam, vi and Emacs editors in the 1980s. ed can be found on virtually every version of Unix and Linux available, and as such is useful for people who have to work with multiple versions of Unix. On Unix-based operating systems, some utilities like SQL*Plus run ed as the editor if the EDITOR and VISUAL environment variables are not defined.[9] If something goes wrong, ed is sometimes the only editor available. This is often the only time when it is used interactively.

The version of ed provided by GNU has a few switches to enhance the feedback. Using `ed -v -p:` provides a simple prompt and enables more useful feedback messages.[10] The `-p` switch is defined in POSIX since XPG2 (1987).[3]

The ed commands are often imitated in other line-based editors. For example, EDLIN in early MS-DOS versions and 32-bit versions of Windows NT has a somewhat similar syntax, and text editors in many MUDs (LPMud and descendants, for example) use ed-like syntax. These editors, however, are typically more limited in function.

## Example

Here is an example transcript of an ed session. For clarity, commands and text typed by the user are in normal face, and output from ed is emphasized.

ed is the standard Unix text editor.
This is line number two.

ed is the standard Unix text editor.$

This is line number two.$
w text

3s/two/three/

ed is the standard Unix text editor.$

This is line number three.$
w text

The end result is a simple text file containing the following text:

ed is the standard Unix text editor.

This is line number three.

Started with an empty file, the `a` command appends text (all ed commands are single letters). The command puts ed in insert mode, inserting the characters that follow and is terminated by a single dot on a line. The two lines that are entered before the dot end up in the file buffer. The `2i` command also goes into insert mode, and will insert the entered text (a single empty line in our case) before line two. All commands may be prefixed by a line number to operate on that line.

In the line `,l`, the lowercase L stands for the list command. The command is prefixed by a range, in this case `,` which is a shortcut for `1,$`. A range is two line numbers separated by a comma (`$` means the last line). In return, ed lists all lines, from first to last. These lines are ended with dollar signs, so that white space at the end of lines is clearly visible.

Once the empty line is inserted in line 2, the line which reads "This is line number two." is now actually the third line. This error is corrected with `3s/two/three/`, a substitution command. The `3` will apply it to the correct line; following the command is the text to be replaced, and then the replacement. Listing all lines with `,l` the line is shown now to be correct.

`w text` writes the buffer to the file "text" making ed respond with 65, the number of characters written to the file. `q` will end an ed session.

## Cultural references

The GNU Project has numerous jokes around ed hosted on its website. In addition, the glibc documentation notes an error code called `ED` with its description (errorstr) merely a single question mark, noting "the experienced user will know what is wrong."[11]

## See also

* Edlin, the standard MS-DOS line editor which was inspired by ed
* Sam (text editor)
* Editor war
* List of Unix commands

## References

1. ↑ Computerphile (2018-07-06), Where GREP Came From – Computerphile, https://www.youtube.com/watch?v=NTfOnGZUZDk&t=119, retrieved 2020-10-21
2. ↑ 2.0 2.1 2.2 Salus, Peter H. (2005). The Daemon, the Gnu and the Penguin. Groklaw. http://www.groklaw.net/article.php?story=20050414215646742.
3. ↑ 3.0 3.1 `ed` – Commands & Utilities Reference, The Single UNIX Specification, Issue 7 from The Open Group
4. ↑ D. M. Ritchie and K. L. Thompson, "QED Text Editor", MM-70-1373-3 (June 1970), reprinted as "QED Text Editor Reference Manual", MHCC-004, Murray Hill Computing, Bell Laboratories (October 1972).
5. ↑ McIlroy, M. D. (1987). A Research Unix reader: annotated excerpts from the Programmer's Manual, 1971–1986 (PDF) (Technical report). CSTR. Bell Labs. 139.
6. ↑ Raymond, Eric (2003). "The Art of Unix Programming". https://nakamotoinstitute.org/static/docs/taoup.pdf.
7. ↑ "On the Early History and Impact of Unix". http://www.columbia.edu/~rh120/ch001j.c11. ""A while later a demand arose for another special-purpose program, gres, for substitution: g/re/s. Lee McMahon undertook to write it, and soon foresaw that there would be no end to the family: g/re/d, g/re/a, etc. As his concept developed it became sed…""
8. ↑ 8.0 8.1 Donald A. Norman (1981). "The truth about UNIX". Datamation. http://www.ceri.memphis.edu/people/smalley/ESCI7205_misc_files/The_truth_about_Unix_cleaned.pdf.
9. ↑ Administering SQL*Plus. Accessed 7/23/2016.
10. ↑ `ed(1)` – Linux General Commands Manual
11. ↑ "The GNU C Library - Error Codes". https://www.gnu.org/software/libc/manual/html_node/Error-Codes.html.

## External links

* `ed`: edit text – Commands & Utilities Reference, The Single UNIX Specification, Issue 7 from The Open Group
* Manual page from Unix First Edition describing ed.
* `ed(1)`: text editor – Version 7 Unix Programmer's Manual
* `ed(1)`: text editor – Plan 9 Programmer's Manual, Volume 1, a direct descendant of the original ed.
* GNU ed homepage
* A History of UNIX before Berkeley section 3.1 describes the history of ed.

* v
* t
* e

Unix command-line interface programs and shell builtins

File system|

* cat
* chmod
* chown
* chgrp
* cksum
* cmp
* cp
* dd
* du
* df
* file
* fuser
* ln
* ls
* mkdir
* mv
* pax
* pwd
* rm
* rmdir
* split
* tee
* touch
* type
* umask

Processes|

* at
* bg
* crontab
* fg
* kill
* nice
* ps
* time

User environment|

* env
* exit
* logname
* mesg
* talk
* tput
* uname
* who
* write

Text processing|

* awk
* basename
* comm
* csplit
* cut
* diff
* dirname
* ed
* ex
* fold
* head
* iconv
* join
* m4
* more
* nl
* paste
* patch
* printf
* sed
* sort
* strings
* tail
* tr
* uniq
* vi
* wc
* xargs

Shell builtins|

* alias
* cd
* echo
* test
* unset
* wait

Searching|

* find
* grep

Documentation|

* man

Software development|

* ar
* ctags
* lex
* make
* nm
* strip
* yacc

Miscellaneous|

* bc
* cal
* expr
* lp
* od
* sleep
* true and false

* Categories
* Standard Unix programs
* Unix SUS2008 utilities
* List

* v
* t
* e

Ken Thompson

Operating systems|

* Unix
* Plan 9 from Bell Labs

Programming languages|

* B
* Bon
* Go

Software|

* Belle
* ed
* grep
* sam
* Space Travel
* Thompson shell

Other|

* UTF-8

0.00

(0 votes)

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Ed_(text_editor)&oldid=3897108"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template