3791 lines
134 KiB
Plaintext
3791 lines
134 KiB
Plaintext
|
||
=encoding utf8
|
||
|
||
=head1 NAME
|
||
|
||
perlglossary - Perl Glossary
|
||
|
||
=head1 VERSION
|
||
|
||
version 5.20201107
|
||
|
||
=head1 DESCRIPTION
|
||
|
||
A glossary of terms (technical and otherwise) used in the Perl
|
||
documentation, derived from the Glossary of I<Programming
|
||
Perl>, Fourth Edition. Words or phrases in bold are defined elsewhere in
|
||
this glossary.
|
||
|
||
Other useful sources include the Unicode Glossary L<http://unicode.org/glossary/>,
|
||
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 B<X<accessor methods, defined>X<methods, accessor>method> used to
|
||
indirectly inspect or update an B<object>’s state (its B<instance
|
||
variables>).
|
||
|
||
=item actual arguments
|
||
|
||
The B<X<actual arguments>X<arguments, actual>scalar values> that you supply
|
||
to a B<function> or B<subroutine> when you call it. For instance, when you
|
||
call C<power("puff")>, the string C<"puff"> is the actual argument. See also
|
||
B<argument> and B<formal arguments>.
|
||
|
||
=item address operator
|
||
|
||
Some X<address operator>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
|
||
B<hard reference>, which is much safer than a memory address.
|
||
|
||
=item algorithm
|
||
|
||
A X<algorithms (term)>well-defined sequence of steps, explained clearly
|
||
enough that even a computer could do them.
|
||
|
||
=item alias
|
||
|
||
A X<aliases, defined>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 C<map> or C<grep> operators, in C<$a> and C<$b>
|
||
during C<sort>’s comparison function, and in each element of C<@_> for the
|
||
B<actual arguments> of a subroutine call. Permanent aliases are explicitly
|
||
created in B<packages> by B<importing> symbols or by assignment to
|
||
B<typeglobs>. Lexically scoped aliases for package variables are explicitly
|
||
created by the C<our> declaration.
|
||
|
||
=item alphabetic
|
||
|
||
The X<alphabetic sort>sort of characters we put into words. In Unicode, this
|
||
is all letters including all ideographs and certain diacritics, letter
|
||
numbers like Roman numerals, and various combining marks.
|
||
|
||
=item alternatives
|
||
|
||
A X<alternative characters>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 B<Boolean> expressions are separated
|
||
with either C<||> or C<or>.
|
||
|
||
=item anonymous
|
||
|
||
Used to X<anonymous referents>X<referents, anonymous>describe a B<referent>
|
||
that is not directly accessible through a named B<variable>. Such a referent
|
||
must be indirectly accessible through at least one B<hard reference>. When
|
||
the last hard reference goes away, the anonymous referent is destroyed
|
||
without pity.
|
||
|
||
=item application
|
||
|
||
A X<applications (term)>bigger, fancier sort of B<program> with a fancier
|
||
name so people don’t realize they are using a program.
|
||
|
||
=item architecture
|
||
|
||
The kind of X<architecture>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 B<compiled>
|
||
into machine code. See also B<platform> and B<operating system>.
|
||
|
||
=item argument
|
||
|
||
A X<arguments, defined>piece of data supplied to a B<program>,
|
||
B<subroutine>, B<function>, or B<method> to tell it what it’s supposed to
|
||
do. Also called a “parameter”.
|
||
|
||
=item ARGV
|
||
|
||
The name of the X<ARGV filehandle>array containing the B<argument> B<vector>
|
||
from the command line. If you use the empty C<E<lt>E<gt>> operator, C<ARGV>
|
||
is the name of both the B<filehandle> used to traverse the arguments and the
|
||
B<scalar> containing the name of the current input file.
|
||
|
||
=item arithmetical operator
|
||
|
||
A B<X<arithmetic operators, about>symbol> such as C<+> or C</> that tells
|
||
Perl to do the arithmetic you were supposed to learn in grade school.
|
||
|
||
=item array
|
||
|
||
An X<arrays, defined>ordered sequence of B<values>, stored such that you can
|
||
easily access any of the values using an I<integer subscript> that specifies
|
||
the value’s B<offset> in the sequence.
|
||
|
||
=item array context
|
||
|
||
An archaic X<array context>expression for what is more correctly referred to
|
||
as B<list context>.
|
||
|
||
=item Artistic License
|
||
|
||
The open X<Artistic License>source license that X<Wall, Larry>Larry Wall
|
||
created for Perl, maximizing Perl’s usefulness, availability, and
|
||
modifiability. The current version is 2. (L<http://www.opensource.org/licenses/artistic-license.php>).
|
||
|
||
=item ASCII
|
||
|
||
The X<ASCII (American Standard Code for Information Interchange)>X<American
|
||
Standard Code for Information Interchange (ASCII)>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 best described as half ASCII. See also B<Unicode>.
|
||
|
||
=item assertion
|
||
|
||
A X<assertions (in regexes), defined>X<regular expressions, assertions
|
||
in>component of a B<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 B<zero-width> assertion.
|
||
|
||
=item assignment
|
||
|
||
An X<assignments, defined>B<operator> whose assigned mission in life is to
|
||
change the value of a B<variable>.
|
||
|
||
=item assignment operator
|
||
|
||
Either a X<assignment operators, about>regular B<assignment> or a compound
|
||
B<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 B<hash>. X<associative arrays>Please. The term associative array is the
|
||
old Perl 4 term for a B<hash>. Some languages call it a dictionary.
|
||
|
||
=item associativity
|
||
|
||
Determines X<associativity>whether you do the left B<operator> first or the
|
||
right B<operator> first when you have “A B<operator> B B<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 Camel
|
||
chapter 3, “Unary and Binary Operators” for a list of operators and their
|
||
associativity.
|
||
|
||
=item asynchronous
|
||
|
||
Said of X<asynchronous event processing>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 B<regular X<atoms>expression> component potentially matching a
|
||
B<substring> containing one or more characters and treated as an indivisible
|
||
syntactic unit by any following B<quantifier>. (Contrast with an
|
||
B<assertion> that matches something of B<zero width> and may not be quantified.)
|
||
|
||
=item atomic operation
|
||
|
||
When X<atomic operation>Democritus gave the word “atom” to the indivisible
|
||
bits of matter, he meant literally something that could not be cut: I<ἀ->
|
||
(not) + I<-τομος> (cuttable). An atomic operation is an action that can’t be
|
||
interrupted, not one forbidden in a nuclear-free zone.
|
||
|
||
=item attribute
|
||
|
||
A new X<attribute feature>feature that allows the declaration of
|
||
B<variables> and B<subroutines> with modifiers, as in C<sub foo : locked
|
||
method>. Also another name for an B<instance variable> of an B<object>.
|
||
|
||
=item autogeneration
|
||
|
||
A X<autogeneration, about>feature of B<operator overloading> of B<objects>,
|
||
whereby the behavior of certain B<operators> 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 Camel
|
||
chapter 13, “Overloading”.
|
||
|
||
=item autoincrement
|
||
|
||
To X<autoincrement (term)>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 X<autoloading, defined>load on demand. (Also called “lazy” loading.)
|
||
Specifically, to call an C<AUTOLOAD> subroutine on behalf of an undefined
|
||
subroutine.
|
||
|
||
=item autosplit
|
||
|
||
To X<autosplit (term)>split a string automatically, as the I<–a> B<switch>
|
||
does when running under I<–p> or I<–n> in order to emulate B<awk>. (See also
|
||
the C<AutoSplit>X<AutoSplit module> module, which has nothing to do with the
|
||
C<–a> switch but a lot to do with autoloading.)
|
||
|
||
=item autovivification
|
||
|
||
A X<autovivification>Graeco-Roman word meaning “to bring oneself to life”.
|
||
In Perl, storage locations (B<lvalues>) spontaneously generate themselves as
|
||
needed, including the creation of any B<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 X<AV (array value)>X<array value (AV)>X<values, array>for “array
|
||
value”, which refers to one of Perl’s internal data types that holds an
|
||
B<array>. The C<AV> type is a subclass of B<SV>.
|
||
|
||
=item awk
|
||
|
||
Descriptive X<awk (editing term)>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 X<backreferences, about>X<references, backreferences>substring B<captured>
|
||
by a subpattern within unadorned parentheses in a B<regex>. Backslashed
|
||
decimal numbers (C<\1>, C<\2>, 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
|
||
B<dynamic scope>.
|
||
|
||
=item backtracking
|
||
|
||
The X<backtracking>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 B<regular expression>, and its earlier attempts don’t
|
||
pan out. See the section “The Little Engine That /Couldn(n’t)” in Camel
|
||
chapter 5, “Pattern Matching”.
|
||
|
||
=item backward compatibility
|
||
|
||
Means X<backward compatibility, defined>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 X<barewords, about>sufficiently ambiguous to be deemed illegal under
|
||
C<use strict 'subs'>. In the absence of that stricture, a bareword is
|
||
treated as if quotes were around it.
|
||
|
||
=item base class
|
||
|
||
A X<base classes>X<classes, base>generic B<object> type; that is, a B<class>
|
||
from which other, more specific classes are derived genetically by
|
||
B<inheritance>. Also called aX<superclasses>X<classes, superclasses>
|
||
“superclass” by people who respect their ancestors.
|
||
|
||
=item big-endian
|
||
|
||
From X<big–endian, defined>X<endianness, big–endian>Swift: someone who
|
||
eats eggs big end first. Also used of computers that store the most
|
||
significant B<byte> of a word at a lower byte address than the least
|
||
significant byte. Often considered superior to little-endian machines. See
|
||
also B<little-endian>.
|
||
|
||
=item binary
|
||
|
||
Having X<binary (term)>to do with numbers represented in base 2. That means
|
||
there’s basically two numbers: 0 and 1. Also used to describe a file of
|
||
“nontext”, presumably because such a file makes full use of all the binary
|
||
bits in its bytes. With the advent of B<Unicode>, this distinction, already
|
||
suspect, loses even more of its meaning.
|
||
|
||
=item binary operator
|
||
|
||
An B<X<binary operators, about>operator> that takes two B<operands>.
|
||
|
||
=item bind
|
||
|
||
To X<bind (term)>assign a specific B<network address> to a B<socket>.
|
||
|
||
=item bit
|
||
|
||
An X<bits, defined>integer in the range from 0 to 1, inclusive. The smallest
|
||
possible unit of information storage. An eighth of a B<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 X<bit–shift operators, defined>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 X<bit string>sequence of B<bits> that is actually being thought of as a
|
||
sequence of bits, for once.
|
||
|
||
=item bless
|
||
|
||
In X<bless function, about>X<bless (term)>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
|
||
B<referent> so that it can function as an B<object>, such as a WebCruncher
|
||
object. See the C<bless> function in Camel chapter 27, “Functions”.
|
||
|
||
=item block
|
||
|
||
What X<blocks, defined>a B<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 B<operating system> likes to
|
||
deal with (normally a power of 2 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 X<BLOCK construct, about>X<constructs, BLOCK>syntactic construct
|
||
consisting of a sequence of Perl B<statements> that is delimited by braces.
|
||
The C<if> and C<while> statements are defined in terms of I<C<BLOCK>>s, for
|
||
instance. Sometimes we also say “block” to mean a lexical scope; that is, a
|
||
sequence of statements that acts like a I<C<BLOCK>>, such as within an
|
||
C<eval> or a file, even though the statements aren’t delimited by braces.
|
||
|
||
=item block buffering
|
||
|
||
A X<block buffering>X<buffering, block>method of making input and output
|
||
efficient by passing one B<block> at a time. By default, Perl does block
|
||
buffering to disk files. See B<buffer> and B<command buffering>.
|
||
|
||
=item Boolean
|
||
|
||
A X<Boolean values>X<values, Boolean>value that is either B<true> or
|
||
B<false>.
|
||
|
||
=item Boolean context
|
||
|
||
A X<Boolean context, about>X<context, Boolean>special kind of B<scalar
|
||
context> used in conditionals to decide whether the B<scalar value> returned
|
||
by an expression is B<true> or B<false>. Does not evaluate as either a
|
||
string or a number. See B<context>.
|
||
|
||
=item breakpoint
|
||
|
||
A X<breakpoints, defined>spot in your program where you’ve told the debugger
|
||
to stop B<execution> so you can poke around and see whether anything is
|
||
wrong yet.
|
||
|
||
=item broadcast
|
||
|
||
To X<broadcast (networking term)>send a B<datagram> to multiple destinations
|
||
simultaneously.
|
||
|
||
=item BSD
|
||
|
||
A X<BSD (Berkeley Standard Distribution)>X<Berkeley Standard Distribution
|
||
(BSD)>psychoactive drug, popular in the ’80s, probably developed at UC
|
||
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 X<buckets (term)>location in a B<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 X<buffers, defined>temporary holding location for data. Data that are
|
||
B<Block buffering> means that the data is passed on to its destination
|
||
whenever the buffer is full. B<Line buffering> means that it’s passed on
|
||
whenever a complete line is received. B<Command buffering> means that it’s
|
||
passed every time you do a C<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 B<X<built–in functions, about>function> that is predefined in the
|
||
language. Even when hidden by B<overriding>, you can always get at a built-
|
||
in function by B<qualifying> its name with the C<CORE::> pseudopackage.
|
||
|
||
=item bundle
|
||
|
||
A X<bundles (term)>group of related modules on B<CPAN>. (Also sometimes
|
||
refers to a group of command-line switches grouped into one B<switch
|
||
cluster>.)
|
||
|
||
=item byte
|
||
|
||
A X<bytes (term)>piece of data worth eight B<bits> in most places.
|
||
|
||
=item bytecode
|
||
|
||
A pidgin-like lingo spoken among ’droids when they don’t wish to reveal
|
||
their orientation (see B<endian>). Named after some similar languages spoken
|
||
(for similar reasons) between compilers and interpreters in the late 20ᵗʰ
|
||
century. These languages are characterized by representing everything as a
|
||
nonarchitecture-dependent sequence of bytes.
|
||
|
||
=back
|
||
|
||
=head2 C
|
||
|
||
=over 4
|
||
|
||
=item C
|
||
|
||
A X<C language, about>language beloved by many for its inside-out B<type>
|
||
definitions, inscrutable B<precedence> rules, and heavy B<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 cache
|
||
|
||
A X<cache (term)>data repository. Instead of computing expensive answers
|
||
several times, compute it once and save the result.
|
||
|
||
=item callback
|
||
|
||
A B<X<callbacks>handler> that you register with some other part of your
|
||
program in the hope that the other part of your program will B<trigger> your
|
||
handler when some event of interest transpires.
|
||
|
||
=item call by reference
|
||
|
||
An B<argument>-passing X<call by reference>X<references, call by reference
|
||
mechanism>mechanism in which the B<formal arguments> refer directly to the
|
||
B<actual arguments>, and the B<subroutine> can change the actual arguments
|
||
by changing the formal arguments. That is, the formal argument is an
|
||
B<alias> for the actual argument. See also B<call by value>.
|
||
|
||
=item call by value
|
||
|
||
An B<X<call by value>argument>-passing mechanism in which the B<formal
|
||
arguments> refer to a copy of the B<actual arguments>, and the
|
||
B<subroutine> cannot change the actual arguments by changing the formal
|
||
arguments. See also B<call by reference>.
|
||
|
||
=item canonical
|
||
|
||
Reduced X<canonical (term)>to a standard form to facilitate comparison.
|
||
|
||
=item capture variables
|
||
|
||
The X<capture variables>X<variables, capture>variables—such as C<$1> and
|
||
C<$2>, and C<%+> and C<%– >—that hold the text remembered in a pattern
|
||
match. See Camel chapter 5, “Pattern Matching”.
|
||
|
||
=item capturing
|
||
|
||
The X<capturing in pattern matching>X<subpatterns, capturing>X<pattern
|
||
matching, capturing in>use of parentheses around a B<subpattern> in a
|
||
B<regular expression> to store the matched B<substring> as a
|
||
B<backreference>. (Captured strings are also returned as a list in B<list
|
||
context>.) See Camel chapter 5, “Pattern Matching”.
|
||
|
||
=item cargo cult
|
||
|
||
Copying X<cargo cult>and pasting code without understanding it, while
|
||
superstitiously believing in its value. This term originated from
|
||
preindustrial cultures dealing with the detritus of explorers and colonizers
|
||
of technologically advanced cultures. See I<The Gods Must Be Crazy>.
|
||
|
||
=item case
|
||
|
||
A X<case (character)>X<characters, case considerations>property of certain
|
||
characters. Originally, typesetter stored capital letters in the upper of
|
||
two cases and small letters in the lower one. Unicode recognizes three
|
||
cases: B<lowercase> (B<character property> C<\p{lower}>), B<titlecase>
|
||
(C<\p{title}>), and B<uppercase> (C<\p{upper}>). A fourth casemapping called
|
||
B<foldcase> is not itself a distinct case, but it is used internally to
|
||
implement B<casefolding>. Not all letters have case, and some nonletters
|
||
have case.
|
||
|
||
=item casefolding
|
||
|
||
Comparing X<casefolding>or matching a string case-insensitively. In Perl, it
|
||
is implemented with the C</i> pattern modifier, the C<fc> function, and the
|
||
C<\F> double-quote translation escape.
|
||
|
||
=item casemapping
|
||
|
||
The X<casemapping>process of converting a string to one of the four Unicode
|
||
B<casemaps>; in Perl, it is implemented with the C<fc>, C<lc>, C<ucfirst>,
|
||
and C<uc> functions.
|
||
|
||
=item character
|
||
|
||
The X<characters, defined>smallest individual element of a string. Computers
|
||
store characters as integers, but Perl lets you operate on them as text. The
|
||
integer used to represent a particular character is called that character’s
|
||
B<codepoint>.
|
||
|
||
=item character class
|
||
|
||
A X<character classes, about>X<classes, character>square-bracketed list of
|
||
characters used in a B<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 X<character property>predefined B<character class> matchable by the C<\p>
|
||
or C<\P> B<metasymbol>. B<Unicode> defines hundreds of standard properties
|
||
for every possible codepoint, and Perl defines a few of its own, too.
|
||
|
||
=item circumfix operator
|
||
|
||
An X<circumfix operator>B<operator> that surrounds its B<operand>, like the
|
||
angle operator, or parentheses, or a hug.
|
||
|
||
=item class
|
||
|
||
A X<classes, defined>user-defined B<type>, implemented in Perl via a
|
||
B<package> that provides (either directly or by inheritance) B<methods>
|
||
(that is, B<subroutines>) to handle B<instances> of the class (its
|
||
B<objects>). See also B<inheritance>.
|
||
|
||
=item class method
|
||
|
||
A B<X<class methods>X<methods, class>method> whose B<invocant> is a
|
||
B<package> name, not an B<object> reference. A method associated with the
|
||
class as a whole. Also see B<instance method>.
|
||
|
||
=item client
|
||
|
||
In X<clients, defined>X<processes, client>networking, a B<process> that
|
||
initiates contact with a B<server> process in order to exchange data and
|
||
perhaps receive a service.
|
||
|
||
=item closure
|
||
|
||
An B<X<closure subroutines>X<subroutines, closure>anonymous> subroutine
|
||
that, when a reference to it is generated at runtime, keeps track of the
|
||
identities of externally visible B<lexical variables>, even after those
|
||
lexical variables have supposedly gone out of B<scope>. They’re called
|
||
“closures” because this sort of behavior gives mathematicians a sense of
|
||
closure.
|
||
|
||
=item cluster
|
||
|
||
A X<clusters, defined>X<subpatterns, cluster>parenthesized B<subpattern>
|
||
used to group parts of a B<regular expression> into a single B<atom>.
|
||
|
||
=item CODE
|
||
|
||
The X<CODE (ref function)>X<ref function, about>word returned by the C<ref>
|
||
function when you apply it to a reference to a subroutine. See also B<CV>.
|
||
|
||
=item code generator
|
||
|
||
A X<code generators, defined>system that writes code for you in a low-level
|
||
language, such as code to implement the backend of a compiler. See B<program
|
||
generator>.
|
||
|
||
=item codepoint
|
||
|
||
The X<codepoints, about>integer a computer uses to represent a given
|
||
character. ASCII codepoints are in the range 0 to 127; Unicode codepoints
|
||
are in the range 0 to 0x1F_FFFF; and Perl codepoints are in the range 0 to
|
||
2³²−1 or 0 to 2⁶⁴−1, depending on your native integer size. In Perl Culture,
|
||
sometimes called B<ordinals>.
|
||
|
||
=item code subpattern
|
||
|
||
A B<X<code subpatterns>X<subpatterns, code>regular expression> subpattern
|
||
whose real purpose is to execute some Perl code—for example, the C<(?{...})>
|
||
and C<(??{...})> subpatterns.
|
||
|
||
=item collating sequence
|
||
|
||
The X<collating sequence>X<collating sequence>order into which B<characters>
|
||
sort. This is used by B<string> comparison routines to decide, for example,
|
||
where in this glossary to put “collating sequence”.
|
||
|
||
=item co-maintainer
|
||
|
||
A X<co–maintainers>person with permissions to index a B<namespace> in
|
||
B<PAUSE>. Anyone can upload any namespace, but only primary and
|
||
co-maintainers get their contributions indexed.
|
||
|
||
=item combining character
|
||
|
||
Any X<combining characters>X<characters, combining>character with the
|
||
General Category of Combining Mark (C<\p{GC=M}>), which may be spacing or
|
||
nonspacing. Some are even invisible. A sequence of combining characters
|
||
following a grapheme base character together make up a single user-visible
|
||
character called a B<grapheme>. Most but not all diacritics are combining
|
||
characters, and vice versa.
|
||
|
||
=item command
|
||
|
||
In B<shell> X<commands, defined>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 B<statement>, which might start with a B<label> and typically ends with
|
||
a semicolon.
|
||
|
||
=item command buffering
|
||
|
||
A X<command buffering>X<buffering, command>mechanism in Perl that lets you
|
||
store up the output of each Perl B<command> and then flush it out as a
|
||
single request to the B<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 B<file> or B<pipe> is to use B<block buffering>.
|
||
|
||
=item command-line arguments
|
||
|
||
The X<command–line arguments>B<X<arguments, command–line>values> you supply
|
||
along with a program name when you tell a B<shell> to execute a B<command>.
|
||
These values are passed to a Perl program through C<@ARGV>.
|
||
|
||
=item command name
|
||
|
||
The X<command names>name of the program currently executing, as typed on the
|
||
command line. In C, the B<command> name is passed to the program as the
|
||
first command-line argument. In Perl, it comes in separately as C<$0>.
|
||
|
||
=item comment
|
||
|
||
A X<comments, defined>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 X<compilation units>B<file> (or B<string>, in the case of C<eval>) that
|
||
is currently being B<compiled>.
|
||
|
||
=item compile
|
||
|
||
The process of turning source code into a machine-usable form. See B<compile
|
||
phase>.
|
||
|
||
=item compile phase
|
||
|
||
Any X<compile phase, defined>time before Perl starts running your main
|
||
program. See also B<run phase>. Compile phase is mostly spent in B<compile
|
||
time>, but may also be spent in B<runtime> when C<BEGIN> blocks, C<use> or
|
||
C<no> declarations, or constant subexpressions are being evaluated. The
|
||
startup and import code of any C<use> declaration is also run during
|
||
compile phase.
|
||
|
||
=item compiler
|
||
|
||
Strictly X<compilers and compiling, about>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 (B<syntax trees>) within the I<perl> process itself, which
|
||
the B<interpreter> then interprets. There are, however, extension B<modules>
|
||
to get Perl to act more like a “real” compiler. See Camel chapter 16,
|
||
“Compiling”.
|
||
|
||
=item compile time
|
||
|
||
The X<compile time, defined>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 B<runtime>.
|
||
|
||
=item composer
|
||
|
||
A “constructor” X<composers, about>for a B<referent> that isn’t really an
|
||
B<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 the section “Creating
|
||
References” in Camel chapter 8, “References”.
|
||
|
||
=item concatenation
|
||
|
||
The X<concatenating strings>X<strings, concatenating>process of gluing one
|
||
cat’s nose to another cat’s tail. Also a similar operation on two
|
||
B<strings>.
|
||
|
||
=item conditional
|
||
|
||
SomethingX<conditional (term)> “iffy”. See B<Boolean context>.
|
||
|
||
=item connection
|
||
|
||
In X<connections (term)>telephony, the temporary electrical circuit between
|
||
the caller’s and the callee’s phone. In networking, the same kind of
|
||
temporary circuit between a B<client> and a B<server>.
|
||
|
||
=item construct
|
||
|
||
As a X<constructs, defined>noun, a piece of syntax made up of smaller
|
||
pieces. As a transitive verb, to create an B<object> using a B<constructor>.
|
||
|
||
=item constructor
|
||
|
||
AnyX<constructors, defined> B<class method>, B<instance>, or B<subroutine>
|
||
that composes, initializes, blesses, and returns an B<object>. Sometimes we
|
||
use the term loosely to mean a B<composer>.
|
||
|
||
=item context
|
||
|
||
The X<context, about>surroundings or environment. The context given by the
|
||
surrounding code determines what kind of data a particular B<expression> is
|
||
expected to return. The three primary contexts are B<list context>,
|
||
B<scalar>, and B<void context>. Scalar context is sometimes subdivided into
|
||
B<Boolean context>, B<numeric context>, B<string context>, and B<void
|
||
context>. There’s also a “don’t care” context (which is dealt with in Camel
|
||
chapter 2, “Bits and Pieces”, if you care).
|
||
|
||
=item continuation
|
||
|
||
The X<continuation lines>treatment of more than one physical B<line> as a
|
||
single logical line. B<Makefile> lines are continued by putting a backslash
|
||
before the B<newline>. Mail headers, as defined by X<RFC 822>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 B<whitespace>
|
||
(including newlines) is gleefully ignored. Usually.
|
||
|
||
=item core dump
|
||
|
||
The X<core dump>corpse of a B<process>, in the form of a file left in the
|
||
B<working directory> of the process, usually as a result of certain kinds
|
||
of fatal errors.
|
||
|
||
=item CPAN
|
||
|
||
The X<Comprehensive Perl Archive Network>X<CPAN (Comprehensive Perl Archive
|
||
Network), about>Comprehensive Perl Archive Network. (See the Camel Preface
|
||
and Camel chapter 19, “CPAN” for details.)
|
||
|
||
=item C preprocessor
|
||
|
||
The X<C preprocessor>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 cracker
|
||
|
||
Someone X<crackers>who breaks security on computer systems. A cracker may
|
||
be a true B<hacker> or only a B<script kiddie>.
|
||
|
||
=item currently selected output channel
|
||
|
||
The X<currently selected output channel>last B<filehandle> that was
|
||
designated with C<select(FILEHANDLE)>; C<STDOUT>, if no filehandle has
|
||
been selected.
|
||
|
||
=item current package
|
||
|
||
The B<package> X<current package>in which the current statement is
|
||
B<compiled>. Scan backward in the text of your program through the current
|
||
B<lexical scope> or any enclosing lexical scopes until you find a package
|
||
declaration. That’s your current package name.
|
||
|
||
=item current working directory
|
||
|
||
SeeX<current working directory> B<working directory>.
|
||
|
||
=item CV
|
||
|
||
In academia, a curriculum vitæ, a fancy kind of résumé. In Perl, an X<CV
|
||
(code value)>X<code value (CV)>internal “code value” typedef holding a
|
||
B<subroutine>. The C<CV> type is a subclass of B<SV>.
|
||
|
||
=back
|
||
|
||
=head2 D
|
||
|
||
=over 4
|
||
|
||
=item dangling statement
|
||
|
||
A bare, single B<X<dangling statements>X<statements, dangling>statement>,
|
||
without any braces, hanging off an C<if> or C<while> conditional. C allows
|
||
them. Perl doesn’t.
|
||
|
||
=item datagram
|
||
|
||
A packet of X<datagrams, defined>data, such as a B<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 B<IP> level,
|
||
but B<stream> protocols such as B<TCP> hide this from your program.)
|
||
|
||
=item data structure
|
||
|
||
How your X<data structures, defined>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 tree.
|
||
|
||
=item data type
|
||
|
||
A set of X<data types, defined>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, as well as
|
||
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 B<concatenation>. Compound types made of a number of
|
||
smaller pieces generally have operations to compose and decompose them, and
|
||
perhaps to rearrange them. B<Objects> 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>
|
||
B<method>.
|
||
|
||
=item DBM
|
||
|
||
Stands for X<DBM (Database Management) routines>X<Database Management (DBM)
|
||
routines>“Database Management” routines, a set of routines that emulate an
|
||
B<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 B<hash> across multiple invocations. You
|
||
can C<tie> your hash variables to various DBM implementations.
|
||
|
||
=item declaration
|
||
|
||
An B<assertion> X<declarations, defined>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
|
||
B<statement> for its opposite. Note that some declarations also function
|
||
as statements. Subroutine declarations also act as definitions if a body
|
||
is supplied.
|
||
|
||
=item declarator
|
||
|
||
Something X<declarators>that tells your program what sort of variable
|
||
you’d like. Perl doesn’t require you to declare variables, but you can use
|
||
C<my>, C<our>, or C<state> to denote that you want something other than
|
||
the default.
|
||
|
||
=item decrement
|
||
|
||
To X<decrementing values>X<values, decrementing>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 B<value> X<default values>X<values, default>chosen for you if you don’t
|
||
supply a value of your own.
|
||
|
||
=item defined
|
||
|
||
Having a X<defined (term)>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 B<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
|
||
B<false> and the C<defined> entry in Camel chapter 27, “Functions”.
|
||
|
||
=item delimiter
|
||
|
||
A B<character> X<delimiters (term)>or B<string> that sets bounds to an
|
||
arbitrarily sized textual object, not to be confused with a B<separator> or
|
||
B<terminator>. “To delimit” really just means “to surround” or “to enclose”
|
||
(like these parentheses are doing).
|
||
|
||
=item dereference
|
||
|
||
A fancy X<dereference (term)>X<references, dereference>computer science term
|
||
meaning “to follow a B<reference> to what it points to”. The “de” part of it
|
||
refers to the fact that you’re taking away one level of B<indirection>.
|
||
|
||
=item derived class
|
||
|
||
A B<class> that X<derived classes>X<classes, derived>X<subclasses>X<classes,
|
||
subclasses>defines some of its B<methods> in terms of a more generic class,
|
||
called a B<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 B<file descriptor>.
|
||
|
||
=item destroy
|
||
|
||
To deallocate the X<destroy (term)>memory of a B<referent> (first triggering
|
||
its C<DESTROY> method, if it has one).
|
||
|
||
=item destructor
|
||
|
||
A special B<method> X<destructor method>X<methods, destructor>that is called
|
||
when an B<object> is thinking about B<destroying> itself. A Perl program’s
|
||
C<DESTROY> method doesn’t do the actual destruction; Perl just B<triggers>
|
||
the method in case the B<class> wants to do any associated cleanup.
|
||
|
||
=item device
|
||
|
||
A whiz-bang X<devices (term)>hardware gizmo (like a disk or tape drive or a
|
||
modem or a joystick or a mouse) attached to your computer, which the
|
||
B<operating system> tries to make look like a B<file> (or a bunch of files).
|
||
Under Unix, these fake files tend to live in the I</dev> directory.
|
||
|
||
=item directive
|
||
|
||
A B<pod> X<directives, defined>directive. See Camel chapter 23, “Plain Old
|
||
Documentation”.
|
||
|
||
=item directory
|
||
|
||
A special X<directories, defined>file that contains other files. Some
|
||
B<operating systems> call these “folders”, “drawers”, “catalogues”, or
|
||
“catalogs”.
|
||
|
||
=item directory handle
|
||
|
||
A name X<directory handle>that represents a particular instance of opening a
|
||
directory to read it, until you close it. See the C<opendir> function.
|
||
|
||
=item discipline
|
||
|
||
Some X<discipline (I/O layer)>people need this and some people avoid it.
|
||
For Perl, it’s an old way to say B<I/O layer>.
|
||
|
||
=item dispatch
|
||
|
||
To send X<dispatching>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
|
||
B<references> or, in the case of object B<methods>, by traversing the
|
||
inheritance tree looking for the most specific definition for the method.
|
||
|
||
=item distribution
|
||
|
||
A standard, X<distributions, defined>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 dual-lived
|
||
|
||
Some X<dual–lived modules>X<modules, dual–lived>modules live both in the
|
||
B<Standard Library> and on B<CPAN>. These modules might be developed on two
|
||
tracks as people modify either version. The trend currently is to untangle
|
||
these situations.
|
||
|
||
=item dweomer
|
||
|
||
An enchantment, illusion, X<dweomer>phantasm, or jugglery. Said when Perl’s
|
||
magical B<dwimmer> effects don’t do what you expect, but rather seem to be
|
||
the product of arcane I<dweomercraft>, sorcery, or wonder working. [From
|
||
Middle English.]
|
||
|
||
=item dwimmer
|
||
|
||
DWIM X<DWIM (Do What I Mean) principle>X<Do What I Mean (DWIM) principle>is
|
||
an acronym for X<dwimming>“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 B<dweomer> instead.
|
||
|
||
=item dynamic scoping
|
||
|
||
Dynamic X<dynamic scope>X<scopes, dynamic>scoping works over a B<dynamic
|
||
scope>, making variables visible throughout the rest of the B<block> in
|
||
which they are first used and in any B<subroutines> that are called by the
|
||
rest of the block. Dynamically scoped variables can have their values
|
||
temporarily changed (and implicitly restored later) by a C<local> operator.
|
||
(Compare B<lexical scoping>.) Used more loosely to mean how a subroutine
|
||
that is in the middle of calling another subroutine “contains” that
|
||
subroutine at B<runtime>.
|
||
|
||
=back
|
||
|
||
=head2 E
|
||
|
||
=over 4
|
||
|
||
=item eclectic
|
||
|
||
Derived X<eclectic (term)>from many sources. Some would say I<too> many.
|
||
|
||
=item element
|
||
|
||
A basic X<elements, about>building block. When you’re talking about an
|
||
B<array>, it’s one of the items that make up the array.
|
||
|
||
=item embedding
|
||
|
||
When X<embedding (term)>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 subclass test
|
||
|
||
The notion X<empty subclass test>that an empty B<derived class> should
|
||
behave exactly like its B<base class>.
|
||
|
||
=item encapsulation
|
||
|
||
The veil of X<encapsulation (term)>abstraction separating the B<interface>
|
||
from the B<implementation> (whether enforced or not), which mandates that
|
||
all access to an B<object>’s state be through B<methods> alone.
|
||
|
||
=item endian
|
||
|
||
See B<little-endian> and B<big-endian>.
|
||
|
||
=item en passant
|
||
|
||
When you X<en passant (term)>change a B<value> as it is being copied. [From
|
||
French “in passing”, as in the exotic pawn-capturing maneuver in chess.]
|
||
|
||
=item environment
|
||
|
||
The collectiveX<environment (term)> set of B<environment variables> your
|
||
B<process> inherits from its parent. Accessed via C<%ENV>.
|
||
|
||
=item environment variable
|
||
|
||
A mechanism X<environment variables>X<variables, environment>X<environment
|
||
variables>by which some high-level agent such as a user can pass its
|
||
preferences down to its future offspring (child B<processes>, grandchild
|
||
processes, great-grandchild processes, and so on). Each environment
|
||
variable is a B<key>/B<value> pair, like one entry in a B<hash>.
|
||
|
||
=item EOF
|
||
|
||
End of File. X<End of File (EOF)>X<EOF (End of File)>Sometimes used
|
||
metaphorically as the terminating string of a B<here document>.
|
||
|
||
=item errno
|
||
|
||
The X<errno (error number)>X<error number (errno)>error number returned by a
|
||
B<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 B<exception> or B<fatal error>.
|
||
|
||
=item escape sequence
|
||
|
||
See B<metasymbol>.
|
||
|
||
=item exception
|
||
|
||
A fancy term for an error. See B<fatal error>.
|
||
|
||
=item exception handling
|
||
|
||
The X<exception handling, defined>way a program responds to an error. The
|
||
exception-handling mechanism in Perl is the C<eval> operator.
|
||
|
||
=item exec
|
||
|
||
To X<exec function>throw away the current B<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 B<file> X<executable files>X<files, executable>that is specially marked to
|
||
tell the B<operating system> that it’s okay to run this file as a program.
|
||
Usually shortened to “executable”.
|
||
|
||
=item execute
|
||
|
||
To run X<execute (term)>a B<program> or B<subroutine>. (Has nothing to do
|
||
with the C<kill> built-in, unless you’re trying to run a B<signal handler>.)
|
||
|
||
=item execute bit
|
||
|
||
The X<execute bit>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 B<status>.
|
||
|
||
=item exploit
|
||
|
||
Used X<exploits, security>as a noun in this case, this refers to a known way
|
||
to compromise a program to get it to do something the author didn’t intend.
|
||
Your task is to write unexploitable programs.
|
||
|
||
=item export
|
||
|
||
To make X<exporting, defined>symbols from a B<module> available for
|
||
B<import> by other modules.
|
||
|
||
=item expression
|
||
|
||
Anything X<expressions, defined>X<expressions>you can legally say in a spot
|
||
where a B<value> is required. Typically composed of B<literals>,
|
||
B<variables>, B<operators>, B<functions>, and B<subroutine> calls, not
|
||
necessarily in that order.
|
||
|
||
=item extension
|
||
|
||
A Perl module X<extensions, defined>that also pulls in B<compiled> C or C++
|
||
code. More generally, any experimental option that can be B<compiled> into
|
||
Perl, such as multithreading.
|
||
|
||
=back
|
||
|
||
=head2 F
|
||
|
||
=over 4
|
||
|
||
=item false
|
||
|
||
In Perl, any value X<false values>X<values, false>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, but not all false values are
|
||
undefined.
|
||
|
||
=item FAQ
|
||
|
||
Frequently Asked QuestionX<FAQ (Frequently Asked
|
||
Question)>X<Frequently Asked Question (FAQ)> (although not necessarily
|
||
frequently answered, especially if the answer appears in the Perl FAQ
|
||
shipped standard with Perl).
|
||
|
||
=item fatal error
|
||
|
||
An uncaught B<exception>, X<fatal errors>which causes termination of the
|
||
B<process> after printing a message on your B<standard error> stream. Errors
|
||
that happen inside an C<eval> are not fatal. Instead, the C<eval> terminates
|
||
after placing the exception message in the C<$@> (C<$EVAL_ERROR>) variable.
|
||
You can try to provoke a fatal error with the C<die> operator (known as
|
||
throwing or raising an exception), but this may be caught by a dynamically
|
||
enclosing C<eval>. If not caught, the C<die> becomes a fatal error.
|
||
|
||
=item feeping creaturism
|
||
|
||
A spoonerism X<feeping creaturism>X<creeping featurism>of “creeping
|
||
featurism”, noting the biological urge to add just one more feature to
|
||
a program.
|
||
|
||
=item field
|
||
|
||
A single X<fields (term)>piece of numeric or string data that is part of a
|
||
longer B<string>, B<record>, or B<line>. Variable-width fields are usually
|
||
split up by B<separators> (so use C<split> to extract the fields), while
|
||
fixed-width fields are usually at fixed positions (so use C<unpack>).
|
||
B<Instance variables> are also known as “fields”.
|
||
|
||
=item FIFO
|
||
|
||
First In, First Out.X<First In, First Out (FIFO)>X<FIFO (First In, First
|
||
Out)> See also B<LIFO>. Also a nickname for a B<named pipe>.
|
||
|
||
=item file
|
||
|
||
A named X<files, defined>collection of data, usually stored on disk in a
|
||
B<directory> in a B<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 X<file descriptors>X<descriptors, file>number the B<operating
|
||
system> uses to keep track of which opened B<file> you’re talking about.
|
||
Perl hides the file descriptor inside a B<standard I/O> stream and then
|
||
attaches the stream to a B<filehandle>.
|
||
|
||
=item fileglob
|
||
|
||
A “wildcard” X<fileglobs>match on B<filenames>. See the C<glob> function.
|
||
|
||
=item filehandle
|
||
|
||
An identifier X<filehandles, about>(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 X<filenames, about>file. This name is listed in a
|
||
B<directory>. You can use it in an C<open> to tell the B<operating system>
|
||
exactly which file you want to open, and associate the file with a
|
||
B<filehandle>, which will carry the subsequent identity of that file in
|
||
your program, until you close it.
|
||
|
||
=item filesystem
|
||
|
||
A set X<filesystems, defined>of B<directories> and B<files> 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 file test operator
|
||
|
||
A built-in X<file test operators, about>unary operator that you use to
|
||
determine whether something is B<true> about a file, such as C<–o
|
||
$filename> to test whether you’re the owner of the file.
|
||
|
||
=item filter
|
||
|
||
A X<filters, defined>program designed to take a B<stream> of input and
|
||
transform it into a stream of output.
|
||
|
||
=item first-come
|
||
|
||
The X<first–come permissions>X<permissions, first–come>first B<PAUSE>
|
||
author to upload a B<namespace> automatically becomes the B<primary
|
||
maintainer> for that namespace. The “first come” permissions distinguish a
|
||
B<primary maintainer> who was assigned that role from one who received it
|
||
automatically.
|
||
|
||
=item flag
|
||
|
||
We X<flags (term)>tend to avoid this term because it means so many things.
|
||
It may mean a command-line B<switch> that takes no argument itself (such as
|
||
Perl’s C<–n> and C<–p> flags) or, less frequently, a single-bit indicator
|
||
(such as the C<O_CREAT> and C<O_EXCL> flags used in C<sysopen>). Sometimes
|
||
informally used to refer to certain regex modifiers.
|
||
|
||
=item floating point
|
||
|
||
A X<floating point methods>X<methods, floating point>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 B<integers>. Floating-point numbers are mere
|
||
approximations of real numbers.
|
||
|
||
=item flush
|
||
|
||
The act of X<flushing buffers>X<buffers, flushing>emptying a B<buffer>,
|
||
often before it’s full.
|
||
|
||
=item FMTEYEWTK
|
||
|
||
Far More Than Everything You Ever Wanted To KnowX<FMTEYEWTK acronym>. An
|
||
exhaustive treatise on one narrow topic, something of a super-B<FAQ>. See
|
||
Tom for far more.
|
||
|
||
=item foldcase
|
||
|
||
The casemap X<foldcase (term)>used in Unicode when comparing or matching
|
||
without regard to case. Comparing lower-, title-, or uppercase are all
|
||
unreliable due to Unicode’s complex, one-to-many case mappings. Foldcase is
|
||
a B<lowercase> variant (using a partially decomposed B<normalization> form
|
||
for certain codepoints) created specifically to resolve this.
|
||
|
||
=item fork
|
||
|
||
To create a X<forking processes>X<processes, forking>child B<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 X<formal arguments>X<arguments, formal>generic names by which a
|
||
B<subroutine> knows its B<arguments>. In many languages, formal arguments
|
||
are always given individual names; 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 C<my> list. See
|
||
also B<actual arguments>.
|
||
|
||
=item format
|
||
|
||
A X<formats, defined>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 X<freely available (term)>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 X<freely redistributable (term)>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, X<freeware (term)>any software that you give away,
|
||
particularly if you make the source code available as well. Now often
|
||
called B<open source software>. Recently there has been a trend to use the
|
||
term in contradistinction to B<open source software>, to refer only to free
|
||
software released under the X<Free Software Foundation>Free Software
|
||
Foundation’s GPL (General Public License), but this is difficult to justify
|
||
etymologically.
|
||
|
||
=item function
|
||
|
||
Mathematically, X<functions, about>a mapping of each of a set of input
|
||
values to a particular output value. In computers, refers to a
|
||
B<subroutine> or B<operator> that returns a B<value>. It may or may not
|
||
have input values (called B<arguments>).
|
||
|
||
=item funny character
|
||
|
||
Someone X<funny characters>X<characters, funny>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—X<garbage collection, defined>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, X<GID (Group ID)>X<Group ID (GID)>the numeric group ID
|
||
that the B<operating system> uses to identify you and members of your
|
||
B<group>.
|
||
|
||
=item glob
|
||
|
||
Strictly, the X<glob (* character)>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 B<fileglob> and B<typeglob>.
|
||
|
||
=item global
|
||
|
||
Something X<global (term)>you can see from anywhere, usually used of
|
||
B<variables> and B<subroutines> 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 B<package>.
|
||
Global variables can be declared with C<our>. See “Global Declarations” in
|
||
Camel chapter 4, “Statements and Declarations”.
|
||
|
||
=item global destruction
|
||
|
||
The B<garbage X<global destruction>collection> of globals (and the running
|
||
of any associated object destructors) that takes place when a Perl
|
||
B<interpreter> is being shut down. Global destruction should not be
|
||
confused with the Apocalypse, except perhaps when it should.
|
||
|
||
=item glue language
|
||
|
||
A language X<glue 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 X<granularity>pieces you’re dealing with, mentally
|
||
speaking.
|
||
|
||
=item grapheme
|
||
|
||
A graphene is X<graphemes, defined>an allotrope of carbon arranged in a
|
||
hexagonal crystal lattice one atom thick. A B<grapheme>, or more fully, a
|
||
I<grapheme cluster string> is a single user-visible B<character>, which may
|
||
in turn be several characters (B<codepoints>) long. For example, a carriage
|
||
return plus a line feed is a single grapheme but two characters, while a
|
||
“ȫ” is a single grapheme but one, two, or even three characters, depending
|
||
on B<normalization>.
|
||
|
||
=item greedy
|
||
|
||
A B<subpattern> X<greedy subpatterns>X<subpatterns, greedy>whose
|
||
B<quantifier> wants to match as many things as possible.
|
||
|
||
=item grep
|
||
|
||
Originally X<grep function>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
|
||
C<grep> function that searches a list for elements matching any given
|
||
criterion, whereas the B<grep>(1) program searches for lines matching a
|
||
B<regular expression> in one or more files.
|
||
|
||
=item group
|
||
|
||
A set of users X<groups, defined>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” X<GV (glob value)>X<glob value (GV)>typedef,
|
||
holding a B<typeglob>. The C<GV> type is a subclass of B<SV>.
|
||
|
||
=back
|
||
|
||
=head2 H
|
||
|
||
=over 4
|
||
|
||
=item hacker
|
||
|
||
Someone X<hackers>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 B<crackers> or clueless B<script kiddies>. If you
|
||
confuse them, we will presume that you are either evil or clueless.
|
||
|
||
=item handler
|
||
|
||
A B<subroutine> X<handlers, defined>or B<method> that Perl calls when your
|
||
program needs to respond to some internal event, such as a B<signal>, or an
|
||
encounter with an operator subject to B<operator overloading>. See also
|
||
B<callback>.
|
||
|
||
=item hard reference
|
||
|
||
A B<scalar> B<value> X<hard references, about>X<references, hard>containing
|
||
the actual address of a B<referent>, such that the referent’s B<reference>
|
||
count accounts for it. (Some hard references are held internally, such as
|
||
the implicit reference from one of a B<typeglob>’s variable slots to its
|
||
corresponding referent.) A hard reference is different from a B<symbolic
|
||
reference>.
|
||
|
||
=item hash
|
||
|
||
An unordered X<hashes, about>association of B<key>/B<value> X<key/value
|
||
pairs, about>pairs, stored such that you can easily use a string B<key> to
|
||
look up its associated data B<value>. This glossary is like a hash, where
|
||
the word to be defined is the key and the definition is the value. A hash
|
||
is also sometimes septisyllabically called an “associative array”, which is
|
||
a pretty good reason for simply calling it a “hash” instead.
|
||
|
||
=item hash table
|
||
|
||
A data X<hash tables>structure used internally by Perl for implementing
|
||
associative arrays (hashes) efficiently. See also B<bucket>.
|
||
|
||
=item header file
|
||
|
||
A file X<header files>X<files, header>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 C<require> in
|
||
Camel chapter 27, “Functions”. (Header files have been superseded by the
|
||
B<module> mechanism.)
|
||
|
||
=item here document
|
||
|
||
So X<here documents>called because of a similar construct in B<shells> that
|
||
pretends that the B<lines> following the B<command> are a separate B<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 X<hexadecimals>number in base 16, “hex” for short. The digits for 10
|
||
through 15 are customarily represented by the letters C<a> through C<f>.
|
||
Hexadecimal constants in Perl start with C<0x>. See also the C<hex>
|
||
function in Camel chapter 27, “Functions”.
|
||
|
||
=item home directory
|
||
|
||
The X<home directory>X<directories, home>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<(get>C<pwuid($E<lt>))[7]>. (Some platforms do not have a concept of a
|
||
home directory.)
|
||
|
||
=item host
|
||
|
||
The computer X<host computers>on which a program or other data resides.
|
||
|
||
=item hubris
|
||
|
||
Excessive pride, X<hubris quality>the sort of thing for which Zeus zaps
|
||
you. 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 B<laziness> and B<impatience>.
|
||
|
||
=item HV
|
||
|
||
Short for a “hash value” X<HV (hash value)>X<hash value (HV)>typedef, which
|
||
holds Perl’s internal representation of a hash. The C<HV> type is a
|
||
subclass of B<SV>.
|
||
|
||
=back
|
||
|
||
=head2 I
|
||
|
||
=over 4
|
||
|
||
=item identifier
|
||
|
||
A legally X<identifiers, defined>formed name for most anything in which a
|
||
computer program might be interested. Many languages (including Perl) allow
|
||
identifiers to start with an alphabetic character, and then contain
|
||
alphabetics and digits. Perl also allows connector punctuation like the
|
||
underscore character wherever it allows alphabetics. (Perl also has more
|
||
complicated names, like B<qualified> names.)
|
||
|
||
=item impatience
|
||
|
||
The anger X<impatience quality>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 B<laziness> and B<hubris>.
|
||
|
||
=item implementation
|
||
|
||
How a X<implementation (term)>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 B<interface>.
|
||
|
||
=item import
|
||
|
||
To gain X<import (term)>access to symbols that are exported from another
|
||
module. See C<use> in Camel chapter 27, “Functions”.
|
||
|
||
=item increment
|
||
|
||
To increase the X<incrementing values>X<values, incrementing>value of
|
||
something by 1 (or by some other number, if so specified).
|
||
|
||
=item indexing
|
||
|
||
In olden days, X<indexing (term)>the act of looking up a B<key> in an
|
||
actual index (such as a phone book). But now it's merely the act of using
|
||
any kind of key or position to find the corresponding B<value>, even if no
|
||
index is involved. Things have degenerated to the point that Perl’s
|
||
C<index> function merely locates the position (index) of one string in
|
||
another.
|
||
|
||
=item indirect filehandle
|
||
|
||
An B<expression> X<indirect filehandles>X<filehandles, indirect>that
|
||
evaluates to something that can be used as a B<filehandle>: a B<string>
|
||
(filehandle name), a B<typeglob>, a typeglob B<reference>, or a low-level
|
||
B<IO> object.
|
||
|
||
=item indirection
|
||
|
||
If something in a X<indirection (term)>program isn’t the value you’re
|
||
looking for but indicates where the value is, that’s indirection. This can
|
||
be done with either B<symbolic references> or B<hard>.
|
||
|
||
=item indirect object
|
||
|
||
In English grammar, X<indirect objects, defined>X<objects, indirect>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 C<STDOUT> is the
|
||
recipient of the C<print> action, and C<"$foo"> is the object being
|
||
printed. Similarly, when invoking a B<method>, you might place the
|
||
invocant in the dative slot between the method and its arguments:
|
||
|
||
$gollum = new Pathetic::Creature "Sméagol";
|
||
give $gollum "Fisssssh!";
|
||
give $gollum "Precious!";
|
||
|
||
=item indirect object slot
|
||
|
||
The syntactic X<indirect object slot>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.) C<STDERR> is in the indirect object slot here:
|
||
|
||
print STDERR "Awake! Awake! Fear, Fire, Foes! Awake!\n";
|
||
|
||
=item infix
|
||
|
||
An B<operator> that X<infix operators>comes in between its B<operands>,
|
||
such as multiplication in C<24 * 7>.
|
||
|
||
=item inheritance
|
||
|
||
What you get from your X<inheritance, defined>ancestors, genetically or
|
||
otherwise. If you happen to be a B<class>, your ancestors are called B<base
|
||
classes> and your descendants are called B<derived classes>. See B<single
|
||
inheritance> and B<multiple inheritance>.
|
||
|
||
=item instance
|
||
|
||
Short for “an instance of a class”, X<instances (term)>meaning an B<object>
|
||
of that B<class>.
|
||
|
||
=item instance data
|
||
|
||
SeeX<instance data> B<instance variable>.
|
||
|
||
=item instance method
|
||
|
||
A B<method> of X<instance methods>X<methods, instance>an B<object>, as
|
||
opposed to a B<class method>.
|
||
|
||
A B<method> whose B<invocant> is an B<object>, not a B<package> name. Every
|
||
object of a class shares all the methods of that class, so an instance
|
||
method applies to all instances of the class, rather than applying to a
|
||
particular instance. Also see B<class method>.
|
||
|
||
=item instance variable
|
||
|
||
An B<attribute> of an B<object>; X<instance variables, defined>X<variables,
|
||
instance>data stored with the particular object rather than with the class
|
||
as a whole.
|
||
|
||
=item integer
|
||
|
||
A number X<integers (term)>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 X<interfaces (term)>a piece of code promises to provide
|
||
forever, in contrast to its B<implementation>, which it should feel free to
|
||
change whenever it likes.
|
||
|
||
=item interpolation
|
||
|
||
The insertion of X<interpolation, defined>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
|
||
I<C<LIST>>.
|
||
|
||
=item interpreter
|
||
|
||
Strictly speaking, X<interpreters, defined>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 B<compilers> 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
|
||
(B<syntax trees>) within the I<perl> process itself, which the Perl
|
||
B<runtime> system then interprets.
|
||
|
||
=item invocant
|
||
|
||
The agent on X<invocants, defined>whose behalf a B<method> is invoked. In a
|
||
B<class> method, the invocant is a package name. In an B<instance> method,
|
||
the invocant is an object reference.
|
||
|
||
=item invocation
|
||
|
||
The act of X<invocation, method>calling up a deity, daemon, program,
|
||
method, subroutine, or function to get it to 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 X<I/O (Input/Output), defined>X<Input/Output (I/O),
|
||
defined>output to, a B<file> or B<device>.
|
||
|
||
=item IO
|
||
|
||
An internal I/O object. Can also mean B<indirect object>.
|
||
|
||
=item I/O layer
|
||
|
||
One of the X<I/O layer>filters between the data and what you get as input
|
||
or what you end up with as output.
|
||
|
||
=item IPA
|
||
|
||
India Pale Ale. Also the X<International Phonetic Alphabet (IPA)>X<IPA
|
||
(International Phonetic Alphabet)>International Phonetic Alphabet, the
|
||
standard alphabet used for phonetic notation worldwide. Draws heavily on
|
||
Unicode, including many combining characters.
|
||
|
||
=item IP
|
||
|
||
Internet ProtocolX<Internet Protocol (IP)>X<IP (Internet Protocol)>, or
|
||
X<IP (Intellectual Property)>X<Intellectual Property (IP)>Intellectual
|
||
Property.
|
||
|
||
=item IPC
|
||
|
||
Interprocess X<Interprocess Communication>X<IPC (Interprocess
|
||
Communication), about>X<communication>Communication.
|
||
|
||
=item is-a
|
||
|
||
A rX<is–a relationship>elationship between two B<objects> 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 B<base
|
||
class> and a specific B<derived class>. Oddly enough, Platonic classes
|
||
don’t always have Platonic relationships—see B<inheritance>.
|
||
|
||
=item iteration
|
||
|
||
Doing X<iteration>something repeatedly.
|
||
|
||
=item iterator
|
||
|
||
A special X<iterators>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 C<each> through
|
||
it.
|
||
|
||
=item IV
|
||
|
||
The integer X<IV (Integer Value)>X<Integer Value (IV)>four, not to be
|
||
confused with six, Tom’s favorite editor. IV also means an internal Integer
|
||
Value of the type a B<scalar> can hold, not to be confused with an B<NV>.
|
||
|
||
=back
|
||
|
||
=head2 J
|
||
|
||
=over 4
|
||
|
||
=item JAPH
|
||
|
||
“Just Another Perl Hacker”, a X<JAPH acronym>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 USENET signatures.
|
||
|
||
=back
|
||
|
||
=head2 K
|
||
|
||
=over 4
|
||
|
||
=item key
|
||
|
||
The X<keys, defined>string index to a B<hash>, used to look up the B<value>
|
||
associated with that key.
|
||
|
||
=item keyword
|
||
|
||
See B<reserved words>.
|
||
|
||
=back
|
||
|
||
=head2 L
|
||
|
||
=over 4
|
||
|
||
=item label
|
||
|
||
A X<labels, defined>name you give to a B<statement> so that you can talk
|
||
about that statement elsewhere in the program.
|
||
|
||
=item laziness
|
||
|
||
The X<laziness quality>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 then 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 B<impatience> and
|
||
B<hubris>.
|
||
|
||
=item leftmost longest
|
||
|
||
The X<leftmost longest preference>X<regular expressions, leftmost longest
|
||
preference>preference of the B<regular expression> engine to match the
|
||
leftmost occurrence of a B<pattern>, then given a position at which a match
|
||
will occur, the preference for the longest match (presuming the use of a
|
||
B<greedy> quantifier). See Camel chapter 5, “Pattern Matching” for I<much>
|
||
more on this subject.
|
||
|
||
=item left shift
|
||
|
||
A B<bit shift> that X<left shift (E<lt>E<lt>) bit operator>X<bit–shift
|
||
operators, left shift>X<E<lt>E<lt> (left shift) bit operator>multiplies the
|
||
number by some power of 2.
|
||
|
||
=item lexeme
|
||
|
||
Fancy X<lexeme (token)>term for a B<token>.
|
||
|
||
=item lexer
|
||
|
||
Fancy X<lexer (tokener)>term for a B<tokener>.
|
||
|
||
=item lexical analysis
|
||
|
||
Fancy X<lexical analysis>term for B<tokenizing>.
|
||
|
||
=item lexical scoping
|
||
|
||
Looking X<lexical scopes, defined>X<scopes>at your I<Oxford English
|
||
Dictionary> through a microscope. (Also known as B<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 theX<static
|
||
scopes>X<scopes, static> lexical scope in which they are declared. —Syn.
|
||
B<static scoping>. —Ant. B<dynamic scoping>.
|
||
|
||
=item lexical variable
|
||
|
||
A B<variable> X<lexical variables, about>X<variables, lexical>subject to
|
||
B<lexical scoping>, declared by C<my>. Often just called a “lexical”. (The
|
||
C<our> declaration declares a lexically scoped name for a global variable,
|
||
which is not itself a lexical variable.)
|
||
|
||
=item library
|
||
|
||
Generally, a X<libraries, defined>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 B<modules> on
|
||
your system.
|
||
|
||
=item LIFO
|
||
|
||
Last In, First OutX<Last In, First Out (LIFO)>X<LIFO (Last In, First
|
||
Out)>X<stacks, defined>. See also B<FIFO>. A LIFO is usually called a
|
||
B<stack>.
|
||
|
||
=item line
|
||
|
||
In Unix, a X<line (term)>sequence of zero or more nonnewline characters
|
||
terminated with a B<newline> character. On non-Unix machines, this is
|
||
emulated by the C library even if the underlying B<operating system> has
|
||
different ideas.
|
||
|
||
=item linebreak
|
||
|
||
A B<grapheme> X<linebreaks>consisting of either a carriage return followed
|
||
by a line feed or any character with the Unicode Vertical Space B<character
|
||
property>.
|
||
|
||
=item line buffering
|
||
|
||
Used by X<line buffering>X<buffering, line>a B<standard I/O> output stream that
|
||
flushes its B<buffer> after every B<newline>. Many standard I/O libraries
|
||
automatically set up line buffering on output that is going to the terminal.
|
||
|
||
=item line number
|
||
|
||
The number X<line 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 X<links, defined>noun, a name in a B<directory> that represents a
|
||
B<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 B<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 X<LIST construct>X<constructs, LIST>construct representing a
|
||
comma- separated list of expressions, evaluated to produce a B<list value>.
|
||
Each B<expression> in a I<C<LIST>> is evaluated in B<list context> and
|
||
interpolated into the list value.
|
||
|
||
=item list
|
||
|
||
An ordered X<lists, defined>set of scalar values.
|
||
|
||
=item list context
|
||
|
||
The situation X<list context>X<context, list>in which an B<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 I<C<LIST>> of
|
||
arguments tell those arguments that they should produce a list value. See
|
||
also B<context>.
|
||
|
||
=item list operator
|
||
|
||
An B<operator> that X<list operators, about>does something with a list of
|
||
values, such as C<join> or C<grep>. Usually used for named built-in
|
||
operators (such as C<print>, C<unlink>, and C<system>) that do not require
|
||
parentheses around their B<argument> list.
|
||
|
||
=item list value
|
||
|
||
An unnamed X<list values, about>X<values, list>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 B<list context>.
|
||
|
||
=item literal
|
||
|
||
A token X<literals, defined>in a programming language, such as a number or
|
||
B<string>, that gives you an actual B<value> instead of merely representing
|
||
possible values as a B<variable> does.
|
||
|
||
=item little-endian
|
||
|
||
From Swift: X<little–endian, defined>X<endianness, little–endian>someone
|
||
who eats eggs little end first. Also used of computers that store the least
|
||
significant B<byte> of a word at a lower byte address than the most
|
||
significant byte. Often considered superior to big-endian machines. See
|
||
also B<big-endian>.
|
||
|
||
=item local
|
||
|
||
Not meaning X<local operator, about>the same thing everywhere. A global
|
||
variable in Perl can be localized inside a B<dynamic scope> via the
|
||
C<local> operator.
|
||
|
||
=item logical operator
|
||
|
||
Symbols X<logical operators, about>representing the concepts “and”, “or”,
|
||
“xor”, and “not”.
|
||
|
||
=item lookahead
|
||
|
||
An B<assertion> that X<lookahead assertions>X<assertions (in regexes),
|
||
lookahead>peeks at the string to the right of the current match location.
|
||
|
||
=item lookbehind
|
||
|
||
An B<assertion> X<lookbehind assertions>X<assertions (in regexes),
|
||
lookbehind>that peeks at the string to the left of the current match
|
||
location.
|
||
|
||
=item loop
|
||
|
||
A construct X<loop constructs and statements, about>X<constructs, loop>that
|
||
performs something repeatedly, like a roller coaster.
|
||
|
||
=item loop control statement
|
||
|
||
Any statement X<statements, loop control>within the body of a loop that can
|
||
make a loop prematurely stop looping or skip an B<iteration>. Generally,
|
||
you shouldn’t try this on roller coasters.
|
||
|
||
=item loop label
|
||
|
||
A kind X<loop labels>X<labels, loop>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 lowercase
|
||
|
||
In Unicode, X<lowercase characters>X<characters, lowercase>not just
|
||
characters with the General Category of Lowercase Letter, but any character
|
||
with the Lowercase property, including Modifier Letters, Letter Numbers,
|
||
some Other Symbols, and one Combining Mark.
|
||
|
||
=item lvaluable
|
||
|
||
Able to X<lvaluable function>X<functions, lvaluable>serve as an B<lvalue>.
|
||
|
||
=item lvalue
|
||
|
||
Term used by X<lvalue (term)>X<values, lvalue>language lawyers for a
|
||
storage location you can assign a new B<value> to, such as a B<variable> or
|
||
an element of an B<array>. The “l” is short for “left”, as in the left side
|
||
of an assignment, a typical place for lvalues. An B<lvaluable> function or
|
||
expression is one to which a value may be assigned, as in C<pos($x) = 10>.
|
||
|
||
=item lvalue modifier
|
||
|
||
An X<lvalue modifier>X<modifiers, lvalue>adjectival pseudofunction that
|
||
warps the meaning of an B<lvalue> in some declarative fashion. Currently
|
||
there are three lvalue modifiers: C<my>, C<our>, and C<local>.
|
||
|
||
=back
|
||
|
||
=head2 M
|
||
|
||
=over 4
|
||
|
||
=item magic
|
||
|
||
Technically X<magic (term)>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 B<increment> X<magical increment operator>operator that knows how to
|
||
bump up ASCII alphabetics as well as numbers.
|
||
|
||
=item magical variables
|
||
|
||
Special variables X<magical variables>X<variables, magical>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 X<Makefile>controls the compilation of a program. Perl programs
|
||
don’t usually need a B<Makefile> because the Perl compiler has plenty of
|
||
self-control.
|
||
|
||
=item man
|
||
|
||
The Unix X<man program (Unix)>program that displays online documentation
|
||
(manual pages) for you.
|
||
|
||
=item manpage
|
||
|
||
A “page” from the X<manpages, defined>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 B<commands>, B<syscalls>, B<library> B<functions>, B<devices>,
|
||
B<protocols>, B<files>, and such. In this book, we call any piece of
|
||
standard Perl documentation (like L<perlop> or L<perldelta>) a manpage, no
|
||
matter what format it’s installed in on your system.
|
||
|
||
=item matching
|
||
|
||
SeeX<matching> B<pattern matching>.
|
||
|
||
=item member data
|
||
|
||
SeeX<member data> B<instance variable>.
|
||
|
||
=item memory
|
||
|
||
This X<memory, defined>always means your main memory, not your disk.
|
||
Clouding the issue is the fact that your machine may implement
|
||
B<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 B<character> that X<metacharacters, about>X<characters, regex
|
||
metacharacters>is I<not> supposed to be treated normally. Which characters
|
||
are to be treated specially as metacharacters varies greatly from context to
|
||
context. Your B<shell> will have certain metacharacters, double-quoted Perl
|
||
B<strings> have other metacharacters,X<regular expressions, metacharacters and>
|
||
and B<regular expression> patterns have all the double-quote metacharacters plus
|
||
some extra ones of their own.
|
||
|
||
=item metasymbol
|
||
|
||
Something we’d call X<metasymbols, about>X<escape sequences>a
|
||
B<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 X<methods, defined>action that an B<object> can take if you tell
|
||
it to. See Camel chapter 12, “Objects”.
|
||
|
||
=item method resolution order
|
||
|
||
The path X<method resolution order (mro)>X<mro (method resolution
|
||
order)>Perl takes through C<@INC>. By default, this is a double depth first
|
||
search, once looking for defined methods and once for C<AUTOLOAD>. However,
|
||
Perl lets you configure this with C<mro>.
|
||
|
||
=item minicpan
|
||
|
||
A CPAN X<minicpan, defined>X<CPAN (Comprehensive Perl Archive Network),
|
||
minicpan and>mirror that includes just the latest versions for each
|
||
distribution, probably created with C<CPAN::Mini>X<CPAN::Mini module>. See
|
||
Camel chapter 19, “CPAN”.
|
||
|
||
=item minimalism
|
||
|
||
The belief X<minimalism>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 X<mode>context of the I<stat>(2) syscall, refers to the field
|
||
holding the B<permission bits> and the type of the B<file>.
|
||
|
||
=item modifier
|
||
|
||
SeeX<modifiers, defined> B<statement modifier>, B<regular expression>, and
|
||
B<lvalue>, not necessarily in that order.
|
||
|
||
=item module
|
||
|
||
A B<file> that X<modules, defined>defines a B<package> of (almost) the same
|
||
name, which can either B<export> symbols or function as an B<object> class.
|
||
(A module’s main I<.pm> file may also load in other files in support of the
|
||
module.) See the C<use> built-in.
|
||
|
||
=item modulus
|
||
|
||
An integer X<modulus (%) operator>X<% (modulus) operator>divisor when
|
||
you’re interested in the remainder instead of the quotient.
|
||
|
||
=item mojibake
|
||
|
||
When you X<mojibake>speak one language and the computer thinks you’re
|
||
speaking another. You’ll see odd translations when you send UTF‑8, for
|
||
instance, but the computer thinks you sent Latin-1, showing all sorts of
|
||
weird characters instead. The term is written 「文字化け」in Japanese and
|
||
means “character rot”, an apt description. Pronounced [C<modʑibake>] in
|
||
standard B<IPA> phonetics, or approximately “moh-jee-bah-keh”.
|
||
|
||
=item monger
|
||
|
||
Short for X<mongers, Perl>X<Perl mongers>one member of B<Perl mongers>, a
|
||
purveyor of Perl.
|
||
|
||
=item mortal
|
||
|
||
A temporary X<mortal value>X<values, mortal>value scheduled to die when the
|
||
current statement finishes.
|
||
|
||
=item mro
|
||
|
||
See B<method resolution order>.
|
||
|
||
=item multidimensional array
|
||
|
||
An array X<multidimensional arrays>X<arrays, multidimensional>with multiple
|
||
subscripts for finding a single element. Perl implements these using
|
||
B<references>—see Camel chapter 9, “Data Structures”.
|
||
|
||
=item multiple inheritance
|
||
|
||
The features X<multiple inheritance>X<inheritance, multiple>you got from
|
||
your mother and father, mixed together unpredictably. (See also
|
||
B<inheritance> and B<single inheritance>.) In computer languages (including
|
||
Perl), it is the notion that a given class may have multiple direct
|
||
ancestors or B<base classes>.
|
||
|
||
=back
|
||
|
||
=head2 N
|
||
|
||
=over 4
|
||
|
||
=item named pipe
|
||
|
||
A B<pipe> X<named pipes>X<pipes, names>with a name embedded in the
|
||
B<filesystem> so that it can be accessed by two unrelated B<processes>.
|
||
|
||
=item namespace
|
||
|
||
A domain of X<namespaces, about>names. You needn’t worry about whether the
|
||
names in one such domain have been used in another. See B<package>.
|
||
|
||
=item NaN
|
||
|
||
Not a number. X<NaN (not a number)>X<not a number (NaN)>The value Perl uses
|
||
for certain invalid or inexpressible floating-point operations.
|
||
|
||
=item network address
|
||
|
||
The most X<network address>important attribute of a socket, like your
|
||
telephone’s telephone number. Typically an IP address. See also B<port>.
|
||
|
||
=item newline
|
||
|
||
A single X<newline character>X<characters, newline>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, X<NFS (Network File System)>X<Network File System
|
||
(NFS)>which allows you to mount a remote filesystem as if it were local.
|
||
|
||
=item normalization
|
||
|
||
Converting a X<normalization>text string into an alternate but equivalent
|
||
B<canonical> (or compatible) representation that can then be compared for
|
||
equivalence. Unicode recognizes four different normalization forms: NFD,
|
||
NFC, NFKD, and NFKC.
|
||
|
||
=item null character
|
||
|
||
A character X<null character>X<characters, null>with the numeric value of
|
||
zero. It’s used by C to terminate strings, but Perl allows strings to
|
||
contain a null.
|
||
|
||
=item null list
|
||
|
||
A B<list value> with X<null lists>X<lists, null>zero elements, represented
|
||
in Perl by C<()>.
|
||
|
||
=item null string
|
||
|
||
A B<string> X<null strings>X<strings, null>containing no characters, not to
|
||
be confused with a string containing a B<null character>, which has a
|
||
positive length and is B<true>.
|
||
|
||
=item numeric context
|
||
|
||
The situation X<numeric context>X<context, numeric>in which an expression
|
||
is expected by its surroundings (the code calling it) to return a number.
|
||
See also B<context> and B<string context>.
|
||
|
||
=item numification
|
||
|
||
(Sometimes spelled I<nummification> and I<nummify>.) X<numification>Perl lingo
|
||
for implicit conversion into a number; the related verb is I<numify>.
|
||
I<Numification> is intended to rhyme with I<mummification>, and I<numify> with
|
||
I<mummify>. It is unrelated to English I<numen>, I<numina>, I<numinous>. We
|
||
originally forgot the extra I<m> a long time ago, and some people got used to
|
||
our funny spelling, and so just as with C<HTTP_REFERER>’s own missing letter,
|
||
our weird spelling has stuck around.
|
||
|
||
=item NV
|
||
|
||
Short for Nevada, X<Numeric Value (NV)>X<NV (Numeric Value)>no part of
|
||
which will ever be confused with civilization. NV also means an internal
|
||
floating- point Numeric Value of the type a B<scalar> can hold, not to be
|
||
confused with an B<IV>.
|
||
|
||
=item nybble
|
||
|
||
Half a B<byte>, X<nybble>equivalent to one B<hexadecimal> digit, and worth
|
||
four B<bits>.
|
||
|
||
=back
|
||
|
||
=head2 O
|
||
|
||
=over 4
|
||
|
||
=item object
|
||
|
||
An B<instance> X<objects, defined>of a B<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 X<octals>in base 8. Only the digits 0 through 7 are allowed. Octal
|
||
constants in Perl start with 0, as in 013. See also the C<oct> function.
|
||
|
||
=item offset
|
||
|
||
How many X<offsets in strings>X<strings, offsets in>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 X<one–liner programs>computer program crammed into one line of
|
||
text.
|
||
|
||
=item open source software
|
||
|
||
Programs X<open source software>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 B<expression> X<operands (term)>that yields a B<value> that an
|
||
B<operator> operates on. See also B<precedence>.
|
||
|
||
=item operating system
|
||
|
||
A special X<operating systems, defined>program that runs on the bare
|
||
machine and hides the gory details of managing B<processes> and B<devices>.
|
||
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
|
||
B<architecture> and B<platform>.
|
||
|
||
=item operator
|
||
|
||
A gizmo X<operators, about>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 B<types> of data you give as its arguments (B<operands>) and what type
|
||
of data you want back from it.
|
||
|
||
=item operator overloading
|
||
|
||
A kind X<operator overloading, about>X<overloading, operator>of
|
||
B<overloading> that you can do on built-in B<operators> to make them work
|
||
on B<objects> as if the objects were ordinary scalar values, but with the
|
||
actual semantics supplied by the object class. This is set up with the
|
||
overload B<pragma>—see Camel chapter 13, “Overloading”.
|
||
|
||
=item options
|
||
|
||
See X<options>either B<switches> or B<regular expression modifiers>.
|
||
|
||
=item ordinal
|
||
|
||
An X<ordinals (term)>abstract character’s integer value. Same thing as
|
||
B<codepoint>.
|
||
|
||
=item overloading
|
||
|
||
Giving X<overloading, defined>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 B<context>.
|
||
|
||
=item overriding
|
||
|
||
Hiding or X<overriding, defined>invalidating some other definition of the
|
||
same name. (Not to be confused with B<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 B<subroutine> to hide a built-in B<function> of the same
|
||
name (see the section “Overriding Built-in Functions” in Camel chapter 11,
|
||
“Modules”), and to describe how you can define a replacement B<method> in a
|
||
B<derived class> to hide a B<base class>’s method of the same name (see
|
||
Camel chapter 12, “Objects”).
|
||
|
||
=item owner
|
||
|
||
The one X<ownership, file>X<files, ownership of>user (apart from the
|
||
superuser) who has absolute control over a B<file>. A file may also have a
|
||
B<group> of users who may exercise joint ownership if the real owner
|
||
permits it. See B<permission bits>.
|
||
|
||
=back
|
||
|
||
=head2 P
|
||
|
||
=over 4
|
||
|
||
=item package
|
||
|
||
A B<namespace> for X<packages, defined>global B<variables>, B<subroutines>,
|
||
and the like, such that they can be kept separate from like-named
|
||
B<symbols> 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 B<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 X<pads (scratchpads)>for B<scratchpad>.
|
||
|
||
=item parameter
|
||
|
||
SeeX<parameters> B<argument>.
|
||
|
||
=item parent class
|
||
|
||
SeeX<parent classes>X<classes, parent> B<base class>.
|
||
|
||
=item parse tree
|
||
|
||
SeeX<parse tree> B<syntax tree>.
|
||
|
||
=item parsing
|
||
|
||
The X<parsing, about>subtle but sometimes brutal art of attempting to turn
|
||
your possibly malformed program into a valid B<syntax tree>.
|
||
|
||
=item patch
|
||
|
||
To X<patches>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 B<patch>(1) program when you want to fix a bug or upgrade
|
||
your old version.
|
||
|
||
=item PATH
|
||
|
||
The X<PATH environment variable>X<variables, environment>list of
|
||
B<directories> the system searches to find a program you want to
|
||
B<execute>. The list is stored as one of your B<environment variables>,
|
||
accessible in Perl as C<$ENV{PATH}>.
|
||
|
||
=item pathname
|
||
|
||
A X<pathname>fully qualified filename such as I</usr/bin/perl>. Sometimes
|
||
confused with C<PATH>.
|
||
|
||
=item pattern
|
||
|
||
A X<patterns, defined>template used in B<pattern matching>.
|
||
|
||
=item pattern matching
|
||
|
||
Taking a X<pattern matching, about>pattern, usually a B<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 PAUSE
|
||
|
||
The X<Perl Authors Upload SErver (PAUSE)>X<PAUSE (Perl Authors Upload
|
||
SErver)>Perl Authors Upload SErver (L<http://pause.perl.org>), the gateway
|
||
for B<modules> on their way to B<CPAN>.
|
||
|
||
=item Perl mongers
|
||
|
||
A X<Perl mongers>X<mongers, Perl>Perl user group, taking the form of its
|
||
name from the New York Perl mongers, the first Perl user group. Find one
|
||
near you at L<http://www.pm.org>.
|
||
|
||
=item permission bits
|
||
|
||
Bits X<permission bits>X<bits, permission>that the B<owner> of a file sets
|
||
or unsets to allow or disallow access to other people. These flag bits are
|
||
part of the B<mode> word returned by the C<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 X<Pern (term)>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 X<pipes, defined>direct B<connection> that carries the output of one
|
||
B<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 X<pipeline>series of B<processes> all in a row, linked by B<pipes>, where
|
||
each passes its output stream to the next.
|
||
|
||
=item platform
|
||
|
||
The X<platforms, defined>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 the following: machine, operating system,
|
||
libraries, compiler, or system configuration. The I<perl> interpreter has
|
||
to be B<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 X<pod (plain old documentation), about>X<plain old documentation>markup
|
||
used to embed documentation into your Perl code. Pod stands for “Plain old
|
||
documentation”. See Camel chapter 23, “Plain Old Documentation”.
|
||
|
||
=item pod command
|
||
|
||
A X<pod commands>X<commands, pod>sequence, such as C<=head1>, that denotes
|
||
the start of a B<pod> section.
|
||
|
||
=item pointer
|
||
|
||
A B<variable> X<pointers>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 B<keys> and B<variable> names, or B<hard references>, which
|
||
aren’t pointers (but act like pointers and do in fact contain pointers).
|
||
|
||
=item polymorphism
|
||
|
||
The notion X<polymorphism>that you can tell an B<object> to do something
|
||
generic, and the object will interpret the command in different ways
|
||
depending on its type. [E<lt> Greek πολυ- + μορϕή, many forms.]
|
||
|
||
=item port
|
||
|
||
The X<ports (term)>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 X<portability, about>upon a time, C code compilable under both BSD and
|
||
SysV. In general, code that can be easily converted to run on another
|
||
B<platform>, where “easily” can be defined however you like, and usually
|
||
is. Anything may be considered portable if you try hard enough, such as a
|
||
mobile home or London Bridge.
|
||
|
||
=item porter
|
||
|
||
Someone X<porters>who “carries” software from one B<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 possessive
|
||
|
||
Said of X<possessive (term)>quantifiers and groups in patterns that refuse
|
||
to give up anything once they’ve gotten their mitts on it. Catchier and
|
||
easier to say than the even more formal I<nonbacktrackable>.
|
||
|
||
=item POSIX
|
||
|
||
The X<Portable Operating System Interface (POSIX), about>X<POSIX (Portable
|
||
Operating System Interface), about>Portable Operating System Interface
|
||
specification.
|
||
|
||
=item postfix
|
||
|
||
An B<operator> X<postfix operator>that follows its B<operand>, as in
|
||
C<$x++>.
|
||
|
||
=item pp
|
||
|
||
An X<pp (push–pop) code>X<push–pop (pp) code>internal shorthand for a
|
||
“push- pop” code; that is, C code implementing Perl’s stack machine.
|
||
|
||
=item pragma
|
||
|
||
A X<pragmas, about>X<modules>standard module whose practical hints and
|
||
suggestions are received (and possibly ignored) at compile time. Pragmas
|
||
are named in all lowercase.
|
||
|
||
=item precedence
|
||
|
||
The X<precedence rules, about>X<operators, precedence rules>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 B<operator> X<prefix operators>that precedes its B<operand>, as in
|
||
C<++$x>.
|
||
|
||
=item preprocessing
|
||
|
||
What X<preprocessing>some helper B<process> did to transform the incoming
|
||
data into a form more suitable for the current process. Often done with an
|
||
incoming B<pipe>. See also B<C preprocessor>.
|
||
|
||
=item primary maintainer
|
||
|
||
The X<primary maintainer>author that PAUSE allows to assign B<co-maintainer>
|
||
permissions to a B<namespace>. A primary maintainer can give up this
|
||
distinction by assigning it to another PAUSE author. See Camel chapter 19,
|
||
“CPAN”.
|
||
|
||
=item procedure
|
||
|
||
AX<procedures, defined> B<subroutine>.
|
||
|
||
=item process
|
||
|
||
An X<processes, defined>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 C<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
|
||
|
||
See B<script>.
|
||
|
||
=item program generator
|
||
|
||
A system X<program generators>that algorithmically writes code for you in a
|
||
high-level language. See also B<code generator>.
|
||
|
||
=item progressive matching
|
||
|
||
B<Pattern matching> X<progressive matching>X<pattern matching, progressive
|
||
matching> matching>that picks up where it left off before.
|
||
|
||
=item property
|
||
|
||
See X<property>either B<instance variable> or B<character property>.
|
||
|
||
=item protocol
|
||
|
||
In X<protocols (term)>networking, an agreed-upon way of sending messages
|
||
back and forth so that neither correspondent will get too confused.
|
||
|
||
=item prototype
|
||
|
||
An X<prototypes, about>optional part of a B<subroutine> declaration telling
|
||
the Perl compiler how many and what flavor of arguments may be passed as
|
||
B<actual arguments>, so you can write subroutine calls that parse much like
|
||
built-in functions. (Or don’t parse, as the case may be.)
|
||
|
||
=item pseudofunction
|
||
|
||
A X<pseudofunctions>X<constructs, pseudofunctions>X<functions,
|
||
pseudofunctions>construct that sometimes looks like a function but really
|
||
isn’t. Usually reserved for B<lvalue> modifiers like C<my>, for B<context>
|
||
modifiers like C<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
|
||
|
||
Formerly, a reference X<pseudohashes>X<hashes, pseudohashes>to an array
|
||
whose initial element happens to hold a reference to a hash. You used to be
|
||
able to treat a pseudohash reference as either an array reference or a hash
|
||
reference. Pseudohashes are no longer supported.
|
||
|
||
=item pseudoliteral
|
||
|
||
An B<operator> X<pseudoliterals>XC<that looks something like a B<literal>,
|
||
such as the output-grabbing operator, <literal
|
||
moreinfo="none">`>I<C<command>>C<`>.
|
||
|
||
=item public domain
|
||
|
||
Something X<public domain>not owned by anybody. Perl is copyrighted and is
|
||
thus I<not> in the public domain—it’s just B<freely available> and B<freely
|
||
redistributable>.
|
||
|
||
=item pumpkin
|
||
|
||
A X<pumpkin (term)>notional “baton” handed around the Perl community
|
||
indicating who is the lead integrator in some arena of development.
|
||
|
||
=item pumpking
|
||
|
||
A B<X<pumpking>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 “X<PV (pointer value)>X<pointer value (PV)>pointer value”, which is Perl
|
||
Internals Talk for a C<char*>.
|
||
|
||
=back
|
||
|
||
=head2 Q
|
||
|
||
=over 4
|
||
|
||
=item qualified
|
||
|
||
Possessing a X<qualified (term)>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 X<quantifiers, about>component of a B<regular expression> specifying how
|
||
many times the foregoing B<atom> may occur.
|
||
|
||
=back
|
||
|
||
=head2 R
|
||
|
||
=over 4
|
||
|
||
=item race condition
|
||
|
||
A X<race conditions, defined>race condition exists when the result of
|
||
several interrelated events depends on the ordering of those events, but
|
||
that order cannot be guaranteed due to nondeterministic timing effects. If
|
||
two or more programs, or parts of the same program, try to go through the
|
||
same series of events, one might interrupt the work of the other. This is a
|
||
good way to find an B<exploit>.
|
||
|
||
=item readable
|
||
|
||
With X<readable (term)>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 X<reaping zombie processes>rites performed by a parent B<process>
|
||
on behalf of a deceased child process so that it doesn’t remain a
|
||
B<zombie>. See the C<wait> and C<waitpid> function calls.
|
||
|
||
=item record
|
||
|
||
A set of X<records, defined>related data values in a B<file> or B<stream>,
|
||
often associated with a unique B<key> field. In Unix, often commensurate
|
||
with a B<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 X<recursion, defined>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 X<references, about>look to find a pointer to information
|
||
somewhere else. (See B<indirection>.) References come in two flavors:
|
||
B<symbolic references> and B<hard references>.
|
||
|
||
=item referent
|
||
|
||
Whatever a X<referents, defined>reference refers to, which may or may not
|
||
have a name. Common types of referents include scalars, arrays, hashes, and
|
||
subroutines.
|
||
|
||
=item regex
|
||
|
||
See B<regular expression>.
|
||
|
||
=item regular expression
|
||
|
||
A single X<regular expressions, defined>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
|
||
Camel chapter 5, “Pattern Matching”.
|
||
|
||
=item regular expression modifier
|
||
|
||
An option on a X<regular expression modifiers>X<modifiers, regular
|
||
expression>pattern or substitution, such as C</i> to render the pattern
|
||
case- insensitive.
|
||
|
||
=item regular file
|
||
|
||
A B<file> that’s X<regular files>X<files, regular>not a B<directory>, a
|
||
B<device>, a named B<pipe> or B<socket>, or a B<symbolic link>. Perl uses
|
||
the C<–f> file test operator to identify regular files. Sometimes called a
|
||
“plain” file.
|
||
|
||
=item relational operator
|
||
|
||
An B<operator> that X<relational operators>says whether a particular
|
||
ordering relationship is B<true> about a pair of B<operands>. Perl has both
|
||
numeric and string relational operators. See B<collating sequence>.
|
||
|
||
=item reserved words
|
||
|
||
A word with a X<reserved words>X<keywords (term)>specific, built-in meaning
|
||
to a B<compiler>, such as C<if> or C<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
|
||
B<labels> or B<filehandles>. Also called “keywords”.
|
||
|
||
=item return value
|
||
|
||
The B<value> produced X<return values>X<values, return>by a B<subroutine>
|
||
or B<expression> when evaluated. In Perl, a return value may be either a
|
||
B<list> or a B<scalar>.
|
||
|
||
=item RFC
|
||
|
||
Request For Comment, X<Request For Comment (RFC)>X<RFC (Request For
|
||
Comment)>which despite the timid connotations is the name of a series of
|
||
important standards documents.
|
||
|
||
=item right shift
|
||
|
||
A B<bit shift> X<right shift (E<gt>E<gt>) bit operator>X<bit–shift
|
||
operators, right shift>X<E<gt>E<gt> (right shift) bit operator>that divides
|
||
a number by some power of 2.
|
||
|
||
=item role
|
||
|
||
A name X<roles (term)>for a concrete set of behaviors. A role is a way to
|
||
add behavior to a class without inheritance.
|
||
|
||
=item root
|
||
|
||
The X<root (term)>superuser (C<UID> == 0). Also the top-level directory of
|
||
the filesystem.
|
||
|
||
=item RTFM
|
||
|
||
What X<RTFM acronym>you are told when someone thinks you should Read The
|
||
Fine Manual.
|
||
|
||
=item run phase
|
||
|
||
Any X<run phase, defined>time after Perl starts running your main program.
|
||
See also B<compile phase>. Run phase is mostly spent in B<runtime> but may
|
||
also be spent in B<compile time> when C<require>, C<do> I<C<FILE>>, or
|
||
C<eval> I<C<STRING>> operators are executed, or when a substitution uses
|
||
the C</ee> modifier.
|
||
|
||
=item runtime
|
||
|
||
The time X<runtime (term), defined>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 B<compile time>.
|
||
|
||
=item runtime pattern
|
||
|
||
A X<runtime patterns>X<patterns, runtime>pattern that contains one or more
|
||
variables to be interpolated before parsing the pattern as a B<regular
|
||
expression>, and that therefore cannot be analyzed at compile time, but
|
||
must be reanalyzed each time the pattern match operator is evaluated.
|
||
Runtime patterns are useful but expensive.
|
||
|
||
=item RV
|
||
|
||
A X<Reference Value (RV)>X<RV (Reference Value)>recreational vehicle, not
|
||
to be confused with vehicular recreation. RV also means an internal
|
||
Reference Value of the type a B<scalar> can hold. See also B<IV> and B<NV>
|
||
if you’re not confused yet.
|
||
|
||
=item rvalue
|
||
|
||
A B<value> that X<rvalue (term)>X<values, rvalue>you might find on the
|
||
right side of an B<assignment>. See also B<lvalue>.
|
||
|
||
=back
|
||
|
||
=head2 S
|
||
|
||
=over 4
|
||
|
||
=item sandbox
|
||
|
||
A X<sandbox, defined>walled off area that’s not supposed to affect beyond
|
||
its walls. You let kids play in the sandbox instead of running in the road.
|
||
See Camel chapter 20, “Security”.
|
||
|
||
=item scalar
|
||
|
||
A X<scalars, defined>simple, singular value; a number, B<string>, or
|
||
B<reference>.
|
||
|
||
=item scalar context
|
||
|
||
The X<scalar context, about>X<context, scalar>situation in which an
|
||
B<expression> is expected by its surroundings (the code calling it) to
|
||
return a single B<value> rather than a B<list> of values. See also
|
||
B<context> and B<list context>. A scalar context sometimes imposes
|
||
additional constraints on the return value—see B<string context> and
|
||
B<numeric context>. Sometimes we talk about a B<Boolean context> inside
|
||
conditionals, but this imposes no additional constraints, since any scalar
|
||
value, whether numeric or B<string>, is already true or false.
|
||
|
||
=item scalar literal
|
||
|
||
A X<scalar literals>X<literals, scalar>number or quoted B<string>—an actual
|
||
B<value> in the text of your program, as opposed to a B<variable>.
|
||
|
||
=item scalar value
|
||
|
||
A X<scalar values, about>X<values, scalar>X<SV>value that happens to be a
|
||
B<scalar> as opposed to a B<list>.
|
||
|
||
=item scalar variable
|
||
|
||
A B<variable> X<scalar variables, defined>X<variables, scalar>prefixed with
|
||
C<$> that holds a single value.
|
||
|
||
=item scope
|
||
|
||
From X<scopes, defined>how far away you can see a variable, looking through
|
||
one. Perl has two visibility mechanisms. It does B<dynamic scoping> of
|
||
C<local> B<variables>, meaning that the rest of the B<block>, and any
|
||
B<subroutines> that are called by the rest of the block, can see the
|
||
variables that are local to the block. Perl does B<lexical scoping> of
|
||
C<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 X<scratchpads>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 X<scripts (term)>X<programs, defined>text B<file> that is a program
|
||
intended to be B<executed> directly rather than B<compiled> to another form
|
||
of file before B<execution>.
|
||
|
||
Also, in the context of B<Unicode>, a writing system for a particular
|
||
language or group of languages, such as Greek, Bengali, or Tengwar.
|
||
|
||
=item script kiddie
|
||
|
||
A B<cracker> X<script kiddie>who is not a B<hacker> but knows just enough
|
||
to run canned scripts. A B<cargo-cult> programmer.
|
||
|
||
=item sed
|
||
|
||
A venerable Stream EDitor X<sed (Stream EDitor)>X<Stream EDitor (sed)>from
|
||
which Perl derives some of its ideas.
|
||
|
||
=item semaphore
|
||
|
||
A fancy X<semaphore>kind of interlock that prevents multiple B<threads> or
|
||
B<processes> from using up the same resources simultaneously.
|
||
|
||
=item separator
|
||
|
||
A B<character> X<separators>X<characters, separators>X<strings,
|
||
separators>or B<string> that keeps two surrounding strings from being
|
||
confused with each other. The C<split> function X<split function,
|
||
separators and>works on separators. Not to be confused with B<delimiters>
|
||
or B<terminators>. The “or” in the previous sentence separated the two
|
||
alternatives.
|
||
|
||
=item serialization
|
||
|
||
Putting a X<serialization>X<marshalling (term)>fancy B<data structure> into
|
||
linear order so that it can be stored as a B<string> in a disk file or
|
||
database, or sent through a B<pipe>. Also called marshalling.
|
||
|
||
=item server
|
||
|
||
In networking, X<servers, defined>X<processes, server>a B<process> that
|
||
either advertises a B<service> or just hangs around at a known location and
|
||
waits for B<clients> who need service to get in touch with it.
|
||
|
||
=item service
|
||
|
||
Something X<services (term)>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 theX<getservent function> C<getservent>
|
||
function.
|
||
|
||
=item setgid
|
||
|
||
Same as B<setuid>, X<setgid program, about>only having to do with giving
|
||
away B<group> privileges.
|
||
|
||
=item setuid
|
||
|
||
Said of a program X<setuid program, about>that runs with the privileges of
|
||
its B<owner> rather than (as is usually the case) the privileges of whoever
|
||
is running it. Also describes the bit in the mode word (B<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 B<memory> X<shared memory>X<memory, shared>accessible by two
|
||
different B<processes> who otherwise would not see each other’s memory.
|
||
|
||
=item shebang
|
||
|
||
Irish for the X<shebang (term)>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 B<command>-X<shell program, defined>line B<interpreter>. The program that
|
||
interactively gives you a prompt, accepts one or more B<lines> of input,
|
||
and executes the programs you mentioned, feeding each of them their proper
|
||
B<arguments> 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 X<side effects>that happens when you evaluate an
|
||
B<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 C<write> or C<print> on the currently selected
|
||
filehandle.
|
||
|
||
=item sigil
|
||
|
||
A glyph X<sigils, defined>used in magic. Or, for Perl, the symbol in front
|
||
of a variable name, such as C<$>, C<@>, and C<%>.
|
||
|
||
=item signal
|
||
|
||
A bolt X<signals and signal handling, about>out of the blue; that is, an
|
||
event triggered by the B<operating system>, probably when you’re least
|
||
expecting it.
|
||
|
||
=item signal handler
|
||
|
||
A B<subroutine> that, X<handlers, signal>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 B<execute>. Under Perl, bolts out of the blue
|
||
are called signals, and you send them with the C<kill> built-in. See the
|
||
C<%SIG> hash in Camel chapter 25, “Special Names” and the section “Signals”
|
||
in Camel chapter 15, “Interprocess Communication”.
|
||
|
||
=item single inheritance
|
||
|
||
The features X<single inheritance>X<inheritance, single>you got from your
|
||
mother, if she told you that you don’t have a father. (See also
|
||
B<inheritance> and B<multiple inheritance>.) In computer languages, the
|
||
idea that B<classes> reproduce asexually so that a given class can only
|
||
have one direct ancestor or B<base class>. Perl supplies no such
|
||
restriction, though you may certainly program Perl that way if you like.
|
||
|
||
=item slice
|
||
|
||
A selection X<slices of elements>X<elements, slices of>of any number of
|
||
B<elements> from a B<list>, B<array>, or B<hash>.
|
||
|
||
=item slurp
|
||
|
||
To read an X<slurp (term)>entire B<file> into a B<string> in one operation.
|
||
|
||
=item socket
|
||
|
||
An endpoint for X<sockets, defined>network communication among multiple
|
||
B<processes> that works much like a telephone or a post office box. The
|
||
most important thing about a socket is its B<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
|
||
|
||
SeeX<soft references>X<references, soft> B<symbolic reference>.
|
||
|
||
=item source filter
|
||
|
||
A special X<source filters>X<filters, source>kind of B<module> that does
|
||
B<preprocessing> on your script just before it gets to the B<tokener>.
|
||
|
||
=item stack
|
||
|
||
A X<stacks, defined>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 B<LIFO>.
|
||
|
||
=item standard
|
||
|
||
Included X<standard (term)>in the official Perl distribution, as in a
|
||
standard module, a standard tool, or a standard Perl B<manpage>.
|
||
|
||
=item standard error
|
||
|
||
The default output B<stream> for nasty remarks that don’t belong in
|
||
B<standard output>. Represented within a Perl program by theX<STDERR
|
||
filehandle, about> output> B<filehandle> C<STDERR>. You can use this
|
||
stream explicitly, but the C<die> and C<warn> built-ins write to your
|
||
standard error stream automatically (unless trapped or otherwise
|
||
intercepted).
|
||
|
||
=item standard input
|
||
|
||
The X<STDIN filehandle, about>default input B<stream> for your program,
|
||
which if possible shouldn’t care where its data is coming from. Represented
|
||
within a Perl program by the B<filehandle> C<STDIN>.
|
||
|
||
=item standard I/O
|
||
|
||
A X<standard I/O>X<I/O (Input/Output), standard>X<Input/Output (I/O),
|
||
standard>X<STDIO filehandle>standard C library for doing B<buffered> input
|
||
and output to the B<operating system>. (The “standard” of standard I/O is
|
||
at most 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 B<flush> the buffer
|
||
more often, just set the C<$|> variable to a true value.
|
||
|
||
=item Standard Library
|
||
|
||
Everything X<Standard Perl Library, about>that comes with the official
|
||
I<perl> distribution. Some vendor versions of I<perl> change their
|
||
distributions, leaving out some parts or including extras. See also
|
||
B<dual-lived>.
|
||
|
||
=item standard output
|
||
|
||
The X<STDOUT filehandle, about>default output B<stream> for your program,
|
||
which if possible shouldn’t care where its data is going. Represented
|
||
within a Perl program by the B<filehandle> C<STDOUT>.
|
||
|
||
=item statement
|
||
|
||
A B<command> to X<statements, about>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 B<declaration>, which doesn’t tell the
|
||
computer to do anything, but just to learn something.
|
||
|
||
=item statement modifier
|
||
|
||
A B<conditional> X<statement modifiers, about>X<modifiers, statement>or
|
||
B<loop> that you put after the B<statement> instead of before, if you know
|
||
what we mean.
|
||
|
||
=item static
|
||
|
||
Varying X<static (term)>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 B<variable>,
|
||
B<subroutine>, or B<method>. In Perl culture, the word is politely avoided.
|
||
|
||
If you’re a C or C++ programmer, you might be looking for Perl’s C<state>
|
||
keyword.
|
||
|
||
=item static method
|
||
|
||
No such X<static methods>X<methods, static>thing. See B<class method>.
|
||
|
||
=item static scoping
|
||
|
||
No such thing. See B<lexical scoping>.
|
||
|
||
=item static variable
|
||
|
||
No such X<static variables>X<variables, static>thing. Just use a B<lexical
|
||
variable> in a scope larger than your B<subroutine>, or declare it with
|
||
C<state> instead of with C<my>.
|
||
|
||
=item stat structure
|
||
|
||
A special X<stat structure>X<data structures, stat structure>internal spot
|
||
in which Perl keeps the information about the last B<file> on which you
|
||
requested information.
|
||
|
||
=item status
|
||
|
||
The B<value> X<status value>X<values, status>X<exit status>returned to the
|
||
parent B<process> when one of its child processes dies. This value is
|
||
placed in the special variable C<$?>. Its upper eight B<bits> 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 C<system> in Camel
|
||
chapter 27, “Functions”.
|
||
|
||
=item STDERR
|
||
|
||
See B<standard error>.
|
||
|
||
=item STDIN
|
||
|
||
See B<standard input>.
|
||
|
||
=item STDIO
|
||
|
||
See B<standard I/O>.
|
||
|
||
=item STDOUT
|
||
|
||
See B<standard output>.
|
||
|
||
=item stream
|
||
|
||
A flow X<streaming data>X<processes, streaming data>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
|
||
B<interface>—the underlying B<implementation> may well break your data up
|
||
into separate packets for delivery, but this is hidden from you.
|
||
|
||
=item string
|
||
|
||
A sequence X<strings, defined>of characters such as “He said !@#*&%@#*?!”.
|
||
A string does not have to be entirely printable.
|
||
|
||
=item string context
|
||
|
||
The situation X<string context>X<context, string>in which an expression is
|
||
expected by its surroundings (the code calling it) to return a B<string>.
|
||
See also B<context> and B<numeric context>.
|
||
|
||
=item stringification
|
||
|
||
The process X<stringification>of producing a B<string> representation of an
|
||
abstract object.
|
||
|
||
=item struct
|
||
|
||
C keyword X<struct keyword>introducing a structure definition or name.
|
||
|
||
=item structure
|
||
|
||
SeeX<structures> B<data structure>.
|
||
|
||
=item subclass
|
||
|
||
See B<derived class>.
|
||
|
||
=item subpattern
|
||
|
||
A X<subpatterns, defined>component of a B<regular expression> pattern.
|
||
|
||
=item subroutine
|
||
|
||
A X<subroutines, defined>named or otherwise accessible piece of program
|
||
that can be invoked from elsewhere in the program in order to accomplish
|
||
some subgoal of the program. A subroutine is often parameterized to
|
||
accomplish different but related things depending on its input
|
||
B<arguments>. If the subroutine returns a meaningful B<value>, it is also
|
||
called a B<function>.
|
||
|
||
=item subscript
|
||
|
||
A B<value> X<subscripts>that indicates the position of a particular
|
||
B<array> B<element> in an array.
|
||
|
||
=item substitution
|
||
|
||
Changing X<substitution (s///) operator, about>X<strings, substitution
|
||
in>X<s/// (substitution) operator, about>parts of a string via the C<s///>
|
||
operator. (We avoid use of this term to mean B<variable interpolation>.)
|
||
|
||
=item substring
|
||
|
||
A portion of a B<string>, X<substrings (term)>starting at a certain
|
||
B<character> position (B<offset>) and proceeding for a certain number of
|
||
characters.
|
||
|
||
=item superclass
|
||
|
||
See B<base class>.
|
||
|
||
=item superuser
|
||
|
||
The X<superusers>person whom the B<operating system> will let do almost
|
||
anything. Typically your system administrator or someone pretending to be
|
||
your system administrator. On Unix systems, the B<root> user. On Windows
|
||
systems, usually the Administrator user.
|
||
|
||
=item SV
|
||
|
||
Short X<scalar values, about>X<values, scalar>for “scalar value”. But
|
||
within the Perl interpreter, every B<referent> is treated as a member of a
|
||
class derived from SV, in an object-oriented sort of way. Every B<value>
|
||
inside Perl is passed around as a C language C<SV*> pointer. The SV
|
||
B<struct> knows its own “referent type”, and the code is smart enough (we
|
||
hope) not to try to call a B<hash> function on a B<subroutine>.
|
||
|
||
=item switch
|
||
|
||
An X<switches, about>X<switches>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 B<switch statement>.
|
||
|
||
=item switch cluster
|
||
|
||
The X<switch clusters>X<clusters, switch>combination of multiple command-
|
||
line switches (I<e.g.>, C<–a –b –c>) into one switch (I<e.g.>, C<–abc>).
|
||
Any switch with an additional B<argument> must be the last switch in a
|
||
cluster.
|
||
|
||
=item switch statement
|
||
|
||
A X<switch statement>X<statements, switch>program technique that lets you
|
||
evaluate an B<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. Most
|
||
switch statements in Perl are spelled C<given>. See “The C<given>
|
||
statement” in Camel chapter 4, “Statements and Declarations”.
|
||
|
||
=item symbol
|
||
|
||
Generally, X<symbols>X<symbols>any B<token> or B<metasymbol>. Often used
|
||
more specifically to mean the sort of name you might find in a B<symbol
|
||
table>.
|
||
|
||
=item symbolic debugger
|
||
|
||
A program X<symbolic debugger>X<debugger, about>that lets you step through
|
||
the B<execution> 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 X<symbolic links>X<links, symbolic>filename that points to the
|
||
real B<filename>, which in turn points to the real B<file>. Whenever the
|
||
B<operating system> is trying to parse a B<pathname> containing a symbolic
|
||
link, it merely substitutes the new name and continues parsing.
|
||
|
||
=item symbolic reference
|
||
|
||
A variable X<symbolic references>X<references, symbolic>whose value is the
|
||
name of another variable or subroutine. By B<dereferencing> the first
|
||
variable, you can get at the second one. Symbolic references are illegal
|
||
under C<use strict "refs">.
|
||
|
||
=item symbol table
|
||
|
||
Where X<symbol tables, about>a B<compiler> remembers symbols. A program
|
||
like Perl must somehow remember all the names of all the B<variables>,
|
||
B<filehandles>, and B<subroutines> you’ve used. It does this by placing the
|
||
names in a symbol table, which is implemented in Perl using a B<hash
|
||
table>. There is a separate symbol table for each B<package> to give each
|
||
package its own B<namespace>.
|
||
|
||
=item synchronous
|
||
|
||
Programming X<synchronous (term)>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 X<syntactic sugar>alternative way of writing something more easily; a
|
||
shortcut.
|
||
|
||
=item syntax
|
||
|
||
From X<syntax, about>Greek σύνταξις, “with-arrangement”. How things
|
||
(particularly symbols) are put together with each other.
|
||
|
||
=item syntax tree
|
||
|
||
An internal X<syntax tree>representation of your program wherein
|
||
lower-level B<constructs> dangle off the higher-level constructs enclosing
|
||
them.
|
||
|
||
=item syscall
|
||
|
||
A B<function> X<syscall function, about>call directly to the B<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 C<system> function, which actually involves many syscalls. To
|
||
avoid any confusion, we nearly always say “syscall” for something you could
|
||
call indirectly via Perl’s C<syscall> function, and never for something you
|
||
would call with Perl’s C<system> function.
|
||
|
||
=back
|
||
|
||
=head2 T
|
||
|
||
=over 4
|
||
|
||
=item taint checks
|
||
|
||
The X<taint checks, about>special bookkeeping Perl does to track the flow
|
||
of external data through your program and disallow their use in system
|
||
commands.
|
||
|
||
=item tainted
|
||
|
||
Said of X<tainted data, about>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 B<setuid> (or B<setgid>) program, or if you use the C<–T> switch.
|
||
|
||
=item taint mode
|
||
|
||
Running X<taint mode>under the C<–T> switch, marking all external data as
|
||
suspect and refusing to use it with system commands. See Camel chapter 20,
|
||
“Security”.
|
||
|
||
=item TCP
|
||
|
||
Short for X<TCP (Transmission Control Protocol)>X<Transmission Control
|
||
Protocol (TCP)>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 B<stream> of bytes.
|
||
(Usually.)
|
||
|
||
=item term
|
||
|
||
Short for X<terms, defined>a “terminal”—that is, a leaf node of a B<syntax
|
||
tree>. A thing that functions grammatically as an B<operand> for the
|
||
operators in an expression.
|
||
|
||
=item terminator
|
||
|
||
A B<character> X<terminators (term)>X<characters, terminators>X<strings,
|
||
terminators in>or B<string> that marks the end of another string. The C<$/>
|
||
variable contains the string that terminates a C<readline> operation, which
|
||
C<chomp> deletes from the end. Not to be confused with B<delimiters> or
|
||
B<separators>. The period at the end of this sentence is a terminator.
|
||
|
||
=item ternary
|
||
|
||
An B<operator> X<ternary operators>taking three B<operands>. Sometimes
|
||
pronounced B<trinary>.
|
||
|
||
=item text
|
||
|
||
A B<string> or B<file> X<text, defined>X<strings, text>X<files,
|
||
text>X<text>containing primarily printable characters.
|
||
|
||
=item thread
|
||
|
||
Like a X<threads (term)>forked process, but without B<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 one another.
|
||
|
||
=item tie
|
||
|
||
The bond X<tied variables, about>between a magical variable and its
|
||
implementation class. See the C<tie> function in Camel chapter 27,
|
||
“Functions” and Camel chapter 14, “Tied Variables”.
|
||
|
||
=item titlecase
|
||
|
||
The case X<titlecase characters>X<characters, titlecase>used for capitals
|
||
that are followed by lowercase characters instead of by more capitals.
|
||
Sometimes called sentence case or headline case. English doesn’t use
|
||
Unicode titlecase, but casing rules for English titles are more complicated
|
||
than simply capitalizing each word’s first character.
|
||
|
||
=item TMTOWTDI
|
||
|
||
There’s More Than One Way To Do It, the Perl MottoX<TMTOWTDI acronym>. 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.)
|
||
|
||
=item token
|
||
|
||
A morpheme X<tokens, defined>in a programming language, the smallest unit
|
||
of text with semantic significance.
|
||
|
||
=item tokener
|
||
|
||
A module that X<tokeners, defined>breaks a program text into a sequence of
|
||
B<tokens> for later analysis by a parser.
|
||
|
||
=item tokenizing
|
||
|
||
Splitting up a X<tokenizing>program text into B<tokens>. Also known as
|
||
“lexing”, in which case you get “lexemes” instead of tokens.
|
||
|
||
=item toolbox approach
|
||
|
||
The notion that, X<toolbox approach>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 topic
|
||
|
||
The thing you’re X<topics (term)>working on. Structures like
|
||
C<while(E<lt>E<gt>)>, C<for>, C<foreach>, and C<given> set the topic for
|
||
you by assigning to C<$_>, the default (I<topic>) variable.
|
||
|
||
=item transliterate
|
||
|
||
To turn one X<tr/// (transliteration) operator, about>X<strings,
|
||
transliteration of>X<transliteration (tr///) operator, about>string
|
||
representation into another by mapping each character of the source string
|
||
to its corresponding character in the result string. Not to be confused
|
||
with translation: for example, Greek I<πολύχρωμος> transliterates into
|
||
I<polychromos> but translates into I<many-colored>. See the C<tr///>
|
||
operator in Camel chapter 5, “Pattern Matching”.
|
||
|
||
=item trigger
|
||
|
||
An event X<triggers (term)>that causes a B<handler> to be run.
|
||
|
||
=item trinary
|
||
|
||
Not a X<trinary operators>stellar system with three stars, but an
|
||
B<operator> taking three B<operands>. Sometimes pronounced B<ternary>.
|
||
|
||
=item troff
|
||
|
||
A venerable X<troff language>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 X<true values>X<values, true>scalar value that doesn’t evaluate to 0 or
|
||
C<"">.
|
||
|
||
=item truncating
|
||
|
||
Emptying a X<truncate function>X<files, truncating>file of existing
|
||
contents, either automatically when opening a file for writing or
|
||
explicitly via the C<truncate> function.
|
||
|
||
=item type
|
||
|
||
SeeX<type> B<data type> and B<class>.
|
||
|
||
=item type casting
|
||
|
||
Converting X<type casting>data from one type to another. C permits this.
|
||
Perl does not need it. Nor want it.
|
||
|
||
=item typedef
|
||
|
||
A type X<typedef>definition in the C and C++ languages.
|
||
|
||
=item typed lexical
|
||
|
||
A B<lexical variable> X<typed lexicals>X<lexical variables, typed
|
||
lexicals>X<variables, variable> lexical>that is declared with a B<class>
|
||
type: C<my Pony $bill>.
|
||
|
||
=item typeglob
|
||
|
||
Use of X<typeglobs, defined>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 “Typeglobs and Filehandles” in
|
||
Camel chapter 2, “Bits and Pieces”.
|
||
|
||
=item typemap
|
||
|
||
A description of X<typemap>how C types may be transformed to and from Perl
|
||
types within an B<extension> module written in B<XS>.
|
||
|
||
=back
|
||
|
||
=head2 U
|
||
|
||
=over 4
|
||
|
||
=item UDP
|
||
|
||
User Datagram Protocol, the X<User Datagram Protocol (UDP)>X<UDP (User
|
||
Datagram Protocol)>X<datagrams, UDP support>typical way to send
|
||
B<datagrams> over the Internet.
|
||
|
||
=item UID
|
||
|
||
A user ID. X<UID (user ID)>X<user ID (UID)>Often used in the context of
|
||
B<file> or B<process> ownership.
|
||
|
||
=item umask
|
||
|
||
A X<umask function>mask of those B<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 C<umask> function.
|
||
|
||
=item unary operator
|
||
|
||
An X<unary operators, about>operator with only one B<operand>, like C<!> or
|
||
C<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 X<Unicode, about>comprising all the major character sets of
|
||
the world, more or less. See L<http://www.unicode.org>.
|
||
|
||
=item Unix
|
||
|
||
A very large X<Unix language>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.
|
||
|
||
=item uppercase
|
||
|
||
In Unicode, X<uppercase characters>X<characters, uppercase>not just
|
||
characters with the General Category of Uppercase Letter, but any character
|
||
with the Uppercase property, including some Letter Numbers and Symbols. Not
|
||
to be confused with B<titlecase>.
|
||
|
||
=back
|
||
|
||
=head2 V
|
||
|
||
=over 4
|
||
|
||
=item value
|
||
|
||
An actual piece X<values, defined>of data, in contrast to all the
|
||
variables, references, keys, indices, operators, and whatnot that you need
|
||
to access the value.
|
||
|
||
=item variable
|
||
|
||
A named storage X<variables, defined>X<variables>location that can hold any
|
||
of various kinds of B<value>, as your program sees fit.
|
||
|
||
=item variable interpolation
|
||
|
||
TheX<variable interpolation>X<interpolation, variable> B<interpolation> of
|
||
a scalar or array variable into a string.
|
||
|
||
=item variadic
|
||
|
||
Said of X<variadic (term)>a B<function> that happily receives an
|
||
indeterminate number of B<actual arguments>.
|
||
|
||
=item vector
|
||
|
||
Mathematical X<vectors>jargon for a list of B<scalar values>.
|
||
|
||
=item virtual
|
||
|
||
Providing the X<virtual (term)>appearance of something without the reality,
|
||
as in: virtual memory is not real memory. (See also B<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 X<void context>X<context, void>of B<scalar context> in which an
|
||
B<expression> is not expected to return any B<value> at all and is
|
||
evaluated for its B<side effects> alone.
|
||
|
||
=item v-string
|
||
|
||
A “version” or “vector”X<v–strings>X<strings, v–strings> B<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
|
||
B<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 X<warning messages>X<STDERR filehandle, warning messages
|
||
and>printed to the C<STDERR> stream to the effect that something might be
|
||
wrong but isn’t worth blowing up over. See C<warn> in Camel chapter 27,
|
||
“Functions” and the C<warnings> pragma in Camel chapter 28, “Pragmantic
|
||
Modules”.
|
||
|
||
=item watch expression
|
||
|
||
An expression which, X<watch expression>X<expressions, watch>when its value
|
||
changes, causes a breakpoint in the Perl debugger.
|
||
|
||
=item weak reference
|
||
|
||
A X<weak references>X<references, weak>reference that doesn’t get counted
|
||
normally. When all the normal references to data disappear, the data
|
||
disappears. These are useful for circular references that would never
|
||
disappear otherwise.
|
||
|
||
=item whitespace
|
||
|
||
A B<character> X<whitespace characters>X<characters, whitespace>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. In
|
||
Unicode, matches many other characters that Unicode considers whitespace,
|
||
including the ɴ-ʙʀ .
|
||
|
||
=item word
|
||
|
||
In normal “computerese”, the X<words (term)>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
|
||
B<identifier> (including underscores), or to a string of nonwhitespace
|
||
B<characters> bounded by whitespace or string boundaries.
|
||
|
||
=item working directory
|
||
|
||
Your X<working directory>X<directories, working>current B<directory>, from
|
||
which relative pathnames are interpreted by the B<operating system>. The
|
||
operating system knows your current directory because you told it with a
|
||
C<chdir>, or because you started out in the place where your parent
|
||
B<process> was when you were born.
|
||
|
||
=item wrapper
|
||
|
||
A program X<wrappers (term)>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 X<WYSIWYG acronym>You See Is What You Get. Usually used when something
|
||
that appears on the screen matches how it will eventually look, like Perl’s
|
||
C<format> declarations. Also used to mean the opposite of magic because
|
||
everything works exactly as it appears, as in the three- argument form of
|
||
C<open>.
|
||
|
||
=back
|
||
|
||
=head2 X
|
||
|
||
=over 4
|
||
|
||
=item XS
|
||
|
||
An X<XS (eXternal Subroutine)>X<eXternal Subroutine (XS)>extraordinarily
|
||
exported, expeditiously excellent, expressly eXternal Subroutine, executed
|
||
in existing C or C++ or in an exciting extension language called
|
||
(exasperatingly) XS.
|
||
|
||
=item XSUB
|
||
|
||
An X<XSUB (term)>external B<subroutine> defined in B<XS>.
|
||
|
||
=back
|
||
|
||
=head2 Y
|
||
|
||
=over 4
|
||
|
||
=item yacc
|
||
|
||
Yet X<yacc acronym>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 X<zero–width assertions>X<subpatterns, zero–width assertions>X<assertions
|
||
(in regexes), zero–width>subpattern B<assertion> matching the B<null
|
||
string> between B<characters>.
|
||
|
||
=item zombie
|
||
|
||
A process X<zombie processes>X<processes, zombie>that has died (exited) but
|
||
whose parent has not yet received proper notification of its demise by
|
||
virtue of having called C<wait> or C<waitpid>. If you C<fork>, you must
|
||
clean up after your child processes when they exit; otherwise, 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 I<Programming Perl>, Fourth Edition,
|
||
by Tom Christiansen, brian d foy, Larry Wall, & Jon Orwant.
|
||
Copyright (c) 2000, 1996, 1991, 2012 O'Reilly Media, Inc.
|
||
This document may be distributed under the same terms as Perl itself.
|