<file system> An element of data storage in a {file system}.

	The history of computing is rich in varied kinds of files and
	{file systems}, whether ornate (e.g., {Macintosh file system}
	for a well-known case) or deficient (e.g., many simple
	pre-1980s file systems don't allow {directories}).

	However, the prototypical file has these characteristics:

	* It is a single sequence of bytes (but consider {Macintosh}
	{resource forks}).

	* It has a finite length, unlike, e.g. a {Unix} {device}.

	* It is stored in a {non-volatile storage} medium (but see
	{ramdrive}).

	* It exists (nominally) in a {directory}.

	* It has a name that it can be referred to by in file
	operations, possibly in combination with its {path}.

	Additionally, a file system may associate other information
	with a file, such as {permission} bits or other {file
	attributes}; timestamps for file creation, last revision, and
	last access; revision numbers (a` la VMS), and other kinds of
	{magic}.

	Compare: {document}.

	(1997-04-08)

<programming> A program which executes other programs.  This
	is in contrast to a {compiler} which does not execute its
	input program (the "{source code}") but translates it into
	executable "{machine code}" (also called "{object code}")
	which is output to a file for later execution.  It may be
	possible to execute the same source code either directly by an
	interpreter or by compiling it and then executing the {machine
	code} produced.

	It takes longer to run a program under an interpreter than to
	run the compiled code but it can take less time to interpret
	it than the total required to compile and run it.  This is
	especially important when prototyping and testing code when an
	edit-interpret-debug cycle can often be much shorter than an
	edit-compile-run-debug cycle.

	Interpreting code is slower than running the compiled code
	because the interpreter must analyse each statement in the
	program each time it is executed and then perform the desired
	action whereas the compiled code just performs the action.
	This run-time analysis is known as "interpretive overhead".
	Access to variables is also slower in an interpreter because
	the mapping of identifiers to storage locations must be done
	repeatedly at run time rather than at compile time.

	There are various compromises between the development speed
	when using an interpreter and the execution speed when using a
	compiler.  Some systems (e.g. some {Lisps}) allow interpreted
	and compiled code to call each other and to share variables.
	This means that once a routine has been tested and debugged
	under the interpreter it can be compiled and thus benefit from
	faster execution while other routines are being developed.
	Many interpreters do not execute the source code as it stands
	but convert it into some more compact internal form.  For
	example, some {BASIC} interpreters replace {keywords} with
	single byte tokens which can be used to {index} into a {jump
	table}.  An interpreter might well use the same {lexical
	analyser} and {parser} as the compiler and then interpret the
	resulting {abstract syntax tree}.

	There is thus a spectrum of possibilities between interpreting
	and compiling, depending on the amount of analysis performed
	before the program is executed.  For example {Emacs Lisp} is
	compiled to "{byte-code}" which is a highly compressed and
	optimised representation of the Lisp source but is not machine
	code (and therefore not tied to any particular hardware).
	This "compiled" code is then executed (interpreted) by a {byte
	code interpreter} (itself written in {C}).  The compiled code
	in this case is {machine code} for a {virtual machine} which
	is implemented not in hardware but in the byte-code
	interpreter.

	See also {partial evaluation}.

	(1995-01-30)

<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> (Or "computer program", "program", "code") The
	instructions executed by a computer, as opposed to the
	physical device on which they run (the "{hardware}").

	The term was coined by the eminent statistician, {John Tukey}.

	Programs stored on {non-volatile storage} built from
	{integrated circuits} (e.g. {ROM} or {PROM}) are usually
	called {firmware}.

	Software can be split into two main types - {system software}
	and application software or {application programs}.  System
	software is any software required to support the production or
	execution of application programs but which is not specific to
	any particular application.  Examples of system software would
	include the {operating system}, {compilers}, editors and
	sorting programs.

	Examples of application programs would include an accounts
	package or a {CAD} program.  Other broad classes of
	application software include {real-time} software, {business
	software}, scientific and engineering software, {embedded
	software}, personal computer software and {artificial
	intelligence} software.

	Software includes both {source code} written by humans and
	executable {machine code} produced by {assemblers} or
	{compilers}.  It does not usually include the data processed
	by programs unless this is in a format such as {multimedia}
	which depends on the use of computers for its presentation.
	This distinction becomes unclear in cases such as {spread
	sheets} which can contain both instructions (formulae and
	{macros}) and data.  There are also various intermediate
	compiled or {semi-compiled}, forms of software such as
	{library} files and {byte-code}.

	Some claim that {documentation} (both paper and electronic) is
	also software.  Others go further and define software to be
	programs plus documentation though this does not correspond
	with common usage.

	The noun "program" describes a single, complete and
	more-or-less self-contained list of instructions, often stored
	in a single {file}, whereas "code" and "software" are
	uncountable nouns describing some number of instructions which
	may constitute one or more programs or part thereof.  Most
	programs, however, rely heavily on various kinds of {operating
	system} software for their execution.  The nounds "code" and
	"software" both refer to the same thing but "code" tends to
	suggest an interest in the implementation details whereas
	"software" is more of a user's term.

	(2002-07-21)

<operating system> See {Microsoft Windows}, {Windows NT}.

	(1997-11-23)