summaryrefslogtreecommitdiff
path: root/Master/tlpkg/tlperl/lib/pods/perlglossary.pod
diff options
context:
space:
mode:
Diffstat (limited to 'Master/tlpkg/tlperl/lib/pods/perlglossary.pod')
-rw-r--r--Master/tlpkg/tlperl/lib/pods/perlglossary.pod3442
1 files changed, 0 insertions, 3442 deletions
diff --git a/Master/tlpkg/tlperl/lib/pods/perlglossary.pod b/Master/tlpkg/tlperl/lib/pods/perlglossary.pod
deleted file mode 100644
index 5adef04b397..00000000000
--- a/Master/tlpkg/tlperl/lib/pods/perlglossary.pod
+++ /dev/null
@@ -1,3442 +0,0 @@
-=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.org/>, 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. A hash can optionally
-be L<restricted|/restricted hash> to a fixed set of keys.
-
-=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 restricted hash
-
-A L</hash> with a closed set of allowed keys. See L<Hash::Util>.
-
-=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
-
-A language to extend Perl with L<C> and C++. XS is an interface description
-file format used to create an extension interface between
-Perl and C code (or a C library) which one wishes to use with Perl.
-See L<perlxs> for the exact explanation or read the L<perlxstut>
-tutorial.
-
-=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.