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)

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)

1. <programming> A common name for the {integer} data type.
	In {C} for example, it means a (signed) integer of the
	computer's native {word length}.

	2. <networking> The {top-level domain} for international
	organisations.

	(1999-01-26)

1. See {multithreading}.

	2. See {threaded code}.

	3. {topic thread}.

	[{Jargon File}]

[WPI] 1. Badly written or functionally poor, e.g. a program
	that is very difficult to use because of gratuitously poor
	design decisions.  Opposite: {cuspy}.

	2. Anything that manipulates a shared resource without regard
	for its other users in such a way as to cause a (non-fatal)
	problem.  Examples: programs that change tty modes without
	resetting them on exit, or windowing programs that keep
	forcing themselves to the top of the window stack.  Compare
	{all-elbows}.

	[{Jargon File}]

	(1994-10-27)

1. <networking> {segmentation}.

	2. The process, or result, of splitting a large area of free
	memory (on disk or in main memory) into smaller non-contiguous
	blocks.  This happens after many blocks have been allocated
	and freed.  For example, if there is 3 kilobytes of free space
	and two 1k blocks are allocated and then the first one (at the
	lowest address) is freed, then there will be 2k of free space
	split between the two 1k blocks.  The maximum size block that
	could then be allocated would be 1k, even though there was 2k
	free.  The solution is to "compact" the free space by moving
	the allocated blocks to one end (and thus the free space to
	the other).

	As modern file systems are used and files are deleted and
	created, the total free space becomes split into smaller
	non-contiguous blocks (composed of "{clusters}" or "{sectors}"
	or some other unit of allocation).  Eventually new files being
	created, and old files being extended, cannot be stored each
	in a single contiguous block but become scattered across the
	file system.  This degrades performance as multiple {seek}
	operations are required to access a single fragmented file.

	Defragmenting consolidates each existing file and the free
	space into a continuous group of sectors.  Access speed will
	be improved due to reduced seeking.

	The rate of fragmentation depends on the {algorithm} used to
	allocate space and the number and position of free sectors.  A
	nearly-full file system will fragment more quickly.

	{MSDOS} and {Microsoft Windows} use the simplest algorithm to
	allocate free clusters and so fragmentation occurs quickly.  A
	disk should be defragmented before fragmentation reaches 10%.

	See {garbage collection}.

	(1997-08-29)