<programming> An unwanted and unintended property of a program
	or piece of hardware, especially one that causes it to
	malfunction.  Antonym of {feature}.  E.g. "There's a bug in
	the editor: it writes things out backward."  The
	identification and removal of bugs in a program is called
	"{debugging}".

	Admiral {Grace Hopper} (an early computing pioneer better
	known for inventing {COBOL}) liked to tell a story in which a
	technician solved a {glitch} in the {Harvard Mark II machine}
	by pulling an actual insect out from between the contacts of
	one of its relays, and she subsequently promulgated {bug} in
	its hackish sense as a joke about the incident (though, as she
	was careful to admit, she was not there when it happened).
	For many years the logbook associated with the incident and
	the actual bug in question (a moth) sat in a display case at
	the Naval Surface Warfare Center (NSWC).  The entire story,
	with a picture of the logbook and the moth taped into it, is
	recorded in the "Annals of the History of Computing", Vol. 3,
	No. 3 (July 1981), pp. 285--286.

	The text of the log entry (from September 9, 1947), reads
	"1545 Relay #70 Panel F (moth) in relay.  First actual case of
	bug being found".  This wording establishes that the term was
	already in use at the time in its current specific sense - and
	Hopper herself reports that the term "bug" was regularly
	applied to problems in radar electronics during WWII.

	Indeed, the use of "bug" to mean an industrial defect was
	already established in Thomas Edison's time, and a more
	specific and rather modern use can be found in an electrical
	handbook from 1896 ("Hawkin's New Catechism of Electricity",
	Theo. Audel & Co.)  which says: "The term "bug" is used to a
	limited extent to designate any fault or trouble in the
	connections or working of electric apparatus."  It further
	notes that the term is "said to have originated in
	{quadruplex} telegraphy and have been transferred to all
	electric apparatus."

	The latter observation may explain a common folk etymology of
	the term; that it came from telephone company usage, in which
	"bugs in a telephone cable" were blamed for noisy lines.
	Though this derivation seems to be mistaken, it may well be a
	distorted memory of a joke first current among *telegraph*
	operators more than a century ago!

	Actually, use of "bug" in the general sense of a disruptive
	event goes back to Shakespeare!  In the first edition of
	Samuel Johnson's dictionary one meaning of "bug" is "A
	frightful object; a walking spectre"; this is traced to
	"bugbear", a Welsh term for a variety of mythological monster
	which (to complete the circle) has recently been reintroduced
	into the popular lexicon through fantasy {role-playing games}.

	In any case, in jargon the word almost never refers to
	insects.  Here is a plausible conversation that never actually
	happened:

	"There is a bug in this ant farm!"

	"What do you mean?  I don't see any ants in it."

	"That's the bug."

	[There has been a widespread myth that the original bug was
	moved to the Smithsonian, and an earlier version of this entry
	so asserted.  A correspondent who thought to check discovered
	that the bug was not there.  While investigating this in late
	1990, your editor discovered that the NSWC still had the bug,
	but had unsuccessfully tried to get the Smithsonian to accept
	it - and that the present curator of their History of
	American Technology Museum didn't know this and agreed that it
	would make a worthwhile exhibit.  It was moved to the
	Smithsonian in mid-1991, but due to space and money
	constraints has not yet been exhibited.  Thus, the process of
	investigating the original-computer-bug bug fixed it in an
	entirely unexpected way, by making the myth true!  - ESR]

	[{Jargon File}]

	(1999-06-29)

