<object-oriented> In {object-oriented programming}, an
	instance of the data structure and behaviour defined by the
	object's {class}.  Each object has its own values for the
	{instance variables} of its class and can respond to the
	{methods} defined by its class.

	For example, an object of the "Point" class might have
	instance variables "x" and "y" and might respond to the "plot"
	method by drawing a dot on the screen at those coordinates.

	(2004-01-26)

After-sale handholding; something many software vendors
	promise but few deliver.  To hackers, most support people are
	useless - because by the time a hacker calls support he or she
	will usually know the software and the relevant manuals better
	than the support people (sadly, this is *not* a joke or
	exaggeration).  A hacker's idea of "support" is a tte--tte
	or exchange of {electronic mail} with the software's designer.

	[{Jargon File}]

	(1995-02-15)

<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)

1. <programming> An {address}, from the point of view of a
	programming language.  A pointer may be typed, with its {type}
	indicating the type of data to which it points.

	The terms "pointer" and "reference" are generally
	interchangable although particular programming languages often
	differentiate these two in subtle ways.  For example, {Perl}
	always calls them references, never pointers.  Conversely, in
	C, "pointer" is used, although "a reference" is often used to
	denote the concept that a pointer implements.

	{Anthony Hoare} once said:

	Pointers are like jumps, leading wildly from one part of the
	data structure to another.  Their introduction into high-level
	languages has been a step backward from which we may never
	recover.

	[C.A.R.Hoare "Hints on Programming Language Design", 1973,
	Prentice-Hall collection of essays and papers by Tony Hoare].

	2. <operating system> (Or "mouse pointer") An {icon}, usually
	a small arrow, that moves on the screen in response to
	movement of a {pointing device}, typically a {mouse}.  The
	pointer shows the user which object on the screen will be
	selected etc. when a mouse button is clicked.

	(1999-07-07)

1. The {supervisor} program or {operating system} on a
	computer.

	2. The entire computer system, including input/output devices,
	the {supervisor} program or {operating system} and possibly
	other {software}.

	3. Any large program.

	4. Any method or {algorithm}.

	[{Jargon File}]

