Dual-life perlglossary.pod as part of perlfaq

1 files changed, 3437 insertions, 0 deletions

diff --git a/cpan/perlfaq/lib/perlglossary.pod b/cpan/perlfaq/lib/perlglossary.pod
new file mode 100644
index 0000000000..014eb99fd5
--- /dev/null
+++ b/cpan/perlfaq/lib/perlglossary.pod
@@ -0,0 +1,3437 @@
+=head1 NAME
+
+perlglossary - Perl Glossary
+
+=head1 DESCRIPTION
+
+A glossary of terms (technical and otherwise) used in the Perl documentation.
+Other useful sources include the Free On-Line Dictionary of Computing
+L<http://foldoc.doc.ic.ac.uk/foldoc/index.html>, the Jargon File
+L<http://catb.org/~esr/jargon/>, and Wikipedia L<http://www.wikipedia.org/>.
+
+=head2 A
+
+=over 4
+
+=item accessor methods
+
+A L</method> used to indirectly inspect or update an L</object>'s
+state (its L<instance variables|/instance variable>).
+
+=item actual arguments
+
+The L<scalar values|/scalar value> that you supply to a L</function>
+or L</subroutine> when you call it.  For instance, when you call
+C<power("puff")>, the string C<"puff"> is the actual argument.  See
+also L</argument> and L</formal arguments>.
+
+=item address operator
+
+Some languages work directly with the memory addresses of values, but
+this can be like playing with fire.  Perl provides a set of asbestos
+gloves for handling all memory management.  The closest to an address
+operator in Perl is the backslash operator, but it gives you a L</hard
+reference>, which is much safer than a memory address.
+
+=item algorithm
+
+A well-defined sequence of steps, clearly enough explained that even a
+computer could do them.
+
+=item alias
+
+A nickname for something, which behaves in all ways as though you'd
+used the original name instead of the nickname.  Temporary aliases are
+implicitly created in the loop variable for C<foreach> loops, in the
+C<$_> variable for L<map|perlfunc/map> or L<grep|perlfunc/grep>
+operators, in C<$a> and C<$b> during L<sort|perlfunc/sort>'s
+comparison function, and in each element of C<@_> for the L</actual
+arguments> of a subroutine call.  Permanent aliases are explicitly
+created in L<packages|/package> by L<importing|/import> symbols or by
+assignment to L<typeglobs|/typeglob>.  Lexically scoped aliases for
+package variables are explicitly created by the L<our|perlfunc/our>
+declaration.
+
+=item alternatives
+
+A list of possible choices from which you may select only one, as in
+"Would you like door A, B, or C?"  Alternatives in regular expressions
+are separated with a single vertical bar: C<|>.  Alternatives in
+normal Perl expressions are separated with a double vertical bar:
+C<||>.  Logical alternatives in L</Boolean> expressions are separated
+with either C<||> or C<or>.
+
+=item anonymous
+
+Used to describe a L</referent> that is not directly accessible
+through a named L</variable>.  Such a referent must be indirectly
+accessible through at least one L</hard reference>.  When the last
+hard reference goes away, the anonymous referent is destroyed without
+pity.
+
+=item architecture
+
+The kind of computer you're working on, where one "kind" of computer
+means all those computers sharing a compatible machine language.
+Since Perl programs are (typically) simple text files, not executable
+images, a Perl program is much less sensitive to the architecture it's
+running on than programs in other languages, such as C, that are
+compiled into machine code.  See also L</platform> and L</operating
+system>.
+
+=item argument
+
+A piece of data supplied to a L<program|/executable file>,
+L</subroutine>, L</function>, or L</method> to tell it what it's
+supposed to do.  Also called a "parameter".
+
+=item ARGV
+
+The name of the array containing the L</argument> L</vector> from the
+command line.  If you use the empty C<< E<lt>E<gt> >> operator, L</ARGV> is
+the name of both the L</filehandle> used to traverse the arguments and
+the L</scalar> containing the name of the current input file.
+
+=item arithmetical operator
+
+A L</symbol> such as C<+> or C</> that tells Perl to do the arithmetic
+you were supposed to learn in grade school.
+
+=item array
+
+An ordered sequence of L<values|/value>, stored such that you can
+easily access any of the values using an integer L</subscript>
+that specifies the value's L</offset> in the sequence.
+
+=item array context
+
+An archaic expression for what is more correctly referred to as
+L</list context>.
+
+=item ASCII
+
+The American Standard Code for Information Interchange (a 7-bit
+character set adequate only for poorly representing English text).
+Often used loosely to describe the lowest 128 values of the various
+ISO-8859-X character sets, a bunch of mutually incompatible 8-bit
+codes sometimes described as half ASCII.  See also L</Unicode>.
+
+=item assertion
+
+A component of a L</regular expression> that must be true for the
+pattern to match but does not necessarily match any characters itself.
+Often used specifically to mean a L</zero width> assertion.
+
+=item assignment
+
+An L</operator> whose assigned mission in life is to change the value
+of a L</variable>.
+
+=item assignment operator
+
+Either a regular L</assignment>, or a compound L</operator> composed
+of an ordinary assignment and some other operator, that changes the
+value of a variable in place, that is, relative to its old value.  For
+example, C<$a += 2> adds C<2> to C<$a>.
+
+=item associative array
+
+See L</hash>.  Please.
+
+=item associativity
+
+Determines whether you do the left L</operator> first or the right
+L</operator> first when you have "A L</operator> B L</operator> C" and
+the two operators are of the same precedence.  Operators like C<+> are
+left associative, while operators like C<**> are right associative.
+See L<perlop> for a list of operators and their associativity.
+
+=item asynchronous
+
+Said of events or activities whose relative temporal ordering is
+indeterminate because too many things are going on at once.  Hence, an
+asynchronous event is one you didn't know when to expect.
+
+=item atom
+
+A L</regular expression> component potentially matching a
+L</substring> containing one or more characters and treated as an
+indivisible syntactic unit by any following L</quantifier>.  (Contrast
+with an L</assertion> that matches something of L</zero width> and may
+not be quantified.)
+
+=item atomic operation
+
+When Democritus gave the word "atom" to the indivisible bits of
+matter, he meant literally something that could not be cut: I<a->
+(not) + I<tomos> (cuttable).  An atomic operation is an action that
+can't be interrupted, not one forbidden in a nuclear-free zone.
+
+=item attribute
+
+A new feature that allows the declaration of L<variables|/variable>
+and L<subroutines|/subroutine> with modifiers as in C<sub foo : locked
+method>.  Also, another name for an L</instance variable> of an
+L</object>.
+
+=item autogeneration
+
+A feature of L</operator overloading> of L<objects|/object>, whereby
+the behavior of certain L<operators|/operator> can be reasonably
+deduced using more fundamental operators.  This assumes that the
+overloaded operators will often have the same relationships as the
+regular operators.  See L<perlop>.
+
+=item autoincrement
+
+To add one to something automatically, hence the name of the C<++>
+operator.  To instead subtract one from something automatically is
+known as an "autodecrement".
+
+=item autoload
+
+To load on demand.  (Also called "lazy" loading.)  Specifically, to
+call an L<AUTOLOAD|perlsub/Autoloading> subroutine on behalf of an
+undefined subroutine.
+
+=item autosplit
+
+To split a string automatically, as the B<-a> L</switch> does when
+running under B<-p> or B<-n> in order to emulate L</awk>.  (See also
+the L<AutoSplit> module, which has nothing to do with the B<-a>
+switch, but a lot to do with autoloading.)
+
+=item autovivification
+
+A Greco-Roman word meaning "to bring oneself to life".  In Perl,
+storage locations (L<lvalues|/lvalue>) spontaneously generate
+themselves as needed, including the creation of any L</hard reference>
+values to point to the next level of storage.  The assignment
+C<$a[5][5][5][5][5] = "quintet"> potentially creates five scalar
+storage locations, plus four references (in the first four scalar
+locations) pointing to four new anonymous arrays (to hold the last
+four scalar locations).  But the point of autovivification is that you
+don't have to worry about it.
+
+=item AV
+
+Short for "array value", which refers to one of Perl's internal data
+types that holds an L</array>.  The L</AV> type is a subclass of
+L</SV>.
+
+=item awk
+
+Descriptive editing term--short for "awkward".  Also coincidentally
+refers to a venerable text-processing language from which Perl derived
+some of its high-level ideas.
+
+=back
+
+=head2 B
+
+=over 4
+
+=item backreference
+
+A substring L<captured|/capturing> by a subpattern within
+unadorned parentheses in a L</regex>, also referred to as a capture group.  The
+sequences (C<\g1>, C<\g2>, etc.)  later in the same pattern refer back to
+the corresponding subpattern in the current match.  Outside the pattern,
+the numbered variables (C<$1>, C<$2>, etc.) continue to refer to these
+same values, as long as the pattern was the last successful match of
+the current dynamic scope.  C<\g{-1}> can be used to refer to a group by
+relative rather than absolute position; and groups can be also be named, and
+referred to later by name rather than number.  See L<perlre/"Capture groups">.
+
+=item backtracking
+
+The practice of saying, "If I had to do it all over, I'd do it
+differently," and then actually going back and doing it all over
+differently.  Mathematically speaking, it's returning from an
+unsuccessful recursion on a tree of possibilities.  Perl backtracks
+when it attempts to match patterns with a L</regular expression>, and
+its earlier attempts don't pan out.  See L<perlre/Backtracking>.
+
+=item backward compatibility
+
+Means you can still run your old program because we didn't break any
+of the features or bugs it was relying on.
+
+=item bareword
+
+A word sufficiently ambiguous to be deemed illegal under L<use strict
+'subs'|strict/strict subs>.  In the absence of that stricture, a
+bareword is treated as if quotes were around it.
+
+=item base class
+
+A generic L</object> type; that is, a L</class> from which other, more
+specific classes are derived genetically by L</inheritance>.  Also
+called a "superclass" by people who respect their ancestors.
+
+=item big-endian
+
+From Swift: someone who eats eggs big end first.  Also used of
+computers that store the most significant L</byte> of a word at a
+lower byte address than the least significant byte.  Often considered
+superior to little-endian machines.  See also L</little-endian>.
+
+=item binary
+
+Having to do with numbers represented in base 2.  That means there's
+basically two numbers, 0 and 1.  Also used to describe a "non-text
+file", presumably because such a file makes full use of all the binary
+bits in its bytes.  With the advent of L</Unicode>, this distinction,
+already suspect, loses even more of its meaning.
+
+=item binary operator
+
+An L</operator> that takes two L<operands|/operand>.
+
+=item bind
+
+To assign a specific L</network address> to a L</socket>.
+
+=item bit
+
+An integer in the range from 0 to 1, inclusive.  The smallest possible
+unit of information storage.  An eighth of a L</byte> or of a dollar.
+(The term "Pieces of Eight" comes from being able to split the old
+Spanish dollar into 8 bits, each of which still counted for money.
+That's why a 25-cent piece today is still "two bits".)
+
+=item bit shift
+
+The movement of bits left or right in a computer word, which has the
+effect of multiplying or dividing by a power of 2.
+
+=item bit string
+
+A sequence of L<bits|/bit> that is actually being thought of as a
+sequence of bits, for once.
+
+=item bless
+
+In corporate life, to grant official approval to a thing, as in, "The
+VP of Engineering has blessed our WebCruncher project." Similarly in
+Perl, to grant official approval to a L</referent> so that it can
+function as an L</object>, such as a WebCruncher object.  See
+L<perlfunc/"bless">.
+
+=item block
+
+What a L</process> does when it has to wait for something: "My process
+blocked waiting for the disk."  As an unrelated noun, it refers to a
+large chunk of data, of a size that the L</operating system> likes to
+deal with (normally a power of two such as 512 or 8192).  Typically
+refers to a chunk of data that's coming from or going to a disk file.
+
+=item BLOCK
+
+A syntactic construct consisting of a sequence of Perl
+L<statements|/statement> that is delimited by braces.  The C<if> and
+C<while> statements are defined in terms of L<BLOCKs|/BLOCK>, for instance.
+Sometimes we also say "block" to mean a lexical scope; that is, a
+sequence of statements that act like a L</BLOCK>, such as within an
+L<eval|perlfunc/eval> or a file, even though the statements aren't
+delimited by braces.
+
+=item block buffering
+
+A method of making input and output efficient by passing one L</block>
+at a time.  By default, Perl does block buffering to disk files.  See
+L</buffer> and L</command buffering>.
+
+=item Boolean
+
+A value that is either L</true> or L</false>.
+
+=item Boolean context
+
+A special kind of L</scalar context> used in conditionals to decide
+whether the L</scalar value> returned by an expression is L</true> or
+L</false>.  Does not evaluate as either a string or a number.  See
+L</context>.
+
+=item breakpoint
+
+A spot in your program where you've told the debugger to stop
+L<execution|/execute> so you can poke around and see whether anything
+is wrong yet.
+
+=item broadcast
+
+To send a L</datagram> to multiple destinations simultaneously.
+
+=item BSD
+
+A psychoactive drug, popular in the 80s, probably developed at
+U. C. Berkeley or thereabouts.  Similar in many ways to the
+prescription-only medication called "System V", but infinitely more
+useful.  (Or, at least, more fun.)  The full chemical name is
+"Berkeley Standard Distribution".
+
+=item bucket
+
+A location in a L</hash table> containing (potentially) multiple
+entries whose keys "hash" to the same hash value according to its hash
+function.  (As internal policy, you don't have to worry about it,
+unless you're into internals, or policy.)
+
+=item buffer
+
+A temporary holding location for data.  L<Block buffering|/block
+buffering> means that the data is passed on to its destination
+whenever the buffer is full.  L<Line buffering|/line buffering> means
+that it's passed on whenever a complete line is received.  L<Command
+buffering|/command buffering> means that it's passed every time you do
+a L<print|perlfunc/print> command (or equivalent).  If your output is
+unbuffered, the system processes it one byte at a time without the use
+of a holding area.  This can be rather inefficient.
+
+=item built-in
+
+A L</function> that is predefined in the language.  Even when hidden
+by L</overriding>, you can always get at a built-in function by
+L<qualifying|/qualified> its name with the C<CORE::> pseudo-package.
+
+=item bundle
+
+A group of related modules on L</CPAN>.  (Also, sometimes refers to a
+group of command-line switches grouped into one L</switch cluster>.)
+
+=item byte
+
+A piece of data worth eight L<bits|/bit> in most places.
+
+=item bytecode
+
+A pidgin-like language spoken among 'droids when they don't wish to
+reveal their orientation (see L</endian>).  Named after some similar
+languages spoken (for similar reasons) between compilers and
+interpreters in the late 20th century.  These languages are
+characterized by representing everything as a
+non-architecture-dependent sequence of bytes.
+
+=back
+
+=head2 C
+
+=over 4
+
+=item C
+
+A language beloved by many for its inside-out L</type> definitions,
+inscrutable L</precedence> rules, and heavy L</overloading> of the
+function-call mechanism.  (Well, actually, people first switched to C
+because they found lowercase identifiers easier to read than upper.)
+Perl is written in C, so it's not surprising that Perl borrowed a few
+ideas from it.
+
+=item C preprocessor
+
+The typical C compiler's first pass, which processes lines beginning
+with C<#> for conditional compilation and macro definition and does
+various manipulations of the program text based on the current
+definitions.  Also known as I<cpp>(1).
+
+=item call by reference
+
+An L</argument>-passing mechanism in which the L</formal arguments>
+refer directly to the L</actual arguments>, and the L</subroutine> can
+change the actual arguments by changing the formal arguments.  That
+is, the formal argument is an L</alias> for the actual argument.  See
+also L</call by value>.
+
+=item call by value
+
+An L</argument>-passing mechanism in which the L</formal arguments>
+refer to a copy of the L</actual arguments>, and the L</subroutine>
+cannot change the actual arguments by changing the formal arguments.
+See also L</call by reference>.
+
+=item callback
+
+A L</handler> that you register with some other part of your program
+in the hope that the other part of your program will L</trigger> your
+handler when some event of interest transpires.
+
+=item canonical
+
+Reduced to a standard form to facilitate comparison.
+
+=item capture buffer, capture group
+
+These two terms are synonymous:
+a L<captured substring|/capturing> by a regex subpattern.
+
+=item capturing
+
+The use of parentheses around a L</subpattern> in a L</regular
+expression> to store the matched L</substring> as a L</backreference>
+or L<capture group|/capture buffer, capture group>.
+(Captured strings are also returned as a list in L</list context>.)
+
+=item character
+
+A small integer representative of a unit of orthography.
+Historically, characters were usually stored as fixed-width integers
+(typically in a byte, or maybe two, depending on the character set),
+but with the advent of UTF-8, characters are often stored in a
+variable number of bytes depending on the size of the integer that
+represents the character.  Perl manages this transparently for you,
+for the most part.
+
+=item character class
+
+A square-bracketed list of characters used in a L</regular expression>
+to indicate that any character of the set may occur at a given point.
+Loosely, any predefined set of characters so used.
+
+=item character property
+
+A predefined L</character class> matchable by the C<\p>
+L</metasymbol>.  Many standard properties are defined for L</Unicode>.
+
+=item circumfix operator
+
+An L</operator> that surrounds its L</operand>, like the angle
+operator, or parentheses, or a hug.
+
+=item class
+
+A user-defined L</type>, implemented in Perl via a L</package> that
+provides (either directly or by inheritance) L<methods|/method> (that
+is, L<subroutines|/subroutine>) to handle L<instances|/instance> of
+the class (its L<objects|/object>).  See also L</inheritance>.
+
+=item class method
+
+A L</method> whose L</invocant> is a L</package> name, not an
+L</object> reference.  A method associated with the class as a whole.
+
+=item client
+
+In networking, a L</process> that initiates contact with a L</server>
+process in order to exchange data and perhaps receive a service.
+
+=item cloister
+
+A L</cluster> used to restrict the scope of a L</regular expression
+modifier>.
+
+=item closure
+
+An L</anonymous> subroutine that, when a reference to it is generated
+at run time, keeps track of the identities of externally visible
+L<lexical variables|/lexical variable> even after those lexical
+variables have supposedly gone out of L</scope>.  They're called
+"closures" because this sort of behavior gives mathematicians a sense
+of closure.
+
+=item cluster
+
+A parenthesized L</subpattern> used to group parts of a L</regular
+expression> into a single L</atom>.
+
+=item CODE
+
+The word returned by the L<ref|perlfunc/ref> function when you apply
+it to a reference to a subroutine.  See also L</CV>.
+
+=item code generator
+
+A system that writes code for you in a low-level language, such as
+code to implement the backend of a compiler.  See L</program
+generator>.
+
+=item code point
+
+The position of a character in a character set encoding.  The character
+C<NULL> is almost certainly at the zeroth position in all character
+sets, so its code point is 0.  The code point for the C<SPACE>
+character in the ASCII character set is 0x20, or 32 decimal; in EBCDIC
+it is 0x40, or 64 decimal.  The L<ord|perlfunc/ord> function returns
+the code point of a character.
+
+"code position" and "ordinal" mean the same thing as "code point".
+
+=item code subpattern
+
+A L</regular expression> subpattern whose real purpose is to execute
+some Perl code, for example, the C<(?{...})> and C<(??{...})>
+subpatterns.
+
+=item collating sequence
+
+The order into which L<characters|/character> sort.  This is used by
+L</string> comparison routines to decide, for example, where in this
+glossary to put "collating sequence".
+
+=item command
+
+In L</shell> programming, the syntactic combination of a program name
+and its arguments.  More loosely, anything you type to a shell (a
+command interpreter) that starts it doing something.  Even more
+loosely, a Perl L</statement>, which might start with a L</label> and
+typically ends with a semicolon.
+
+=item command buffering
+
+A mechanism in Perl that lets you store up the output of each Perl
+L</command> and then flush it out as a single request to the
+L</operating system>.  It's enabled by setting the C<$|>
+(C<$AUTOFLUSH>) variable to a true value.  It's used when you don't
+want data sitting around not going where it's supposed to, which may
+happen because the default on a L</file> or L</pipe> is to use
+L</block buffering>.
+
+=item command name
+
+The name of the program currently executing, as typed on the command
+line.  In C, the L</command> name is passed to the program as the
+first command-line argument.  In Perl, it comes in separately as
+C<$0>.
+
+=item command-line arguments
+
+The L<values|/value> you supply along with a program name when you
+tell a L</shell> to execute a L</command>.  These values are passed to
+a Perl program through C<@ARGV>.
+
+=item comment
+
+A remark that doesn't affect the meaning of the program.  In Perl, a
+comment is introduced by a C<#> character and continues to the end of
+the line.
+
+=item compilation unit
+
+The L</file> (or L</string>, in the case of L<eval|perlfunc/eval>)
+that is currently being compiled.
+
+=item compile phase
+
+Any time before Perl starts running your main program.  See also
+L</run phase>.  Compile phase is mostly spent in L</compile time>, but
+may also be spent in L</run time> when C<BEGIN> blocks,
+L<use|perlfunc/use> declarations, or constant subexpressions are being
+evaluated.  The startup and import code of any L<use|perlfunc/use>
+declaration is also run during compile phase.
+
+=item compile time
+
+The time when Perl is trying to make sense of your code, as opposed to
+when it thinks it knows what your code means and is merely trying to
+do what it thinks your code says to do, which is L</run time>.
+
+=item compiler
+
+Strictly speaking, a program that munches up another program and spits
+out yet another file containing the program in a "more executable"
+form, typically containing native machine instructions.  The I<perl>
+program is not a compiler by this definition, but it does contain a
+kind of compiler that takes a program and turns it into a more
+executable form (L<syntax trees|/syntax tree>) within the I<perl>
+process itself, which the L</interpreter> then interprets.  There are,
+however, extension L<modules|/module> to get Perl to act more like a
+"real" compiler.  See L<O>.
+
+=item composer
+
+A "constructor" for a L</referent> that isn't really an L</object>,
+like an anonymous array or a hash (or a sonata, for that matter).  For
+example, a pair of braces acts as a composer for a hash, and a pair of
+brackets acts as a composer for an array.  See L<perlref/Making
+References>.
+
+=item concatenation
+
+The process of gluing one cat's nose to another cat's tail.  Also, a
+similar operation on two L<strings|/string>.
+
+=item conditional
+
+Something "iffy".  See L</Boolean context>.
+
+=item connection
+
+In telephony, the temporary electrical circuit between the caller's
+and the callee's phone.  In networking, the same kind of temporary
+circuit between a L</client> and a L</server>.
+
+=item construct
+
+As a noun, a piece of syntax made up of smaller pieces.  As a
+transitive verb, to create an L</object> using a L</constructor>.
+
+=item constructor
+
+Any L</class method>, instance L</method>, or L</subroutine>
+that composes, initializes, blesses, and returns an L</object>.
+Sometimes we use the term loosely to mean a L</composer>.
+
+=item context
+
+The surroundings, or environment.  The context given by the
+surrounding code determines what kind of data a particular
+L</expression> is expected to return.  The three primary contexts are
+L</list context>, L</scalar context>, and L</void context>.  Scalar
+context is sometimes subdivided into L</Boolean context>, L</numeric
+context>, L</string context>, and L</void context>.  There's also a
+"don't care" scalar context (which is dealt with in Programming Perl,
+Third Edition, Chapter 2, "Bits and Pieces" if you care).
+
+=item continuation
+
+The treatment of more than one physical L</line> as a single logical
+line.  L</Makefile> lines are continued by putting a backslash before
+the L</newline>.  Mail headers as defined by RFC 822 are continued by
+putting a space or tab I<after> the newline.  In general, lines in
+Perl do not need any form of continuation mark, because L</whitespace>
+(including newlines) is gleefully ignored.  Usually.
+
+=item core dump
+
+The corpse of a L</process>, in the form of a file left in the
+L</working directory> of the process, usually as a result of certain
+kinds of fatal error.
+
+=item CPAN
+
+The Comprehensive Perl Archive Network.  (See L<perlfaq2/What modules and extensions are available for Perl?  What is CPAN?>).
+
+=item cracker
+
+Someone who breaks security on computer systems.  A cracker may be a
+true L</hacker> or only a L</script kiddie>.
+
+=item current package
+
+The L</package> in which the current statement is compiled.  Scan
+backwards in the text of your program through the current L<lexical
+scope|/lexical scoping> or any enclosing lexical scopes till you find
+a package declaration.  That's your current package name.
+
+=item current working directory
+
+See L</working directory>.
+
+=item currently selected output channel
+
+The last L</filehandle> that was designated with
+L<select|perlfunc/select>(C<FILEHANDLE>); L</STDOUT>, if no filehandle
+has been selected.
+
+=item CV
+
+An internal "code value" typedef, holding a L</subroutine>.  The L</CV>
+type is a subclass of L</SV>.
+
+=back
+
+=head2 D
+
+=over 4
+
+=item dangling statement
+
+A bare, single L</statement>, without any braces, hanging off an C<if>
+or C<while> conditional.  C allows them.  Perl doesn't.
+
+=item data structure
+
+How your various pieces of data relate to each other and what shape
+they make when you put them all together, as in a rectangular table or
+a triangular-shaped tree.
+
+=item data type
+
+A set of possible values, together with all the operations that know
+how to deal with those values.  For example, a numeric data type has a
+certain set of numbers that you can work with and various mathematical
+operations that you can do on the numbers but would make little sense
+on, say, a string such as C<"Kilroy">.  Strings have their own
+operations, such as L</concatenation>.  Compound types made of a
+number of smaller pieces generally have operations to compose and
+decompose them, and perhaps to rearrange them.  L<Objects|/object>
+that model things in the real world often have operations that
+correspond to real activities.  For instance, if you model an
+elevator, your elevator object might have an C<open_door()>
+L</method>.
+
+=item datagram
+
+A packet of data, such as a L</UDP> message, that (from the viewpoint
+of the programs involved) can be sent independently over the network.
+(In fact, all packets are sent independently at the L</IP> level, but
+L</stream> protocols such as L</TCP> hide this from your program.)
+
+=item DBM
+
+Stands for "Data Base Management" routines, a set of routines that
+emulate an L</associative array> using disk files.  The routines use a
+dynamic hashing scheme to locate any entry with only two disk
+accesses.  DBM files allow a Perl program to keep a persistent
+L</hash> across multiple invocations.  You can L<tie|perlfunc/tie>
+your hash variables to various DBM implementations--see L<AnyDBM_File>
+and L<DB_File>.
+
+=item declaration
+
+An L</assertion> that states something exists and perhaps describes
+what it's like, without giving any commitment as to how or where
+you'll use it.  A declaration is like the part of your recipe that
+says, "two cups flour, one large egg, four or five tadpoles..."  See
+L</statement> for its opposite.  Note that some declarations also
+function as statements.  Subroutine declarations also act as
+definitions if a body is supplied.
+
+=item decrement
+
+To subtract a value from a variable, as in "decrement C<$x>" (meaning
+to remove 1 from its value) or "decrement C<$x> by 3".
+
+=item default
+
+A L</value> chosen for you if you don't supply a value of your own.
+
+=item defined
+
+Having a meaning.  Perl thinks that some of the things people try to
+do are devoid of meaning, in particular, making use of variables that
+have never been given a L</value> and performing certain operations on
+data that isn't there.  For example, if you try to read data past the
+end of a file, Perl will hand you back an undefined value.  See also
+L</false> and L<perlfunc/defined>.
+
+=item delimiter
+
+A L</character> or L</string> that sets bounds to an arbitrarily-sized
+textual object, not to be confused with a L</separator> or
+L</terminator>.  "To delimit" really just means "to surround" or "to
+enclose" (like these parentheses are doing).
+
+=item deprecated modules and features
+
+Deprecated modules and features are those which were part of a stable
+release, but later found to be subtly flawed, and which should be avoided.
+They are subject to removal and/or bug-incompatible reimplementation in
+the next major release (but they will be preserved through maintenance
+releases).  Deprecation warnings are issued under B<-w> or C<use
+diagnostics>, and notices are found in L<perldelta>s, as well as various
+other PODs. Coding practices that misuse features, such as C<my $foo if
+0>, can also be deprecated.
+
+=item dereference
+
+A fancy computer science term meaning "to follow a L</reference> to
+what it points to".  The "de" part of it refers to the fact that
+you're taking away one level of L</indirection>.
+
+=item derived class
+
+A L</class> that defines some of its L<methods|/method> in terms of a
+more generic class, called a L</base class>.  Note that classes aren't
+classified exclusively into base classes or derived classes: a class
+can function as both a derived class and a base class simultaneously,
+which is kind of classy.
+
+=item descriptor
+
+See L</file descriptor>.
+
+=item destroy
+
+To deallocate the memory of a L</referent> (first triggering its
+C<DESTROY> method, if it has one).
+
+=item destructor
+
+A special L</method> that is called when an L</object> is thinking
+about L<destroying|/destroy> itself.  A Perl program's C<DESTROY>
+method doesn't do the actual destruction; Perl just
+L<triggers|/trigger> the method in case the L</class> wants to do any
+associated cleanup.
+
+=item device
+
+A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a
+joystick or a mouse) attached to your computer, that the L</operating
+system> tries to make look like a L</file> (or a bunch of files).
+Under Unix, these fake files tend to live in the I</dev> directory.
+
+=item directive
+
+A L</pod> directive.  See L<perlpod>.
+
+=item directory
+
+A special file that contains other files.  Some L<operating
+systems|/operating system> call these "folders", "drawers", or
+"catalogs".
+
+=item directory handle
+
+A name that represents a particular instance of opening a directory to
+read it, until you close it.  See the L<opendir|perlfunc/opendir>
+function.
+
+=item dispatch
+
+To send something to its correct destination.  Often used
+metaphorically to indicate a transfer of programmatic control to a
+destination selected algorithmically, often by lookup in a table of
+function L<references|/reference> or, in the case of object
+L<methods|/method>, by traversing the inheritance tree looking for the
+most specific definition for the method.
+
+=item distribution
+
+A standard, bundled release of a system of software.  The default
+usage implies source code is included.  If that is not the case, it
+will be called a "binary-only" distribution.
+
+=item (to be) dropped modules
+
+When Perl 5 was first released (see L<perlhist>), several modules were
+included, which have now fallen out of common use.  It has been suggested
+that these modules should be removed, since the distribution became rather
+large, and the common criterion for new module additions is now limited to
+modules that help to build, test, and extend perl itself.  Furthermore,
+the CPAN (which didn't exist at the time of Perl 5.0) can become the new
+home of dropped modules. Dropping modules is currently not an option, but
+further developments may clear the last barriers.
+
+=item dweomer
+
+An enchantment, illusion, phantasm, or jugglery.  Said when Perl's
+magical L</dwimmer> effects don't do what you expect, but rather seem
+to be the product of arcane dweomercraft, sorcery, or wonder working.
+[From Old English]
+
+=item dwimmer
+
+DWIM is an acronym for "Do What I Mean", the principle that something
+should just do what you want it to do without an undue amount of fuss.
+A bit of code that does "dwimming" is a "dwimmer".  Dwimming can
+require a great deal of behind-the-scenes magic, which (if it doesn't
+stay properly behind the scenes) is called a L</dweomer> instead.
+
+=item dynamic scoping
+
+Dynamic scoping works over a dynamic scope, making variables visible
+throughout the rest of the L</block> in which they are first used and
+in any L<subroutines|/subroutine> that are called by the rest of the
+block.  Dynamically scoped variables can have their values temporarily
+changed (and implicitly restored later) by a L<local|perlfunc/local>
+operator.  (Compare L</lexical scoping>.)  Used more loosely to mean
+how a subroutine that is in the middle of calling another subroutine
+"contains" that subroutine at L</run time>.
+
+=back
+
+=head2 E
+
+=over 4
+
+=item eclectic
+
+Derived from many sources.  Some would say I<too> many.
+
+=item element
+
+A basic building block.  When you're talking about an L</array>, it's
+one of the items that make up the array.
+
+=item embedding
+
+When something is contained in something else, particularly when that
+might be considered surprising: "I've embedded a complete Perl
+interpreter in my editor!"
+
+=item empty list
+
+See </null list>.
+
+=item empty subclass test
+
+The notion that an empty L</derived class> should behave exactly like
+its L</base class>.
+
+=item en passant
+
+When you change a L</value> as it is being copied.  [From French, "in
+passing", as in the exotic pawn-capturing maneuver in chess.]
+
+=item encapsulation
+
+The veil of abstraction separating the L</interface> from the
+L</implementation> (whether enforced or not), which mandates that all
+access to an L</object>'s state be through L<methods|/method> alone.
+
+=item endian
+
+See L</little-endian> and L</big-endian>.
+
+=item environment
+
+The collective set of L<environment variables|/environment variable>
+your L</process> inherits from its parent.  Accessed via C<%ENV>.
+
+=item environment variable
+
+A mechanism by which some high-level agent such as a user can pass its
+preferences down to its future offspring (child L<processes|/process>,
+grandchild processes, great-grandchild processes, and so on).  Each
+environment variable is a L</key>/L</value> pair, like one entry in a
+L</hash>.
+
+=item EOF
+
+End of File.  Sometimes used metaphorically as the terminating string
+of a L</here document>.
+
+=item errno
+
+The error number returned by a L</syscall> when it fails.  Perl refers
+to the error by the name C<$!> (or C<$OS_ERROR> if you use the English
+module).
+
+=item error
+
+See L</exception> or L</fatal error>.
+
+=item escape sequence
+
+See L</metasymbol>.
+
+=item exception
+
+A fancy term for an error.  See L</fatal error>.
+
+=item exception handling
+
+The way a program responds to an error.  The exception handling
+mechanism in Perl is the L<eval|perlfunc/eval> operator.
+
+=item exec
+
+To throw away the current L</process>'s program and replace it with
+another without exiting the process or relinquishing any resources
+held (apart from the old memory image).
+
+=item executable file
+
+A L</file> that is specially marked to tell the L</operating system>
+that it's okay to run this file as a program.  Usually shortened to
+"executable".
+
+=item execute
+
+To run a L<program|/executable file> or L</subroutine>.  (Has nothing
+to do with the L<kill|perlfunc/kill> built-in, unless you're trying to
+run a L</signal handler>.)
+
+=item execute bit
+
+The special mark that tells the operating system it can run this
+program.  There are actually three execute bits under Unix, and which
+bit gets used depends on whether you own the file singularly,
+collectively, or not at all.
+
+=item exit status
+
+See L</status>.
+
+=item export
+
+To make symbols from a L</module> available for L</import> by other modules.
+
+=item expression
+
+Anything you can legally say in a spot where a L</value> is required.
+Typically composed of L<literals|/literal>, L<variables|/variable>,
+L<operators|/operator>, L<functions|/function>, and L</subroutine>
+calls, not necessarily in that order.
+
+=item extension
+
+A Perl module that also pulls in compiled C or C++ code.  More
+generally, any experimental option that can be compiled into Perl,
+such as multithreading.
+
+=back
+
+=head2 F
+
+=over 4
+
+=item false
+
+In Perl, any value that would look like C<""> or C<"0"> if evaluated
+in a string context.  Since undefined values evaluate to C<"">, all
+undefined values are false (including the L</null list>), but not all
+false values are undefined.
+
+=item FAQ
+
+Frequently Asked Question (although not necessarily frequently
+answered, especially if the answer appears in the Perl FAQ shipped
+standard with Perl).
+
+=item fatal error
+
+An uncaught L</exception>, which causes termination of the L</process>
+after printing a message on your L</standard error> stream.  Errors
+that happen inside an L<eval|perlfunc/eval> are not fatal.  Instead,
+the L<eval|perlfunc/eval> terminates after placing the exception
+message in the C<$@> (C<$EVAL_ERROR>) variable.  You can try to
+provoke a fatal error with the L<die|perlfunc/die> operator (known as
+throwing or raising an exception), but this may be caught by a
+dynamically enclosing L<eval|perlfunc/eval>.  If not caught, the
+L<die|perlfunc/die> becomes a fatal error.
+
+=item field
+
+A single piece of numeric or string data that is part of a longer
+L</string>, L</record>, or L</line>.  Variable-width fields are usually
+split up by L<separators|/separator> (so use L<split|perlfunc/split> to
+extract the fields), while fixed-width fields are usually at fixed
+positions (so use L<unpack|perlfunc/unpack>).  L<Instance
+variables|/instance variable> are also known as fields.
+
+=item FIFO
+
+First In, First Out.  See also L</LIFO>.  Also, a nickname for a
+L</named pipe>.
+
+=item file
+
+A named collection of data, usually stored on disk in a L</directory>
+in a L</filesystem>.  Roughly like a document, if you're into office
+metaphors.  In modern filesystems, you can actually give a file more
+than one name.  Some files have special properties, like directories
+and devices.
+
+=item file descriptor
+
+The little number the L</operating system> uses to keep track of which
+opened L</file> you're talking about.  Perl hides the file descriptor
+inside a L</standard IE<sol>O> stream and then attaches the stream to
+a L</filehandle>.
+
+=item file test operator
+
+A built-in unary operator that you use to determine whether something
+is L</true> about a file, such as C<-o $filename> to test whether
+you're the owner of the file.
+
+=item fileglob
+
+A "wildcard" match on L<filenames|/filename>.  See the
+L<glob|perlfunc/glob> function.
+
+=item filehandle
+
+An identifier (not necessarily related to the real name of a file)
+that represents a particular instance of opening a file until you
+close it.  If you're going to open and close several different files
+in succession, it's fine to open each of them with the same
+filehandle, so you don't have to write out separate code to process
+each file.
+
+=item filename
+
+One name for a file.  This name is listed in a L</directory>, and you
+can use it in an L<open|perlfunc/open> to tell the L</operating
+system> exactly which file you want to open, and associate the file
+with a L</filehandle> which will carry the subsequent identity of that
+file in your program, until you close it.
+
+=item filesystem
+
+A set of L<directories|/directory> and L<files|/file> residing on a
+partition of the disk.  Sometimes known as a "partition".  You can
+change the file's name or even move a file around from directory to
+directory within a filesystem without actually moving the file itself,
+at least under Unix.
+
+=item filter
+
+A program designed to take a L</stream> of input and transform it into
+a stream of output.
+
+=item flag
+
+We tend to avoid this term because it means so many things.  It may
+mean a command-line L</switch> that takes no argument
+itself (such as Perl's B<-n> and B<-p>
+flags) or, less frequently, a single-bit indicator (such as the
+C<O_CREAT> and C<O_EXCL> flags used in
+L<sysopen|perlfunc/sysopen>).
+
+=item floating point
+
+A method of storing numbers in "scientific notation", such that the
+precision of the number is independent of its magnitude (the decimal
+point "floats").  Perl does its numeric work with floating-point
+numbers (sometimes called "floats"), when it can't get away with
+using L<integers|/integer>.  Floating-point numbers are mere
+approximations of real numbers.
+
+=item flush
+
+The act of emptying a L</buffer>, often before it's full.
+
+=item FMTEYEWTK
+
+Far More Than Everything You Ever Wanted To Know.  An exhaustive
+treatise on one narrow topic, something of a super-L</FAQ>.  See Tom
+for far more.
+
+=item fork
+
+To create a child L</process> identical to the parent process at its
+moment of conception, at least until it gets ideas of its own.  A
+thread with protected memory.
+
+=item formal arguments
+
+The generic names by which a L</subroutine> knows its
+L<arguments|/argument>.  In many languages, formal arguments are
+always given individual names, but in Perl, the formal arguments are
+just the elements of an array.  The formal arguments to a Perl program
+are C<$ARGV[0]>, C<$ARGV[1]>, and so on.  Similarly, the formal
+arguments to a Perl subroutine are C<$_[0]>, C<$_[1]>, and so on.  You
+may give the arguments individual names by assigning the values to a
+L<my|perlfunc/my> list.  See also L</actual arguments>.
+
+=item format
+
+A specification of how many spaces and digits and things to put
+somewhere so that whatever you're printing comes out nice and pretty.
+
+=item freely available
+
+Means you don't have to pay money to get it, but the copyright on it
+may still belong to someone else (like Larry).
+
+=item freely redistributable
+
+Means you're not in legal trouble if you give a bootleg copy of it to
+your friends and we find out about it.  In fact, we'd rather you gave
+a copy to all your friends.
+
+=item freeware
+
+Historically, any software that you give away, particularly if you
+make the source code available as well.  Now often called C<open
+source software>.  Recently there has been a trend to use the term in
+contradistinction to L</open source software>, to refer only to free
+software released under the Free Software Foundation's GPL (General
+Public License), but this is difficult to justify etymologically.
+
+=item function
+
+Mathematically, a mapping of each of a set of input values to a
+particular output value.  In computers, refers to a L</subroutine> or
+L</operator> that returns a L</value>.  It may or may not have input
+values (called L<arguments|/argument>).
+
+=item funny character
+
+Someone like Larry, or one of his peculiar friends.  Also refers to
+the strange prefixes that Perl requires as noun markers on its
+variables.
+
+=back
+
+=head2 G
+
+=over 4
+
+=item garbage collection
+
+A misnamed feature--it should be called, "expecting your mother to
+pick up after you".  Strictly speaking, Perl doesn't do this, but it
+relies on a reference-counting mechanism to keep things tidy.
+However, we rarely speak strictly and will often refer to the
+reference-counting scheme as a form of garbage collection.  (If it's
+any comfort, when your interpreter exits, a "real" garbage collector
+runs to make sure everything is cleaned up if you've been messy with
+circular references and such.)
+
+=item GID
+
+Group ID--in Unix, the numeric group ID that the L</operating system>
+uses to identify you and members of your L</group>.
+
+=item glob
+
+Strictly, the shell's C<*> character, which will match a "glob" of
+characters when you're trying to generate a list of filenames.
+Loosely, the act of using globs and similar symbols to do pattern
+matching.  See also L</fileglob> and L</typeglob>.
+
+=item global
+
+Something you can see from anywhere, usually used of
+L<variables|/variable> and L<subroutines|/subroutine> that are visible
+everywhere in your program.  In Perl, only certain special variables
+are truly global--most variables (and all subroutines) exist only in
+the current L</package>.  Global variables can be declared with
+L<our|perlfunc/our>.  See L<perlfunc/our>.
+
+=item global destruction
+
+The L</garbage collection> of globals (and the running of any
+associated object destructors) that takes place when a Perl
+L</interpreter> is being shut down.  Global destruction should not be
+confused with the Apocalypse, except perhaps when it should.
+
+=item glue language
+
+A language such as Perl that is good at hooking things together that
+weren't intended to be hooked together.
+
+=item granularity
+
+The size of the pieces you're dealing with, mentally speaking.
+
+=item greedy
+
+A L</subpattern> whose L</quantifier> wants to match as many things as
+possible.
+
+=item grep
+
+Originally from the old Unix editor command for "Globally search for a
+Regular Expression and Print it", now used in the general sense of any
+kind of search, especially text searches.  Perl has a built-in
+L<grep|perlfunc/grep> function that searches a list for elements
+matching any given criterion, whereas the I<grep>(1) program searches
+for lines matching a L</regular expression> in one or more files.
+
+=item group
+
+A set of users of which you are a member.  In some operating systems
+(like Unix), you can give certain file access permissions to other
+members of your group.
+
+=item GV
+
+An internal "glob value" typedef, holding a L</typeglob>.  The L</GV>
+type is a subclass of L</SV>.
+
+=back
+
+=head2 H
+
+=over 4
+
+=item hacker
+
+Someone who is brilliantly persistent in solving technical problems,
+whether these involve golfing, fighting orcs, or programming.  Hacker
+is a neutral term, morally speaking.  Good hackers are not to be
+confused with evil L<crackers|/cracker> or clueless L<script
+kiddies|/script kiddie>.  If you confuse them, we will presume that
+you are either evil or clueless.
+
+=item handler
+
+A L</subroutine> or L</method> that is called by Perl when your
+program needs to respond to some internal event, such as a L</signal>,
+or an encounter with an operator subject to L</operator overloading>.
+See also L</callback>.
+
+=item hard reference
+
+A L</scalar> L</value> containing the actual address of a
+L</referent>, such that the referent's L</reference> count accounts
+for it.  (Some hard references are held internally, such as the
+implicit reference from one of a L</typeglob>'s variable slots to its
+corresponding referent.)  A hard reference is different from a
+L</symbolic reference>.
+
+=item hash
+
+An unordered association of L</key>/L</value> pairs, stored such that
+you can easily use a string L</key> to look up its associated data
+L</value>.  This glossary is like a hash, where the word to be defined
+is the key, and the definition is the value.  A hash is also sometimes
+septisyllabically called an "associative array", which is a pretty
+good reason for simply calling it a "hash" instead.
+
+=item hash table
+
+A data structure used internally by Perl for implementing associative
+arrays (hashes) efficiently.  See also L</bucket>.
+
+=item header file
+
+A file containing certain required definitions that you must include
+"ahead" of the rest of your program to do certain obscure operations.
+A C header file has a I<.h> extension.  Perl doesn't really have
+header files, though historically Perl has sometimes used translated
+I<.h> files with a I<.ph> extension.  See L<perlfunc/require>.
+(Header files have been superseded by the L</module> mechanism.)
+
+=item here document
+
+So called because of a similar construct in L<shells|/shell> that
+pretends that the L<lines|/line> following the L</command> are a
+separate L</file> to be fed to the command, up to some terminating
+string.  In Perl, however, it's just a fancy form of quoting.
+
+=item hexadecimal
+
+A number in base 16, "hex" for short.  The digits for 10 through 16
+are customarily represented by the letters C<a> through C<f>.
+Hexadecimal constants in Perl start with C<0x>.  See also
+L<perlfunc/hex>.
+
+=item home directory
+
+The directory you are put into when you log in.  On a Unix system, the
+name is often placed into C<$ENV{HOME}> or C<$ENV{LOGDIR}> by
+I<login>, but you can also find it with C<(getpwuid($E<lt>))[7]>.
+(Some platforms do not have a concept of a home directory.)
+
+=item host
+
+The computer on which a program or other data resides.
+
+=item hubris
+
+Excessive pride, the sort of thing Zeus zaps you for.  Also the
+quality that makes you write (and maintain) programs that other people
+won't want to say bad things about.  Hence, the third great virtue of
+a programmer.  See also L</laziness> and L</impatience>.
+
+=item HV
+
+Short for a "hash value" typedef, which holds Perl's internal
+representation of a hash.  The L</HV> type is a subclass of L</SV>.
+
+=back
+
+=head2 I
+
+=over 4
+
+=item identifier
+
+A legally formed name for most anything in which a computer program
+might be interested.  Many languages (including Perl) allow
+identifiers that start with a letter and contain letters and digits.
+Perl also counts the underscore character as a valid letter.  (Perl
+also has more complicated names, such as L</qualified> names.)
+
+=item impatience
+
+The anger you feel when the computer is being lazy.  This makes you
+write programs that don't just react to your needs, but actually
+anticipate them.  Or at least that pretend to.  Hence, the second
+great virtue of a programmer.  See also L</laziness> and L</hubris>.
+
+=item implementation
+
+How a piece of code actually goes about doing its job.  Users of the
+code should not count on implementation details staying the same
+unless they are part of the published L</interface>.
+
+=item import
+
+To gain access to symbols that are exported from another module.  See
+L<perlfunc/use>.
+
+=item increment
+
+To increase the value of something by 1 (or by some other number, if
+so specified).
+
+=item indexing
+
+In olden days, the act of looking up a L</key> in an actual index
+(such as a phone book), but now merely the act of using any kind of
+key or position to find the corresponding L</value>, even if no index
+is involved.  Things have degenerated to the point that Perl's
+L<index|perlfunc/index> function merely locates the position (index)
+of one string in another.
+
+=item indirect filehandle
+
+An L</expression> that evaluates to something that can be used as a
+L</filehandle>: a L</string> (filehandle name), a L</typeglob>, a
+typeglob L</reference>, or a low-level L</IO> object.
+
+=item indirect object
+
+In English grammar, a short noun phrase between a verb and its direct
+object indicating the beneficiary or recipient of the action.  In
+Perl, C<print STDOUT "$foo\n";> can be understood as "verb
+indirect-object object" where L</STDOUT> is the recipient of the
+L<print|perlfunc/print> action, and C<"$foo"> is the object being
+printed.  Similarly, when invoking a L</method>, you might place the
+invocant between the method and its arguments:
+
+  $gollum = new Pathetic::Creature "Smeagol";
+  give $gollum "Fisssssh!";
+  give $gollum "Precious!";
+
+In modern Perl, calling methods this way is often considered bad practice and
+to be avoided.
+
+=item indirect object slot
+
+The syntactic position falling between a method call and its arguments
+when using the indirect object invocation syntax.  (The slot is
+distinguished by the absence of a comma between it and the next
+argument.) L</STDERR> is in the indirect object slot here:
+
+  print STDERR "Awake!  Awake!  Fear, Fire,
+      Foes!  Awake!\n";
+
+=item indirection
+
+If something in a program isn't the value you're looking for but
+indicates where the value is, that's indirection.  This can be done
+with either L<symbolic references|/symbolic reference> or L<hard
+references|/hard reference>.
+
+=item infix
+
+An L</operator> that comes in between its L<operands|/operand>, such
+as multiplication in C<24 * 7>.
+
+=item inheritance
+
+What you get from your ancestors, genetically or otherwise.  If you
+happen to be a L</class>, your ancestors are called L<base
+classes|/base class> and your descendants are called L<derived
+classes|/derived class>.  See L</single inheritance> and L</multiple
+inheritance>.
+
+=item instance
+
+Short for "an instance of a class", meaning an L</object> of that L</class>.
+
+=item instance variable
+
+An L</attribute> of an L</object>; data stored with the particular
+object rather than with the class as a whole.
+
+=item integer
+
+A number with no fractional (decimal) part.  A counting number, like
+1, 2, 3, and so on, but including 0 and the negatives.
+
+=item interface
+
+The services a piece of code promises to provide forever, in contrast to
+its L</implementation>, which it should feel free to change whenever it
+likes.
+
+=item interpolation
+
+The insertion of a scalar or list value somewhere in the middle of
+another value, such that it appears to have been there all along.  In
+Perl, variable interpolation happens in double-quoted strings and
+patterns, and list interpolation occurs when constructing the list of
+values to pass to a list operator or other such construct that takes a
+L</LIST>.
+
+=item interpreter
+
+Strictly speaking, a program that reads a second program and does what
+the second program says directly without turning the program into a
+different form first, which is what L<compilers|/compiler> do.  Perl
+is not an interpreter by this definition, because it contains a kind
+of compiler that takes a program and turns it into a more executable
+form (L<syntax trees|/syntax tree>) within the I<perl> process itself,
+which the Perl L</run time> system then interprets.
+
+=item invocant
+
+The agent on whose behalf a L</method> is invoked.  In a L</class>
+method, the invocant is a package name.  In an L</instance> method,
+the invocant is an object reference.
+
+=item invocation
+
+The act of calling up a deity, daemon, program, method, subroutine, or
+function to get it do what you think it's supposed to do.  We usually
+"call" subroutines but "invoke" methods, since it sounds cooler.
+
+=item I/O
+
+Input from, or output to, a L</file> or L</device>.
+
+=item IO
+
+An internal I/O object.  Can also mean L</indirect object>.
+
+=item IP
+
+Internet Protocol, or Intellectual Property.
+
+=item IPC
+
+Interprocess Communication.
+
+=item is-a
+
+A relationship between two L<objects|/object> in which one object is
+considered to be a more specific version of the other, generic object:
+"A camel is a mammal."  Since the generic object really only exists in
+a Platonic sense, we usually add a little abstraction to the notion of
+objects and think of the relationship as being between a generic
+L</base class> and a specific L</derived class>.  Oddly enough,
+Platonic classes don't always have Platonic relationships--see
+L</inheritance>.
+
+=item iteration
+
+Doing something repeatedly.
+
+=item iterator
+
+A special programming gizmo that keeps track of where you are in
+something that you're trying to iterate over.  The C<foreach> loop in
+Perl contains an iterator; so does a hash, allowing you to
+L<each|perlfunc/each> through it.
+
+=item IV
+
+The integer four, not to be confused with six, Tom's favorite editor.
+IV also means an internal Integer Value of the type a L</scalar> can
+hold, not to be confused with an L</NV>.
+
+=back
+
+=head2 J
+
+=over 4
+
+=item JAPH
+
+"Just Another Perl Hacker," a clever but cryptic bit of Perl code that
+when executed, evaluates to that string.  Often used to illustrate a
+particular Perl feature, and something of an ongoing Obfuscated Perl
+Contest seen in Usenix signatures.
+
+=back
+
+=head2 K
+
+=over 4
+
+=item key
+
+The string index to a L</hash>, used to look up the L</value>
+associated with that key.
+
+=item keyword
+
+See L</reserved words>.
+
+=back
+
+=head2 L
+
+=over 4
+
+=item label
+
+A name you give to a L</statement> so that you can talk about that
+statement elsewhere in the program.
+
+=item laziness
+
+The quality that makes you go to great effort to reduce overall energy
+expenditure.  It makes you write labor-saving programs that other
+people will find useful, and document what you wrote so you don't have
+to answer so many questions about it.  Hence, the first great virtue
+of a programmer.  Also hence, this book.  See also L</impatience> and
+L</hubris>.
+
+=item left shift
+
+A L</bit shift> that multiplies the number by some power of 2.
+
+=item leftmost longest
+
+The preference of the L</regular expression> engine to match the
+leftmost occurrence of a L</pattern>, then given a position at which a
+match will occur, the preference for the longest match (presuming the
+use of a L</greedy> quantifier).  See L<perlre> for I<much> more on
+this subject.
+
+=item lexeme
+
+Fancy term for a L</token>.
+
+=item lexer
+
+Fancy term for a L</tokener>.
+
+=item lexical analysis
+
+Fancy term for L</tokenizing>.
+
+=item lexical scoping
+
+Looking at your I<Oxford English Dictionary> through a microscope.
+(Also known as L</static scoping>, because dictionaries don't change
+very fast.)  Similarly, looking at variables stored in a private
+dictionary (namespace) for each scope, which are visible only from
+their point of declaration down to the end of the lexical scope in
+which they are declared.  --Syn. L</static scoping>.
+--Ant. L</dynamic scoping>.
+
+=item lexical variable
+
+A L</variable> subject to L</lexical scoping>, declared by
+L<my|perlfunc/my>.  Often just called a "lexical".  (The
+L<our|perlfunc/our> declaration declares a lexically scoped name for a
+global variable, which is not itself a lexical variable.)
+
+=item library
+
+Generally, a collection of procedures.  In ancient days, referred to a
+collection of subroutines in a I<.pl> file.  In modern times, refers
+more often to the entire collection of Perl L<modules|/module> on your
+system.
+
+=item LIFO
+
+Last In, First Out.  See also L</FIFO>.  A LIFO is usually called a
+L</stack>.
+
+=item line
+
+In Unix, a sequence of zero or more non-newline characters terminated
+with a L</newline> character.  On non-Unix machines, this is emulated
+by the C library even if the underlying L</operating system> has
+different ideas.
+
+=item line buffering
+
+Used by a L</standard IE<sol>O> output stream that flushes its
+L</buffer> after every L</newline>.  Many standard I/O libraries
+automatically set up line buffering on output that is going to the
+terminal.
+
+=item line number
+
+The number of lines read previous to this one, plus 1.  Perl keeps a
+separate line number for each source or input file it opens.  The
+current source file's line number is represented by C<__LINE__>.  The
+current input line number (for the file that was most recently read
+via C<< E<lt>FHE<gt> >>) is represented by the C<$.>
+(C<$INPUT_LINE_NUMBER>) variable.  Many error messages report both
+values, if available.
+
+=item link
+
+Used as a noun, a name in a L</directory>, representing a L</file>.  A
+given file can have multiple links to it.  It's like having the same
+phone number listed in the phone directory under different names.  As
+a verb, to resolve a partially compiled file's unresolved symbols into
+a (nearly) executable image.  Linking can generally be static or
+dynamic, which has nothing to do with static or dynamic scoping.
+
+=item LIST
+
+A syntactic construct representing a comma-separated list of
+expressions, evaluated to produce a L</list value>.  Each
+L</expression> in a L</LIST> is evaluated in L</list context> and
+interpolated into the list value.
+
+=item list
+
+An ordered set of scalar values.
+
+=item list context
+
+The situation in which an L</expression> is expected by its
+surroundings (the code calling it) to return a list of values rather
+than a single value.  Functions that want a L</LIST> of arguments tell
+those arguments that they should produce a list value.  See also
+L</context>.
+
+=item list operator
+
+An L</operator> that does something with a list of values, such as
+L<join|perlfunc/join> or L<grep|perlfunc/grep>.  Usually used for
+named built-in operators (such as L<print|perlfunc/print>,
+L<unlink|perlfunc/unlink>, and L<system|perlfunc/system>) that do not
+require parentheses around their L</argument> list.
+
+=item list value
+
+An unnamed list of temporary scalar values that may be passed around
+within a program from any list-generating function to any function or
+construct that provides a L</list context>.
+
+=item literal
+
+A token in a programming language such as a number or L</string> that
+gives you an actual L</value> instead of merely representing possible
+values as a L</variable> does.
+
+=item little-endian
+
+From Swift: someone who eats eggs little end first.  Also used of
+computers that store the least significant L</byte> of a word at a
+lower byte address than the most significant byte.  Often considered
+superior to big-endian machines.  See also L</big-endian>.
+
+=item local
+
+Not meaning the same thing everywhere.  A global variable in Perl can
+be localized inside a L<dynamic scope|/dynamic scoping> via the
+L<local|perlfunc/local> operator.
+
+=item logical operator
+
+Symbols representing the concepts "and", "or", "xor", and "not".
+
+=item lookahead
+
+An L</assertion> that peeks at the string to the right of the current
+match location.
+
+=item lookbehind
+
+An L</assertion> that peeks at the string to the left of the current
+match location.
+
+=item loop
+
+A construct that performs something repeatedly, like a roller coaster.
+
+=item loop control statement
+
+Any statement within the body of a loop that can make a loop
+prematurely stop looping or skip an L</iteration>.  Generally you
+shouldn't try this on roller coasters.
+
+=item loop label
+
+A kind of key or name attached to a loop (or roller coaster) so that
+loop control statements can talk about which loop they want to
+control.
+
+=item lvaluable
+
+Able to serve as an L</lvalue>.
+
+=item lvalue
+
+Term used by language lawyers for a storage location you can assign a
+new L</value> to, such as a L</variable> or an element of an
+L</array>.  The "l" is short for "left", as in the left side of an
+assignment, a typical place for lvalues.  An L</lvaluable> function or
+expression is one to which a value may be assigned, as in C<pos($x) =
+10>.
+
+=item lvalue modifier
+
+An adjectival pseudofunction that warps the meaning of an L</lvalue>
+in some declarative fashion.  Currently there are three lvalue
+modifiers: L<my|perlfunc/my>, L<our|perlfunc/our>, and
+L<local|perlfunc/local>.
+
+=back
+
+=head2 M
+
+=over 4
+
+=item magic
+
+Technically speaking, any extra semantics attached to a variable such
+as C<$!>, C<$0>, C<%ENV>, or C<%SIG>, or to any tied variable.
+Magical things happen when you diddle those variables.
+
+=item magical increment
+
+An L</increment> operator that knows how to bump up alphabetics as
+well as numbers.
+
+=item magical variables
+
+Special variables that have side effects when you access them or
+assign to them.  For example, in Perl, changing elements of the
+C<%ENV> array also changes the corresponding environment variables
+that subprocesses will use.  Reading the C<$!> variable gives you the
+current system error number or message.
+
+=item Makefile
+
+A file that controls the compilation of a program.  Perl programs
+don't usually need a L</Makefile> because the Perl compiler has plenty
+of self-control.
+
+=item man
+
+The Unix program that displays online documentation (manual pages) for
+you.
+
+=item manpage
+
+A "page" from the manuals, typically accessed via the I<man>(1)
+command.  A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
+BUGS, and so on, and is typically longer than a page.  There are
+manpages documenting L<commands|/command>, L<syscalls|/syscall>,
+L</library> L<functions|/function>, L<devices|/device>,
+L<protocols|/protocol>, L<files|/file>, and such.  In this book, we
+call any piece of standard Perl documentation (like I<perlop> or
+I<perldelta>) a manpage, no matter what format it's installed in on
+your system.
+
+=item matching
+
+See L</pattern matching>.
+
+=item member data
+
+See L</instance variable>.
+
+=item memory
+
+This always means your main memory, not your disk.  Clouding the issue
+is the fact that your machine may implement L</virtual> memory; that
+is, it will pretend that it has more memory than it really does, and
+it'll use disk space to hold inactive bits.  This can make it seem
+like you have a little more memory than you really do, but it's not a
+substitute for real memory.  The best thing that can be said about
+virtual memory is that it lets your performance degrade gradually
+rather than suddenly when you run out of real memory.  But your
+program can die when you run out of virtual memory too, if you haven't
+thrashed your disk to death first.
+
+=item metacharacter
+
+A L</character> that is I<not> supposed to be treated normally.  Which
+characters are to be treated specially as metacharacters varies
+greatly from context to context.  Your L</shell> will have certain
+metacharacters, double-quoted Perl L<strings|/string> have other
+metacharacters, and L</regular expression> patterns have all the
+double-quote metacharacters plus some extra ones of their own.
+
+=item metasymbol
+
+Something we'd call a L</metacharacter> except that it's a sequence of
+more than one character.  Generally, the first character in the
+sequence must be a true metacharacter to get the other characters in
+the metasymbol to misbehave along with it.
+
+=item method
+
+A kind of action that an L</object> can take if you tell it to.  See
+L<perlobj>.
+
+=item minimalism
+
+The belief that "small is beautiful."  Paradoxically, if you say
+something in a small language, it turns out big, and if you say it in
+a big language, it turns out small.  Go figure.
+
+=item mode
+
+In the context of the L<stat(2)> syscall, refers to the field holding
+the L</permission bits> and the type of the L</file>.
+
+=item modifier
+
+See L</statement modifier>, L</regular expression modifier>, and
+L</lvalue modifier>, not necessarily in that order.
+
+=item module
+
+A L</file> that defines a L</package> of (almost) the same name, which
+can either L</export> symbols or function as an L</object> class.  (A
+module's main I<.pm> file may also load in other files in support of
+the module.)  See the L<use|perlfunc/use> built-in.
+
+=item modulus
+
+An integer divisor when you're interested in the remainder instead of
+the quotient.
+
+=item monger
+
+Short for Perl Monger, a purveyor of Perl.
+
+=item mortal
+
+A temporary value scheduled to die when the current statement
+finishes.
+
+=item multidimensional array
+
+An array with multiple subscripts for finding a single element.  Perl
+implements these using L<references|/reference>--see L<perllol> and
+L<perldsc>.
+
+=item multiple inheritance
+
+The features you got from your mother and father, mixed together
+unpredictably.  (See also L</inheritance>, and L</single
+inheritance>.)  In computer languages (including Perl), the notion
+that a given class may have multiple direct ancestors or L<base
+classes|/base class>.
+
+=back
+
+=head2 N
+
+=over 4
+
+=item named pipe
+
+A L</pipe> with a name embedded in the L</filesystem> so that it can
+be accessed by two unrelated L<processes|/process>.
+
+=item namespace
+
+A domain of names.  You needn't worry about whether the names in one
+such domain have been used in another.  See L</package>.
+
+=item network address
+
+The most important attribute of a socket, like your telephone's
+telephone number.  Typically an IP address.  See also L</port>.
+
+=item newline
+
+A single character that represents the end of a line, with the ASCII
+value of 012 octal under Unix (but 015 on a Mac), and represented by
+C<\n> in Perl strings.  For Windows machines writing text files, and
+for certain physical devices like terminals, the single newline gets
+automatically translated by your C library into a line feed and a
+carriage return, but normally, no translation is done.
+
+=item NFS
+
+Network File System, which allows you to mount a remote filesystem as
+if it were local.
+
+=item null character
+
+A character with the ASCII value of zero.  It's used by C to terminate
+strings, but Perl allows strings to contain a null.
+
+=item null list
+
+A valueless value represented in Perl by C<()>.  It is not really a
+L</LIST>, but an expression that yields C<undef> in L</scalar context> and
+a L</list value> with zero elements in L</list context>.
+
+=item null string
+
+A L</string> containing no characters, not to be confused with a
+string containing a L</null character>, which has a positive length
+and is L</true>.
+
+=item numeric context
+
+The situation in which an expression is expected by its surroundings
+(the code calling it) to return a number.  See also L</context> and
+L</string context>.
+
+=item NV
+
+Short for Nevada, no part of which will ever be confused with
+civilization.  NV also means an internal floating-point Numeric Value
+of the type a L</scalar> can hold, not to be confused with an L</IV>.
+
+=item nybble
+
+Half a L</byte>, equivalent to one L</hexadecimal> digit, and worth
+four L<bits|/bit>.
+
+=back
+
+=head2 O
+
+=over 4
+
+=item object
+
+An L</instance> of a L</class>.  Something that "knows" what
+user-defined type (class) it is, and what it can do because of what
+class it is.  Your program can request an object to do things, but the
+object gets to decide whether it wants to do them or not.  Some
+objects are more accommodating than others.
+
+=item octal
+
+A number in base 8.  Only the digits 0 through 7 are allowed.  Octal
+constants in Perl start with 0, as in 013.  See also the
+L<oct|perlfunc/oct> function.
+
+=item offset
+
+How many things you have to skip over when moving from the beginning
+of a string or array to a specific position within it.  Thus, the
+minimum offset is zero, not one, because you don't skip anything to
+get to the first item.
+
+=item one-liner
+
+An entire computer program crammed into one line of text.
+
+=item open source software
+
+Programs for which the source code is freely available and freely
+redistributable, with no commercial strings attached.  For a more
+detailed definition, see L<http://www.opensource.org/osd.html>.
+
+=item operand
+
+An L</expression> that yields a L</value> that an L</operator>
+operates on.  See also L</precedence>.
+
+=item operating system
+
+A special program that runs on the bare machine and hides the gory
+details of managing L<processes|/process> and L<devices|/device>.
+Usually used in a looser sense to indicate a particular culture of
+programming.  The loose sense can be used at varying levels of
+specificity.  At one extreme, you might say that all versions of Unix
+and Unix-lookalikes are the same operating system (upsetting many
+people, especially lawyers and other advocates).  At the other
+extreme, you could say this particular version of this particular
+vendor's operating system is different from any other version of this
+or any other vendor's operating system.  Perl is much more portable
+across operating systems than many other languages.  See also
+L</architecture> and L</platform>.
+
+=item operator
+
+A gizmo that transforms some number of input values to some number of
+output values, often built into a language with a special syntax or
+symbol.  A given operator may have specific expectations about what
+L<types|/type> of data you give as its arguments
+(L<operands|/operand>) and what type of data you want back from it.
+
+=item operator overloading
+
+A kind of L</overloading> that you can do on built-in
+L<operators|/operator> to make them work on L<objects|/object> as if
+the objects were ordinary scalar values, but with the actual semantics
+supplied by the object class.  This is set up with the L<overload>
+L</pragma>.
+
+=item options
+
+See either L<switches|/switch> or L</regular expression modifier>.
+
+=item ordinal
+
+Another name for L</code point>
+
+=item overloading
+
+Giving additional meanings to a symbol or construct.  Actually, all
+languages do overloading to one extent or another, since people are
+good at figuring out things from L</context>.
+
+=item overriding
+
+Hiding or invalidating some other definition of the same name.  (Not
+to be confused with L</overloading>, which adds definitions that must
+be disambiguated some other way.) To confuse the issue further, we use
+the word with two overloaded definitions: to describe how you can
+define your own L</subroutine> to hide a built-in L</function> of the
+same name (see L<perlsub/Overriding Built-in Functions>) and to
+describe how you can define a replacement L</method> in a L</derived
+class> to hide a L</base class>'s method of the same name (see
+L<perlobj>).
+
+=item owner
+
+The one user (apart from the superuser) who has absolute control over
+a L</file>.  A file may also have a L</group> of users who may
+exercise joint ownership if the real owner permits it.  See
+L</permission bits>.
+
+=back
+
+=head2 P
+
+=over 4
+
+=item package
+
+A L</namespace> for global L<variables|/variable>,
+L<subroutines|/subroutine>, and the like, such that they can be kept
+separate from like-named L<symbols|/symbol> in other namespaces.  In a
+sense, only the package is global, since the symbols in the package's
+symbol table are only accessible from code compiled outside the
+package by naming the package.  But in another sense, all package
+symbols are also globals--they're just well-organized globals.
+
+=item pad
+
+Short for L</scratchpad>.
+
+=item parameter
+
+See L</argument>.
+
+=item parent class
+
+See L</base class>.
+
+=item parse tree
+
+See L</syntax tree>.
+
+=item parsing
+
+The subtle but sometimes brutal art of attempting to turn your
+possibly malformed program into a valid L</syntax tree>.
+
+=item patch
+
+To fix by applying one, as it were.  In the realm of hackerdom, a
+listing of the differences between two versions of a program as might
+be applied by the I<patch>(1) program when you want to fix a bug or
+upgrade your old version.
+
+=item PATH
+
+The list of L<directories|/directory> the system searches to find a
+program you want to L</execute>.  The list is stored as one of your
+L<environment variables|/environment variable>, accessible in Perl as
+C<$ENV{PATH}>.
+
+=item pathname
+
+A fully qualified filename such as I</usr/bin/perl>.  Sometimes
+confused with L</PATH>.
+
+=item pattern
+
+A template used in L</pattern matching>.
+
+=item pattern matching
+
+Taking a pattern, usually a L</regular expression>, and trying the
+pattern various ways on a string to see whether there's any way to
+make it fit.  Often used to pick interesting tidbits out of a file.
+
+=item permission bits
+
+Bits that the L</owner> of a file sets or unsets to allow or disallow
+access to other people.  These flag bits are part of the L</mode> word
+returned by the L<stat|perlfunc/stat> built-in when you ask about a
+file.  On Unix systems, you can check the I<ls>(1) manpage for more
+information.
+
+=item Pern
+
+What you get when you do C<Perl++> twice.  Doing it only once will
+curl your hair.  You have to increment it eight times to shampoo your
+hair.  Lather, rinse, iterate.
+
+=item pipe
+
+A direct L</connection> that carries the output of one L</process> to
+the input of another without an intermediate temporary file.  Once the
+pipe is set up, the two processes in question can read and write as if
+they were talking to a normal file, with some caveats.
+
+=item pipeline
+
+A series of L<processes|/process> all in a row, linked by
+L<pipes|/pipe>, where each passes its output stream to the next.
+
+=item platform
+
+The entire hardware and software context in which a program runs.  A
+ program written in a platform-dependent language might break if you
+change any of: machine, operating system, libraries, compiler, or
+system configuration.  The I<perl> interpreter has to be compiled
+differently for each platform because it is implemented in C, but
+programs written in the Perl language are largely
+platform-independent.
+
+=item pod
+
+The markup used to embed documentation into your Perl code.  See
+L<perlpod>.
+
+=item pointer
+
+A L</variable> in a language like C that contains the exact memory
+location of some other item.  Perl handles pointers internally so you
+don't have to worry about them.  Instead, you just use symbolic
+pointers in the form of L<keys|/key> and L</variable> names, or L<hard
+references|/hard reference>, which aren't pointers (but act like
+pointers and do in fact contain pointers).
+
+=item polymorphism
+
+The notion that you can tell an L</object> to do something generic,
+and the object will interpret the command in different ways depending
+on its type.  [E<lt>Gk many shapes]
+
+=item port
+
+The part of the address of a TCP or UDP socket that directs packets to
+the correct process after finding the right machine, something like
+the phone extension you give when you reach the company operator.
+Also, the result of converting code to run on a different platform
+than originally intended, or the verb denoting this conversion.
+
+=item portable
+
+Once upon a time, C code compilable under both BSD and SysV.  In
+general, code that can be easily converted to run on another
+L</platform>, where "easily" can be defined however you like, and
+usually is.  Anything may be considered portable if you try hard
+enough.  See I<mobile home> or I<London Bridge>.
+
+=item porter
+
+Someone who "carries" software from one L</platform> to another.
+Porting programs written in platform-dependent languages such as C can
+be difficult work, but porting programs like Perl is very much worth
+the agony.
+
+=item POSIX
+
+The Portable Operating System Interface specification.
+
+=item postfix
+
+An L</operator> that follows its L</operand>, as in C<$x++>.
+
+=item pp
+
+An internal shorthand for a "push-pop" code, that is, C code
+implementing Perl's stack machine.
+
+=item pragma
+
+A standard module whose practical hints and suggestions are received
+(and possibly ignored) at compile time.  Pragmas are named in all
+lowercase.
+
+=item precedence
+
+The rules of conduct that, in the absence of other guidance, determine
+what should happen first.  For example, in the absence of parentheses,
+you always do multiplication before addition.
+
+=item prefix
+
+An L</operator> that precedes its L</operand>, as in C<++$x>.
+
+=item preprocessing
+
+What some helper L</process> did to transform the incoming data into a
+form more suitable for the current process.  Often done with an
+incoming L</pipe>.  See also L</C preprocessor>.
+
+=item procedure
+
+A L</subroutine>.
+
+=item process
+
+An instance of a running program.  Under multitasking systems like
+Unix, two or more separate processes could be running the same program
+independently at the same time--in fact, the L<fork|perlfunc/fork>
+function is designed to bring about this happy state of affairs.
+Under other operating systems, processes are sometimes called
+"threads", "tasks", or "jobs", often with slight nuances in meaning.
+
+=item program generator
+
+A system that algorithmically writes code for you in a high-level
+language.  See also L</code generator>.
+
+=item progressive matching
+
+L<Pattern matching|/pattern matching> that picks up where it left off before.
+
+=item property
+
+See either L</instance variable> or L</character property>.
+
+=item protocol
+
+In networking, an agreed-upon way of sending messages back and forth
+so that neither correspondent will get too confused.
+
+=item prototype
+
+An optional part of a L</subroutine> declaration telling the Perl
+compiler how many and what flavor of arguments may be passed as
+L</actual arguments>, so that you can write subroutine calls that
+parse much like built-in functions.  (Or don't parse, as the case may
+be.)
+
+=item pseudofunction
+
+A construct that sometimes looks like a function but really isn't.
+Usually reserved for L</lvalue> modifiers like L<my|perlfunc/my>, for
+L</context> modifiers like L<scalar|perlfunc/scalar>, and for the
+pick-your-own-quotes constructs, C<q//>, C<qq//>, C<qx//>, C<qw//>,
+C<qr//>, C<m//>, C<s///>, C<y///>, and C<tr///>.
+
+=item pseudohash
+
+A reference to an array whose initial element happens to hold a
+reference to a hash.  You can treat a pseudohash reference as either
+an array reference or a hash reference.
+
+=item pseudoliteral
+
+An L</operator> that looks something like a L</literal>, such as the
+output-grabbing operator, C<`>I<C<command>>C<`>.
+
+=item public domain
+
+Something not owned by anybody.  Perl is copyrighted and is thus
+I<not> in the public domain--it's just L</freely available> and
+L</freely redistributable>.
+
+=item pumpkin
+
+A notional "baton" handed around the Perl community indicating who is
+the lead integrator in some arena of development.
+
+=item pumpking
+
+A L</pumpkin> holder, the person in charge of pumping the pump, or at
+least priming it.  Must be willing to play the part of the Great
+Pumpkin now and then.
+
+=item PV
+
+A "pointer value", which is Perl Internals Talk for a C<char*>.
+
+=back
+
+=head2 Q
+
+=over 4
+
+=item qualified
+
+Possessing a complete name.  The symbol C<$Ent::moot> is qualified;
+C<$moot> is unqualified.  A fully qualified filename is specified from
+the top-level directory.
+
+=item quantifier
+
+A component of a L</regular expression> specifying how many times the
+foregoing L</atom> may occur.
+
+=back
+
+=head2 R
+
+=over 4
+
+=item readable
+
+With respect to files, one that has the proper permission bit set to
+let you access the file.  With respect to computer programs, one
+that's written well enough that someone has a chance of figuring out
+what it's trying to do.
+
+=item reaping
+
+The last rites performed by a parent L</process> on behalf of a
+deceased child process so that it doesn't remain a L</zombie>.  See
+the L<wait|perlfunc/wait> and L<waitpid|perlfunc/waitpid> function
+calls.
+
+=item record
+
+A set of related data values in a L</file> or L</stream>, often
+associated with a unique L</key> field.  In Unix, often commensurate
+with a L</line>, or a blank-line-terminated set of lines (a
+"paragraph").  Each line of the I</etc/passwd> file is a record, keyed
+on login name, containing information about that user.
+
+=item recursion
+
+The art of defining something (at least partly) in terms of itself,
+which is a naughty no-no in dictionaries but often works out okay in
+computer programs if you're careful not to recurse forever, which is
+like an infinite loop with more spectacular failure modes.
+
+=item reference
+
+Where you look to find a pointer to information somewhere else.  (See
+L</indirection>.)  References come in two flavors, L<symbolic
+references|/symbolic reference> and L<hard references|/hard
+reference>.
+
+=item referent
+
+Whatever a reference refers to, which may or may not have a name.
+Common types of referents include scalars, arrays, hashes, and
+subroutines.
+
+=item regex
+
+See L</regular expression>.
+
+=item regular expression
+
+A single entity with various interpretations, like an elephant.  To a
+computer scientist, it's a grammar for a little language in which some
+strings are legal and others aren't.  To normal people, it's a pattern
+you can use to find what you're looking for when it varies from case
+to case.  Perl's regular expressions are far from regular in the
+theoretical sense, but in regular use they work quite well.  Here's a
+regular expression: C</Oh s.*t./>.  This will match strings like "C<Oh
+say can you see by the dawn's early light>" and "C<Oh sit!>".  See
+L<perlre>.
+
+=item regular expression modifier
+
+An option on a pattern or substitution, such as C</i> to render the
+pattern case insensitive.  See also L</cloister>.
+
+=item regular file
+
+A L</file> that's not a L</directory>, a L</device>, a named L</pipe>
+or L</socket>, or a L</symbolic link>.  Perl uses the C<-f> file test
+operator to identify regular files.  Sometimes called a "plain" file.
+
+=item relational operator
+
+An L</operator> that says whether a particular ordering relationship
+is L</true> about a pair of L<operands|/operand>.  Perl has both
+numeric and string relational operators.  See L</collating sequence>.
+
+=item reserved words
+
+A word with a specific, built-in meaning to a L</compiler>, such as
+C<if> or L<delete|perlfunc/delete>.  In many languages (not Perl),
+it's illegal to use reserved words to name anything else.  (Which is
+why they're reserved, after all.)  In Perl, you just can't use them to
+name L<labels|/label> or L<filehandles|/filehandle>.  Also called
+"keywords".
+
+=item return value
+
+The L</value> produced by a L</subroutine> or L</expression> when
+evaluated.  In Perl, a return value may be either a L</list> or a
+L</scalar>.
+
+=item RFC
+
+Request For Comment, which despite the timid connotations is the name
+of a series of important standards documents.
+
+=item right shift
+
+A L</bit shift> that divides a number by some power of 2.
+
+=item root
+
+The superuser (UID == 0).  Also, the top-level directory of the
+filesystem.
+
+=item RTFM
+
+What you are told when someone thinks you should Read The Fine Manual.
+
+=item run phase
+
+Any time after Perl starts running your main program.  See also
+L</compile phase>.  Run phase is mostly spent in L</run time> but may
+also be spent in L</compile time> when L<require|perlfunc/require>,
+L<do|perlfunc/do> C<FILE>, or L<eval|perlfunc/eval> C<STRING>
+operators are executed or when a substitution uses the C</ee>
+modifier.
+
+=item run time
+
+The time when Perl is actually doing what your code says to do, as
+opposed to the earlier period of time when it was trying to figure out
+whether what you said made any sense whatsoever, which is L</compile
+time>.
+
+=item run-time pattern
+
+A pattern that contains one or more variables to be interpolated
+before parsing the pattern as a L</regular expression>, and that
+therefore cannot be analyzed at compile time, but must be re-analyzed
+each time the pattern match operator is evaluated.  Run-time patterns
+are useful but expensive.
+
+=item RV
+
+A recreational vehicle, not to be confused with vehicular recreation.
+RV also means an internal Reference Value of the type a L</scalar> can
+hold.  See also L</IV> and L</NV> if you're not confused yet.
+
+=item rvalue
+
+A L</value> that you might find on the right side of an
+L</assignment>.  See also L</lvalue>.
+
+=back
+
+=head2 S
+
+=over 4
+
+=item scalar
+
+A simple, singular value; a number, L</string>, or L</reference>.
+
+=item scalar context
+
+The situation in which an L</expression> is expected by its
+surroundings (the code calling it) to return a single L</value> rather
+than a L</list> of values.  See also L</context> and L</list context>.
+A scalar context sometimes imposes additional constraints on the
+return value--see L</string context> and L</numeric context>.
+Sometimes we talk about a L</Boolean context> inside conditionals, but
+this imposes no additional constraints, since any scalar value,
+whether numeric or L</string>, is already true or false.
+
+=item scalar literal
+
+A number or quoted L</string>--an actual L</value> in the text of your
+program, as opposed to a L</variable>.
+
+=item scalar value
+
+A value that happens to be a L</scalar> as opposed to a L</list>.
+
+=item scalar variable
+
+A L</variable> prefixed with C<$> that holds a single value.
+
+=item scope
+
+How far away you can see a variable from, looking through one.  Perl
+has two visibility mechanisms: it does L</dynamic scoping> of
+L<local|perlfunc/local> L<variables|/variable>, meaning that the rest
+of the L</block>, and any L<subroutines|/subroutine> that are called
+by the rest of the block, can see the variables that are local to the
+block.  Perl does L</lexical scoping> of L<my|perlfunc/my> variables,
+meaning that the rest of the block can see the variable, but other
+subroutines called by the block I<cannot> see the variable.
+
+=item scratchpad
+
+The area in which a particular invocation of a particular file or
+subroutine keeps some of its temporary values, including any lexically
+scoped variables.
+
+=item script
+
+A text L</file> that is a program intended to be L<executed|/execute>
+directly rather than L<compiled|/compiler> to another form of file
+before execution.  Also, in the context of L</Unicode>, a writing
+system for a particular language or group of languages, such as Greek,
+Bengali, or Klingon.
+
+=item script kiddie
+
+A L</cracker> who is not a L</hacker>, but knows just enough to run
+canned scripts.  A cargo-cult programmer.
+
+=item sed
+
+A venerable Stream EDitor from which Perl derives some of its ideas.
+
+=item semaphore
+
+A fancy kind of interlock that prevents multiple L<threads|/thread> or
+L<processes|/process> from using up the same resources simultaneously.
+
+=item separator
+
+A L</character> or L</string> that keeps two surrounding strings from
+being confused with each other.  The L<split|perlfunc/split> function
+works on separators.  Not to be confused with L<delimiters|/delimiter>
+or L<terminators|/terminator>.  The "or" in the previous sentence
+separated the two alternatives.
+
+=item serialization
+
+Putting a fancy L</data structure> into linear order so that it can be
+stored as a L</string> in a disk file or database or sent through a
+L</pipe>.  Also called marshalling.
+
+=item server
+
+In networking, a L</process> that either advertises a L</service> or
+just hangs around at a known location and waits for L<clients|/client>
+who need service to get in touch with it.
+
+=item service
+
+Something you do for someone else to make them happy, like giving them
+the time of day (or of their life).  On some machines, well-known
+services are listed by the L<getservent|perlfunc/getservent> function.
+
+=item setgid
+
+Same as L</setuid>, only having to do with giving away L</group>
+privileges.
+
+=item setuid
+
+Said of a program that runs with the privileges of its L</owner>
+rather than (as is usually the case) the privileges of whoever is
+running it.  Also describes the bit in the mode word (L</permission
+bits>) that controls the feature.  This bit must be explicitly set by
+the owner to enable this feature, and the program must be carefully
+written not to give away more privileges than it ought to.
+
+=item shared memory
+
+A piece of L</memory> accessible by two different
+L<processes|/process> who otherwise would not see each other's memory.
+
+=item shebang
+
+Irish for the whole McGillicuddy.  In Perl culture, a portmanteau of
+"sharp" and "bang", meaning the C<#!> sequence that tells the system
+where to find the interpreter.
+
+=item shell
+
+A L</command>-line L</interpreter>.  The program that interactively
+gives you a prompt, accepts one or more L<lines|/line> of input, and
+executes the programs you mentioned, feeding each of them their proper
+L<arguments|/argument> and input data.  Shells can also execute
+scripts containing such commands.  Under Unix, typical shells include
+the Bourne shell (I</bin/sh>), the C shell (I</bin/csh>), and the Korn
+shell (I</bin/ksh>).  Perl is not strictly a shell because it's not
+interactive (although Perl programs can be interactive).
+
+=item side effects
+
+Something extra that happens when you evaluate an L</expression>.
+Nowadays it can refer to almost anything.  For example, evaluating a
+simple assignment statement typically has the "side effect" of
+assigning a value to a variable.  (And you thought assigning the value
+was your primary intent in the first place!)  Likewise, assigning a
+value to the special variable C<$|> (C<$AUTOFLUSH>) has the side
+effect of forcing a flush after every L<write|perlfunc/write> or
+L<print|perlfunc/print> on the currently selected filehandle.
+
+=item signal
+
+A bolt out of the blue; that is, an event triggered by the
+L</operating system>, probably when you're least expecting it.
+
+=item signal handler
+
+A L</subroutine> that, instead of being content to be called in the
+normal fashion, sits around waiting for a bolt out of the blue before
+it will deign to L</execute>.  Under Perl, bolts out of the blue are
+called signals, and you send them with the L<kill|perlfunc/kill>
+built-in.  See L<perlvar/%SIG> and L<perlipc/Signals>.
+
+=item single inheritance
+
+The features you got from your mother, if she told you that you don't
+have a father.  (See also L</inheritance> and L</multiple
+inheritance>.)  In computer languages, the notion that
+L<classes|/class> reproduce asexually so that a given class can only
+have one direct ancestor or L</base class>.  Perl supplies no such
+restriction, though you may certainly program Perl that way if you
+like.
+
+=item slice
+
+A selection of any number of L<elements|/element> from a L</list>,
+L</array>, or L</hash>.
+
+=item slurp
+
+To read an entire L</file> into a L</string> in one operation.
+
+=item socket
+
+An endpoint for network communication among multiple
+L<processes|/process> that works much like a telephone or a post
+office box.  The most important thing about a socket is its L</network
+address> (like a phone number).  Different kinds of sockets have
+different kinds of addresses--some look like filenames, and some
+don't.
+
+=item soft reference
+
+See L</symbolic reference>.
+
+=item source filter
+
+A special kind of L</module> that does L</preprocessing> on your
+script just before it gets to the L</tokener>.
+
+=item stack
+
+A device you can put things on the top of, and later take them back
+off in the opposite order in which you put them on.  See L</LIFO>.
+
+=item standard
+
+Included in the official Perl distribution, as in a standard module, a
+standard tool, or a standard Perl L</manpage>.
+
+=item standard error
+
+The default output L</stream> for nasty remarks that don't belong in
+L</standard output>.  Represented within a Perl program by the
+L</filehandle> L</STDERR>.  You can use this stream explicitly, but the
+L<die|perlfunc/die> and L<warn|perlfunc/warn> built-ins write to your
+standard error stream automatically.
+
+=item standard I/O
+
+A standard C library for doing L<buffered|/buffer> input and output to
+the L</operating system>.  (The "standard" of standard I/O is only
+marginally related to the "standard" of standard input and output.)
+In general, Perl relies on whatever implementation of standard I/O a
+given operating system supplies, so the buffering characteristics of a
+Perl program on one machine may not exactly match those on another
+machine.  Normally this only influences efficiency, not semantics.  If
+your standard I/O package is doing block buffering and you want it to
+L</flush> the buffer more often, just set the C<$|> variable to a true
+value.
+
+=item standard input
+
+The default input L</stream> for your program, which if possible
+shouldn't care where its data is coming from.  Represented within a
+Perl program by the L</filehandle> L</STDIN>.
+
+=item standard output
+
+The default output L</stream> for your program, which if possible
+shouldn't care where its data is going.  Represented within a Perl
+program by the L</filehandle> L</STDOUT>.
+
+=item stat structure
+
+A special internal spot in which Perl keeps the information about the
+last L</file> on which you requested information.
+
+=item statement
+
+A L</command> to the computer about what to do next, like a step in a
+recipe: "Add marmalade to batter and mix until mixed."  A statement is
+distinguished from a L</declaration>, which doesn't tell the computer
+to do anything, but just to learn something.
+
+=item statement modifier
+
+A L</conditional> or L</loop> that you put after the L</statement>
+instead of before, if you know what we mean.
+
+=item static
+
+Varying slowly compared to something else.  (Unfortunately, everything
+is relatively stable compared to something else, except for certain
+elementary particles, and we're not so sure about them.)  In
+computers, where things are supposed to vary rapidly, "static" has a
+derogatory connotation, indicating a slightly dysfunctional
+L</variable>, L</subroutine>, or L</method>.  In Perl culture, the
+word is politely avoided.
+
+=item static method
+
+No such thing.  See L</class method>.
+
+=item static scoping
+
+No such thing.  See L</lexical scoping>.
+
+=item static variable
+
+No such thing.  Just use a L</lexical variable> in a scope larger than
+your L</subroutine>.
+
+=item status
+
+The L</value> returned to the parent L</process> when one of its child
+processes dies.  This value is placed in the special variable C<$?>.
+Its upper eight L<bits|/bit> are the exit status of the defunct
+process, and its lower eight bits identify the signal (if any) that
+the process died from.  On Unix systems, this status value is the same
+as the status word returned by I<wait>(2).  See L<perlfunc/system>.
+
+=item STDERR
+
+See L</standard error>.
+
+=item STDIN
+
+See L</standard input>.
+
+=item STDIO
+
+See L</standard IE<sol>O>.
+
+=item STDOUT
+
+See L</standard output>.
+
+=item stream
+
+A flow of data into or out of a process as a steady sequence of bytes
+or characters, without the appearance of being broken up into packets.
+This is a kind of L</interface>--the underlying L</implementation> may
+well break your data up into separate packets for delivery, but this
+is hidden from you.
+
+=item string
+
+A sequence of characters such as "He said !@#*&%@#*?!".  A string does
+not have to be entirely printable.
+
+=item string context
+
+The situation in which an expression is expected by its surroundings
+(the code calling it) to return a L</string>.  See also L</context>
+and L</numeric context>.
+
+=item stringification
+
+The process of producing a L</string> representation of an abstract
+object.
+
+=item struct
+
+C keyword introducing a structure definition or name.
+
+=item structure
+
+See L</data structure>.
+
+=item subclass
+
+See L</derived class>.
+
+=item subpattern
+
+A component of a L</regular expression> pattern.
+
+=item subroutine
+
+A named or otherwise accessible piece of program that can be invoked
+from elsewhere in the program in order to accomplish some sub-goal of
+the program.  A subroutine is often parameterized to accomplish
+different but related things depending on its input
+L<arguments|/argument>.  If the subroutine returns a meaningful
+L</value>, it is also called a L</function>.
+
+=item subscript
+
+A L</value> that indicates the position of a particular L</array>
+L</element> in an array.
+
+=item substitution
+
+Changing parts of a string via the C<s///> operator.  (We avoid use of
+this term to mean L</variable interpolation>.)
+
+=item substring
+
+A portion of a L</string>, starting at a certain L</character>
+position (L</offset>) and proceeding for a certain number of
+characters.
+
+=item superclass
+
+See L</base class>.
+
+=item superuser
+
+The person whom the L</operating system> will let do almost anything.
+Typically your system administrator or someone pretending to be your
+system administrator.  On Unix systems, the L</root> user.  On Windows
+systems, usually the Administrator user.
+
+=item SV
+
+Short for "scalar value".  But within the Perl interpreter every
+L</referent> is treated as a member of a class derived from SV, in an
+object-oriented sort of way.  Every L</value> inside Perl is passed
+around as a C language C<SV*> pointer.  The SV L</struct> knows its
+own "referent type", and the code is smart enough (we hope) not to try
+to call a L</hash> function on a L</subroutine>.
+
+=item switch
+
+An option you give on a command line to influence the way your program
+works, usually introduced with a minus sign.  The word is also used as
+a nickname for a L</switch statement>.
+
+=item switch cluster
+
+The combination of multiple command-line switches (e.g., B<-a -b -c>)
+into one switch (e.g., B<-abc>).  Any switch with an additional
+L</argument> must be the last switch in a cluster.
+
+=item switch statement
+
+A program technique that lets you evaluate an L</expression> and then,
+based on the value of the expression, do a multiway branch to the
+appropriate piece of code for that value.  Also called a "case
+structure", named after the similar Pascal construct.  See
+See L<perlsyn/Basic BLOCKs>.
+
+=item symbol
+
+Generally, any L</token> or L</metasymbol>.  Often used more
+specifically to mean the sort of name you might find in a L</symbol
+table>.
+
+=item symbol table
+
+Where a L</compiler> remembers symbols.  A program like Perl must
+somehow remember all the names of all the L<variables|/variable>,
+L<filehandles|/filehandle>, and L<subroutines|/subroutine> you've
+used.  It does this by placing the names in a symbol table, which is
+implemented in Perl using a L</hash table>.  There is a separate
+symbol table for each L</package> to give each package its own
+L</namespace>.
+
+=item symbolic debugger
+
+A program that lets you step through the L<execution|/execute> of your
+program, stopping or printing things out here and there to see whether
+anything has gone wrong, and if so, what.  The "symbolic" part just
+means that you can talk to the debugger using the same symbols with
+which your program is written.
+
+=item symbolic link
+
+An alternate filename that points to the real L</filename>, which in
+turn points to the real L</file>.  Whenever the L</operating system>
+is trying to parse a L</pathname> containing a symbolic link, it
+merely substitutes the new name and continues parsing.
+
+=item symbolic reference
+
+A variable whose value is the name of another variable or subroutine.
+By L<dereferencing|/dereference> the first variable, you can get at
+the second one.  Symbolic references are illegal under L<use strict
+'refs'|strict/strict refs>.
+
+=item synchronous
+
+Programming in which the orderly sequence of events can be determined;
+that is, when things happen one after the other, not at the same time.
+
+=item syntactic sugar
+
+An alternative way of writing something more easily; a shortcut.
+
+=item syntax
+
+From Greek, "with-arrangement".  How things (particularly symbols) are
+put together with each other.
+
+=item syntax tree
+
+An internal representation of your program wherein lower-level
+L<constructs|/construct> dangle off the higher-level constructs
+enclosing them.
+
+=item syscall
+
+A L</function> call directly to the L</operating system>.  Many of the
+important subroutines and functions you use aren't direct system
+calls, but are built up in one or more layers above the system call
+level.  In general, Perl programmers don't need to worry about the
+distinction.  However, if you do happen to know which Perl functions
+are really syscalls, you can predict which of these will set the C<$!>
+(C<$ERRNO>) variable on failure.  Unfortunately, beginning programmers
+often confusingly employ the term "system call" to mean what happens
+when you call the Perl L<system|perlfunc/system> function, which
+actually involves many syscalls.  To avoid any confusion, we nearly
+always use say "syscall" for something you could call indirectly via
+Perl's L<syscall|perlfunc/syscall> function, and never for something
+you would call with Perl's L<system|perlfunc/system> function.
+
+=back
+
+=head2 T
+
+=over 4
+
+=item tainted
+
+Said of data derived from the grubby hands of a user and thus unsafe
+for a secure program to rely on.  Perl does taint checks if you run a
+L</setuid> (or L</setgid>) program, or if you use the B<-T> switch.
+
+=item TCP
+
+Short for Transmission Control Protocol.  A protocol wrapped around
+the Internet Protocol to make an unreliable packet transmission
+mechanism appear to the application program to be a reliable
+L</stream> of bytes.  (Usually.)
+
+=item term
+
+Short for a "terminal", that is, a leaf node of a L</syntax tree>.  A
+thing that functions grammatically as an L</operand> for the operators
+in an expression.
+
+=item terminator
+
+A L</character> or L</string> that marks the end of another string.
+The C<$/> variable contains the string that terminates a
+L<readline|perlfunc/readline> operation, which L<chomp|perlfunc/chomp>
+deletes from the end.  Not to be confused with
+L<delimiters|/delimiter> or L<separators|/separator>.  The period at
+the end of this sentence is a terminator.
+
+=item ternary
+
+An L</operator> taking three L<operands|/operand>.  Sometimes
+pronounced L</trinary>.
+
+=item text
+
+A L</string> or L</file> containing primarily printable characters.
+
+=item thread
+
+Like a forked process, but without L</fork>'s inherent memory
+protection.  A thread is lighter weight than a full process, in that a
+process could have multiple threads running around in it, all fighting
+over the same process's memory space unless steps are taken to protect
+threads from each other.  See L<threads>.
+
+=item tie
+
+The bond between a magical variable and its implementation class.  See
+L<perlfunc/tie> and L<perltie>.
+
+=item TMTOWTDI
+
+There's More Than One Way To Do It, the Perl Motto.  The notion that
+there can be more than one valid path to solving a programming problem
+in context.  (This doesn't mean that more ways are always better or
+that all possible paths are equally desirable--just that there need
+not be One True Way.)  Pronounced TimToady.
+
+=item token
+
+A morpheme in a programming language, the smallest unit of text with
+semantic significance.
+
+=item tokener
+
+A module that breaks a program text into a sequence of
+L<tokens|/token> for later analysis by a parser.
+
+=item tokenizing
+
+Splitting up a program text into L<tokens|/token>.  Also known as
+"lexing", in which case you get "lexemes" instead of tokens.
+
+=item toolbox approach
+
+The notion that, with a complete set of simple tools that work well
+together, you can build almost anything you want.  Which is fine if
+you're assembling a tricycle, but if you're building a defranishizing
+comboflux regurgalator, you really want your own machine shop in which
+to build special tools.  Perl is sort of a machine shop.
+
+=item transliterate
+
+To turn one string representation into another by mapping each
+character of the source string to its corresponding character in the
+result string.  See
+L<perlop/trE<sol>SEARCHLISTE<sol>REPLACEMENTLISTE<sol>cdsr>.
+
+=item trigger
+
+An event that causes a L</handler> to be run.
+
+=item trinary
+
+Not a stellar system with three stars, but an L</operator> taking
+three L<operands|/operand>.  Sometimes pronounced L</ternary>.
+
+=item troff
+
+A venerable typesetting language from which Perl derives the name of
+its C<$%> variable and which is secretly used in the production of
+Camel books.
+
+=item true
+
+Any scalar value that doesn't evaluate to 0 or C<"">.
+
+=item truncating
+
+Emptying a file of existing contents, either automatically when
+opening a file for writing or explicitly via the
+L<truncate|perlfunc/truncate> function.
+
+=item type
+
+See L</data type> and L</class>.
+
+=item type casting
+
+Converting data from one type to another.  C permits this.  Perl does
+not need it.  Nor want it.
+
+=item typed lexical
+
+A L</lexical variable> that is declared with a L</class> type: C<my
+Pony $bill>.
+
+=item typedef
+
+A type definition in the C language.
+
+=item typeglob
+
+Use of a single identifier, prefixed with C<*>.  For example, C<*name>
+stands for any or all of C<$name>, C<@name>, C<%name>, C<&name>, or
+just C<name>.  How you use it determines whether it is interpreted as
+all or only one of them.  See L<perldata/Typeglobs and Filehandles>.
+
+=item typemap
+
+A description of how C types may be transformed to and from Perl types
+within an L</extension> module written in L</XS>.
+
+=back
+
+=head2 U
+
+=over 4
+
+=item UDP
+
+User Datagram Protocol, the typical way to send L<datagrams|/datagram>
+over the Internet.
+
+=item UID
+
+A user ID.  Often used in the context of L</file> or L</process>
+ownership.
+
+=item umask
+
+A mask of those L</permission bits> that should be forced off when
+creating files or directories, in order to establish a policy of whom
+you'll ordinarily deny access to.  See the L<umask|perlfunc/umask>
+function.
+
+=item unary operator
+
+An operator with only one L</operand>, like C<!> or
+L<chdir|perlfunc/chdir>.  Unary operators are usually prefix
+operators; that is, they precede their operand.  The C<++> and C<-->
+operators can be either prefix or postfix.  (Their position I<does>
+change their meanings.)
+
+=item Unicode
+
+A character set comprising all the major character sets of the world,
+more or less.  See L<perlunicode> and L<http://www.unicode.org>.
+
+=item Unix
+
+A very large and constantly evolving language with several alternative
+and largely incompatible syntaxes, in which anyone can define anything
+any way they choose, and usually do.  Speakers of this language think
+it's easy to learn because it's so easily twisted to one's own ends,
+but dialectical differences make tribal intercommunication nearly
+impossible, and travelers are often reduced to a pidgin-like subset of
+the language.  To be universally understood, a Unix shell programmer
+must spend years of study in the art.  Many have abandoned this
+discipline and now communicate via an Esperanto-like language called
+Perl.
+
+In ancient times, Unix was also used to refer to some code that a
+couple of people at Bell Labs wrote to make use of a PDP-7 computer
+that wasn't doing much of anything else at the time.
+
+=back
+
+=head2 V
+
+=over 4
+
+=item value
+
+An actual piece of data, in contrast to all the variables, references,
+keys, indexes, operators, and whatnot that you need to access the
+value.
+
+=item variable
+
+A named storage location that can hold any of various kinds of
+L</value>, as your program sees fit.
+
+=item variable interpolation
+
+The L</interpolation> of a scalar or array variable into a string.
+
+=item variadic
+
+Said of a L</function> that happily receives an indeterminate number
+of L</actual arguments>.
+
+=item vector
+
+Mathematical jargon for a list of L<scalar values|/scalar value>.
+
+=item virtual
+
+Providing the appearance of something without the reality, as in:
+virtual memory is not real memory.  (See also L</memory>.)  The
+opposite of "virtual" is "transparent", which means providing the
+reality of something without the appearance, as in: Perl handles the
+variable-length UTF-8 character encoding transparently.
+
+=item void context
+
+A form of L</scalar context> in which an L</expression> is not
+expected to return any L</value> at all and is evaluated for its
+L</side effects> alone.
+
+=item v-string
+
+A "version" or "vector" L</string> specified with a C<v> followed by a
+series of decimal integers in dot notation, for instance,
+C<v1.20.300.4000>.  Each number turns into a L</character> with the
+specified ordinal value.  (The C<v> is optional when there are at
+least three integers.)
+
+=back
+
+=head2 W
+
+=over 4
+
+=item warning
+
+A message printed to the L</STDERR> stream to the effect that something
+might be wrong but isn't worth blowing up over.  See L<perlfunc/warn>
+and the L<warnings> pragma.
+
+=item watch expression
+
+An expression which, when its value changes, causes a breakpoint in
+the Perl debugger.
+
+=item whitespace
+
+A L</character> that moves your cursor but doesn't otherwise put
+anything on your screen.  Typically refers to any of: space, tab, line
+feed, carriage return, or form feed.
+
+=item word
+
+In normal "computerese", the piece of data of the size most
+efficiently handled by your computer, typically 32 bits or so, give or
+take a few powers of 2.  In Perl culture, it more often refers to an
+alphanumeric L</identifier> (including underscores), or to a string of
+nonwhitespace L<characters|/character> bounded by whitespace or string
+boundaries.
+
+=item working directory
+
+Your current L</directory>, from which relative pathnames are
+interpreted by the L</operating system>.  The operating system knows
+your current directory because you told it with a
+L<chdir|perlfunc/chdir> or because you started out in the place where
+your parent L</process> was when you were born.
+
+=item wrapper
+
+A program or subroutine that runs some other program or subroutine for
+you, modifying some of its input or output to better suit your
+purposes.
+
+=item WYSIWYG
+
+What You See Is What You Get.  Usually used when something that
+appears on the screen matches how it will eventually look, like Perl's
+L<format|perlfunc/format> declarations.  Also used to mean the
+opposite of magic because everything works exactly as it appears, as
+in the three-argument form of L<open|perlfunc/open>.
+
+=back
+
+=head2 X
+
+=over 4
+
+=item XS
+
+An extraordinarily exported, expeditiously excellent, expressly
+eXternal Subroutine, executed in existing C or C++ or in an exciting
+new extension language called (exasperatingly) XS.  Examine L<perlxs>
+for the exact explanation or L<perlxstut> for an exemplary unexacting
+one.
+
+=item XSUB
+
+An external L</subroutine> defined in L</XS>.
+
+=back
+
+=head2 Y
+
+=over 4
+
+=item yacc
+
+Yet Another Compiler Compiler.  A parser generator without which Perl
+probably would not have existed.  See the file I<perly.y> in the Perl
+source distribution.
+
+=back
+
+=head2 Z
+
+=over 4
+
+=item zero width
+
+A subpattern L</assertion> matching the L</null string> between
+L<characters|/character>.
+
+=item zombie
+
+A process that has died (exited) but whose parent has not yet received
+proper notification of its demise by virtue of having called
+L<wait|perlfunc/wait> or L<waitpid|perlfunc/waitpid>.  If you
+L<fork|perlfunc/fork>, you must clean up after your child processes
+when they exit, or else the process table will fill up and your system
+administrator will Not Be Happy with you.
+
+=back
+
+=head1 AUTHOR AND COPYRIGHT
+
+Based on the Glossary of Programming Perl, Third Edition,
+by Larry Wall, Tom Christiansen & Jon Orwant.
+Copyright (c) 2000, 1996, 1991 O'Reilly Media, Inc.
+This document may be distributed under the same terms as Perl itself.