<software> Instructions for a computer in some programming
	language, often {machine language}.  The word "code" is often
	used to distinguish instructions from {data} (e.g. "The code
	is marked 'read-only'") whereas "{software}" is used in
	contrast with "{hardware}" and may consist of more than just
	code.

	(2000-04-08)

<programming> A sequence of {data} values, usually {bytes},
	which usually stand for {characters} (a "character string").
	The {mapping} between values and characters is determined by
	the {character set} which is itself specified implcitly or
	explicitly by the environment in which the string is being
	interpreted.

	The most common character set is {ASCII} but, since the late
	1990s, there has been increased interest in larger character
	sets such as {Unicode} where each character is represented by
	more than eight {bits}.

	Most programming languages consider strings (e.g.
	"124:shabooya:\n", "hello world") basically distinct from
	numbers which are typically stored in fixed-length {binary} or
	{floating-point} representation.

	A {bit string} is a sequence of {bits}.

	(1999-12-21)

<programming> (Sometimes "var" /veir/ or /var/) A named memory
	location in which a program can store intermediate results and
	from which it can read it them.  Each {programming language}
	has different rules about how variables can be named, typed,
	and used.  Typically, a value is "assigned" to a variable in
	an {assignment} statement.  The value is obtained by
	evaluating an expression and then stored in the variable.  For
	example, the assignment

		x = y + 1

	means "add one to y and store the result in x".  This may look
	like a mathematical equation but the mathematical equality is
	only true in the program until the value of x or y changes.
	Furthermore, statements like

		x = x + 1

	are common.  This means "add one to x", which only makes sense
	as a state changing operation, not as a mathematical equality.

	The simplest form of variable corresponds to a single-{word}
	of {memory} or a {CPU} {register} and an assignment to a
	{load} or {store} {machine code} operation.

	A variable is usually defined to have a {type}, which never
	changes, and which defines the set of values the variable can
	hold.  A type may specify a single ("atomic") value or a
	collection ("aggregate") of values of the same or different
	types.  A common aggregate type is the {array} - a set of
	values, one of which can be selected by supplying a numerical
	{index}.

	Languages may be {untyped}, {weakly typed}, {strongly typed},
	or some combination.  {Object-oriented programming} languages
	extend this to {object} types or {classes}.

	A variable's {scope} is the region of the program source
	within which it represents a certain thing.  Scoping rules are
	also highly language dependent but most serious languages
	support both {local variables} and {global variables}.
	{Subroutine} and {function} {formal arguments} are special
	variables which are set automatically by the language runtime
	on entry to the subroutine.

	In a {functional programming} language, a variable's value
	never changes and change of state is handled as recursion over
	lists of values.

	(2004-11-16)

<language, programming> (Or "source", or rarely "source
	language") The form in which a computer program is written by
	the programmer.  Source code is written in some formal
	programming language which can be compiled automatically into
	{object code} or {machine code} or executed by an
	{interpreter}.

	(1995-01-05)

<data> A data structure holding many values, possibly of
	different types, which is usually accessed sequentially,
	working from the head to the end of the tail - an "ordered
	list".  This contrasts with a (one-dimensional) {array}, any
	element of which can be accessed equally quickly.

	Lists are often stored using a cell and pointer arrangement
	where each value is stored in a cell along with an associated
	pointer to the next cell.  A special pointer, e.g. zero, marks
	the end of the list.  This is known as a (singly) "linked
	list".  A doubly linked list has pointers from each cell to
	both next and previous cells.

	An unordered list is a {set}.

	(1998-11-12)

<jargon> /pree'pend'/ (by analogy with "append") To prefix or
	add to the beginning.

	[{Jargon File}]

	(1998-04-23)

1. <mathematics> (Or "map", "mapping") If D and C are sets
	(the domain and codomain) then a function f from D to C,
	normally written "f : D -> C" is a subset of D x C such that:

	1. For each d in D there exists some c in C such that (d,c) is
	an element of f.  I.e. the function is defined for every
	element of D.

	2. For each d in D, c1 and c2 in C, if both (d,c1) and (d,c2)
	are elements of f then c1 = c2.  I.e. the function is uniquely
	defined for every element of D.

	See also {image}, {inverse}, {partial function}.

	2. <programming> Computing usage derives from the mathematical
	term but is much less strict.  In programming (except in
	{functional programming}), a function may return different
	values each time it is called with the same argument values
	and may have {side effects}.

	A {procedure} is a function which returns no value but has
	only {side-effects}.  The {C} language, for example, has no
	procedures, only functions.  {ANSI C} even defines a {type},
	{void}, for the result of a function that has no result.

	(1996-09-01)

1. A discrepancy between a computed, observed, or measured
	value or condition and the true, specified, or theoretically
	correct value or condition.

	2. <programming> A mental mistake made by a programmer that
	may result in a program {fault}.

	3. (verb) What a program does when it stops as result of a
	programming error.

	(2000-03-28)

1. <hardware> An electrical conductor.  For distances larger
	than a breadbox, a single line may consist of two electrical
	conductors in twisted, parallel, or concentric arrangement
	used to transport one logical signal.

	By extension, a (usually physical) medium such as an {optical
	fibre} which carries a signal.

	(1995-09-29)

To produce something according to an {algorithm} or program or
	set of rules, or as a (possibly unintended) {side effect} of
	the execution of an algorithm or program.

	The opposite of {parse}.

	[{Jargon File}]

	(1995-06-15)

1. <programming> A collection of identically typed data items
	distinguished by their indices (or "subscripts").  The number
	of dimensions an array can have depends on the language but is
	usually unlimited.

	An array is a kind of {aggregate} data type.  A single
	ordinary variable (a "{scalar}") could be considered as a
	zero-dimensional array.  A one-dimensional array is also known
	as a "{vector}".

	A reference to an array element is written something like
	A[i,j,k] where A is the array name and i, j and k are the
	indices.  The {C} language is peculiar in that each index is
	written in separate brackets, e.g. A[i][j][k].  This expresses
	the fact that, in C, an N-dimensional array is actually a
	vector, each of whose elements is an N-1 dimensional array.

	Elements of an array are usually stored contiguously.
	Languages differ as to whether the leftmost or rightmost index
	varies most rapidly, i.e. whether each row is stored
	contiguously or each column (for a 2D array).

	Arrays are appropriate for storing data which must be accessed
	in an unpredictable order, in contrast to {lists} which are
	best when accessed sequentially.

	See also {associative array}.

	2. <architecture> A {processor array}, not to be confused with
	an {array processor}.

	(1995-01-25)

(Plural "indices" or "indexes")

	1. <programming> A number used to select an element of a list,
	vector, {array} or other sequence.  Such indices are nearly
	always non-negative integers but see {associative array}.

	2. <database> See {inverted index}.  [Other kinds?]

	3. <World-Wide Web> A {search engine}.

	4. <World-Wide Web> A {subject index}.

	4. <jargon> See {coefficient of X}.

	[{Jargon File}]

	(1997-04-09)

<programming> A special value used in several languages to
	represent the thing referred to by an uninitialised pointer.

	<database> A special value that may be stored in some database
	columns to represent an unknown, missing, not applicable, or
	undefined value.  Nulls are treated completely differently
	from ordinary values when evaluating SQL expressions and there
	are several SQL constructs for dealing with nulls.

	(2003-06-17)

<programming> (Or "parameter") A name in a {function} or
	{subroutine} definition that is replaced by, or bound to, the
	corresponding {actual argument} when the function or
	subroutine is called.  In many languages formal arguments
	behave like {local variables} which get initialised on entry.

	See: {argument}.

	(2002-07-02)