<mathematics, graphics> A fractal is a rough or fragmented
	geometric shape that can be subdivided in parts, each of which
	is (at least approximately) a smaller copy of the whole.
	Fractals are generally self-similar (bits look like the whole)
	and independent of scale (they look similar, no matter how
	close you zoom in).

	Many mathematical structures are fractals; e.g. {Sierpinski
	triangle}, {Koch snowflake}, {Peano curve}, {Mandelbrot set}
	and {Lorenz attractor}.  Fractals also describe many
	real-world objects that do not have simple geometric shapes,
	such as clouds, mountains, turbulence, and coastlines.

	{Benoit Mandelbrot}, the discoverer of the {Mandelbrot set},
	coined the term "fractal" in 1975 from the Latin fractus or
	"to break".  He defines a fractal as a set for which the
	{Hausdorff Besicovich dimension} strictly exceeds the
	{topological dimension}.  However, he is not satisfied with
	this definition as it excludes sets one would consider
	fractals.

	{sci.fractals FAQ
	(ftp://src.doc.ic.ac.uk/usenet/usenet-by-group/sci.fractals/)}.

	See also {fractal compression}, {fractal dimension}, {Iterated
	Function System}.

	{Usenet} newsgroups: {news:sci.fractals},
	{news:alt.binaries.pictures.fractals}, {news:comp.graphics}.

	["The Fractal Geometry of Nature", Benoit Mandelbrot].

	[Are there non-self-similar fractals?]

	(1997-07-02)

<benchmark> A standard program or set of programs which can be
	run on different computers to give an inaccurate measure of
	their performance.

	"In the computer industry, there are three kinds of lies:
	lies, damn lies, and benchmarks."

	A benchmark may attempt to indicate the overall power of a
	system by including a "typical" mixture of programs or it may
	attempt to measure more specific aspects of performance, like
	graphics, I/O or computation (integer or {floating-point}).
	Others measure specific tasks like {rendering} polygons,
	reading and writing files or performing operations on
	matrices.  The most useful kind of benchmark is one which is
	tailored to a user's own typical tasks.  While no one
	benchmark can fully characterise overall system performance,
	the results of a variety of realistic benchmarks can give
	valuable insight into expected real performance.

	Benchmarks should be carefully interpreted, you should know
	exactly which benchmark was run (name, version); exactly what
	configuration was it run on (CPU, memory, compiler options,
	single user/multi-user, peripherals, network); how does the
	benchmark relate to your workload?

	Well-known benchmarks include {Whetstone}, {Dhrystone},
	{Rhealstone} (see {h}), the {Gabriel benchmarks} for {Lisp},
	the {SPECmark} suite, and {LINPACK}.

	See also {machoflops}, {MIPS}, {smoke and mirrors}.

	{Usenet} newsgroup: {news:comp.benchmarks}.

	{Tennessee BenchWeb (http://netlib.org/benchweb/)}.

	[{Jargon File}]

	(2002-03-26)

<language>

	1. A {relational language} designed by Jones and M. Sheeran in
	1986 for describing and designing circuits (a {hardware
	description language}).  Ruby programs denote {binary
	relations} and programs are built-up inductively from
	primitive relations using a pre-defined set of {relational
	operators}.  Ruby programs also have a geometric
	interpretation as networks of primitive relations connected by
	wires, which is important when layout is considered in circuit
	design.

	Ruby has been continually developed since 1986, and has been
	used to design many different kinds of circuits, including
	{systolic arrays}, {butterfly networks} and arithmetic
	circuits.

	{(ftp://ftp.cs.chalmers.se/pub/misc/ruby/)}.

	E-mail: <graham@cs.chalmers.se>.

	["Ruby - A Language of Relations and Higher-Order Functions",
	M. Sheeran, Proc 3rd Banff Workshop on Hardware Verification,
	Springer 1990].

	(1994-10-27)

	2. One of five pedagogical languages based on {Markov
	algorithms}, used in Higman's report (below).  The other
	languages are {Brilliant}, {Diamond}, {Nonpareil}, and
	{Pearl}.

	["Nonpareil, a Machine Level Machine Independent Language for
	the Study of Semantics", B. Higman, ULICS Intl Report No ICSI
	170, U London (1968)].

	(1994-10-27)

	3. A fully {object oriented} {interpreted} {scripting
	language} by Yukihiro Matsumoto <matz@netlab.co.jp>.

	Similar in scope to {Perl} and {Python}, Ruby has high-level
	{data types}, automatic {memory management}, {dynamic typing},
	a {module} system, {exceptions}, and a rich standard library.
	Other features are {CLU}-style {iterators} for {loop
	abstraction}, {singleton classes}/{methods} and {lexical
	closures}.

	In Ruby, everything is an {object}, including the basic data
	types.  For example, the number 1 is an instance of {class}
	Fixnum.

	Current version (stable): 1.6.7, as of 2002-03-01.

	{Ruby Home (http://www.ruby-lang.org/)}.

	{Ruby Central (http://www.rubycentral.com/)}.

	["Programming Ruby - The Pragmatic Programmer's Guide", David
	Thomas, Andrew Hunt, Yukihiro Matsumoto pub. Addison Wesley
	2000].

	(2002-06-19)

1. <architecture> {cache hit}.

	2. <World-Wide Web> A request to a {web server} from a {web
	browser} or other {client} (e.g. a {robot}).

	The number of hits on a server may be important for
	determining advertising revenue.

	In the course of loading a single {web page}, a browser may
	hit a web server many times e.g. to retrieve the page itself
	and each {image} on the page.  In contrast, caching by
	browsers and {web proxies} reduces the number of hits on the
	server because some requests are satisfied from the cache.

	3. <jargon> To press and release a key on the keyboard.  Some
	prefer the less aggressive "tap".

	(2000-02-20)

1. Not simulated.  Often used as a specific antonym to
	{virtual} in any of its jargon senses.

	2. <mathematics> {real number}.

	[{Jargon File}]

	(1997-03-12)

<operating system, programming> The process of carrying out
	the {instructions} in a computer program by a computer.

	See also {dry run}.

	(1996-05-13)

<programming, library> A collection of {subroutines} and
	{functions} stored in one or more files, usually in compiled
	form, for linking with other programs.  Libraries are one of
	the earliest forms of organised {code reuse}.  They are often
	supplied by the {operating system} or {software development
	environment} developer to be used in many different programs.
	The routines in a library may be general purpose or designed
	for some specific function such as three dimensional animated
	graphics.

	Libraries are linked with the user's program to form a
	complete {executable}.  The linking may be {static linking}
	or, in some systems, {dynamic linking}.

	(1998-11-21)

1. <mathematics> A collection of {nodes} and {edges}.

	See also {connected graph}, {degree}, {directed graph}, {Moore
	bound}, {regular graph}, {tree}.

	2. <graphics> A visual representation of algebraic equations
	or data.

	(1996-09-22)

<mathematics, data> The {ancestor} {node} in a {tree} that
	points to the current node (one of its child nodes).

	(2005-09-15)

1. <programming> The prototype for an {object} in an
	{object-oriented language}; analogous to a {derived type} in a
	{procedural language}.  A class may also be considered to be a
	set of objects which share a common structure and behaviour.
	The structure of a class is determined by the {class
	variables} which represent the {state} of an object of that
	class and the behaviour is given by a set of {methods}
	associated with the class.

	Classes are related in a {class hierarchy}.  One class may be
	a specialisation (a "{subclass}") of another (one of its
	"{superclasses}") or it may be composed of other classes or it
	may use other classes in a {client-server} relationship.  A
	class may be an {abstract class} or a {concrete class}.

	See also {signature}.

	2. <programming> See {type class}.

	3. <networking> One of three types of {Internet addresses}
	distinguished by their most significant bits.

	3. <language> A language developed by the {Andrew Project}.
	It was one of the first attempts to add {object-oriented}
	features to {C}.

	(1995-05-01)

<operating system> A character string which tells a program to
	perform a specific action.  Most commands take {arguments}
	which either modify the action performed or supply it with
	input.  Commands may be typed by the user or read from a file
	by a {command interpreter}.  It is also common to refer to
	menu items as commands.

	(1997-06-21)

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)

1. One of a small number of high-speed memory locations in a
	computer's {CPU}.  Registers differ from ordinary
	{random access memory} in several respects:

	There are only a small number of registers (the "register
	set"), typically 32 in a modern processor though some,
	e.g. {SPARC}, have as many as 144.  A register may be directly
	addressed with a few bits.  In contrast, there are usually
	millions of words of main memory (RAM), requiring at least
	twenty bits to specify a memory location.  Main memory
	locations are often specified indirectly, using an {indirect
	addressing} mode where the actual memory address is held in a
	register.

	Registers are fast; typically, two registers can be read and a
	third written -- all in a single cycle.  Memory is slower; a
	single access can require several cycles.

	The limited size and high speed of the register set makes it
	one of the critical resources in most computer architectures.
	{Register allocation}, typically one phase of the {back-end},
	controls the use of registers by a compiled program.

	See also {accumulator}, {FUBAR}, {orthogonal}, {register
	dancing}, {register allocation}, {register spilling}.

	2. An addressable location in a {memory-mapped} peripheral
	device.  E.g. the transmit data register in a {UART}.

1. Non-functional; {down}; {crash}ed.  Especially used of
	{hardware}.

	2. At {XEROX PARC}, software that is working but not
	undergoing continued development and support.

	[{Jargon File}]

<programming> To Traverse a data structure, especially an
	{array} or {linked-list} in {core}.

	See also {codewalker}, {silly walk}, {clobber}.

	(2001-04-12)

What many users feel for computers.

	"I don't really love computers, I just say that to get them
	into bed with me". (Terry Pratchet)

	[What did you expect in a computing dictionary?]

	(1995-05-10)

<language, architecture> (JVM) A specification for software
	which interprets {Java} programs that have been compiled into
	{byte-codes}, and usually stored in a ".class" file.  The JVM
	{instruction set} is {stack}-oriented, with variable
	instruction length.  Unlike some other instruction sets, the
	JVM's supports {object-oriented} programming directly by
	including instructions for object {method} invocation (similar
	to {subroutine} call in other instruction sets).

	The JVM itself is written in {C} and so can be {ported} to run
	on most {platforms}.  It needs {thread} support and {I/O} (for
	{dynamic class loading}).  The Java byte-code is independent
	of the platform.

	There are also some hardware implementations of the JVM.

	{Specification
	(http://www.javasoft.com/docs/books/vmspec/html/VMSpecTOC.doc.html)}.

	{Sun's Java chip
	(http://news.com/News/Item/0,4,9328,00.html)}.

	[Documentation?  Versions?]

	(2000-01-03)

1. <unit, text> (Sometimes abbreviated "pt") The unit of
	length used in {typography} to specify text character height,
	{rule} width, and other small measurements.

	There are six slightly different definitions: {Truchet point},
	{Didot point}, {ATA point}, {TeX point}, {Postscript point},
	and {IN point}.

	In Europe, the most commonly used is Didot and in the US, the
	formerly standard ATA point has essentially been replaced by
	the PostScript point due to the demise of traditional
	typesetting systems and rise of desktop computer based systems
	running software such as {QuarkXPress}, {Adobe InDesign} and
	{Adobe Pagemaker}.

	There are 20 {twips} in a point and 12 points in a {pica}
	(known as a "Cicero" in the Didot system).

	{Different point systems
	(http://www.vakcer.com/oberon/dtp/fonts/point.htm)}.

	(2004-12-23)

	2. <hardware> To move a {pointing device} so that the
	on-screen pointer is positioned over a certain object on the
	screen such as a {button} in a {graphical user interface}.  In
	most {window systems} it is then necessary to {click} a
	(physical) button on the pointing device to activate or select
	the object.  In some systems, just pointing to an object is
	known as "mouse-over" {event} which may cause some help text
	(called a "tool tip" in {Windows}) to be displayed.

	(2001-05-21)

<storage> These days, usually used synonymously with {Random
	Access Memory} or {Read-Only Memory}, but in the general sense
	it can be any device that can hold {data} in
	{machine-readable} format.

	(1996-05-25)

1. Not operating.  "The up escalator is down" is considered a
	humorous thing to say, and "The elevator is down" always
	means "The elevator isn't working" and never refers to what
	floor the elevator is on.  With respect to computers, this
	term has passed into the mainstream; the extension to other
	kinds of machine is still hackish.

	2. "go down" To stop functioning; usually said of the
	{system}.  The message from the {console} that every hacker
	hates to hear from the operator is "System going down in 5
	minutes".

	3. "take down", "bring down" To deactivate purposely, usually
	for repair work or {PM}.  "I'm taking the system down to work
	on that bug in the tape drive."  Occasionally one hears the
	word "down" by itself used as a verb in this sense.

	See {crash}; opposite: {up}.

	[{Jargon File}]

	(1994-12-07)

<algorithm, programming> A detailed sequence of actions to
	perform to accomplish some task.  Named after an Iranian
	mathematician, Al-Khawarizmi.

	Technically, an algorithm must reach a result after a {finite}
	number of steps, thus ruling out {brute force} search methods
	for certain problems, though some might claim that brute force
	search was also a valid (generic) algorithm.  The term is also
	used loosely for any sequence of actions (which may or may not
	terminate).

	{Paul E. Black's Dictionary of Algorithms, Data Structures,
	and Problems (http://www.nist.gov/dads/)}.

	(2002-02-05)

1. See {multithreading}.

	2. See {threaded code}.

	3. {topic thread}.

	[{Jargon File}]

<computer, parallel> (Or "multi-tasking", "multiprogramming",
	"concurrent processing", "concurrency", "process scheduling")
	A technique used in an {operating system} for sharing a single
	processor between several independent jobs.  The first
	multitasking operating systems were designed in the early
	1960s.

	Under "{cooperative multitasking}" the running task decides
	when to give up the CPU and under "{pre-emptive multitasking}"
	(probably more common) a system process called the
	"{scheduler}" suspends the currently running task after it has
	run for a fixed period known as a "{time-slice}".  In both
	cases the scheduler is responsible for selecting the next task
	to run and (re)starting it.

	The running task may relinquish control voluntarily even in a
	pre-emptive system if it is waiting for some external {event}.
	In either system a task may be suspended prematurely if a
	hardware {interrupt} occurs, especially if a higher priority
	task was waiting for this event and has therefore become
	runnable.

	The scheduling {algorithm} used by the scheduler determines
	which task will run next.  Some common examples are
	{round-robin} scheduling, {priority scheduling}, {shortest job
	first} and {guaranteed scheduling}.

	Multitasking introduces {overheads} because the processor
	spends some time in choosing the next job to run and in saving
	and restoring tasks' state, but it reduces the worst-case time
	from job submission to completion compared with a simple
	{batch} system where each job must finish before the next one
	starts.  Multitasking also means that while one task is
	waiting for some external event, the {CPU} to do useful work
	on other tasks.

	A multitasking operating system should provide some degree of
	protection of one task from another to prevent tasks from
	interacting in unexpected ways such as accidentally modifying
	the contents of each other's memory areas.

	The jobs in a multitasking system may belong to one or many
	users.  This is distinct from {parallel processing} where one
	user runs several tasks on several processors.  {Time-sharing}
	is almost synonymous but implies that there is more than one
	user.

	{Multithreading} is a kind of multitasking with low
	{overheads} and no protection of tasks from each other, all
	threads share the same memory.

	(1998-04-24)

<parallel> Sharing a single {CPU} between multiple tasks (or
	"threads") in a way designed to minimise the time required to
	switch threads.  This is accomplished by sharing as much as
	possible of the program execution environment between the
	different threads so that very little state needs to be saved
	and restored when changing thread.

	Multithreading differs from {multitasking} in that threads
	share more of their environment with each other than do tasks
	under multitasking.  Threads may be distinguished only by the
	value of their {program counters} and {stack pointers} while
	sharing a single {address space} and set of {global
	variables}.  There is thus very little protection of one
	thread from another, in contrast to multitasking.

	Multithreading can thus be used for very fine-grain
	multitasking, at the level of a few instructions, and so can
	hide {latency} by keeping the processor busy after one thread
	issues a long-latency instruction on which subsequent
	instructions in that thread depend.

	A {light-weight process} is somewhere between a thread and a
	full process.

	{TL0} is an example of a threaded machine language.
	{Dataflow} computation (E.g. {Id} and {SISAL}) is an extreme
	form of multithreading.

	(1997-12-23)

1. <electronics> An aspect of an electronic circuit which is
	determined by the wiring of the hardware, as opposed to being
	programmable in software or controlled by a switch.

	2. <software, jargon> In software, a synonym for {hard-coded}.

	3. By extension, anything that is not modifiable, especially
	in the sense of customisable to one's particular needs or
	tastes.

	[{Jargon File}]

	(1999-10-18)

<language, tool> A {Unix} tool written in {Tcl} and a {script
	language} for automating the operation of {interactive}
	applications such as {telnet}, {FTP}, {passwd}, {fsck},
	{rlogin}, {tip}, etc..  Expect can feed input to other
	programs and perform {pattern matching} on their output.  It
	is also useful for testing these applications.  By adding
	{Tk}, you can also wrap interactive applications in {X11}
	{GUIs}.

	{Home (http://expect.nist.gov/)}.

	["expect: Scripts for Controlling Interactive Tasks", Don
	Libes, Comp Sys 4(2), U Cal Press Journals, Nov 1991].

	(1997-06-09)

1. <storage> {Main memory} or {RAM}.  This term dates from the
	days of {ferrite core memory}; now archaic most places outside
	{IBM}, but also still used in the {Unix} community and by
	old-time {hackers} or those who would sound like them.

	Some derived idioms are quite current; "in core", for example,
	means "in memory" ({paged in}, as opposed to "on disk", {paged
	out}), and both {core dump} and the "core image" or "core
	file" produced by one are terms in favour.  Some varieties of
	Commonwealth hackish prefer {store}.

	[{Jargon File}]

	(1995-03-03)

	2. <processor> An {integrated circuit} design, usually for a
	{microprocessor}, which includes only the {CPU} and which is
	intended to form part of a complete circuit design which
	incorporates other circuits on the same chip such as {cache},
	{memory management unit}, I/O ports and timers.

	The {ARM6}, {ARM7} and {ARM8} are examples.

	3. <language> A varient on {kernel} as used to describe
	features built into a language as opposed to those provided by
	{libraries}.

	(1995-03-03)

1. <software> An occurrence or happening of significance to a
	task or program, such as the completion of an asynchronous
	input/output operation.  A task may wait for an event or any
	of a set of events or it may (request to) receive asynchronous
	notification (a {signal} or {interrupt}) that the event has
	occurred.

	See also {event-driven}.

	2. <data> A transaction or other activity that affects the
	records in a file.

	(2000-02-09)

<database> An action causing the automatic invocation of a
	procedure, for instance to preserve {referential integrity}.
	A triggers goes into effect when a user attempts to modify
	data with an insert, delete, or update command.  A trigger can
	instruct the system to take any number of actions when a
	specified change is attempted.  By preventing incorrect,
	unauthorized, or inconsistent changes to data, triggers help
	maintain the integrity of the database.

	[Sybase SQL Server Release 10.0 Transact-SQL User's Guide].

	(1995-02-22)

<storage> The part of a {disk} which passes under one
	read/write head while the head is stationary.  The number of
	tracks on a disk surface therefore corresponds to the number
	of different radial positions of the head(s).  The collection
	of all tracks on all surfaces at a given radial position is
	known a {cylinder} and each track is divided into {sectors}.

	(1997-07-15)

<jargon, architecture> (Via the technical term {virtual
	memory}, probably from the term "virtual image" in optics)
	1. Common alternative to {logical}; often used to refer to the
	artificial objects (like addressable {virtual memory} larger
	than physical memory) created by a computer system to help the
	system control access to shared resources.

	2. Simulated; performing the functions of something that isn't
	really there.  An imaginative child's doll may be a virtual
	playmate.

	Opposite of {real} or physical.

	[{Jargon File}]

	(1994-11-30)

<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)

[probably from "main store"] In some varieties of Commonwealth
	hackish, the preferred synonym for {core}.  Thus, "bringing a
	program into store" means not that one is returning
	shrink-wrapped software but that a program is being {swap}ped
	in.

	[{Jargon File}]

<chat> (From SF fandom via {Usenet}) In My Humble Opinion.
	Also seen in variant forms such as IMO, IMNSHO (In My
	Not-So-Humble Opinion) and IMAO (In My Arrogant Opinion).

	[{Jargon File}]

	(1998-09-24)

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. <programming> A variable or quantity that can take on one
	of two values; a bit, particularly one that is used to
	indicate one of two outcomes or is used to control which of
	two things is to be done.  "This flag controls whether to
	clear the screen before printing the message."  "The program
	status word contains several flag bits."  See also {hidden
	flag}, {mode bit}.

	2. {command line option}.

	[{Jargon File}]

	(1998-05-02)

1. Resources (in computing usually processing time or storage
	space) consumed for purposes which are incidental to, but
	necessary to, the main one.  Overheads are usually
	quantifiable "costs" of some kind.

	Examples: The overheads in running a business include the cost
	of heating the building.  Keeping a program running all the
	time eliminates the overhead of loading and initialising it
	for each transaction.  Turning a {subroutine} into {inline}
	code eliminates the call and return time overhead for each
	execution but introduces space overheads.

	2. <communications> information, such as control, routing, and
	error checking characters, that is transmitted along with the
	user data.  It also includes information such as network
	status or operational instructions, network routing
	information, and retransmissions of user data received in
	error.

	3. Overhead transparencies or "slides" (usually 8-1/2" x 11")
	that are projected to an audience via an overhead (flatbed)
	projector.

	(1997-09-01)

<programming> The name given in {Smalltalk} and other
	{object-oriented languages} to a procedure or routine
	associated with one or more {classes}.  An {object} of a
	certain class knows how to perform actions, e.g. printing
	itself or creating a new instance of itself, rather than the
	function (e.g. printing) knowing how to handle different types
	of object.

	Different classes may define methods with the same name
	(i.e. methods may be {polymorphic}).  The term "method" is used
	both for a named operation, e.g. "PRINT" and also for the code
	which a specific class provides to perform tha
	t operation.

	Most methods operate on objects that are instances of a
	certain class.  Some object-oriented languages call these
	"object methods" to distinguish then from "{class methods}".

	In {Smalltalk}, a method is defined by giving its name,
	documentation, temporary local variables and a sequence of
	expressions separated by "."s.

	(2000-03-22)

<character> The space character, {ASCII} 32.

	See {octal forty}.

<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)

1. <unit> A unit of data or memory, often, but not
	exclusively, on a {magnetic disk} or {magnetic tape}.

	Compare {record}, {sector}.

	(2000-07-17)

	2. <operating system> To delay or sit idle while waiting for
	something.

	Compare {busy-wait}.

	(2000-07-17)

	3. <programming> A delimited section of {source code} in a
	{block-structured} language.

	(2004-09-29)

1. <character> {hash character}.

	2. <programming> {hash coding}.

	3. The preferred term for a {Perl} {associative array}.

	(1995-03-06)

<library, networking> {Berkeley} {Unix} networking {socket}
	library routine to satisfy a connection request from a remote
	{host}.  A specified socket on the local host (which must be
	capable of accepting the connection) is connected to the
	requesting socket on the remote host.  The remote socket's
	socket address is returned.

	{Unix manual pages}: accept(2), connect(2).

	(1994-11-08)

[{Usenet}] 1. To duplicate a portion (or whole) of another's
	message (typically with attribution to the source) in a reply
	or followup, for clarifying the context of one's response.
	See the discussion of inclusion styles under "Hacker Writing
	Style".

	2. [{C}] "#include <disclaimer.h>" has appeared in {sig
	blocks} to refer to a notional "standard {disclaimer} file".

	[{Jargon File}]

<jargon> Different systems (e.g., {programs}, {file formats},
	{protocols}, even {programming languages}) that can work
	together or exchange data are said to be compatible.

	See also {backward compatible}, {forward compatible}.

	(1998-01-15)

<programming> Repetition of a sequence of instructions.  A
	fundamental part of many {algorithms}.  Iteration is
	characterised by a set of initial conditions, an iterative
	step and a termination condition.

	A well known example of iteration in mathematics is
	Newton-Raphson iteration.  Iteration in programs is expressed
	using {loops}, e.g. in {C}:

		new_x = n/2;
		do
		{
		  x = new_x;
		  new_x = 0.5 * (x + n/x);
		} while (abs(new_x-x) > epsilon);

	Iteration can be expressed in functional languages using
	recursion:

		solve x n = if abs(new_x-x) > epsilon
			    then solve new_x n
			    else new_x
			    where new_x = 0.5 * (x + n/x)

	        solve n/2 n

	(1998-04-04)

<unit> (b) {binary} digit.

	The unit of information; the amount of information obtained by
	asking a yes-or-no question; a computational quantity that can
	take on one of two values, such as false and true or 0 and 1;
	the smallest unit of storage - sufficient to hold one bit.

	A bit is said to be "set" if its value is true or 1, and
	"reset" or "clear" if its value is false or 0.  One speaks of
	setting and clearing bits.  To {toggle} or "invert" a bit is
	to change it, either from 0 to 1 or from 1 to 0.

	The term "bit" first appeared in print in the computer-science
	sense in 1949, and seems to have been coined by the eminent
	statistician, {John Tukey}.  Tukey records that it evolved
	over a lunch table as a handier alternative to "bigit" or
	"binit".

	See also {flag}, {trit}, {mode bit}, {byte}, {word}.

	[{Jargon File}]

	(2002-01-22)

<programming> (Or "arg") A value or reference passed to a
	{function}, {procedure}, {subroutine}, command or program, by
	the caller.  For example, in the function definition

		square(x) = x * x

	x is the {formal argument} or "parameter", and in the call

		y = square(3+4)

	3+4 is the {actual argument}.  This will execute the function
	square with x having the value 7 and return the result 49.

	There are many different conventions for passing arguments to
	functions and procedures including {call-by-value},
	{call-by-name}, {call-by-reference}, {call-by-need}.  These
	affect whether the value of the argument is computed by the
	caller or the callee (the function) and whether the callee can
	modify the value of the argument as seen by the caller (if it
	is a variable).

	Arguments to functions are usually, following mathematical
	notation, written in parentheses after the function name,
	separated by commas (but see {curried function}).  Arguments
	to a program are usually given after the command name,
	separated by spaces, e.g.:

		cat myfile yourfile hisfile

	Here "cat" is the command and "myfile", "yourfile", and
	"hisfile" are the arguments.

	(2006-05-27)

<programming, operating system> A {variable} that is bound in
	the current environment.  When evaluating an expression in
	some environment, the evaluation of a variable consists of
	looking up its name in the environment and substituting its
	value.

	Most programming languages have some concept of an environment
	but in {Unix} {shell scripts} it has a specific meaning
	slightly different from other contexts.  In shell scripts,
	environment variables are one kind of {shell variable}.  They
	differ from {local variables} and {command line arguments} in
	that they are inheritted by a {child process}.  Examples are
	the PATH variable that tells the shell the {file system}
	{paths} to search to find command {executables} and the TZ
	variable which contains the local time zone.  The variable
	called "SHELL" specifies the type of shell being used.

	These variables are used by commands or {shell scripts} to
	discover things about the environment they are operating in.
	Environment variables can be changed or created by the {user}
	or a program.

	To see a list of environment variables type "setenv" at the
	{csh} or {tcsh} {prompt} or "set" at the {sh}, {bash}, {jsh}
	or {ksh} prompt.

	In other programming languages, e.g. {functional programming}
	languages, the environment is extended with new bindings when
	a {function}'s {parameters} are bound to its {actual
	arguments} or when new variables are declared.  In a
	{block-structured} {procedural} language, the environment
	usually consists of a {linked list} of {activation records}.

	(1999-01-26)

<architecture> Not synchronised by a shared signal such as
	{clock} or {semaphore}, proceeding independently.

	Opposite: {synchronous}.

	1. <operating system> A {process} in a {multitasking} system
	whose execution can proceed independently, "in the
	{background}".  Other processes may be started before the
	asynchronous process has finished.

	2. <communications> A communications system in which data
	transmission may start at any time and is indicated by a
	{start bit}, e.g. {EIA-232}.  A data {byte} (or other element
	defined by the {protocol}) ends with a {stop bit}.  A
	continuous marking condition (identical to stop bits but not
	quantized in time), is then maintained until data resumes.

	(1995-12-08)