Return to emacs-11 CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / info

Annotation of 43BSDReno/contrib/emacs-18.55/info/emacs-11, revision 1.1

1.1     ! root        1: Info file emacs, produced by texinfo-format-buffer   -*-Text-*-
        !             2: from file emacs.tex
        !             3: 
        !             4: This file documents the GNU Emacs editor.
        !             5: 
        !             6: Copyright (C) 1985, 1986 Richard M. Stallman.
        !             7: 
        !             8: Permission is granted to make and distribute verbatim copies of
        !             9: this manual provided the copyright notice and this permission notice
        !            10: are preserved on all copies.
        !            11: 
        !            12: Permission is granted to copy and distribute modified versions of this
        !            13: manual under the conditions for verbatim copying, provided also that the
        !            14: sections entitled "The GNU Manifesto", "Distribution" and "GNU Emacs
        !            15: General Public License" are included exactly as in the original, and
        !            16: provided that the entire resulting derived work is distributed under the
        !            17: terms of a permission notice identical to this one.
        !            18: 
        !            19: Permission is granted to copy and distribute translations of this manual
        !            20: into another language, under the above conditions for modified versions,
        !            21: except that the sections entitled "The GNU Manifesto", "Distribution"
        !            22: and "GNU Emacs General Public License" may be included in a translation
        !            23: approved by the author instead of in the original English.
        !            24: 
        !            25: 
        !            26: File: emacs  Node: Syntax Change, Prev: Syntax Entry, Up: Syntax
        !            27: 
        !            28: Altering Syntax Information
        !            29: ---------------------------
        !            30: 
        !            31:   It is possible to alter a character's syntax table entry by storing a new
        !            32: number in the appropriate element of the syntax table, but it would be hard
        !            33: to determine what number to use.  Therefore, Emacs provides a command that
        !            34: allows you to specify the syntactic properties of a character in a
        !            35: convenient way.
        !            36: 
        !            37:   `M-x modify-syntax-entry' is the command to change a character's
        !            38: syntax.  It can be used interactively, and is also the means used by major
        !            39: modes to initialize their own syntax tables.  Its first argument is the
        !            40: character to change.  The second argument is a string that specifies the
        !            41: new syntax.  When called from Lisp code, there is a third, optional
        !            42: argument, which specifies the syntax table in which to make the change.  If
        !            43: not supplied, or if this command is called interactively, the third
        !            44: argument defaults to the current buffer's syntax table.
        !            45: 
        !            46:   1. The first character in the string specifies the syntactic class.  It
        !            47:      is one of the characters in the previous table (*Note Syntax Entry::).
        !            48:      
        !            49:   2. The second character is the matching delimiter.  For a character that
        !            50:      is not an opening or closing delimiter, this should be a space, and may
        !            51:      be omitted if no following characters are needed.
        !            52:      
        !            53:   3. The remaining characters are flags.  The flag characters allowed are
        !            54:      
        !            55:      `1'     
        !            56:           Flag this character as the first of a two-character comment starting sequence.
        !            57:      `2'     
        !            58:           Flag this character as the second of a two-character comment starting sequence.
        !            59:      `3'     
        !            60:           Flag this character as the first of a two-character comment ending sequence.
        !            61:      `4'     
        !            62:           Flag this character as the second of a two-character comment ending sequence.
        !            63: 
        !            64:   A description of the contents of the current syntax table can be
        !            65: displayed with `C-h s' (`describe-syntax').  The description of
        !            66: each character includes both the string you would have to give to
        !            67: `modify-syntax-entry' to set up that character's current syntax, and
        !            68: some English to explain that string if necessary.
        !            69: 
        !            70: 
        !            71: File: emacs  Node: Init File, Prev: Syntax, Up: Customization
        !            72: 
        !            73: The Init File, .emacs
        !            74: =====================
        !            75: 
        !            76:   When Emacs is started, it normally loads the file `.emacs' in your
        !            77: home directory.  This file, if it exists, should contain Lisp code.  It is
        !            78: called your "init file".  The command line switches `-q' and
        !            79: `-u' can be used to tell Emacs whether to load an init file
        !            80: (*Note Entering Emacs::).
        !            81: 
        !            82:   There can also be a "default init file", which is the library named
        !            83: `default.el', found via the standard search path for libraries.  The
        !            84: Emacs distribution contains no such library; your site may create one for
        !            85: local customizations.  If this library exists, it is loaded whenever you
        !            86: start Emacs.  But your init file, if any, is loaded first; if it sets
        !            87: `inhibit-default-init' non-`nil', then `default' is not
        !            88: loaded.
        !            89: 
        !            90:   If you have a large amount of code in your `.emacs' file, you
        !            91: should move it into another file named `SOMETHING.el',
        !            92: byte-compile it (*Note Lisp Libraries::), and make your `.emacs'
        !            93: file load the other file using `load'.
        !            94: 
        !            95: * Menu:
        !            96: 
        !            97: * Init Syntax::     Syntax of constants in Emacs Lisp.
        !            98: * Init Examples::   How to do some things with an init file.
        !            99: * Terminal Init::   Each terminal type can have an init file.
        !           100: 
        !           101: 
        !           102: File: emacs  Node: Init Syntax, Prev: Init File, Up: Init File, Next: Init Examples
        !           103: 
        !           104: Init File Syntax
        !           105: ----------------
        !           106: 
        !           107:   The `.emacs' file contains one or more Lisp function call
        !           108: expressions.  Each of these consists of a function name followed by
        !           109: arguments, all surrounded by parentheses.  For example, `(setq
        !           110: fill-column 60)' represents a call to the function `setq' which is
        !           111: used to set the variable `fill-column' (*Note Filling::) to 60.
        !           112: 
        !           113:   The second argument to `setq' is an expression for the new value of
        !           114: the variable.  This can be a constant, a variable, or a function call
        !           115: expression.  In `.emacs', constants are used most of the time.  They can be:
        !           116: 
        !           117: Numbers:     
        !           118:      Numbers are written in decimal, with an optional initial minus sign.
        !           119:      
        !           120: Strings:     
        !           121:      Lisp string syntax is the same as C string syntax with a few extra
        !           122:      features.  Use a double-quote character to begin and end a string constant.
        !           123:      
        !           124:      Newlines and special characters may be present literally in strings.  They
        !           125:      can also be represented as backslash sequences: `\n' for newline,
        !           126:      `\b' for backspace, `\r' for carriage return, `\t' for tab,
        !           127:      `\f' for formfeed (control-l), `\e' for escape, `\\' for a
        !           128:      backslash, `\"' for a double-quote, or `\OOO' for the
        !           129:      character whose octal code is OOO.  Backslash and double-quote are
        !           130:      the only characters for which backslash sequences are mandatory.
        !           131:      
        !           132:      `\C-' can be used as a prefix for a control character, as in `\C-s'
        !           133:      for ASCII Control-S, and `\M-' can be used as a prefix for a meta
        !           134:      character, as in `\M-a' for Meta-A or `\M-\C-a' for Control-Meta-A.
        !           135:      
        !           136: Characters:     
        !           137:      Lisp character constant syntax consists of a `?' followed by
        !           138:      either a character or an escape sequence starting with `\'.
        !           139:      Examples: `?x', `?\n', `?\"', `?\)'.  Note that
        !           140:      strings and characters are not interchangeable in Lisp; some contexts
        !           141:      require one and some contexts require the other.
        !           142:      
        !           143: True:     
        !           144:      `t' stands for `true'.
        !           145:      
        !           146: False:     
        !           147:      `nil' stands for `false'.
        !           148:      
        !           149: Other Lisp objects:     
        !           150:      Write a single-quote (') followed by the Lisp object you want.
        !           151: 
        !           152: 
        !           153: File: emacs  Node: Init Examples, Prev: Init Syntax, Up: Init File, Next: Terminal Init
        !           154: 
        !           155: Init File Examples
        !           156: ------------------
        !           157: 
        !           158:   Here are some examples of doing certain commonly desired things with
        !           159: Lisp expressions:
        !           160: 
        !           161:    * Make TAB in C mode just insert a tab if point is in the middle of a
        !           162:      line.
        !           163:      
        !           164:           (setq c-tab-always-indent nil)
        !           165:      
        !           166:      Here we have a variable whose value is normally `t' for `true'
        !           167:      and the alternative is `nil' for `false'.
        !           168:      
        !           169:    * Make searches case sensitive by default (in all buffers that do not
        !           170:      override this).
        !           171:      
        !           172:           (setq-default case-fold-search nil)
        !           173:      
        !           174:      This sets the default value, which is effective in all buffers that do
        !           175:      not have local values for the variable.  Setting `case-fold-search'
        !           176:      with `setq' affects only the current buffer's local value, which
        !           177:      is not what you probably want to do in an init file.
        !           178:      
        !           179:    * Make Text mode the default mode for new buffers.
        !           180:      
        !           181:           (setq default-major-mode 'text-mode)
        !           182:      
        !           183:      Note that `text-mode' is used because it is the command for entering
        !           184:      the mode we want.  A single-quote is written before it to make a symbol
        !           185:      constant; otherwise, `text-mode' would be treated as a variable name.
        !           186:      
        !           187:    * Turn on Auto Fill mode automatically in Text mode and related modes.
        !           188:      
        !           189:           (setq text-mode-hook
        !           190:             '(lambda () (auto-fill-mode 1)))
        !           191:      
        !           192:      Here we have a variable whose value should be a Lisp function.  The
        !           193:      function we supply is a list starting with `lambda', and a single
        !           194:      quote is written in front of it to make it (for the purpose of this
        !           195:      `setq') a list constant rather than an expression.  Lisp functions
        !           196:      are not explained here, but for mode hooks it is enough to know that
        !           197:      `(auto-fill-mode 1)' is an expression that will be executed when
        !           198:      Text mode is entered, and you could replace it with any other expression
        !           199:      that you like, or with several expressions in a row.
        !           200:      
        !           201:           (setq text-mode-hook 'turn-on-auto-fill)
        !           202:      
        !           203:      This is another way to accomplish the same result.
        !           204:      `turn-on-auto-fill' is a symbol whose function definition is
        !           205:      `(lambda () (auto-fill-mode 1))'.
        !           206:      
        !           207:    * Load the installed Lisp library named `foo' (actually a file
        !           208:      `foo.elc' or `foo.el' in a standard Emacs directory).
        !           209:      
        !           210:           (load "foo")
        !           211:      
        !           212:      When the argument to `load' is a relative pathname, not starting
        !           213:      with `/' or `~', `load' searches the directories in
        !           214:      `load-path' (*Note Loading::).
        !           215:      
        !           216:    * Load the compiled Lisp file `foo.elc' from your home directory.
        !           217:      
        !           218:           (load "~/foo.elc")
        !           219:      
        !           220:      Here an absolute file name is used, so no searching is done.
        !           221:      
        !           222:    * Rebind the key `C-x l' to run the function `make-symbolic-link'.
        !           223:      
        !           224:           (global-set-key "\C-xl" 'make-symbolic-link)
        !           225:      
        !           226:      or
        !           227:      
        !           228:           (define-key global-map "\C-xl" 'make-symbolic-link)
        !           229:      
        !           230:      Note once again the single-quote used to refer to the symbol
        !           231:      `make-symbolic-link' instead of its value as a variable.
        !           232:      
        !           233:    * Do the same thing for C mode only.
        !           234:      
        !           235:           (define-key c-mode-map "\C-xl" 'make-symbolic-link)
        !           236:      
        !           237:    * Redefine all keys which now run `next-line' in Fundamental mode
        !           238:      so that they run `forward-line' instead.
        !           239:      
        !           240:           (substitute-key-definition 'next-line 'forward-line
        !           241:                                      global-map)
        !           242:      
        !           243:    * Make `C-x C-v' undefined.
        !           244:      
        !           245:           (global-unset-key "\C-x\C-v")
        !           246:      
        !           247:      One reason to undefine a key is so that you can make it a prefix.
        !           248:      Simply defining `C-x C-v ANYTHING' would make `C-x C-v'
        !           249:      a prefix, but `C-x C-v' must be freed of any non-prefix definition
        !           250:      first.
        !           251:      
        !           252:    * Make `$' have the syntax of punctuation in Text mode.
        !           253:      Note the use of a character constant for `$'.
        !           254:      
        !           255:           (modify-syntax-entry ?\$ "." text-mode-syntax-table)
        !           256:      
        !           257:    * Enable the use of the command `eval-expression' without confirmation.
        !           258:      
        !           259:           (put 'eval-expression 'disabled nil)
        !           260: 
        !           261: 
        !           262: File: emacs  Node: Terminal Init, Prev: Init Examples, Up: Init File
        !           263: 
        !           264: Terminal-specific Initialization
        !           265: --------------------------------
        !           266: 
        !           267:   Each terminal type can have a Lisp library to be loaded into Emacs when
        !           268: it is run on that type of terminal.  For a terminal type named TERMTYPE,
        !           269: the library is called `term/TERMTYPE' and it is found by searching the
        !           270: directories `load-path' as usual and trying the suffixes `.elc' and `.el'.
        !           271: Normally it appears in the subdirectory `term' of the directory where most
        !           272: Emacs libraries are kept.
        !           273: 
        !           274:   The usual purpose of the terminal-specific library is to define the
        !           275: escape sequences used by the terminal's function keys using the library
        !           276: `keypad.el'.  See the file `term/vt100.el' for an example of how this is
        !           277: done.
        !           278: 
        !           279:   When the terminal type contains a hyphen, only the part of the name
        !           280: before the first hyphen is significant in choosing the library name.  Thus,
        !           281: terminal types `aaa-48' and `aaa-30-rv' both use the library `term/aaa'.
        !           282: The code in the library can use `(getenv "TERM")' to find the full terminal
        !           283: type name.
        !           284: 
        !           285:   The library's name is constructed by concatenating the value of the
        !           286: variable `term-file-prefix' and the terminal type.  Your `.emacs'
        !           287: file can prevent the loading of the terminal-specific library by setting
        !           288: `term-file-prefix' to `nil'.
        !           289: 
        !           290:   The value of the variable `term-setup-hook', if not `nil', is called as a
        !           291: function of no arguments at the end of Emacs initialization, after both
        !           292: your `.emacs' file and any terminal-specific library have been read in.
        !           293: You can set the value in the `.emacs' file to override part of any of the
        !           294: terminal-specific libraries and to define initializations for terminals
        !           295: that do not have a library.
        !           296: 
        !           297: 
        !           298: 
        !           299: File: emacs  Node: Quitting, Prev: Customization, Up: Top, Next: Lossage
        !           300: 
        !           301: Quitting and Aborting
        !           302: =====================
        !           303: 
        !           304: `C-g'     
        !           305:      Quit.  Cancel running or partially typed command.
        !           306: `C-]'     
        !           307:      Abort innermost recursive editing level and cancel the command which
        !           308:      invoked it (`abort-recursive-edit').
        !           309: `M-x top-level'     
        !           310:      Abort all recursive editing levels that are currently executing.
        !           311: `C-x u'     
        !           312:      Cancel an already-executed command, usually (`undo').
        !           313: 
        !           314:   There are two ways of cancelling commands which are not finished
        !           315: executing: "quitting" with `C-g', and "aborting" with `C-]'
        !           316: or `M-x top-level'.  Quitting is cancelling a partially typed command
        !           317: or one which is already running.  Aborting is getting out of a recursive
        !           318: editing level and cancelling the command that invoked the recursive edit.
        !           319: 
        !           320:   Quitting with `C-g' is used for getting rid of a partially typed
        !           321: command, or a numeric argument that you don't want.  It also stops a
        !           322: running command in the middle in a relatively safe way, so you can use it
        !           323: if you accidentally give a command which takes a long time.  In particular,
        !           324: it is safe to quit out of killing; either your text will ALL still be
        !           325: there, or it will ALL be in the kill ring (or maybe both).  Quitting
        !           326: an incremental search does special things documented under searching; in
        !           327: general, it may take two successive `C-g' characters to get out of a
        !           328: search.  `C-g' works by setting the variable `quit-flag' to
        !           329: `t' the instant `C-g' is typed; Emacs Lisp checks this variable
        !           330: frequently and quits if it is non-`nil'.  `C-g' is only actually
        !           331: executed as a command if it is typed while Emacs is waiting for input.
        !           332: 
        !           333:   If you quit twice in a row before the first `C-g' is recognized, you
        !           334: activate the "emergency escape" feature and return to the shell.
        !           335: *Note Emergency Escape::.
        !           336: 
        !           337:   Aborting with `C-]' (`abort-recursive-edit') is used to get out
        !           338: of a recursive editing level and cancel the command which invoked it.
        !           339: Quitting with `C-g' does not do this, and could not do this, because it
        !           340: is used to cancel a partially typed command within the recursive
        !           341: editing level.  Both operations are useful.  For example, if you are in the
        !           342: Emacs debugger (*Note Lisp Debug::) and have typed `C-u 8' to enter a
        !           343: numeric argument, you can cancel that argument with `C-g' and remain in
        !           344: the debugger.
        !           345: 
        !           346:   The command `M-x top-level' is equivalent to "enough" `C-]'
        !           347: commands to get you out of all the levels of recursive edits that you are
        !           348: in.  `C-]' gets you out one level at a time, but `M-x top-level'
        !           349: goes out all levels at once.  Both `C-]' and `M-x top-level' are
        !           350: like all other commands, and unlike `C-g', in that they are effective
        !           351: only when Emacs is ready for a command.  `C-]' is an ordinary key and
        !           352: has its meaning only because of its binding in the keymap.
        !           353: *Note Recursive Edit::.
        !           354: 
        !           355:   `C-x u' (`undo') is not strictly speaking a way of cancelling a
        !           356: command, but you can think of it as cancelling a command already finished
        !           357: executing.  *Note Undo::.
        !           358: 
        !           359: 
        !           360: File: emacs  Node: Lossage, Prev: Quitting, Up: Top, Next: Bugs
        !           361: 
        !           362: Dealing with Emacs Trouble
        !           363: ==========================
        !           364: 
        !           365:   This section describes various conditions in which Emacs fails to work,
        !           366: and how to recognize them and correct them.
        !           367: 
        !           368: * Menu:
        !           369: 
        !           370: * Stuck Recursive::    `[...]' in mode line around the parentheses
        !           371: * Screen Garbled::     Garbage on the screen
        !           372: * Text Garbled::       Garbage in the text
        !           373: * Unasked-for Search:: Spontaneous entry to incremental search
        !           374: * Emergency Escape::   Emergency escape---
        !           375:                         What to do if Emacs stops responding
        !           376: * Total Frustration::  When you are at your wits' end.
        !           377: 
        !           378: 
        !           379: File: emacs  Node: Stuck Recursive, Prev: Lossage, Up: Lossage, Next: Screen Garbled
        !           380: 
        !           381: Recursive Editing Levels
        !           382: ------------------------
        !           383: 
        !           384:   Recursive editing levels are important and useful features of Emacs, but
        !           385: they can seem like malfunctions to the user who does not understand them.
        !           386: 
        !           387:   If the mode line has square brackets `[...]' around the parentheses
        !           388: that contain the names of the major and minor modes, you have entered a
        !           389: recursive editing level.  If you did not do this on purpose, or if you
        !           390: don't understand what that means, you should just get out of the recursive
        !           391: editing level.  To do so, type `M-x top-level'.  This is called getting
        !           392: back to top level.  *Note Recursive Edit::.
        !           393: 
        !           394: 
        !           395: File: emacs  Node: Screen Garbled, Prev: Stuck Recursive, Up: Lossage, Next: Text Garbled
        !           396: 
        !           397: Garbage on the Screen
        !           398: ---------------------
        !           399: 
        !           400:   If the data on the screen looks wrong, the first thing to do is see
        !           401: whether the text is really wrong.  Type `C-l', to redisplay the entire
        !           402: screen.  If it appears correct after this, the problem was entirely in the
        !           403: previous screen update.
        !           404: 
        !           405:   Display updating problems often result from an incorrect termcap entry
        !           406: for the terminal you are using.  The file `etc/TERMS' in the Emacs
        !           407: distribution gives the fixes for known problems of this sort.
        !           408: `INSTALL' contains general advice for these problems in one of its
        !           409: sections.  Very likely there is simply insufficient padding for certain
        !           410: display operations.  To investigate the possibility that you have this sort
        !           411: of problem, try Emacs on another terminal made by a different manufacturer.
        !           412: If problems happen frequently on one kind of terminal but not another kind,
        !           413: it is likely to be a bad termcap entry, though it could also be due to a
        !           414: bug in Emacs that appears for terminals that have or that lack specific
        !           415: features.
        !           416: 
        !           417: 
        !           418: File: emacs  Node: Text Garbled, Prev: Screen Garbled, Up: Lossage, Next: Unasked-for Search
        !           419: 
        !           420: Garbage in the Text
        !           421: -------------------
        !           422: 
        !           423:   If `C-l' shows that the text is wrong, try undoing the changes to it
        !           424: using `C-x u' until it gets back to a state you consider correct.  Also
        !           425: try `C-h l' to find out what command you typed to produce the observed
        !           426: results.
        !           427: 
        !           428:   If a large portion of text appears to be missing at the beginning or
        !           429: end of the buffer, check for the word `Narrow' in the mode line.
        !           430: If it appears, the text is still present, but marked off-limits.
        !           431: To make it visible again, type `C-x w'.  *Note Narrowing::.
        !           432: 
        !           433: 
        !           434: File: emacs  Node: Unasked-for Search, Prev: Text Garbled, Up: Lossage, Next: Emergency Escape
        !           435: 
        !           436: Spontaneous Entry to Incremental Search
        !           437: ---------------------------------------
        !           438: 
        !           439:   If Emacs spontaneously displays `I-search:' at the bottom of the
        !           440: screen, it means that the terminal is sending `C-s' and `C-q'
        !           441: according to the poorly designed xon/xoff "flow control" protocol.  You
        !           442: should try to prevent this by putting the terminal in a mode where it will
        !           443: not use flow control or giving it enough padding that it will never send a
        !           444: `C-s'.  If that cannot be done, you must tell Emacs to expect flow
        !           445: control to be used, until you can get a properly designed terminal.
        !           446: 
        !           447:   Information on how to do these things can be found in the file
        !           448: `INSTALL' in the Emacs distribution.
        !           449: 
        !           450: 
        !           451: File: emacs  Node: Emergency Escape, Prev: Unasked-for Search, Up: Lossage, Next: Total Frustration
        !           452: 
        !           453: Emergency Escape
        !           454: ----------------
        !           455: 
        !           456:   Because at times there have been bugs causing Emacs to loop without
        !           457: checking `quit-flag', a special feature causes Emacs to be suspended
        !           458: immediately if you type a second `C-g' while the flag is already set,
        !           459: so you can always get out of GNU Emacs.  Normally Emacs recognizes and
        !           460: clears `quit-flag' (and quits!) quickly enough to prevent this from
        !           461: happening.
        !           462: 
        !           463:   When you resume Emacs after a suspension caused by multiple `C-g', it
        !           464: asks two questions before going back to what it had been doing:
        !           465: 
        !           466:      Auto-save? (y or n)
        !           467:      Abort (and dump core)? (y or n)
        !           468: 
        !           469: Answer each one with `y' or `n' followed by RET.
        !           470: 
        !           471:   Saying `y' to `Auto-save?' causes immediate auto-saving of all
        !           472: modified buffers in which auto-saving is enabled.
        !           473: 
        !           474:   Saying `y' to `Abort (and dump core)?' causes an illegal instruction to be
        !           475: executed, dumping core.  This is to enable a wizard to figure out why Emacs
        !           476: was failing to quit in the first place.  Execution does not continue
        !           477: after a core dump.  If you answer `n', execution does continue.  With
        !           478: luck, GNU Emacs will ultimately check `quit-flag' and quit normally.
        !           479: If not, and you type another `C-g', it is suspended again.
        !           480: 
        !           481:   If Emacs is not really hung, just slow, you may invoke the double
        !           482: `C-g' feature without really meaning to.  Then just resume and answer
        !           483: `n' to both questions, and you will arrive at your former state.
        !           484: Presumably the quit you requested will happen soon.
        !           485: 
        !           486:   The double-`C-g' feature may be turned off when Emacs is running under
        !           487: a window system, since the window system always enables you to kill Emacs
        !           488: or to create another window and run another program.
        !           489: 
        !           490: 
        !           491: File: emacs  Node: Total Frustration, Prev: Emergency Escape, Up: Lossage
        !           492: 
        !           493: Help for Total Frustration
        !           494: --------------------------
        !           495: 
        !           496:   If using Emacs (or something else) becomes terribly frustrating and none
        !           497: of the techniques described above solve the problem, Emacs can still help
        !           498: you.
        !           499: 
        !           500:   First, if the Emacs you are using is not responding to commands, type
        !           501: `C-g C-g' to get out of it and then start a new one.
        !           502: 
        !           503:   Second, type `M-x doctor RET'.
        !           504: 
        !           505:   The doctor will make you feel better.  Each time you say something to
        !           506: the doctor, you must end it by typing RET RET.  This lets the
        !           507: doctor know you are finished.
        !           508: 
        !           509: 
        !           510: File: emacs  Node: Bugs, Prev: Lossage, Up: Top, Next: Manifesto
        !           511: 
        !           512: Reporting Bugs
        !           513: ==============
        !           514: 
        !           515:   Sometimes you will encounter a bug in Emacs.  Although we cannot promise
        !           516: we can or will fix the bug, and we might not even agree that it is a bug,
        !           517: we want to hear about bugs you encounter in case we do want to fix them.
        !           518: 
        !           519:   To make it possible for us to fix a bug, you must report it.  In order
        !           520: to do so effectively, you must know when and how to do it.
        !           521: 
        !           522: 
        !           523: When Is There a Bug
        !           524: -------------------
        !           525: 
        !           526:   If Emacs executes an illegal instruction, or dies with an operating
        !           527: system error message that indicates a problem in the program (as opposed to
        !           528: something like "disk full"), then it is certainly a bug.
        !           529: 
        !           530:   If Emacs updates the display in a way that does not correspond to what is
        !           531: in the buffer, then it is certainly a bug.  If a command seems to do the
        !           532: wrong thing but the problem corrects itself if you type `C-l', it is a
        !           533: case of incorrect display updating.
        !           534: 
        !           535:   Taking forever to complete a command can be a bug, but you must make
        !           536: certain that it was really Emacs's fault.  Some commands simply take a long
        !           537: time.  Type `C-g' and then `C-h l' to see whether the input Emacs
        !           538: received was what you intended to type; if the input was such that you
        !           539: KNOW it should have been processed quickly, report a bug.  If you
        !           540: don't know whether the command should take a long time, find out by looking
        !           541: in the manual or by asking for assistance.
        !           542: 
        !           543:   If a command you are familiar with causes an Emacs error message in a
        !           544: case where its usual definition ought to be reasonable, it is probably a
        !           545: bug.
        !           546: 
        !           547:   If a command does the wrong thing, that is a bug.  But be sure you know
        !           548: for certain what it ought to have done.  If you aren't familiar with the
        !           549: command, or don't know for certain how the command is supposed to work,
        !           550: then it might actually be working right.  Rather than jumping to
        !           551: conclusions, show the problem to someone who knows for certain.
        !           552: 
        !           553:   Finally, a command's intended definition may not be best for editing
        !           554: with.  This is a very important sort of problem, but it is also a matter of
        !           555: judgment.  Also, it is easy to come to such a conclusion out of ignorance
        !           556: of some of the existing features.  It is probably best not to complain
        !           557: about such a problem until you have checked the documentation in the usual
        !           558: ways, feel confident that you understand it, and know for certain that what
        !           559: you want is not available.  If you are not sure what the command is
        !           560: supposed to do after a careful reading of the manual, check the index and
        !           561: glossary for any terms that may be unclear.  If you still do not
        !           562: understand, this indicates a bug in the manual.  The manual's job is to
        !           563: make everything clear.  It is just as important to report documentation
        !           564: bugs as program bugs.
        !           565: 
        !           566:   If the on-line documentation string of a function or variable disagrees
        !           567: with the manual, one of them must be wrong, so report the bug.
        !           568: 
        !           569: 
        !           570: How to Report a Bug
        !           571: -------------------
        !           572: 
        !           573:   When you decide that there is a bug, it is important to report it and to
        !           574: report it in a way which is useful.  What is most useful is an exact
        !           575: description of what commands you type, starting with the shell command to
        !           576: run Emacs, until the problem happens.  Always include the version number
        !           577: of Emacs that you are using; type `M-x emacs-version' to print this.
        !           578: 
        !           579:   The most important principle in reporting a bug is to report FACTS,
        !           580: not hypotheses or categorizations.  It is always easier to report the facts,
        !           581: but people seem to prefer to strain to posit explanations and report
        !           582: them instead.  If the explanations are based on guesses about how Emacs is
        !           583: implemented, they will be useless; we will have to try to figure out what
        !           584: the facts must have been to lead to such speculations.  Sometimes this is
        !           585: impossible.  But in any case, it is unnecessary work for us.
        !           586: 
        !           587:   For example, suppose that you type `C-x C-f /glorp/baz.ugh
        !           588: RET', visiting a file which (you know) happens to be rather large,
        !           589: and Emacs prints out `I feel pretty today'.  The best way to report
        !           590: the bug is with a sentence like the preceding one, because it gives all the
        !           591: facts and nothing but the facts.
        !           592: 
        !           593:   Do not assume that the problem is due to the size of the file and say,
        !           594: "When I visit a large file, Emacs prints out `I feel pretty today'."
        !           595: This is what we mean by "guessing explanations".  The problem is just as
        !           596: likely to be due to the fact that there is a `z' in the file name.  If
        !           597: this is so, then when we got your report, we would try out the problem with
        !           598: some "large file", probably with no `z' in its name, and not find
        !           599: anything wrong.  There is no way in the world that we could guess that we
        !           600: should try visiting a file with a `z' in its name.
        !           601: 
        !           602:   Alternatively, the problem might be due to the fact that the file starts
        !           603: with exactly 25 spaces.  For this reason, you should make sure that you
        !           604: inform us of the exact contents of any file that is needed to reproduce the
        !           605: bug.  What if the problem only occurs when you have typed the `C-x C-a'
        !           606: command previously?  This is why we ask you to give the exact sequence of
        !           607: characters you typed since starting to use Emacs.
        !           608: 
        !           609:   You should not even say "visit a file" instead of `C-x C-f' unless you
        !           610: know that it makes no difference which visiting command is used.
        !           611: Similarly, rather than saying "if I have three characters on the line," say
        !           612: "after I type `RET A B C RET C-p'," if that is the way you entered the
        !           613: text.
        !           614: 
        !           615:   If you are not in Fundamental mode when the problem occurs, you should
        !           616: say what mode you are in.
        !           617: 
        !           618:   If the manifestation of the bug is an Emacs error message, it is
        !           619: important to report not just the text of the error message but a backtrace
        !           620: showing how the Lisp program in Emacs arrived at the error.  To make the
        !           621: backtrace, you must execute the Lisp expression `(setq debug-on-error t)'
        !           622: before the error happens (that is to say, you must execute that expression
        !           623: and then make the bug happen).  This causes the Lisp debugger to run
        !           624: (*Note Lisp Debug::).  The debugger's backtrace can be copied as text into
        !           625: the bug report.  This use of the debugger is possible only if you know how
        !           626: to make the bug happen again.  Do note the error message the first time the
        !           627: bug happens, so if you can't make it happen again, you can report at least
        !           628: that.
        !           629: 
        !           630:   Check whether any programs you have loaded into the Lisp world, including
        !           631: your `.emacs' file, set any variables that may affect the functioning
        !           632: of Emacs.  Also, see whether the problem happens in a freshly started Emacs
        !           633: without loading your `.emacs' file (start Emacs with the `-q' switch
        !           634: to prevent loading the init file.)  If the problem does NOT occur
        !           635: then, it is essential that we know the contents of any programs that you
        !           636: must load into the Lisp world in order to cause the problem to occur.
        !           637: 
        !           638:   If the problem does depend on an init file or other Lisp programs that
        !           639: are not part of the standard Emacs system, then you should make sure it is
        !           640: not a bug in those programs by complaining to their maintainers first.
        !           641: After they verify that they are using Emacs in a way that is supposed to
        !           642: work, they should report the bug.
        !           643: 
        !           644:   If you can tell us a way to cause the problem without visiting any files,
        !           645: please do so.  This makes it much easier to debug.  If you do need files,
        !           646: make sure you arrange for us to see their exact contents.  For example, it
        !           647: can often matter whether there are spaces at the ends of lines, or a
        !           648: newline after the last line in the buffer (nothing ought to care whether
        !           649: the last line is terminated, but tell that to the bugs).
        !           650: 
        !           651:   The easy way to record the input to Emacs precisely is to to write a
        !           652: dribble file; execute the Lisp expression
        !           653: 
        !           654:      (open-dribble-file "~/dribble")
        !           655: 
        !           656: using `Meta-ESC' or from the `*scratch*' buffer just after starting
        !           657: Emacs.  From then on, all Emacs input will be written in the specified
        !           658: dribble file until the Emacs process is killed.
        !           659: 
        !           660:   For possible display bugs, it is important to report the terminal type
        !           661: (the value of environment variable `TERM'), the complete termcap entry
        !           662: for the terminal from `/etc/termcap' (since that file is not identical
        !           663: on all machines), and the output that Emacs actually sent to the terminal.
        !           664: The way to collect this output is to execute the Lisp expression
        !           665: 
        !           666:      (open-termscript "~/termscript")
        !           667: 
        !           668: using `Meta-ESC' or from the `*scratch*' buffer just after starting Emacs.
        !           669: From then on, all output from Emacs to the terminal will be written in the
        !           670: specified termscript file as well, until the Emacs process is killed.  If
        !           671: the problem happens when Emacs starts up, put this expression into your
        !           672: `.emacs' file so that the termscript file will be open when Emacs displays
        !           673: the screen for the first time.  Be warned: it is often difficult, and
        !           674: sometimes impossible, to fix a terminal-dependent bug without access to a
        !           675: terminal of the type that stimulates the bug.
        !           676: 
        !           677:   The address for reporting bugs is
        !           678: 
        !           679:      GNU Emacs Bugs
        !           680:      545 Tech Sq, rm 703
        !           681:      Cambridge, MA 02139
        !           682: 
        !           683: or send email to `mit-eddie!bug-gnu-emacs' (Usenet) or
        !           684: `[email protected]' (Internet).
        !           685: 
        !           686:   Once again, we do not promise to fix the bug; but if the bug is serious,
        !           687: or ugly, or easy to fix, chances are we will want to.
        !           688: 
        !           689: 
        !           690: 
        !           691: File: emacs  Node: Manifesto, Prev: Bugs, Up: Top
        !           692: 
        !           693: The GNU Manifesto
        !           694: *****************
        !           695: 
        !           696: 
        !           697: What's GNU?  Gnu's Not Unix!
        !           698: ============================
        !           699: 
        !           700: GNU, which stands for Gnu's Not Unix, is the name for the complete
        !           701: Unix-compatible software system which I am writing so that I can give it
        !           702: away free to everyone who can use it.  Several other volunteers are helping
        !           703: me.  Contributions of time, money, programs and equipment are greatly
        !           704: needed.
        !           705: 
        !           706: So far we have an Emacs text editor with Lisp for writing editor commands,
        !           707: a source level debugger, a yacc-compatible parser generator, a linker, and
        !           708: around 35 utilities.  A shell (command interpreter) is nearly completed.  A
        !           709: new portable optimizing C compiler has compiled itself and may be released
        !           710: this year.  An initial kernel exists but many more features are needed to
        !           711: emulate Unix.  When the kernel and compiler are finished, it will be
        !           712: possible to distribute a GNU system suitable for program development.  We
        !           713: will use TeX as our text formatter, but an nroff is being worked on.  We
        !           714: will use the free, portable X window system as well.  After this we will
        !           715: add a portable Common Lisp, an Empire game, a spreadsheet, and hundreds of
        !           716: other things, plus on-line documentation.  We hope to supply, eventually,
        !           717: everything useful that normally comes with a Unix system, and more.
        !           718: 
        !           719: GNU will be able to run Unix programs, but will not be identical to Unix.
        !           720: We will make all improvements that are convenient, based on our experience
        !           721: with other operating systems.  In particular, we plan to have longer
        !           722: filenames, file version numbers, a crashproof file system, filename
        !           723: completion perhaps, terminal-independent display support, and perhaps
        !           724: eventually a Lisp-based window system through which several Lisp programs
        !           725: and ordinary Unix programs can share a screen.  Both C and Lisp will be
        !           726: available as system programming languages.  We will try to support UUCP,
        !           727: MIT Chaosnet, and Internet protocols for communication.
        !           728: 
        !           729: GNU is aimed initially at machines in the 68000/16000 class with virtual
        !           730: memory, because they are the easiest machines to make it run on.  The extra
        !           731: effort to make it run on smaller machines will be left to someone who wants
        !           732: to use it on them.
        !           733: 
        !           734: To avoid horrible confusion, please pronounce the `G' in the word `GNU'
        !           735: when it is the name of this project.
        !           736: 
        !           737: 
        !           738: Why I Must Write GNU
        !           739: ====================
        !           740: 
        !           741: I consider that the golden rule requires that if I like a program I must
        !           742: share it with other people who like it.  Software sellers want to divide
        !           743: the users and conquer them, making each user agree not to share with
        !           744: others.  I refuse to break solidarity with other users in this way.  I
        !           745: cannot in good conscience sign a nondisclosure agreement or a software
        !           746: license agreement.  For years I worked within the Artificial Intelligence
        !           747: Lab to resist such tendencies and other inhospitalities, but eventually
        !           748: they had gone too far: I could not remain in an institution where such
        !           749: things are done for me against my will.
        !           750: 
        !           751: So that I can continue to use computers without dishonor, I have decided to
        !           752: put together a sufficient body of free software so that I will be able to
        !           753: get along without any software that is not free.  I have resigned from the
        !           754: AI lab to deny MIT any legal excuse to prevent me from giving GNU away.
        !           755: 
        !           756: 
        !           757: Why GNU Will Be Compatible with Unix
        !           758: ====================================
        !           759: 
        !           760: Unix is not my ideal system, but it is not too bad.  The essential features
        !           761: of Unix seem to be good ones, and I think I can fill in what Unix lacks
        !           762: without spoiling them.  And a system compatible with Unix would be
        !           763: convenient for many other people to adopt.
        !           764: 
        !           765: 
        !           766: How GNU Will Be Available
        !           767: =========================
        !           768: 
        !           769: GNU is not in the public domain.  Everyone will be permitted to modify and
        !           770: redistribute GNU, but no distributor will be allowed to restrict its
        !           771: further redistribution.  That is to say, proprietary modifications will not
        !           772: be allowed.  I want to make sure that all versions of GNU remain free.
        !           773: 
        !           774: 
        !           775: Why Many Other Programmers Want to Help
        !           776: =======================================
        !           777: 
        !           778: I have found many other programmers who are excited about GNU and want to
        !           779: help.
        !           780: 
        !           781: Many programmers are unhappy about the commercialization of system
        !           782: software.  It may enable them to make more money, but it requires them to
        !           783: feel in conflict with other programmers in general rather than feel as
        !           784: comrades.  The fundamental act of friendship among programmers is the
        !           785: sharing of programs; marketing arrangements now typically used essentially
        !           786: forbid programmers to treat others as friends.  The purchaser of software
        !           787: must choose between friendship and obeying the law.  Naturally, many decide
        !           788: that friendship is more important.  But those who believe in law often do
        !           789: not feel at ease with either choice.  They become cynical and think that
        !           790: programming is just a way of making money.
        !           791: 
        !           792: By working on and using GNU rather than proprietary programs, we can be
        !           793: hospitable to everyone and obey the law.  In addition, GNU serves as an
        !           794: example to inspire and a banner to rally others to join us in sharing.
        !           795: This can give us a feeling of harmony which is impossible if we use
        !           796: software that is not free.  For about half the programmers I talk to, this
        !           797: is an important happiness that money cannot replace.
        !           798: 
        !           799: 
        !           800: How You Can Contribute
        !           801: ======================
        !           802: 
        !           803: I am asking computer manufacturers for donations of machines and money.
        !           804: I'm asking individuals for donations of programs and work.
        !           805: 
        !           806: One consequence you can expect if you donate machines is that GNU will run
        !           807: on them at an early date.  The machines should be complete, ready to use
        !           808: systems, approved for use in a residential area, and not in need of
        !           809: sophisticated cooling or power.
        !           810: 
        !           811: I have found very many programmers eager to contribute part-time work for
        !           812: GNU.  For most projects, such part-time distributed work would be very hard
        !           813: to coordinate; the independently-written parts would not work together.
        !           814: But for the particular task of replacing Unix, this problem is absent.  A
        !           815: complete Unix system contains hundreds of utility programs, each of which
        !           816: is documented separately.  Most interface specifications are fixed by Unix
        !           817: compatibility.  If each contributor can write a compatible replacement for
        !           818: a single Unix utility, and make it work properly in place of the original
        !           819: on a Unix system, then these utilities will work right when put together.
        !           820: Even allowing for Murphy to create a few unexpected problems, assembling
        !           821: these components will be a feasible task.  (The kernel will require closer
        !           822: communication and will be worked on by a small, tight group.)
        !           823: 
        !           824: If I get donations of money, I may be able to hire a few people full or
        !           825: part time.  The salary won't be high by programmers' standards, but I'm
        !           826: looking for people for whom building community spirit is as important as
        !           827: making money.  I view this as a way of enabling dedicated people to devote
        !           828: their full energies to working on GNU by sparing them the need to make a
        !           829: living in another way.
        !           830: 
        !           831: 
        !           832: Why All Computer Users Will Benefit
        !           833: ===================================
        !           834: 
        !           835: Once GNU is written, everyone will be able to obtain good system software
        !           836: free, just like air.
        !           837: 
        !           838: This means much more than just saving everyone the price of a Unix license.
        !           839: It means that much wasteful duplication of system programming effort will
        !           840: be avoided.  This effort can go instead into advancing the state of the
        !           841: art.
        !           842: 
        !           843: Complete system sources will be available to everyone.  As a result, a user
        !           844: who needs changes in the system will always be free to make them himself,
        !           845: or hire any available programmer or company to make them for him.  Users
        !           846: will no longer be at the mercy of one programmer or company which owns the
        !           847: sources and is in sole position to make changes.
        !           848: 
        !           849: Schools will be able to provide a much more educational environment by
        !           850: encouraging all students to study and improve the system code.  Harvard's
        !           851: computer lab used to have the policy that no program could be installed on
        !           852: the system if its sources were not on public display, and upheld it by
        !           853: actually refusing to install certain programs.  I was very much inspired by
        !           854: this.
        !           855: 
        !           856: Finally, the overhead of considering who owns the system software and what
        !           857: one is or is not entitled to do with it will be lifted.
        !           858: 
        !           859: Arrangements to make people pay for using a program, including licensing of
        !           860: copies, always incur a tremendous cost to society through the cumbersome
        !           861: mechanisms necessary to figure out how much (that is, which programs) a
        !           862: person must pay for.  And only a police state can force everyone to obey
        !           863: them.  Consider a space station where air must be manufactured at great
        !           864: cost: charging each breather per liter of air may be fair, but wearing the
        !           865: metered gas mask all day and all night is intolerable even if everyone can
        !           866: afford to pay the air bill.  And the TV cameras everywhere to see if you
        !           867: ever take the mask off are outrageous.  It's better to support the air
        !           868: plant with a head tax and chuck the masks.
        !           869: 
        !           870: Copying all or parts of a program is as natural to a programmer as
        !           871: breathing, and as productive.  It ought to be as free.
        !           872: 
        !           873: 
        !           874: Some Easily Rebutted Objections to GNU's Goals
        !           875: ==============================================
        !           876: 
        !           877:      "Nobody will use it if it is free, because that means they can't rely
        !           878:      on any support."
        !           879:      
        !           880:      "You have to charge for the program to pay for providing the
        !           881:      support."
        !           882: 
        !           883: If people would rather pay for GNU plus service than get GNU free without
        !           884: service, a company to provide just service to people who have obtained GNU
        !           885: free ought to be profitable.
        !           886: 
        !           887: We must distinguish between support in the form of real programming work
        !           888: and mere handholding.  The former is something one cannot rely on from a
        !           889: software vendor.  If your problem is not shared by enough people, the
        !           890: vendor will tell you to get lost.
        !           891: 
        !           892: If your business needs to be able to rely on support, the only way is to
        !           893: have all the necessary sources and tools.  Then you can hire any available
        !           894: person to fix your problem; you are not at the mercy of any individual.
        !           895: With Unix, the price of sources puts this out of consideration for most
        !           896: businesses.  With GNU this will be easy.  It is still possible for there to
        !           897: be no available competent person, but this problem cannot be blamed on
        !           898: distibution arrangements.  GNU does not eliminate all the world's problems,
        !           899: only some of them.
        !           900: 
        !           901: Meanwhile, the users who know nothing about computers need handholding:
        !           902: doing things for them which they could easily do themselves but don't know
        !           903: how.
        !           904: 
        !           905: Such services could be provided by companies that sell just hand-holding
        !           906: and repair service.  If it is true that users would rather spend money and
        !           907: get a product with service, they will also be willing to buy the service
        !           908: having got the product free.  The service companies will compete in quality
        !           909: and price; users will not be tied to any particular one.  Meanwhile, those
        !           910: of us who don't need the service should be able to use the program without
        !           911: paying for the service.
        !           912: 
        !           913:      "You cannot reach many people without advertising,
        !           914:      and you must charge for the program to support that."
        !           915:      
        !           916:      "It's no use advertising a program people can get free."
        !           917: 
        !           918: There are various forms of free or very cheap publicity that can be used to
        !           919: inform numbers of computer users about something like GNU.  But it may be
        !           920: true that one can reach more microcomputer users with advertising.  If this
        !           921: is really so, a business which advertises the service of copying and
        !           922: mailing GNU for a fee ought to be successful enough to pay for its
        !           923: advertising and more.  This way, only the users who benefit from the
        !           924: advertising pay for it.
        !           925: 
        !           926: On the other hand, if many people get GNU from their friends, and such
        !           927: companies don't succeed, this will show that advertising was not really
        !           928: necessary to spread GNU.  Why is it that free market advocates don't want
        !           929: to let the free market decide this?
        !           930: 
        !           931:      "My company needs a proprietary operating system
        !           932:      to get a competitive edge."
        !           933: 
        !           934: GNU will remove operating system software from the realm of competition.
        !           935: You will not be able to get an edge in this area, but neither will your
        !           936: competitors be able to get an edge over you.  You and they will compete in
        !           937: other areas, while benefitting mutually in this one.  If your business is
        !           938: selling an operating system, you will not like GNU, but that's tough on
        !           939: you.  If your business is something else, GNU can save you from being
        !           940: pushed into the expensive business of selling operating systems.
        !           941: 
        !           942: I would like to see GNU development supported by gifts from many
        !           943: manufacturers and users, reducing the cost to each.
        !           944: 
        !           945:      "Don't programmers deserve a reward for their creativity?"
        !           946: 
        !           947: If anything deserves a reward, it is social contribution.  Creativity can
        !           948: be a social contribution, but only in so far as society is free to use the
        !           949: results.  If programmers deserve to be rewarded for creating innovative
        !           950: programs, by the same token they deserve to be punished if they restrict
        !           951: the use of these programs.
        !           952: 
        !           953:      "Shouldn't a programmer be able to ask for a reward for his creativity?"
        !           954: 
        !           955: There is nothing wrong with wanting pay for work, or seeking to maximize
        !           956: one's income, as long as one does not use means that are destructive.  But
        !           957: the means customary in the field of software today are based on
        !           958: destruction.
        !           959: 
        !           960: Extracting money from users of a program by restricting their use of it is
        !           961: destructive because the restrictions reduce the amount and the ways that
        !           962: the program can be used.  This reduces the amount of wealth that humanity
        !           963: derives from the program.  When there is a deliberate choice to restrict,
        !           964: the harmful consequences are deliberate destruction.
        !           965: 
        !           966: The reason a good citizen does not use such destructive means to become
        !           967: wealthier is that, if everyone did so, we would all become poorer from the
        !           968: mutual destructiveness.  This is Kantian ethics; or, the Golden Rule.
        !           969: Since I do not like the consequences that result if everyone hoards
        !           970: information, I am required to consider it wrong for one to do so.
        !           971: Specifically, the desire to be rewarded for one's creativity does not
        !           972: justify depriving the world in general of all or part of that creativity.
        !           973: 
        !           974:      "Won't programmers starve?"
        !           975: 
        !           976: I could answer that nobody is forced to be a programmer.  Most of us cannot
        !           977: manage to get any money for standing on the street and making faces.  But
        !           978: we are not, as a result, condemned to spend our lives standing on the
        !           979: street making faces, and starving.  We do something else.
        !           980: 
        !           981: But that is the wrong answer because it accepts the questioner's implicit
        !           982: assumption: that without ownership of software, programmers cannot possibly
        !           983: be paid a cent.  Supposedly it is all or nothing.
        !           984: 
        !           985: The real reason programmers will not starve is that it will still be
        !           986: possible for them to get paid for programming; just not paid as much as
        !           987: now.
        !           988: 
        !           989: Restricting copying is not the only basis for business in software.  It is
        !           990: the most common basis because it brings in the most money.  If it were
        !           991: prohibited, or rejected by the customer, software business would move to
        !           992: other bases of organization which are now used less often.  There are
        !           993: always numerous ways to organize any kind of business.
        !           994: 
        !           995: Probably programming will not be as lucrative on the new basis as it is
        !           996: now.  But that is not an argument against the change.  It is not considered
        !           997: an injustice that sales clerks make the salaries that they now do.  If
        !           998: programmers made the same, that would not be an injustice either.  (In
        !           999: practice they would still make considerably more than that.)
        !          1000: 
        !          1001:      "Don't people have a right to control how their creativity is used?"
        !          1002: 
        !          1003: "Control over the use of one's ideas" really constitutes control over
        !          1004: other people's lives; and it is usually used to make their lives more
        !          1005: difficult.
        !          1006: 
        !          1007: People who have studied the issue of intellectual property rights carefully
        !          1008: (such as lawyers) say that there is no intrinsic right to intellectual
        !          1009: property.  The kinds of supposed intellectual property rights that the
        !          1010: government recognizes were created by specific acts of legislation for
        !          1011: specific purposes.
        !          1012: 
        !          1013: For example, the patent system was established to encourage inventors to
        !          1014: disclose the details of their inventions.  Its purpose was to help society
        !          1015: rather than to help inventors.  At the time, the life span of 17 years for
        !          1016: a patent was short compared with the rate of advance of the state of the
        !          1017: art.  Since patents are an issue only among manufacturers, for whom the
        !          1018: cost and effort of a license agreement are small compared with setting up
        !          1019: production, the patents often do not do much harm.  They do not obstruct
        !          1020: most individuals who use patented products.
        !          1021: 
        !          1022: The idea of copyright did not exist in ancient times, when authors
        !          1023: frequently copied other authors at length in works of non-fiction.  This
        !          1024: practice was useful, and is the only way many authors' works have survived
        !          1025: even in part.  The copyright system was created expressly for the purpose
        !          1026: of encouraging authorship.  In the domain for which it was
        !          1027: invented---books, which could be copied economically only on a printing
        !          1028: press---it did little harm, and did not obstruct most of the individuals
        !          1029: who read the books.
        !          1030: 
        !          1031: All intellectual property rights are just licenses granted by society
        !          1032: because it was thought, rightly or wrongly, that society as a whole would
        !          1033: benefit by granting them.  But in any particular situation, we have to ask:
        !          1034: are we really better off granting such license?  What kind of act are we
        !          1035: licensing a person to do?
        !          1036: 
        !          1037: The case of programs today is very different from that of books a hundred
        !          1038: years ago.  The fact that the easiest way to copy a program is from one
        !          1039: neighbor to another, the fact that a program has both source code and
        !          1040: object code which are distinct, and the fact that a program is used rather
        !          1041: than read and enjoyed, combine to create a situation in which a person who
        !          1042: enforces a copyright is harming society as a whole both materially and
        !          1043: spiritually; in which a person should not do so regardless of whether the
        !          1044: law enables him to.
        !          1045: 
        !          1046:      "Competition makes things get done better."
        !          1047: 
        !          1048: The paradigm of competition is a race: by rewarding the winner, we
        !          1049: encourage everyone to run faster.  When capitalism really works this way,
        !          1050: it does a good job; but its defenders are wrong in assuming it always works
        !          1051: this way.  If the runners forget why the reward is offered and become
        !          1052: intent on winning, no matter how, they may find other strategies---such as,
        !          1053: attacking other runners.  If the runners get into a fist fight, they will
        !          1054: all finish late.
        !          1055: 
        !          1056: Proprietary and secret software is the moral equivalent of runners in a
        !          1057: fist fight.  Sad to say, the only referee we've got does not seem to
        !          1058: object to fights; he just regulates them ("For every ten yards you run,
        !          1059: you can fire one shot").  He really ought to break them up, and penalize
        !          1060: runners for even trying to fight.
        !          1061: 
        !          1062:      "Won't everyone stop programming without a monetary incentive?"
        !          1063: 
        !          1064: Actually, many people will program with absolutely no monetary incentive.
        !          1065: Programming has an irresistible fascination for some people, usually the
        !          1066: people who are best at it.  There is no shortage of professional musicians
        !          1067: who keep at it even though they have no hope of making a living that way.
        !          1068: 
        !          1069: But really this question, though commonly asked, is not appropriate to the
        !          1070: situation.  Pay for programmers will not disappear, only become less.  So
        !          1071: the right question is, will anyone program with a reduced monetary
        !          1072: incentive?  My experience shows that they will.
        !          1073: 
        !          1074: For more than ten years, many of the world's best programmers worked at the
        !          1075: Artificial Intelligence Lab for far less money than they could have had
        !          1076: anywhere else.  They got many kinds of non-monetary rewards: fame and
        !          1077: appreciation, for example.  And creativity is also fun, a reward in itself.
        !          1078: 
        !          1079: Then most of them left when offered a chance to do the same interesting
        !          1080: work for a lot of money.
        !          1081: 
        !          1082: What the facts show is that people will program for reasons other than
        !          1083: riches; but if given a chance to make a lot of money as well, they will
        !          1084: come to expect and demand it.  Low-paying organizations do poorly in
        !          1085: competition with high-paying ones, but they do not have to do badly if the
        !          1086: high-paying ones are banned.
        !          1087: 
        !          1088:      "We need the programmers desperately.  If they demand that we
        !          1089:      stop helping our neighbors, we have to obey."
        !          1090: 
        !          1091: You're never so desperate that you have to obey this sort of demand.
        !          1092: Remember: millions for defense, but not a cent for tribute!
        !          1093: 
        !          1094:      "Programmers need to make a living somehow."
        !          1095: 
        !          1096: In the short run, this is true.  However, there are plenty of ways that
        !          1097: programmers could make a living without selling the right to use a program.
        !          1098: This way is customary now because it brings programmers and businessmen the
        !          1099: most money, not because it is the only way to make a living.  It is easy to
        !          1100: find other ways if you want to find them.  Here are a number of examples.
        !          1101: 
        !          1102: A manufacturer introducing a new computer will pay for the porting of
        !          1103: operating systems onto the new hardware.
        !          1104: 
        !          1105: The sale of teaching, hand-holding and maintenance services could also
        !          1106: employ programmers.
        !          1107: 
        !          1108: People with new ideas could distribute programs as freeware, asking for
        !          1109: donations from satisfied users, or selling hand-holding services.  I have
        !          1110: met people who are already working this way successfully.
        !          1111: 
        !          1112: Users with related needs can form users' groups, and pay dues.  A group
        !          1113: would contract with programming companies to write programs that the
        !          1114: group's members would like to use.
        !          1115: 
        !          1116: All sorts of development can be funded with a Software Tax:
        !          1117: 
        !          1118:      Suppose everyone who buys a computer has to pay x percent of
        !          1119:      the price as a software tax.  The government gives this to
        !          1120:      an agency like the NSF to spend on software development.
        !          1121:      
        !          1122:      But if the computer buyer makes a donation to software development
        !          1123:      himself, he can take a credit against the tax.  He can donate to
        !          1124:      the project of his own choosing---often, chosen because he hopes to
        !          1125:      use the results when it is done.  He can take a credit for any amount
        !          1126:      of donation up to the total tax he had to pay.
        !          1127:      
        !          1128:      The total tax rate could be decided by a vote of the payers of
        !          1129:      the tax, weighted according to the amount they will be taxed on.
        !          1130:      
        !          1131:      The consequences:
        !          1132:      
        !          1133:         * The computer-using community supports software development.
        !          1134:         * This community decides what level of support is needed.
        !          1135:         * Users who care which projects their share is spent on
        !          1136:           can choose this for themselves.
        !          1137: 
        !          1138: In the long run, making programs free is a step toward the post-scarcity
        !          1139: world, where nobody will have to work very hard just to make a living.
        !          1140: People will be free to devote themselves to activities that are fun, such
        !          1141: as programming, after spending the necessary ten hours a week on required
        !          1142: tasks such as legislation, family counseling, robot repair and asteroid
        !          1143: prospecting.  There will be no need to be able to make a living from
        !          1144: programming.
        !          1145: 
        !          1146: We have already greatly reduced the amount of work that the whole society
        !          1147: must do for its actual productivity, but only a little of this has
        !          1148: translated itself into leisure for workers because much nonproductive
        !          1149: activity is required to accompany productive activity.  The main causes of
        !          1150: this are bureaucracy and isometric struggles against competition.  Free
        !          1151: software will greatly reduce these drains in the area of software
        !          1152: production.  We must do this, in order for technical gains in productivity
        !          1153: to translate into less work for us.
        !          1154: 
        !          1155: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.