PERLGLOSSARY(1) Perl Programmers Reference Guide PERLGLOSSARY(1) #
PERLGLOSSARY(1) Perl Programmers Reference Guide PERLGLOSSARY(1)
NNAAMMEE #
perlglossary - Perl Glossary
VVEERRSSIIOONN #
version 5.20210520
DDEESSCCRRIIPPTTIIOONN #
A glossary of terms (technical and otherwise) used in the Perl
documentation, derived from the Glossary of _P_r_o_g_r_a_m_m_i_n_g _P_e_r_l, Fourth
Edition. Words or phrases in bold are defined elsewhere in this
glossary.
Other useful sources include the Unicode Glossary
<http://unicode.org/glossary/>, the Free On-Line Dictionary of Computing
<http://foldoc.org/>, the Jargon File <http://catb.org/~esr/jargon/>, and
Wikipedia <http://www.wikipedia.org/>.
AA #
accessor methods
A mmeetthhoodd used to indirectly inspect or update an oobbjjeecctt’s state (its
iinnssttaannccee vvaarriiaabblleess).
actual arguments
The ssccaallaarr vvaalluueess that you supply to a ffuunnccttiioonn or ssuubbrroouuttiinnee when
you call it. For instance, when you call "power("puff")", the string
"puff" is the actual argument. See also aarrgguummeenntt and ffoorrmmaall
aarrgguummeennttss.
address operator
Some languages work directly with the memory addresses of values, but
this can be like playing with fire. Perl provides a set of asbestos
gloves for handling all memory management. The closest to an address
operator in Perl is the backslash operator, but it gives you a hhaarrdd
rreeffeerreennccee, which is much safer than a memory address.
algorithm
A well-defined sequence of steps, explained clearly enough that even
a computer could do them.
alias
A nickname for something, which behaves in all ways as though you’d
used the original name instead of the nickname. Temporary aliases are
implicitly created in the loop variable for "foreach" loops, in the
$_ variable for "map" or "grep" operators, in $a and $b during
"sort"’s comparison function, and in each element of @_ for the
aaccttuuaall aarrgguummeennttss of a subroutine call. Permanent aliases are
explicitly created in ppaacckkaaggeess by iimmppoorrttiinngg symbols or by assignment
to ttyyppeegglloobbss. Lexically scoped aliases for package variables are
explicitly created by the "our" declaration.
alphabetic
The 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.
alternatives
A list of possible choices from which you may select only one, as in,
“Would you like door A, B, or C?” Alternatives in regular expressions
are separated with a single vertical bar: "|". Alternatives in
normal Perl expressions are separated with a double vertical bar:
"||". Logical alternatives in BBoooolleeaann expressions are separated with
either "||" or "or".
anonymous
Used to describe a rreeffeerreenntt that is not directly accessible through a
named vvaarriiaabbllee. Such a referent must be indirectly accessible through
at least one hhaarrdd rreeffeerreennccee. When the last hard reference goes away,
the anonymous referent is destroyed without pity.
application
A bigger, fancier sort of pprrooggrraamm with a fancier name so people don’t
realize they are using a program.
architecture
The kind of computer you’re working on, where one “kind of computer”
means all those computers sharing a compatible machine language.
Since Perl programs are (typically) simple text files, not executable
images, a Perl program is much less sensitive to the architecture
it’s running on than programs in other languages, such as C, that are
ccoommppiilleedd into machine code. See also ppllaattffoorrmm and ooppeerraattiinngg ssyysstteemm.
argument
A piece of data supplied to a pprrooggrraamm, ssuubbrroouuttiinnee, ffuunnccttiioonn, or
mmeetthhoodd to tell it what it’s supposed to do. Also called a
“parameter”.
ARGV #
The name of the array containing the aarrgguummeenntt vveeccttoorr from the command
line. If you use the empty "<>" operator, "ARGV" is the name of both
the ffiilleehhaannddllee used to traverse the arguments and the ssccaallaarr
containing the name of the current input file.
arithmetical operator
A ssyymmbbooll such as "+" or "/" that tells Perl to do the arithmetic you
were supposed to learn in grade school.
array
An ordered sequence of vvaalluueess, stored such that you can easily access
any of the values using an _i_n_t_e_g_e_r _s_u_b_s_c_r_i_p_t that specifies the
value’s ooffffsseett in the sequence.
array context
An archaic expression for what is more correctly referred to as lliisstt
ccoonntteexxtt.
Artistic License
The open source license that Larry Wall created for Perl, maximizing
Perl’s usefulness, availability, and modifiability. The current
version is 2.
(<http://www.opensource.org/licenses/artistic-license.php>).
ASCII #
The American Standard Code for Information Interchange (a 7-bit
character set adequate only for poorly representing English text).
Often used loosely to describe the lowest 128 values of the various
ISO-8859-X character sets, a bunch of mutually incompatible 8-bit
codes best described as half ASCII. See also UUnniiccooddee.
assertion
A component of a rreegguullaarr eexxpprreessssiioonn that must be true for the pattern
to match but does not necessarily match any characters itself. Often
used specifically to mean a zzeerroo--wwiiddtthh assertion.
assignment
An ooppeerraattoorr whose assigned mission in life is to change the value of
a vvaarriiaabbllee.
assignment operator
Either a regular aassssiiggnnmmeenntt or a compound ooppeerraattoorr 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, "$a += 2" adds 2 to $a.
associative array
See hhaasshh. Please. The term associative array is the old Perl 4 term
for a hhaasshh. Some languages call it a dictionary.
associativity
Determines whether you do the left ooppeerraattoorr first or the right
ooppeerraattoorr first when you have “A ooppeerraattoorr B ooppeerraattoorr C”, and the two
operators are of the same precedence. Operators like "+" are left
associative, while operators like "**" are right associative. See
Camel chapter 3, “Unary and Binary Operators” for a list of operators
and their associativity.
asynchronous
Said of events or activities whose relative temporal ordering is
indeterminate because too many things are going on at once. Hence, an
asynchronous event is one you didn’t know when to expect.
atom
A rreegguullaarr eexxpprreessssiioonn component potentially matching a ssuubbssttrriinngg
containing one or more characters and treated as an indivisible
syntactic unit by any following qquuaannttiiffiieerr. (Contrast with an
aasssseerrttiioonn that matches something of zzeerroo wwiiddtthh and may not be
quantified.)
atomic operation
When Democritus gave the word “atom” to the indivisible bits of
matter, he meant literally something that could not be cut: _ἀ_- (not)
+ _-_τ_ο_μ_ο_ς (cuttable). An atomic operation is an action that can’t be
interrupted, not one forbidden in a nuclear-free zone.
attribute
A new feature that allows the declaration of vvaarriiaabblleess and
ssuubbrroouuttiinneess with modifiers, as in "sub foo : locked method". Also
another name for an iinnssttaannccee vvaarriiaabbllee of an oobbjjeecctt.
autogeneration
A feature of ooppeerraattoorr oovveerrllooaaddiinngg of oobbjjeeccttss, whereby the behavior of
certain ooppeerraattoorrss 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”.
autoincrement
To add one to something automatically, hence the name of the "++"
operator. To instead subtract one from something automatically is
known as an “autodecrement”.
autoload
To load on demand. (Also called “lazy” loading.) Specifically, to
call an "AUTOLOAD" subroutine on behalf of an undefined subroutine.
autosplit
To split a string automatically, as the _–_a sswwiittcchh does when running
under _–_p or _–_n in order to emulate aawwkk. (See also the "AutoSplit"
module, which has nothing to do with the "–a" switch but a lot to do
with autoloading.)
autovivification
A Graeco-Roman word meaning “to bring oneself to life”. In Perl,
storage locations (llvvaalluueess) spontaneously generate themselves as
needed, including the creation of any hhaarrdd rreeffeerreennccee values to point
to the next level of storage. The assignment "$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.
AV Short for “array value”, which refers to one of Perl’s internal data
types that holds an aarrrraayy. The "AV" type is a subclass of SSVV.
awk Descriptive editing term—short for “awkward”. Also coincidentally
refers to a venerable text-processing language from which Perl
derived some of its high-level ideas.
BB #
backreference
A substring ccaappttuurreedd by a subpattern within unadorned parentheses in
a rreeggeexx. Backslashed decimal numbers ("\1", "\2", etc.) later in the
same pattern refer back to the corresponding subpattern in the
current match. Outside the pattern, the numbered variables ($1, $2,
etc.) continue to refer to these same values, as long as the pattern
was the last successful match of the current ddyynnaammiicc ssccooppee.
backtracking
The practice of saying, “If I had to do it all over, I’d do it
differently,” and then actually going back and doing it all over
differently. Mathematically speaking, it’s returning from an
unsuccessful recursion on a tree of possibilities. Perl backtracks
when it attempts to match patterns with a rreegguullaarr eexxpprreessssiioonn, and its
earlier attempts don’t pan out. See the section “The Little Engine
That /Couldn(n’t)” in Camel chapter 5, “Pattern Matching”.
backward compatibility
Means you can still run your old program because we didn’t break any
of the features or bugs it was relying on.
bareword
A word sufficiently ambiguous to be deemed illegal under "use strict
'subs'". In the absence of that stricture, a bareword is treated as
if quotes were around it.
base class
A generic oobbjjeecctt type; that is, a ccllaassss from which other, more
specific classes are derived genetically by iinnhheerriittaannccee. Also called
a “superclass” by people who respect their ancestors.
big-endian
From Swift: someone who eats eggs big end first. Also used of
computers that store the most significant bbyyttee of a word at a lower
byte address than the least significant byte. Often considered
superior to little-endian machines. See also lliittttllee--eennddiiaann.
binary
Having to do with numbers represented in base 2. That means there’s
basically two numbers: 0 and 1. Also used to describe a file of
“nontext”, presumably because such a file makes full use of all the
binary bits in its bytes. With the advent of UUnniiccooddee, this
distinction, already suspect, loses even more of its meaning.
binary operator
An ooppeerraattoorr that takes two ooppeerraannddss.
bind
To assign a specific nneettwwoorrkk aaddddrreessss to a ssoocckkeett.
bit An integer in the range from 0 to 1, inclusive. The smallest possible
unit of information storage. An eighth of a bbyyttee 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”.)
bit shift
The movement of bits left or right in a computer word, which has the
effect of multiplying or dividing by a power of 2.
bit string
A sequence of bbiittss that is actually being thought of as a sequence of
bits, for once.
bless
In corporate life, to grant official approval to a thing, as in, “The
VP of Engineering has blessed our WebCruncher project.” Similarly, in
Perl, to grant official approval to a rreeffeerreenntt so that it can
function as an oobbjjeecctt, such as a WebCruncher object. See the "bless"
function in Camel chapter 27, “Functions”.
block
What a pprroocceessss 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 ooppeerraattiinngg ssyysstteemm 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.
BLOCK #
A syntactic construct consisting of a sequence of Perl ssttaatteemmeennttss
that is delimited by braces. The "if" and "while" statements are
defined in terms of _"_B_L_O_C_K_"s, for instance. Sometimes we also say
“block” to mean a lexical scope; that is, a sequence of statements
that acts like a _"_B_L_O_C_K_", such as within an "eval" or a file, even
though the statements aren’t delimited by braces.
block buffering
A method of making input and output efficient by passing one bblloocckk at
a time. By default, Perl does block buffering to disk files. See
bbuuffffeerr and ccoommmmaanndd bbuuffffeerriinngg.
Boolean
A value that is either ttrruuee or ffaallssee.
Boolean context
A special kind of ssccaallaarr ccoonntteexxtt used in conditionals to decide
whether the ssccaallaarr vvaalluuee returned by an expression is ttrruuee or ffaallssee.
Does not evaluate as either a string or a number. See ccoonntteexxtt.
breakpoint
A spot in your program where you’ve told the debugger to stop
eexxeeccuuttiioonn so you can poke around and see whether anything is wrong
yet.
broadcast
To send a ddaattaaggrraamm to multiple destinations simultaneously.
BSD A 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”.
bucket
A location in a hhaasshh ttaabbllee 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.)
buffer
A temporary holding location for data. Data that are BBlloocckk bbuuffffeerriinngg
means that the data is passed on to its destination whenever the
buffer is full. LLiinnee bbuuffffeerriinngg means that it’s passed on whenever a
complete line is received. CCoommmmaanndd bbuuffffeerriinngg means that it’s passed
every time you do a "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.
built-in
A ffuunnccttiioonn that is predefined in the language. Even when hidden by
oovveerrrriiddiinngg, you can always get at a built- in function by qquuaalliiffyyiinngg
its name with the "CORE::" pseudopackage.
bundle
A group of related modules on CCPPAANN. (Also sometimes refers to a group
of command-line switches grouped into one sswwiittcchh cclluusstteerr.)
byte
A piece of data worth eight bbiittss in most places.
bytecode
A pidgin-like lingo spoken among ’droids when they don’t wish to
reveal their orientation (see eennddiiaann). 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.
CC #
C A language beloved by many for its inside-out ttyyppee definitions,
inscrutable pprreecceeddeennccee rules, and heavy oovveerrllooaaddiinngg 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.
cache
A data repository. Instead of computing expensive answers several
times, compute it once and save the result.
callback
A hhaannddlleerr that you register with some other part of your program in
the hope that the other part of your program will ttrriiggggeerr your
handler when some event of interest transpires.
call by reference
An aarrgguummeenntt-passing mechanism in which the ffoorrmmaall aarrgguummeennttss refer
directly to the aaccttuuaall aarrgguummeennttss, and the ssuubbrroouuttiinnee can change the
actual arguments by changing the formal arguments. That is, the
formal argument is an aalliiaass for the actual argument. See also ccaallll bbyy
vvaalluuee.
call by value
An aarrgguummeenntt-passing mechanism in which the ffoorrmmaall aarrgguummeennttss refer to
a copy of the aaccttuuaall aarrgguummeennttss, and the ssuubbrroouuttiinnee cannot change the
actual arguments by changing the formal arguments. See also ccaallll bbyy
rreeffeerreennccee.
canonical
Reduced to a standard form to facilitate comparison.
capture variables
The variables—such as $1 and $2, and "%+" and "%– "—that hold the
text remembered in a pattern match. See Camel chapter 5, “Pattern
Matching”.
capturing
The use of parentheses around a ssuubbppaatttteerrnn in a rreegguullaarr eexxpprreessssiioonn to
store the matched ssuubbssttrriinngg as a bbaacckkrreeffeerreennccee. (Captured strings are
also returned as a list in lliisstt ccoonntteexxtt.) See Camel chapter 5,
“Pattern Matching”.
cargo cult
Copying 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 _T_h_e _G_o_d_s _M_u_s_t _B_e
_C_r_a_z_y.
case
A 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: lloowweerrccaassee (cchhaarraacctteerr
pprrooppeerrttyy "\p{lower}"), ttiittlleeccaassee ("\p{title}"), and uuppppeerrccaassee
("\p{upper}"). A fourth casemapping called ffoollddccaassee is not itself a
distinct case, but it is used internally to implement ccaasseeffoollddiinngg.
Not all letters have case, and some nonletters have case.
casefolding
Comparing or matching a string case-insensitively. In Perl, it is
implemented with the "/i" pattern modifier, the "fc" function, and
the "\F" double-quote translation escape.
casemapping
The process of converting a string to one of the four Unicode
ccaasseemmaappss; in Perl, it is implemented with the "fc", "lc", "ucfirst",
and "uc" functions.
character
The 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 ccooddeeppooiinntt.
character class
A square-bracketed list of characters used in a rreegguullaarr eexxpprreessssiioonn to
indicate that any character of the set may occur at a given point.
Loosely, any predefined set of characters so used.
character property
A predefined cchhaarraacctteerr ccllaassss matchable by the "\p" or "\P"
mmeettaassyymmbbooll. UUnniiccooddee defines hundreds of standard properties for every
possible codepoint, and Perl defines a few of its own, too.
circumfix operator
An ooppeerraattoorr that surrounds its ooppeerraanndd, like the angle operator, or
parentheses, or a hug.
class
A user-defined ttyyppee, implemented in Perl via a ppaacckkaaggee that provides
(either directly or by inheritance) mmeetthhooddss (that is, ssuubbrroouuttiinneess) to
handle iinnssttaanncceess of the class (its oobbjjeeccttss). See also iinnhheerriittaannccee.
class method
A mmeetthhoodd whose iinnvvooccaanntt is a ppaacckkaaggee name, not an oobbjjeecctt reference. A
method associated with the class as a whole. Also see iinnssttaannccee
mmeetthhoodd.
client
In networking, a pprroocceessss that initiates contact with a sseerrvveerr process
in order to exchange data and perhaps receive a service.
closure
An aannoonnyymmoouuss subroutine that, when a reference to it is generated at
runtime, keeps track of the identities of externally visible lleexxiiccaall
vvaarriiaabblleess, even after those lexical variables have supposedly gone
out of ssccooppee. They’re called “closures” because this sort of behavior
gives mathematicians a sense of closure.
cluster
A parenthesized ssuubbppaatttteerrnn used to group parts of a rreegguullaarr
eexxpprreessssiioonn into a single aattoomm.
CODE #
The word returned by the "ref" function when you apply it to a
reference to a subroutine. See also CCVV.
code generator
A system that writes code for you in a low-level language, such as
code to implement the backend of a compiler. See pprrooggrraamm ggeenneerraattoorr.
codepoint
The 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 oorrddiinnaallss.
code subpattern
A rreegguullaarr eexxpprreessssiioonn subpattern whose real purpose is to execute some
Perl code—for example, the "(?{...})" and "(??{...})" subpatterns.
collating sequence
The order into which cchhaarraacctteerrss sort. This is used by ssttrriinngg
comparison routines to decide, for example, where in this glossary to
put “collating sequence”.
co-maintainer
A person with permissions to index a nnaammeessppaaccee in PPAAUUSSEE. Anyone can
upload any namespace, but only primary and co-maintainers get their
contributions indexed.
combining character
Any character with the General Category of Combining Mark
("\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 ggrraapphheemmee. Most but not all diacritics are combining
characters, and vice versa.
command
In sshheellll 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 ssttaatteemmeenntt, which might start with a llaabbeell and typically ends
with a semicolon.
command buffering
A mechanism in Perl that lets you store up the output of each Perl
ccoommmmaanndd and then flush it out as a single request to the ooppeerraattiinngg
ssyysstteemm. It’s enabled by setting the $| ($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 ffiillee or ppiippee is to use bblloocckk bbuuffffeerriinngg.
command-line arguments
The vvaalluueess you supply along with a program name when you tell a sshheellll
to execute a ccoommmmaanndd. These values are passed to a Perl program
through @ARGV.
command name
The name of the program currently executing, as typed on the command
line. In C, the ccoommmmaanndd name is passed to the program as the first
command-line argument. In Perl, it comes in separately as $0.
comment
A remark that doesn’t affect the meaning of the program. In Perl, a
comment is introduced by a "#" character and continues to the end of
the line.
compilation unit
The ffiillee (or ssttrriinngg, in the case of "eval") that is currently being
ccoommppiilleedd.
compile
The process of turning source code into a machine-usable form. See
ccoommppiillee pphhaassee.
compile phase
Any time before Perl starts running your main program. See also rruunn
pphhaassee. Compile phase is mostly spent in ccoommppiillee ttiimmee, but may also be
spent in rruunnttiimmee when "BEGIN" blocks, "use" or "no" declarations, or
constant subexpressions are being evaluated. The startup and import
code of any "use" declaration is also run during compile phase.
compiler
Strictly speaking, a program that munches up another program and
spits out yet another file containing the program in a “more
executable” form, typically containing native machine instructions.
The _p_e_r_l 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 (ssyynnttaaxx ttrreeeess) within the _p_e_r_l process itself,
which the iinntteerrpprreetteerr then interprets. There are, however, extension
mmoodduulleess to get Perl to act more like a “real” compiler. See Camel
chapter 16, “Compiling”.
compile time
The time when Perl is trying to make sense of your code, as opposed
to when it thinks it knows what your code means and is merely trying
to do what it thinks your code says to do, which is rruunnttiimmee.
composer
A “constructor” for a rreeffeerreenntt that isn’t really an oobbjjeecctt, 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”.
concatenation
The process of gluing one cat’s nose to another cat’s tail. Also a
similar operation on two ssttrriinnggss.
conditional
Something “iffy”. See BBoooolleeaann ccoonntteexxtt.
connection
In telephony, the temporary electrical circuit between the caller’s
and the callee’s phone. In networking, the same kind of temporary
circuit between a cclliieenntt and a sseerrvveerr.
construct
As a noun, a piece of syntax made up of smaller pieces. As a
transitive verb, to create an oobbjjeecctt using a ccoonnssttrruuccttoorr.
constructor
Any ccllaassss mmeetthhoodd, iinnssttaannccee, or ssuubbrroouuttiinnee that composes, initializes,
blesses, and returns an oobbjjeecctt. Sometimes we use the term loosely to
mean a ccoommppoosseerr.
context
The surroundings or environment. The context given by the surrounding
code determines what kind of data a particular eexxpprreessssiioonn is expected
to return. The three primary contexts are lliisstt ccoonntteexxtt, ssccaallaarr, and
vvooiidd ccoonntteexxtt. Scalar context is sometimes subdivided into BBoooolleeaann
ccoonntteexxtt, nnuummeerriicc ccoonntteexxtt, ssttrriinngg ccoonntteexxtt, and vvooiidd ccoonntteexxtt. There’s
also a “don’t care” context (which is dealt with in Camel chapter 2,
“Bits and Pieces”, if you care).
continuation
The treatment of more than one physical lliinnee as a single logical
line. MMaakkeeffiillee lines are continued by putting a backslash before the
nneewwlliinnee. Mail headers, as defined by RFC 822, are continued by
putting a space or tab _a_f_t_e_r the newline. In general, lines in Perl
do not need any form of continuation mark, because wwhhiitteessppaaccee
(including newlines) is gleefully ignored. Usually.
core dump
The corpse of a pprroocceessss, in the form of a file left in the wwoorrkkiinngg
ddiirreeccttoorryy of the process, usually as a result of certain kinds of
fatal errors.
CPAN #
The Comprehensive Perl Archive Network. (See the Camel Preface and
Camel chapter 19, “CPAN” for details.)
C preprocessor
The typical C compiler’s first pass, which processes lines beginning
with "#" for conditional compilation and macro definition, and does
various manipulations of the program text based on the current
definitions. Also known as _c_p_p(1).
cracker
Someone who breaks security on computer systems. A cracker may be a
true hhaacckkeerr or only a ssccrriipptt kkiiddddiiee.
currently selected output channel
The last ffiilleehhaannddllee that was designated with "select(FILEHANDLE)";
"STDOUT", if no filehandle has been selected.
current package
The ppaacckkaaggee in which the current statement is ccoommppiilleedd. Scan backward
in the text of your program through the current lleexxiiccaall ssccooppee or any
enclosing lexical scopes until you find a package declaration. That’s
your current package name.
current working directory
See wwoorrkkiinngg ddiirreeccttoorryy.
CV In academia, a curriculum vitæ, a fancy kind of résumé. In Perl, an
internal “code value” typedef holding a ssuubbrroouuttiinnee. The "CV" type is
a subclass of SSVV.
DD #
dangling statement
A bare, single ssttaatteemmeenntt, without any braces, hanging off an "if" or
"while" conditional. C allows them. Perl doesn’t.
datagram
A packet of data, such as a UUDDPP 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 IIPP level, but
ssttrreeaamm protocols such as TTCCPP hide this from your program.)
data structure
How your various pieces of data relate to each other and what shape
they make when you put them all together, as in a rectangular table
or a triangular tree.
data type
A set of possible values, together with all the operations that know
how to deal with those values. For example, a numeric data type has a
certain set of numbers that you can work with, as well as various
mathematical operations that you can do on the numbers, but would
make little sense on, say, a string such as "Kilroy". Strings have
their own operations, such as ccoonnccaatteennaattiioonn. Compound types made of a
number of smaller pieces generally have operations to compose and
decompose them, and perhaps to rearrange them. OObbjjeeccttss 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 "open_door" mmeetthhoodd.
DBM Stands for “Database Management” routines, a set of routines that
emulate an aassssoocciiaattiivvee aarrrraayy 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 hhaasshh
across multiple invocations. You can "tie" your hash variables to
various DBM implementations.
declaration
An aasssseerrttiioonn 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 ssttaatteemmeenntt for
its opposite. Note that some declarations also function as
statements. Subroutine declarations also act as definitions if a body
is supplied.
declarator
Something that tells your program what sort of variable you’d like.
Perl doesn’t require you to declare variables, but you can use "my",
"our", or "state" to denote that you want something other than the
default.
decrement
To subtract a value from a variable, as in “decrement $x” (meaning to
remove 1 from its value) or “decrement $x by 3”.
default
A vvaalluuee chosen for you if you don’t supply a value of your own.
defined
Having a meaning. Perl thinks that some of the things people try to
do are devoid of meaning; in particular, making use of variables that
have never been given a vvaalluuee 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
ffaallssee and the "defined" entry in Camel chapter 27, “Functions”.
delimiter
A cchhaarraacctteerr or ssttrriinngg that sets bounds to an arbitrarily sized
textual object, not to be confused with a sseeppaarraattoorr or tteerrmmiinnaattoorr.
“To delimit” really just means “to surround” or “to enclose” (like
these parentheses are doing).
dereference
A fancy computer science term meaning “to follow a rreeffeerreennccee to what
it points to”. The “de” part of it refers to the fact that you’re
taking away one level of iinnddiirreeccttiioonn.
derived class
A ccllaassss that defines some of its mmeetthhooddss in terms of a more generic
class, called a bbaassee ccllaassss. 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.
descriptor
See ffiillee ddeessccrriippttoorr.
destroy
To deallocate the memory of a rreeffeerreenntt (first triggering its
"DESTROY" method, if it has one).
destructor
A special mmeetthhoodd that is called when an oobbjjeecctt is thinking about
ddeessttrrooyyiinngg itself. A Perl program’s "DESTROY" method doesn’t do the
actual destruction; Perl just ttrriiggggeerrss the method in case the ccllaassss
wants to do any associated cleanup.
device
A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a
joystick or a mouse) attached to your computer, which the ooppeerraattiinngg
ssyysstteemm tries to make look like a ffiillee (or a bunch of files). Under
Unix, these fake files tend to live in the _/_d_e_v directory.
directive
A ppoodd directive. See Camel chapter 23, “Plain Old Documentation”.
directory
A special file that contains other files. Some ooppeerraattiinngg ssyysstteemmss call
these “folders”, “drawers”, “catalogues”, or “catalogs”.
directory handle
A name that represents a particular instance of opening a directory
to read it, until you close it. See the "opendir" function.
discipline
Some people need this and some people avoid it. For Perl, it’s an
old way to say II//OO llaayyeerr.
dispatch
To send something to its correct destination. Often used
metaphorically to indicate a transfer of programmatic control to a
destination selected algorithmically, often by lookup in a table of
function rreeffeerreenncceess or, in the case of object mmeetthhooddss, by traversing
the inheritance tree looking for the most specific definition for the
method.
distribution
A standard, bundled release of a system of software. The default
usage implies source code is included. If that is not the case, it
will be called a “binary-only” distribution.
dual-lived
Some modules live both in the SSttaannddaarrdd LLiibbrraarryy and on CCPPAANN. These
modules might be developed on two tracks as people modify either
version. The trend currently is to untangle these situations.
dweomer
An enchantment, illusion, phantasm, or jugglery. Said when Perl’s
magical ddwwiimmmmeerr effects don’t do what you expect, but rather seem to
be the product of arcane _d_w_e_o_m_e_r_c_r_a_f_t, sorcery, or wonder working.
[From Middle English.]
dwimmer
DWIM is an acronym for “Do What I Mean”, the principle that something
should just do what you want it to do without an undue amount of
fuss. A bit of code that does “dwimming” is a “dwimmer”. Dwimming can
require a great deal of behind-the-scenes magic, which (if it doesn’t
stay properly behind the scenes) is called a ddwweeoommeerr instead.
dynamic scoping
Dynamic scoping works over a ddyynnaammiicc ssccooppee, making variables visible
throughout the rest of the bblloocckk in which they are first used and in
any ssuubbrroouuttiinneess that are called by the rest of the block. Dynamically
scoped variables can have their values temporarily changed (and
implicitly restored later) by a "local" operator. (Compare lleexxiiccaall
ssccooppiinngg.) Used more loosely to mean how a subroutine that is in the
middle of calling another subroutine “contains” that subroutine at
rruunnttiimmee.
EE #
eclectic
Derived from many sources. Some would say _t_o_o many.
element
A basic building block. When you’re talking about an aarrrraayy, it’s one
of the items that make up the array.
embedding
When something is contained in something else, particularly when that
might be considered surprising: “I’ve embedded a complete Perl
interpreter in my editor!”
empty subclass test
The notion that an empty ddeerriivveedd ccllaassss should behave exactly like its
bbaassee ccllaassss.
encapsulation
The veil of abstraction separating the iinntteerrffaaccee from the
iimmpplleemmeennttaattiioonn (whether enforced or not), which mandates that all
access to an oobbjjeecctt’s state be through mmeetthhooddss alone.
endian
See lliittttllee--eennddiiaann and bbiigg--eennddiiaann.
en passant
When you change a vvaalluuee as it is being copied. [From French “in
passing”, as in the exotic pawn-capturing maneuver in chess.]
environment
The collective set of eennvviirroonnmmeenntt vvaarriiaabblleess your pprroocceessss inherits
from its parent. Accessed via %ENV.
environment variable
A mechanism by which some high-level agent such as a user can pass
its preferences down to its future offspring (child pprroocceesssseess,
grandchild processes, great-grandchild processes, and so on). Each
environment variable is a kkeeyy/vvaalluuee pair, like one entry in a hhaasshh.
EOF End of File. Sometimes used metaphorically as the terminating string
of a hheerree ddooccuummeenntt.
errno
The error number returned by a ssyyssccaallll when it fails. Perl refers to
the error by the name $! (or $OS_ERROR if you use the English
module).
error
See eexxcceeppttiioonn or ffaattaall eerrrroorr.
escape sequence
See mmeettaassyymmbbooll.
exception
A fancy term for an error. See ffaattaall eerrrroorr.
exception handling
The way a program responds to an error. The exception-handling
mechanism in Perl is the "eval" operator.
exec
To throw away the current pprroocceessss’s program and replace it with
another, without exiting the process or relinquishing any resources
held (apart from the old memory image).
executable file
A ffiillee that is specially marked to tell the ooppeerraattiinngg ssyysstteemm that
it’s okay to run this file as a program. Usually shortened to
“executable”.
execute
To run a pprrooggrraamm or ssuubbrroouuttiinnee. (Has nothing to do with the "kill"
built-in, unless you’re trying to run a ssiiggnnaall hhaannddlleerr.)
execute bit
The special mark that tells the operating system it can run this
program. There are actually three execute bits under Unix, and which
bit gets used depends on whether you own the file singularly,
collectively, or not at all.
exit status
See ssttaattuuss.
exploit
Used 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.
export
To make symbols from a mmoodduullee available for iimmppoorrtt by other modules.
expression
Anything you can legally say in a spot where a vvaalluuee is required.
Typically composed of lliitteerraallss, vvaarriiaabblleess, ooppeerraattoorrss, ffuunnccttiioonnss, and
ssuubbrroouuttiinnee calls, not necessarily in that order.
extension
A Perl module that also pulls in ccoommppiilleedd C or C++ code. More
generally, any experimental option that can be ccoommppiilleedd into Perl,
such as multithreading.
FF #
false
In Perl, any value that would look like "" or "0" if evaluated in a
string context. Since undefined values evaluate to "", all undefined
values are false, but not all false values are undefined.
FAQ Frequently Asked Question (although not necessarily frequently
answered, especially if the answer appears in the Perl FAQ shipped
standard with Perl).
fatal error
An uncaught eexxcceeppttiioonn, which causes termination of the pprroocceessss after
printing a message on your ssttaannddaarrdd eerrrroorr stream. Errors that happen
inside an "eval" are not fatal. Instead, the "eval" terminates after
placing the exception message in the $@ ($EVAL_ERROR) variable. You
can try to provoke a fatal error with the "die" operator (known as
throwing or raising an exception), but this may be caught by a
dynamically enclosing "eval". If not caught, the "die" becomes a
fatal error.
feeping creaturism
A spoonerism of “creeping featurism”, noting the biological urge to
add just one more feature to a program.
field
A single piece of numeric or string data that is part of a longer
ssttrriinngg, rreeccoorrdd, or lliinnee. Variable-width fields are usually split up
by sseeppaarraattoorrss (so use "split" to extract the fields), while fixed-
width fields are usually at fixed positions (so use "unpack").
IInnssttaannccee vvaarriiaabblleess are also known as “fields”.
FIFO #
First In, First Out. See also LLIIFFOO. Also a nickname for a nnaammeedd ppiippee.
file
A named collection of data, usually stored on disk in a ddiirreeccttoorryy in
a ffiilleessyysstteemm. 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.
file descriptor
The little number the ooppeerraattiinngg ssyysstteemm uses to keep track of which
opened ffiillee you’re talking about. Perl hides the file descriptor
inside a ssttaannddaarrdd II//OO stream and then attaches the stream to a
ffiilleehhaannddllee.
fileglob
A “wildcard” match on ffiilleennaammeess. See the "glob" function.
filehandle
An identifier (not necessarily related to the real name of a file)
that represents a particular instance of opening a file, until you
close it. If you’re going to open and close several different files
in succession, it’s fine to open each of them with the same
filehandle, so you don’t have to write out separate code to process
each file.
filename
One name for a file. This name is listed in a ddiirreeccttoorryy. You can use
it in an "open" to tell the ooppeerraattiinngg ssyysstteemm exactly which file you
want to open, and associate the file with a ffiilleehhaannddllee, which will
carry the subsequent identity of that file in your program, until you
close it.
filesystem
A set of ddiirreeccttoorriieess and ffiilleess 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.
file test operator
A built-in unary operator that you use to determine whether something
is ttrruuee about a file, such as "–o $filename" to test whether you’re
the owner of the file.
filter
A program designed to take a ssttrreeaamm of input and transform it into a
stream of output.
first-come
The first PPAAUUSSEE author to upload a nnaammeessppaaccee automatically becomes
the pprriimmaarryy mmaaiinnttaaiinneerr for that namespace. The “first come”
permissions distinguish a pprriimmaarryy mmaaiinnttaaiinneerr who was assigned that
role from one who received it automatically.
flag
We tend to avoid this term because it means so many things. It may
mean a command-line sswwiittcchh that takes no argument itself (such as
Perl’s "–n" and "–p" flags) or, less frequently, a single-bit
indicator (such as the "O_CREAT" and "O_EXCL" flags used in
"sysopen"). Sometimes informally used to refer to certain regex
modifiers.
floating point
A method of storing numbers in “scientific notation”, such that the
precision of the number is independent of its magnitude (the decimal
point “floats”). Perl does its numeric work with floating-point
numbers (sometimes called “floats”) when it can’t get away with using
iinntteeggeerrss. Floating-point numbers are mere approximations of real
numbers.
flush
The act of emptying a bbuuffffeerr, often before it’s full.
FMTEYEWTK #
Far More Than Everything You Ever Wanted To Know. An exhaustive
treatise on one narrow topic, something of a super-FFAAQQ. See Tom for
far more.
foldcase
The casemap 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
lloowweerrccaassee variant (using a partially decomposed nnoorrmmaalliizzaattiioonn form
for certain codepoints) created specifically to resolve this.
fork
To create a child pprroocceessss identical to the parent process at its
moment of conception, at least until it gets ideas of its own. A
thread with protected memory.
formal arguments
The generic names by which a ssuubbrroouuttiinnee knows its aarrgguummeennttss. 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 $ARGV[0], $ARGV[1], and so on.
Similarly, the formal arguments to a Perl subroutine are $_[0],
$_[1], and so on. You may give the arguments individual names by
assigning the values to a "my" list. See also aaccttuuaall aarrgguummeennttss.
format
A specification of how many spaces and digits and things to put
somewhere so that whatever you’re printing comes out nice and pretty.
freely available
Means you don’t have to pay money to get it, but the copyright on it
may still belong to someone else (like Larry).
freely redistributable
Means you’re not in legal trouble if you give a bootleg copy of it to
your friends and we find out about it. In fact, we’d rather you gave
a copy to all your friends.
freeware
Historically, any software that you give away, particularly if you
make the source code available as well. Now often called ooppeenn ssoouurrccee
ssooffttwwaarree. Recently there has been a trend to use the term in
contradistinction to ooppeenn ssoouurrccee ssooffttwwaarree, to refer only to free
software released under the Free Software Foundation’s GPL (General
Public License), but this is difficult to justify etymologically.
function
Mathematically, a mapping of each of a set of input values to a
particular output value. In computers, refers to a ssuubbrroouuttiinnee or
ooppeerraattoorr that returns a vvaalluuee. It may or may not have input values
(called aarrgguummeennttss).
funny character
Someone like Larry, or one of his peculiar friends. Also refers to
the strange prefixes that Perl requires as noun markers on its
variables.
GG #
garbage collection
A misnamed feature—it should be called, “expecting your mother to
pick up after you”. Strictly speaking, Perl doesn’t do this, but it
relies on a reference-counting mechanism to keep things tidy.
However, we rarely speak strictly and will often refer to the
reference-counting scheme as a form of garbage collection. (If it’s
any comfort, when your interpreter exits, a “real” garbage collector
runs to make sure everything is cleaned up if you’ve been messy with
circular references and such.)
GID Group ID—in Unix, the numeric group ID that the ooppeerraattiinngg ssyysstteemm uses
to identify you and members of your ggrroouupp.
glob
Strictly, the shell’s "*" 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 ffiilleegglloobb and ttyyppeegglloobb.
global
Something you can see from anywhere, usually used of vvaarriiaabblleess and
ssuubbrroouuttiinneess 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 ppaacckkaaggee. Global variables
can be declared with "our". See “Global Declarations” in Camel
chapter 4, “Statements and Declarations”.
global destruction
The ggaarrbbaaggee ccoolllleeccttiioonn of globals (and the running of any associated
object destructors) that takes place when a Perl iinntteerrpprreetteerr is being
shut down. Global destruction should not be confused with the
Apocalypse, except perhaps when it should.
glue language
A language such as Perl that is good at hooking things together that
weren’t intended to be hooked together.
granularity
The size of the pieces you’re dealing with, mentally speaking.
grapheme
A graphene is an allotrope of carbon arranged in a hexagonal crystal
lattice one atom thick. A ggrraapphheemmee, or more fully, a _g_r_a_p_h_e_m_e _c_l_u_s_t_e_r
_s_t_r_i_n_g is a single user-visible cchhaarraacctteerr, which may in turn be
several characters (ccooddeeppooiinnttss) 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 nnoorrmmaalliizzaattiioonn.
greedy
A ssuubbppaatttteerrnn whose qquuaannttiiffiieerr wants to match as many things as
possible.
grep
Originally from the old Unix editor command for “Globally search for
a Regular Expression and Print it”, now used in the general sense of
any kind of search, especially text searches. Perl has a built-in
"grep" function that searches a list for elements matching any given
criterion, whereas the ggrreepp(1) program searches for lines matching a
rreegguullaarr eexxpprreessssiioonn in one or more files.
group
A set of users of which you are a member. In some operating systems
(like Unix), you can give certain file access permissions to other
members of your group.
GV An internal “glob value” typedef, holding a ttyyppeegglloobb. The "GV" type
is a subclass of SSVV.
HH #
hacker
Someone who is brilliantly persistent in solving technical problems,
whether these involve golfing, fighting orcs, or programming. Hacker
is a neutral term, morally speaking. Good hackers are not to be
confused with evil ccrraacckkeerrss or clueless ssccrriipptt kkiiddddiieess. If you
confuse them, we will presume that you are either evil or clueless.
handler
A ssuubbrroouuttiinnee or mmeetthhoodd that Perl calls when your program needs to
respond to some internal event, such as a ssiiggnnaall, or an encounter
with an operator subject to ooppeerraattoorr oovveerrllooaaddiinngg. See also ccaallllbbaacckk.
hard reference
A ssccaallaarr vvaalluuee containing the actual address of a rreeffeerreenntt, such that
the referent’s rreeffeerreennccee count accounts for it. (Some hard references
are held internally, such as the implicit reference from one of a
ttyyppeegglloobb’s variable slots to its corresponding referent.) A hard
reference is different from a ssyymmbboolliicc rreeffeerreennccee.
hash
An unordered association of kkeeyy/vvaalluuee pairs, stored such that you can
easily use a string kkeeyy to look up its associated data vvaalluuee. 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.
hash table
A data structure used internally by Perl for implementing associative
arrays (hashes) efficiently. See also bbuucckkeett.
header file
A file containing certain required definitions that you must include
“ahead” of the rest of your program to do certain obscure operations.
A C header file has a _._h extension. Perl doesn’t really have header
files, though historically Perl has sometimes used translated _._h
files with a _._p_h extension. See "require" in Camel chapter 27,
“Functions”. (Header files have been superseded by the mmoodduullee
mechanism.)
here document
So called because of a similar construct in sshheellllss that pretends that
the lliinneess following the ccoommmmaanndd are a separate ffiillee to be fed to the
command, up to some terminating string. In Perl, however, it’s just a
fancy form of quoting.
hexadecimal
A number in base 16, “hex” for short. The digits for 10 through 15
are customarily represented by the letters "a" through "f".
Hexadecimal constants in Perl start with "0x". See also the "hex"
function in Camel chapter 27, “Functions”.
home directory
The directory you are put into when you log in. On a Unix system, the
name is often placed into $ENV{HOME} or $ENV{LOGDIR} by _l_o_g_i_n, but
you can also find it with "(get""pwuid($<))[7]". (Some platforms do
not have a concept of a home directory.)
host
The computer on which a program or other data resides.
hubris
Excessive pride, 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 llaazziinneessss and iimmppaattiieennccee.
HV Short for a “hash value” typedef, which holds Perl’s internal
representation of a hash. The "HV" type is a subclass of SSVV.
II #
identifier
A legally 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 qquuaalliiffiieedd names.)
impatience
The anger you feel when the computer is being lazy. This makes you
write programs that don’t just react to your needs, but actually
anticipate them. Or at least that pretend to. Hence, the second great
virtue of a programmer. See also llaazziinneessss and hhuubbrriiss.
implementation
How a piece of code actually goes about doing its job. Users of the
code should not count on implementation details staying the same
unless they are part of the published iinntteerrffaaccee.
import
To gain access to symbols that are exported from another module. See
"use" in Camel chapter 27, “Functions”.
increment
To increase the value of something by 1 (or by some other number, if
so specified).
indexing
In olden days, the act of looking up a kkeeyy 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 vvaalluuee, even if no index is
involved. Things have degenerated to the point that Perl’s "index"
function merely locates the position (index) of one string in
another.
indirect filehandle
An eexxpprreessssiioonn that evaluates to something that can be used as a
ffiilleehhaannddllee: a ssttrriinngg (filehandle name), a ttyyppeegglloobb, a typeglob
rreeffeerreennccee, or a low-level IIOO object.
indirection
If something in a program isn’t the value you’re looking for but
indicates where the value is, that’s indirection. This can be done
with either ssyymmbboolliicc rreeffeerreenncceess or hhaarrdd.
indirect object
In English grammar, a short noun phrase between a verb and its direct
object indicating the beneficiary or recipient of the action. In
Perl, "print STDOUT "$foo\n";" can be understood as “verb indirect-
object object”, where "STDOUT" is the recipient of the "print"
action, and "$foo" is the object being printed. Similarly, when
invoking a mmeetthhoodd, 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!";
indirect object slot
The syntactic position falling between a method call and its
arguments when using the indirect object invocation syntax. (The slot
is distinguished by the absence of a comma between it and the next
argument.) "STDERR" is in the indirect object slot here:
print STDERR "Awake! Awake! Fear, Fire, Foes! Awake!\n";
infix
An ooppeerraattoorr that comes in between its ooppeerraannddss, such as
multiplication in "24 * 7".
inheritance
What you get from your ancestors, genetically or otherwise. If you
happen to be a ccllaassss, your ancestors are called bbaassee ccllaasssseess and your
descendants are called ddeerriivveedd ccllaasssseess. See ssiinnggllee iinnhheerriittaannccee and
mmuullttiippllee iinnhheerriittaannccee.
instance
Short for “an instance of a class”, meaning an oobbjjeecctt of that ccllaassss.
instance data
See iinnssttaannccee vvaarriiaabbllee.
instance method
A mmeetthhoodd of an oobbjjeecctt, as opposed to a ccllaassss mmeetthhoodd.
A mmeetthhoodd whose iinnvvooccaanntt is an oobbjjeecctt, not a ppaacckkaaggee 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 ccllaassss mmeetthhoodd.
instance variable
An aattttrriibbuuttee of an oobbjjeecctt; data stored with the particular object
rather than with the class as a whole.
integer
A number with no fractional (decimal) part. A counting number, like
1, 2, 3, and so on, but including 0 and the negatives.
interface
The services a piece of code promises to provide forever, in contrast
to its iimmpplleemmeennttaattiioonn, which it should feel free to change whenever
it likes.
interpolation
The insertion of a scalar or list value somewhere in the middle of
another value, such that it appears to have been there all along. In
Perl, variable interpolation happens in double-quoted strings and
patterns, and list interpolation occurs when constructing the list of
values to pass to a list operator or other such construct that takes
a _"_L_I_S_T_".
interpreter
Strictly speaking, a program that reads a second program and does
what the second program says directly without turning the program
into a different form first, which is what ccoommppiilleerrss 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 (ssyynnttaaxx ttrreeeess) within the _p_e_r_l process itself, which the Perl
rruunnttiimmee system then interprets.
invocant
The agent on whose behalf a mmeetthhoodd is invoked. In a ccllaassss method, the
invocant is a package name. In an iinnssttaannccee method, the invocant is an
object reference.
invocation
The act of 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.
I/O Input from, or output to, a ffiillee or ddeevviiccee.
IO An internal I/O object. Can also mean iinnddiirreecctt oobbjjeecctt.
I/O layer
One of the filters between the data and what you get as input or what
you end up with as output.
IPA India Pale Ale. Also the International Phonetic Alphabet, the
standard alphabet used for phonetic notation worldwide. Draws heavily
on Unicode, including many combining characters.
IP Internet Protocol, or Intellectual Property.
IPC Interprocess Communication.
is-a
A relationship between two oobbjjeeccttss 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 bbaassee
ccllaassss and a specific ddeerriivveedd ccllaassss. Oddly enough, Platonic classes
don’t always have Platonic relationships—see iinnhheerriittaannccee.
iteration
Doing something repeatedly.
iterator
A special programming gizmo that keeps track of where you are in
something that you’re trying to iterate over. The "foreach" loop in
Perl contains an iterator; so does a hash, allowing you to "each"
through it.
IV The integer four, not to be confused with six, Tom’s favorite editor.
IV also means an internal Integer Value of the type a ssccaallaarr can
hold, not to be confused with an NNVV.
JJ #
JAPH #
“Just Another Perl Hacker”, a clever but cryptic bit of Perl code
that, when executed, evaluates to that string. Often used to
illustrate a particular Perl feature, and something of an ongoing
Obfuscated Perl Contest seen in USENET signatures.
KK #
key The string index to a hhaasshh, used to look up the vvaalluuee associated with
that key.
keyword
See rreesseerrvveedd wwoorrddss.
LL #
label
A name you give to a ssttaatteemmeenntt so that you can talk about that
statement elsewhere in the program.
laziness
The quality that makes you go to great effort to reduce overall
energy expenditure. It makes you write labor-saving programs that
other people will find useful, and 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
iimmppaattiieennccee and hhuubbrriiss.
leftmost longest
The preference of the rreegguullaarr eexxpprreessssiioonn engine to match the leftmost
occurrence of a ppaatttteerrnn, then given a position at which a match will
occur, the preference for the longest match (presuming the use of a
ggrreeeeddyy quantifier). See Camel chapter 5, “Pattern Matching” for _m_u_c_h
more on this subject.
left shift
A bbiitt sshhiifftt that multiplies the number by some power of 2.
lexeme
Fancy term for a ttookkeenn.
lexer
Fancy term for a ttookkeenneerr.
lexical analysis
Fancy term for ttookkeenniizziinngg.
lexical scoping
Looking at your _O_x_f_o_r_d _E_n_g_l_i_s_h _D_i_c_t_i_o_n_a_r_y through a microscope. (Also
known as ssttaattiicc ssccooppiinngg, because dictionaries don’t change very
fast.) Similarly, looking at variables stored in a private dictionary
(namespace) for each scope, which are visible only from their point
of declaration down to the end of the lexical scope in which they are
declared. —Syn. ssttaattiicc ssccooppiinngg. —Ant. ddyynnaammiicc ssccooppiinngg.
lexical variable
A vvaarriiaabbllee subject to lleexxiiccaall ssccooppiinngg, declared by "my". Often just
called a “lexical”. (The "our" declaration declares a lexically
scoped name for a global variable, which is not itself a lexical
variable.)
library
Generally, a collection of procedures. In ancient days, referred to a
collection of subroutines in a _._p_l file. In modern times, refers more
often to the entire collection of Perl mmoodduulleess on your system.
LIFO #
Last In, First Out. See also FFIIFFOO. A LIFO is usually called a ssttaacckk.
line
In Unix, a sequence of zero or more nonnewline characters terminated
with a nneewwlliinnee character. On non-Unix machines, this is emulated by
the C library even if the underlying ooppeerraattiinngg ssyysstteemm has different
ideas.
linebreak
A ggrraapphheemmee consisting of either a carriage return followed by a line
feed or any character with the Unicode Vertical Space cchhaarraacctteerr
pprrooppeerrttyy.
line buffering
Used by a ssttaannddaarrdd II//OO output stream that flushes its bbuuffffeerr after
every nneewwlliinnee. Many standard I/O libraries automatically set up line
buffering on output that is going to the terminal.
line number
The number of lines read previous to this one, plus 1. Perl keeps a
separate line number for each source or input file it opens. The
current source file’s line number is represented by "__LINE__". The
current input line number (for the file that was most recently read
via "<FH>") is represented by the $. ($INPUT_LINE_NUMBER) variable.
Many error messages report both values, if available.
link
Used as a noun, a name in a ddiirreeccttoorryy that represents a ffiillee. 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 ccoommppiilleedd 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.
LIST #
A syntactic construct representing a comma- separated list of
expressions, evaluated to produce a lliisstt vvaalluuee. Each eexxpprreessssiioonn in a
_"_L_I_S_T_" is evaluated in lliisstt ccoonntteexxtt and interpolated into the list
value.
list
An ordered set of scalar values.
list context
The situation in which an eexxpprreessssiioonn is expected by its surroundings
(the code calling it) to return a list of values rather than a single
value. Functions that want a _"_L_I_S_T_" of arguments tell those arguments
that they should produce a list value. See also ccoonntteexxtt.
list operator
An ooppeerraattoorr that does something with a list of values, such as "join"
or "grep". Usually used for named built-in operators (such as
"print", "unlink", and "system") that do not require parentheses
around their aarrgguummeenntt list.
list value
An unnamed list of temporary scalar values that may be passed around
within a program from any list-generating function to any function or
construct that provides a lliisstt ccoonntteexxtt.
literal
A token in a programming language, such as a number or ssttrriinngg, that
gives you an actual vvaalluuee instead of merely representing possible
values as a vvaarriiaabbllee does.
little-endian
From Swift: someone who eats eggs little end first. Also used of
computers that store the least significant bbyyttee of a word at a lower
byte address than the most significant byte. Often considered
superior to big-endian machines. See also bbiigg--eennddiiaann.
local
Not meaning the same thing everywhere. A global variable in Perl can
be localized inside a ddyynnaammiicc ssccooppee via the "local" operator.
logical operator
Symbols representing the concepts “and”, “or”, “xor”, and “not”.
lookahead
An aasssseerrttiioonn that peeks at the string to the right of the current
match location.
lookbehind
An aasssseerrttiioonn that peeks at the string to the left of the current
match location.
loop
A construct that performs something repeatedly, like a roller
coaster.
loop control statement
Any statement within the body of a loop that can make a loop
prematurely stop looping or skip an iitteerraattiioonn. Generally, you
shouldn’t try this on roller coasters.
loop label
A kind of key or name attached to a loop (or roller coaster) so that
loop control statements can talk about which loop they want to
control.
lowercase
In Unicode, 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.
lvaluable
Able to serve as an llvvaalluuee.
lvalue
Term used by language lawyers for a storage location you can assign a
new vvaalluuee to, such as a vvaarriiaabbllee or an element of an aarrrraayy. The “l”
is short for “left”, as in the left side of an assignment, a typical
place for lvalues. An llvvaalluuaabbllee function or expression is one to
which a value may be assigned, as in "pos($x) = 10".
lvalue modifier
An adjectival pseudofunction that warps the meaning of an llvvaalluuee in
some declarative fashion. Currently there are three lvalue modifiers:
"my", "our", and "local".
MM #
magic
Technically speaking, any extra semantics attached to a variable such
as $!, $0, %ENV, or %SIG, or to any tied variable. Magical things
happen when you diddle those variables.
magical increment
An iinnccrreemmeenntt operator that knows how to bump up ASCII alphabetics as
well as numbers.
magical variables
Special variables that have side effects when you access them or
assign to them. For example, in Perl, changing elements of the %ENV
array also changes the corresponding environment variables that
subprocesses will use. Reading the $! variable gives you the current
system error number or message.
Makefile
A file that controls the compilation of a program. Perl programs
don’t usually need a MMaakkeeffiillee because the Perl compiler has plenty of
self-control.
man The Unix program that displays online documentation (manual pages)
for you.
manpage
A “page” from the manuals, typically accessed via the _m_a_n(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 ccoommmmaannddss, ssyyssccaallllss, lliibbrraarryy ffuunnccttiioonnss, ddeevviicceess,
pprroottooccoollss, ffiilleess, and such. In this book, we call any piece of
standard Perl documentation (like perlop or perldelta) a manpage, no
matter what format it’s installed in on your system.
matching
See ppaatttteerrnn mmaattcchhiinngg.
member data
See iinnssttaannccee vvaarriiaabbllee.
memory
This always means your main memory, not your disk. Clouding the
issue is the fact that your machine may implement vviirrttuuaall 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.
metacharacter
A cchhaarraacctteerr that is _n_o_t supposed to be treated normally. Which
characters are to be treated specially as metacharacters varies
greatly from context to context. Your sshheellll will have certain
metacharacters, double-quoted Perl ssttrriinnggss have other metacharacters,
and rreegguullaarr eexxpprreessssiioonn patterns have all the double-quote
metacharacters plus some extra ones of their own.
metasymbol
Something we’d call a mmeettaacchhaarraacctteerr 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.
method
A kind of action that an oobbjjeecctt can take if you tell it to. See Camel
chapter 12, “Objects”.
method resolution order
The path Perl takes through @INC. By default, this is a double depth
first search, once looking for defined methods and once for
"AUTOLOAD". However, Perl lets you configure this with "mro".
minicpan
A CPAN mirror that includes just the latest versions for each
distribution, probably created with "CPAN::Mini". See Camel chapter
19, “CPAN”. #
minimalism
The belief that “small is beautiful”. Paradoxically, if you say
something in a small language, it turns out big, and if you say it in
a big language, it turns out small. Go figure.
mode
In the context of the _s_t_a_t(2) syscall, refers to the field holding
the ppeerrmmiissssiioonn bbiittss and the type of the ffiillee.
modifier
See ssttaatteemmeenntt mmooddiiffiieerr, rreegguullaarr eexxpprreessssiioonn, and llvvaalluuee, not
necessarily in that order.
module
A ffiillee that defines a ppaacckkaaggee of (almost) the same name, which can
either eexxppoorrtt symbols or function as an oobbjjeecctt class. (A module’s
main _._p_m file may also load in other files in support of the module.)
See the "use" built-in.
modulus
An integer divisor when you’re interested in the remainder instead of
the quotient.
mojibake
When you 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
["modʑibake"] in standard IIPPAA phonetics, or approximately
“moh-jee-bah-keh”.
monger
Short for one member of PPeerrll mmoonnggeerrss, a purveyor of Perl.
mortal
A temporary value scheduled to die when the current statement
finishes.
mro See mmeetthhoodd rreessoolluuttiioonn oorrddeerr.
multidimensional array
An array with multiple subscripts for finding a single element. Perl
implements these using rreeffeerreenncceess—see Camel chapter 9, “Data
Structures”.
multiple inheritance
The features you got from your mother and father, mixed together
unpredictably. (See also iinnhheerriittaannccee and ssiinnggllee iinnhheerriittaannccee.) In
computer languages (including Perl), it is the notion that a given
class may have multiple direct ancestors or bbaassee ccllaasssseess.
NN #
named pipe
A ppiippee with a name embedded in the ffiilleessyysstteemm so that it can be
accessed by two unrelated pprroocceesssseess.
namespace
A domain of names. You needn’t worry about whether the names in one
such domain have been used in another. See ppaacckkaaggee.
NaN Not a number. The value Perl uses for certain invalid or
inexpressible floating-point operations.
network address
The most important attribute of a socket, like your telephone’s
telephone number. Typically an IP address. See also ppoorrtt.
newline
A single character that represents the end of a line, with the ASCII
value of 012 octal under Unix (but 015 on a Mac), and represented by
"\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.
NFS Network File System, which allows you to mount a remote filesystem as
if it were local.
normalization
Converting a text string into an alternate but equivalent ccaannoonniiccaall
(or compatible) representation that can then be compared for
equivalence. Unicode recognizes four different normalization forms:
NFD, NFC, NFKD, and NFKC.
null character
A character with the numeric value of zero. It’s used by C to
terminate strings, but Perl allows strings to contain a null.
null list
A lliisstt vvaalluuee with zero elements, represented in Perl by "()".
null string
A ssttrriinngg containing no characters, not to be confused with a string
containing a nnuullll cchhaarraacctteerr, which has a positive length and is ttrruuee.
numeric context
The situation in which an expression is expected by its surroundings
(the code calling it) to return a number. See also ccoonntteexxtt and
ssttrriinngg ccoonntteexxtt.
numification
(Sometimes spelled _n_u_m_m_i_f_i_c_a_t_i_o_n and _n_u_m_m_i_f_y.) Perl lingo for
implicit conversion into a number; the related verb is _n_u_m_i_f_y.
_N_u_m_i_f_i_c_a_t_i_o_n is intended to rhyme with _m_u_m_m_i_f_i_c_a_t_i_o_n, and _n_u_m_i_f_y with
_m_u_m_m_i_f_y. It is unrelated to English _n_u_m_e_n, _n_u_m_i_n_a, _n_u_m_i_n_o_u_s. We
originally forgot the extra _m a long time ago, and some people got
used to our funny spelling, and so just as with "HTTP_REFERER"’s own
missing letter, our weird spelling has stuck around.
NV Short for Nevada, no part of which will ever be confused with
civilization. NV also means an internal floating- point Numeric Value
of the type a ssccaallaarr can hold, not to be confused with an IIVV.
nybble
Half a bbyyttee, equivalent to one hheexxaaddeecciimmaall digit, and worth four
bbiittss.
OO #
object
An iinnssttaannccee of a ccllaassss. 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.
octal
A number in base 8. Only the digits 0 through 7 are allowed. Octal
constants in Perl start with 0, as in 013. See also the "oct"
function.
offset
How many things you have to skip over when moving from the beginning
of a string or array to a specific position within it. Thus, the
minimum offset is zero, not one, because you don’t skip anything to
get to the first item.
one-liner
An entire computer program crammed into one line of text.
open source software
Programs for which the source code is freely available and freely
redistributable, with no commercial strings attached. For a more
detailed definition, see <http://www.opensource.org/osd.html>.
operand
An eexxpprreessssiioonn that yields a vvaalluuee that an ooppeerraattoorr operates on. See
also pprreecceeddeennccee.
operating system
A special program that runs on the bare machine and hides the gory
details of managing pprroocceesssseess and ddeevviicceess. 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 aarrcchhiitteeccttuurree and ppllaattffoorrmm.
operator
A gizmo that transforms some number of input values to some number of
output values, often built into a language with a special syntax or
symbol. A given operator may have specific expectations about what
ttyyppeess of data you give as its arguments (ooppeerraannddss) and what type of
data you want back from it.
operator overloading
A kind of oovveerrllooaaddiinngg that you can do on built-in ooppeerraattoorrss to make
them work on oobbjjeeccttss 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 pprraaggmmaa—see Camel chapter 13, “Overloading”.
options
See either sswwiittcchheess or rreegguullaarr eexxpprreessssiioonn mmooddiiffiieerrss.
ordinal
An abstract character’s integer value. Same thing as ccooddeeppooiinntt.
overloading
Giving additional meanings to a symbol or construct. Actually, all
languages do overloading to one extent or another, since people are
good at figuring out things from ccoonntteexxtt.
overriding
Hiding or invalidating some other definition of the same name. (Not
to be confused with oovveerrllooaaddiinngg, 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 ssuubbrroouuttiinnee to hide a built-in ffuunnccttiioonn 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 mmeetthhoodd in a ddeerriivveedd ccllaassss to hide a bbaassee ccllaassss’s method
of the same name (see Camel chapter 12, “Objects”).
owner
The one user (apart from the superuser) who has absolute control over
a ffiillee. A file may also have a ggrroouupp of users who may exercise joint
ownership if the real owner permits it. See ppeerrmmiissssiioonn bbiittss.
PP #
package
A nnaammeessppaaccee for global vvaarriiaabblleess, ssuubbrroouuttiinneess, and the like, such
that they can be kept separate from like-named ssyymmbboollss 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 ccoommppiilleedd
outside the package by naming the package. But in another sense, all
package symbols are also globals—they’re just well-organized globals.
pad Short for ssccrraattcchhppaadd.
parameter
See aarrgguummeenntt.
parent class
See bbaassee ccllaassss.
parse tree
See ssyynnttaaxx ttrreeee.
parsing
The subtle but sometimes brutal art of attempting to turn your
possibly malformed program into a valid ssyynnttaaxx ttrreeee.
patch
To fix by applying one, as it were. In the realm of hackerdom, a
listing of the differences between two versions of a program as might
be applied by the ppaattcchh(1) program when you want to fix a bug or
upgrade your old version.
PATH #
The list of ddiirreeccttoorriieess the system searches to find a program you
want to eexxeeccuuttee. The list is stored as one of your eennvviirroonnmmeenntt
vvaarriiaabblleess, accessible in Perl as $ENV{PATH}.
pathname
A fully qualified filename such as _/_u_s_r_/_b_i_n_/_p_e_r_l. Sometimes confused
with "PATH".
pattern
A template used in ppaatttteerrnn mmaattcchhiinngg.
pattern matching
Taking a pattern, usually a rreegguullaarr eexxpprreessssiioonn, 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.
PAUSE #
The Perl Authors Upload SErver (<http://pause.perl.org>), the gateway
for mmoodduulleess on their way to CCPPAANN.
Perl mongers
A 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
<http://www.pm.org>.
permission bits
Bits that the oowwnneerr of a file sets or unsets to allow or disallow
access to other people. These flag bits are part of the mmooddee word
returned by the "stat" built-in when you ask about a file. On Unix
systems, you can check the _l_s(1) manpage for more information.
Pern
What you get when you do "Perl++" twice. Doing it only once will curl
your hair. You have to increment it eight times to shampoo your hair.
Lather, rinse, iterate.
pipe
A direct ccoonnnneeccttiioonn that carries the output of one pprroocceessss 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.
pipeline
A series of pprroocceesssseess all in a row, linked by ppiippeess, where each
passes its output stream to the next.
platform
The entire hardware and software context in which a program runs. A
program written in a platform-dependent language might break if you
change any of the following: machine, operating system, libraries,
compiler, or system configuration. The _p_e_r_l interpreter has to be
ccoommppiilleedd differently for each platform because it is implemented in
C, but programs written in the Perl language are largely platform
independent.
pod The markup used to embed documentation into your Perl code. Pod
stands for “Plain old documentation”. See Camel chapter 23, “Plain
Old Documentation”.
pod command
A sequence, such as "=head1", that denotes the start of a ppoodd
section.
pointer
A vvaarriiaabbllee 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 kkeeyyss and vvaarriiaabbllee names, or hhaarrdd rreeffeerreenncceess,
which aren’t pointers (but act like pointers and do in fact contain
pointers).
polymorphism
The notion that you can tell an oobbjjeecctt to do something generic, and
the object will interpret the command in different ways depending on
its type. [< Greek πολυ- + μορϕή, many forms.]
port
The part of the address of a TCP or UDP socket that directs packets
to the correct process after finding the right machine, something
like the phone extension you give when you reach the company
operator. Also the result of converting code to run on a different
platform than originally intended, or the verb denoting this
conversion.
portable
Once upon a time, C code compilable under both BSD and SysV. In
general, code that can be easily converted to run on another
ppllaattffoorrmm, 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.
porter
Someone who “carries” software from one ppllaattffoorrmm 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.
possessive
Said of 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 _n_o_n_b_a_c_k_t_r_a_c_k_a_b_l_e.
POSIX #
The Portable Operating System Interface specification.
postfix
An ooppeerraattoorr that follows its ooppeerraanndd, as in "$x++".
pp An internal shorthand for a “push- pop” code; that is, C code
implementing Perl’s stack machine.
pragma
A standard module whose practical hints and suggestions are received
(and possibly ignored) at compile time. Pragmas are named in all
lowercase.
precedence
The rules of conduct that, in the absence of other guidance,
determine what should happen first. For example, in the absence of
parentheses, you always do multiplication before addition.
prefix
An ooppeerraattoorr that precedes its ooppeerraanndd, as in "++$x".
preprocessing
What some helper pprroocceessss did to transform the incoming data into a
form more suitable for the current process. Often done with an
incoming ppiippee. See also CC pprreepprroocceessssoorr.
primary maintainer
The author that PAUSE allows to assign ccoo--mmaaiinnttaaiinneerr permissions to a
nnaammeessppaaccee. A primary maintainer can give up this distinction by
assigning it to another PAUSE author. See Camel chapter 19, “CPAN”.
procedure
A ssuubbrroouuttiinnee.
process
An instance of a running program. Under multitasking systems like
Unix, two or more separate processes could be running the same
program independently at the same time—in fact, the "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.
program
See ssccrriipptt.
program generator
A system that algorithmically writes code for you in a high-level
language. See also ccooddee ggeenneerraattoorr.
progressive matching
PPaatttteerrnn mmaattcchhiinngg matching>that picks up where it left off before.
property
See either iinnssttaannccee vvaarriiaabbllee or cchhaarraacctteerr pprrooppeerrttyy.
protocol
In networking, an agreed-upon way of sending messages back and forth
so that neither correspondent will get too confused.
prototype
An optional part of a ssuubbrroouuttiinnee declaration telling the Perl
compiler how many and what flavor of arguments may be passed as
aaccttuuaall aarrgguummeennttss, so you can write subroutine calls that parse much
like built-in functions. (Or don’t parse, as the case may be.)
pseudofunction
A construct that sometimes looks like a function but really isn’t.
Usually reserved for llvvaalluuee modifiers like "my", for ccoonntteexxtt
modifiers like "scalar", and for the pick-your-own-quotes constructs,
"q//", "qq//", "qx//", "qw//", "qr//", "m//", "s///", "y///", and
"tr///".
pseudohash
Formerly, a reference 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.
pseudoliteral
An ooppeerraattoorr X"that looks something like a lliitteerraall, such as the
output-grabbing operator, <literal moreinfo="none""`>_"_c_o_m_m_a_n_d_""`".
public domain
Something not owned by anybody. Perl is copyrighted and is thus _n_o_t
in the public domain—it’s just ffrreeeellyy aavvaaiillaabbllee and ffrreeeellyy
rreeddiissttrriibbuuttaabbllee.
pumpkin
A notional “baton” handed around the Perl community indicating who is
the lead integrator in some arena of development.
pumpking
A ppuummppkkiinn 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.
PV A “pointer value”, which is Perl Internals Talk for a "char*".
QQ #
qualified
Possessing a complete name. The symbol $Ent::moot is qualified; $moot
is unqualified. A fully qualified filename is specified from the top-
level directory.
quantifier
A component of a rreegguullaarr eexxpprreessssiioonn specifying how many times the
foregoing aattoomm may occur.
RR #
race condition
A 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 eexxppllooiitt.
readable
With respect to files, one that has the proper permission bit set to
let you access the file. With respect to computer programs, one
that’s written well enough that someone has a chance of figuring out
what it’s trying to do.
reaping
The last rites performed by a parent pprroocceessss on behalf of a deceased
child process so that it doesn’t remain a zzoommbbiiee. See the "wait" and
"waitpid" function calls.
record
A set of related data values in a ffiillee or ssttrreeaamm, often associated
with a unique kkeeyy field. In Unix, often commensurate with a lliinnee, or
a blank-line–terminated set of lines (a “paragraph”). Each line of
the _/_e_t_c_/_p_a_s_s_w_d file is a record, keyed on login name, containing
information about that user.
recursion
The art of defining something (at least partly) in terms of itself,
which is a naughty no-no in dictionaries but often works out okay in
computer programs if you’re careful not to recurse forever (which is
like an infinite loop with more spectacular failure modes).
reference
Where you look to find a pointer to information somewhere else. (See
iinnddiirreeccttiioonn.) References come in two flavors: ssyymmbboolliicc rreeffeerreenncceess and
hhaarrdd rreeffeerreenncceess.
referent
Whatever a reference refers to, which may or may not have a name.
Common types of referents include scalars, arrays, hashes, and
subroutines.
regex
See rreegguullaarr eexxpprreessssiioonn.
regular expression
A single entity with various interpretations, like an elephant. To a
computer scientist, it’s a grammar for a little language in which
some strings are legal and others aren’t. To normal people, it’s a
pattern you can use to find what you’re looking for when it varies
from case to case. Perl’s regular expressions are far from regular in
the theoretical sense, but in regular use they work quite well.
Here’s a regular expression: "/Oh s.*t./". This will match strings
like “"Oh say can you see by the dawn's early light"” and “"Oh
sit!"”. See Camel chapter 5, “Pattern Matching”.
regular expression modifier
An option on a pattern or substitution, such as "/i" to render the
pattern case- insensitive.
regular file
A ffiillee that’s not a ddiirreeccttoorryy, a ddeevviiccee, a named ppiippee or ssoocckkeett, or a
ssyymmbboolliicc lliinnkk. Perl uses the "–f" file test operator to identify
regular files. Sometimes called a “plain” file.
relational operator
An ooppeerraattoorr that says whether a particular ordering relationship is
ttrruuee about a pair of ooppeerraannddss. Perl has both numeric and string
relational operators. See ccoollllaattiinngg sseeqquueennccee.
reserved words
A word with a specific, built-in meaning to a ccoommppiilleerr, such as "if"
or "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 llaabbeellss or
ffiilleehhaannddlleess. Also called “keywords”.
return value
The vvaalluuee produced by a ssuubbrroouuttiinnee or eexxpprreessssiioonn when evaluated. In
Perl, a return value may be either a lliisstt or a ssccaallaarr.
RFC Request For Comment, which despite the timid connotations is the name
of a series of important standards documents.
right shift
A bbiitt sshhiifftt that divides a number by some power of 2.
role
A name for a concrete set of behaviors. A role is a way to add
behavior to a class without inheritance.
root
The superuser ("UID" == 0). Also the top-level directory of the
filesystem.
RTFM #
What you are told when someone thinks you should Read The Fine
Manual.
run phase
Any time after Perl starts running your main program. See also
ccoommppiillee pphhaassee. Run phase is mostly spent in rruunnttiimmee but may also be
spent in ccoommppiillee ttiimmee when "require", "do" _"_F_I_L_E_", or "eval" _"_S_T_R_I_N_G_"
operators are executed, or when a substitution uses the "/ee"
modifier.
runtime
The time when Perl is actually doing what your code says to do, as
opposed to the earlier period of time when it was trying to figure
out whether what you said made any sense whatsoever, which is ccoommppiillee
ttiimmee.
runtime pattern
A pattern that contains one or more variables to be interpolated
before parsing the pattern as a rreegguullaarr eexxpprreessssiioonn, 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.
RV A recreational vehicle, not to be confused with vehicular recreation.
RV also means an internal Reference Value of the type a ssccaallaarr can
hold. See also IIVV and NNVV if you’re not confused yet.
rvalue
A vvaalluuee that you might find on the right side of an aassssiiggnnmmeenntt. See
also llvvaalluuee.
SS #
sandbox
A 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”.
scalar
A simple, singular value; a number, ssttrriinngg, or rreeffeerreennccee.
scalar context
The situation in which an eexxpprreessssiioonn is expected by its surroundings
(the code calling it) to return a single vvaalluuee rather than a lliisstt of
values. See also ccoonntteexxtt and lliisstt ccoonntteexxtt. A scalar context sometimes
imposes additional constraints on the return value—see ssttrriinngg ccoonntteexxtt
and nnuummeerriicc ccoonntteexxtt. Sometimes we talk about a BBoooolleeaann ccoonntteexxtt inside
conditionals, but this imposes no additional constraints, since any
scalar value, whether numeric or ssttrriinngg, is already true or false.
scalar literal
A number or quoted ssttrriinngg—an actual vvaalluuee in the text of your
program, as opposed to a vvaarriiaabbllee.
scalar value
A value that happens to be a ssccaallaarr as opposed to a lliisstt.
scalar variable
A vvaarriiaabbllee prefixed with "$" that holds a single value.
scope
From how far away you can see a variable, looking through one. Perl
has two visibility mechanisms. It does ddyynnaammiicc ssccooppiinngg of "local"
vvaarriiaabblleess, meaning that the rest of the bblloocckk, and any ssuubbrroouuttiinneess
that are called by the rest of the block, can see the variables that
are local to the block. Perl does lleexxiiccaall ssccooppiinngg of "my" variables,
meaning that the rest of the block can see the variable, but other
subroutines called by the block _c_a_n_n_o_t see the variable.
scratchpad
The area in which a particular invocation of a particular file or
subroutine keeps some of its temporary values, including any
lexically scoped variables.
script
A text ffiillee that is a program intended to be eexxeeccuutteedd directly rather
than ccoommppiilleedd to another form of file before eexxeeccuuttiioonn.
Also, in the context of UUnniiccooddee, a writing system for a particular
language or group of languages, such as Greek, Bengali, or Tengwar.
script kiddie
A ccrraacckkeerr who is not a hhaacckkeerr but knows just enough to run canned
scripts. A ccaarrggoo--ccuulltt programmer.
sed A venerable Stream EDitor from which Perl derives some of its ideas.
semaphore
A fancy kind of interlock that prevents multiple tthhrreeaaddss or pprroocceesssseess
from using up the same resources simultaneously.
separator
A cchhaarraacctteerr or ssttrriinngg that keeps two surrounding strings from being
confused with each other. The "split" function works on separators.
Not to be confused with ddeelliimmiitteerrss or tteerrmmiinnaattoorrss. The “or” in the
previous sentence separated the two alternatives.
serialization
Putting a fancy ddaattaa ssttrruuccttuurree into linear order so that it can be
stored as a ssttrriinngg in a disk file or database, or sent through a
ppiippee. Also called marshalling.
server
In networking, a pprroocceessss that either advertises a sseerrvviiccee or just
hangs around at a known location and waits for cclliieennttss who need
service to get in touch with it.
service
Something you do for someone else to make them happy, like giving
them the time of day (or of their life). On some machines, well-known
services are listed by the "getservent" function.
setgid
Same as sseettuuiidd, only having to do with giving away ggrroouupp privileges.
setuid
Said of a program that runs with the privileges of its oowwnneerr rather
than (as is usually the case) the privileges of whoever is running
it. Also describes the bit in the mode word (ppeerrmmiissssiioonn bbiittss) 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.
shared memory
A piece of mmeemmoorryy accessible by two different pprroocceesssseess who otherwise
would not see each other’s memory.
shebang
Irish for the whole McGillicuddy. In Perl culture, a portmanteau of
“sharp” and “bang”, meaning the "#!" sequence that tells the system
where to find the interpreter.
shell
A ccoommmmaanndd-line iinntteerrpprreetteerr. The program that interactively gives you
a prompt, accepts one or more lliinneess of input, and executes the
programs you mentioned, feeding each of them their proper aarrgguummeennttss
and input data. Shells can also execute scripts containing such
commands. Under Unix, typical shells include the Bourne shell
(_/_b_i_n_/_s_h), the C shell (_/_b_i_n_/_c_s_h), and the Korn shell (_/_b_i_n_/_k_s_h).
Perl is not strictly a shell because it’s not interactive (although
Perl programs can be interactive).
side effects
Something extra that happens when you evaluate an eexxpprreessssiioonn.
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 $| ($AUTOFLUSH) has the side effect of
forcing a flush after every "write" or "print" on the currently
selected filehandle.
sigil
A glyph used in magic. Or, for Perl, the symbol in front of a
variable name, such as "$", "@", and "%".
signal
A bolt out of the blue; that is, an event triggered by the ooppeerraattiinngg
ssyysstteemm, probably when you’re least expecting it.
signal handler
A ssuubbrroouuttiinnee that, instead of being content to be called in the
normal fashion, sits around waiting for a bolt out of the blue before
it will deign to eexxeeccuuttee. Under Perl, bolts out of the blue are
called signals, and you send them with the "kill" built-in. See the
%SIG hash in Camel chapter 25, “Special Names” and the section
“Signals” in Camel chapter 15, “Interprocess Communication”.
single inheritance
The features you got from your mother, if she told you that you don’t
have a father. (See also iinnhheerriittaannccee and mmuullttiippllee iinnhheerriittaannccee.) In
computer languages, the idea that ccllaasssseess reproduce asexually so that
a given class can only have one direct ancestor or bbaassee ccllaassss. Perl
supplies no such restriction, though you may certainly program Perl
that way if you like.
slice
A selection of any number of eelleemmeennttss from a lliisstt, aarrrraayy, or hhaasshh.
slurp
To read an entire ffiillee into a ssttrriinngg in one operation.
socket
An endpoint for network communication among multiple pprroocceesssseess that
works much like a telephone or a post office box. The most important
thing about a socket is its nneettwwoorrkk aaddddrreessss (like a phone number).
Different kinds of sockets have different kinds of addresses—some
look like filenames, and some don’t.
soft reference
See ssyymmbboolliicc rreeffeerreennccee.
source filter
A special kind of mmoodduullee that does pprreepprroocceessssiinngg on your script just
before it gets to the ttookkeenneerr.
stack
A device you can put things on the top of, and later take them back
off in the opposite order in which you put them on. See LLIIFFOO.
standard
Included in the official Perl distribution, as in a standard module,
a standard tool, or a standard Perl mmaannppaaggee.
standard error
The default output ssttrreeaamm for nasty remarks that don’t belong in
ssttaannddaarrdd oouuttppuutt. Represented within a Perl program by the output>
ffiilleehhaannddllee "STDERR". You can use this stream explicitly, but the
"die" and "warn" built-ins write to your standard error stream
automatically (unless trapped or otherwise intercepted).
standard input
The default input ssttrreeaamm for your program, which if possible
shouldn’t care where its data is coming from. Represented within a
Perl program by the ffiilleehhaannddllee "STDIN".
standard I/O
A standard C library for doing bbuuffffeerreedd input and output to the
ooppeerraattiinngg ssyysstteemm. (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
fflluusshh the buffer more often, just set the $| variable to a true
value.
Standard Library
Everything that comes with the official _p_e_r_l distribution. Some
vendor versions of _p_e_r_l change their distributions, leaving out some
parts or including extras. See also dduuaall--lliivveedd.
standard output
The default output ssttrreeaamm for your program, which if possible
shouldn’t care where its data is going. Represented within a Perl
program by the ffiilleehhaannddllee "STDOUT".
statement
A ccoommmmaanndd to the computer about what to do next, like a step in a
recipe: “Add marmalade to batter and mix until mixed.” A statement is
distinguished from a ddeeccllaarraattiioonn, which doesn’t tell the computer to
do anything, but just to learn something.
statement modifier
A ccoonnddiittiioonnaall or lloooopp that you put after the ssttaatteemmeenntt instead of
before, if you know what we mean.
static
Varying slowly compared to something else. (Unfortunately, everything
is relatively stable compared to something else, except for certain
elementary particles, and we’re not so sure about them.) In
computers, where things are supposed to vary rapidly, “static” has a
derogatory connotation, indicating a slightly dysfunctional vvaarriiaabbllee,
ssuubbrroouuttiinnee, or mmeetthhoodd. In Perl culture, the word is politely avoided.
If you’re a C or C++ programmer, you might be looking for Perl’s
"state" keyword.
static method
No such thing. See ccllaassss mmeetthhoodd.
static scoping
No such thing. See lleexxiiccaall ssccooppiinngg.
static variable
No such thing. Just use a lleexxiiccaall vvaarriiaabbllee in a scope larger than
your ssuubbrroouuttiinnee, or declare it with "state" instead of with "my".
stat structure
A special internal spot in which Perl keeps the information about the
last ffiillee on which you requested information.
status
The vvaalluuee returned to the parent pprroocceessss when one of its child
processes dies. This value is placed in the special variable $?. Its
upper eight bbiittss 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 _w_a_i_t(2). See "system" in Camel chapter 27,
“Functions”.
STDERR #
See ssttaannddaarrdd eerrrroorr.
STDIN #
See ssttaannddaarrdd iinnppuutt.
STDIO #
See ssttaannddaarrdd II//OO.
STDOUT #
See ssttaannddaarrdd oouuttppuutt.
stream
A flow of data into or out of a process as a steady sequence of bytes
or characters, without the appearance of being broken up into
packets. This is a kind of iinntteerrffaaccee—the underlying iimmpplleemmeennttaattiioonn
may well break your data up into separate packets for delivery, but
this is hidden from you.
string
A sequence of characters such as “He said !@#*&%@#*?!”. A string
does not have to be entirely printable.
string context
The situation in which an expression is expected by its surroundings
(the code calling it) to return a ssttrriinngg. See also ccoonntteexxtt and
nnuummeerriicc ccoonntteexxtt.
stringification
The process of producing a ssttrriinngg representation of an abstract
object.
struct
C keyword introducing a structure definition or name.
structure
See ddaattaa ssttrruuccttuurree.
subclass
See ddeerriivveedd ccllaassss.
subpattern
A component of a rreegguullaarr eexxpprreessssiioonn pattern.
subroutine
A 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 aarrgguummeennttss. If the
subroutine returns a meaningful vvaalluuee, it is also called a ffuunnccttiioonn.
subscript
A vvaalluuee that indicates the position of a particular aarrrraayy eelleemmeenntt in
an array.
substitution
Changing parts of a string via the "s///" operator. (We avoid use of
this term to mean vvaarriiaabbllee iinntteerrppoollaattiioonn.)
substring
A portion of a ssttrriinngg, starting at a certain cchhaarraacctteerr position
(ooffffsseett) and proceeding for a certain number of characters.
superclass
See bbaassee ccllaassss.
superuser
The person whom the ooppeerraattiinngg ssyysstteemm will let do almost anything.
Typically your system administrator or someone pretending to be your
system administrator. On Unix systems, the rroooott user. On Windows
systems, usually the Administrator user.
SV Short for “scalar value”. But within the Perl interpreter, every
rreeffeerreenntt is treated as a member of a class derived from SV, in an
object-oriented sort of way. Every vvaalluuee inside Perl is passed around
as a C language "SV*" pointer. The SV ssttrruucctt knows its own “referent
type”, and the code is smart enough (we hope) not to try to call a
hhaasshh function on a ssuubbrroouuttiinnee.
switch
An option you give on a command line to influence the way your
program works, usually introduced with a minus sign. The word is
also used as a nickname for a sswwiittcchh ssttaatteemmeenntt.
switch cluster
The combination of multiple command- line switches (_e_._g_., "–a –b –c")
into one switch (_e_._g_., "–abc"). Any switch with an additional
aarrgguummeenntt must be the last switch in a cluster.
switch statement
A program technique that lets you evaluate an eexxpprreessssiioonn 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 "given". See “The "given" statement”
in Camel chapter 4, “Statements and Declarations”.
symbol
Generally, any ttookkeenn or mmeettaassyymmbbooll. Often used more specifically to
mean the sort of name you might find in a ssyymmbbooll ttaabbllee.
symbolic debugger
A program that lets you step through the eexxeeccuuttiioonn 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.
symbolic link
An alternate filename that points to the real ffiilleennaammee, which in turn
points to the real ffiillee. Whenever the ooppeerraattiinngg ssyysstteemm is trying to
parse a ppaatthhnnaammee containing a symbolic link, it merely substitutes
the new name and continues parsing.
symbolic reference
A variable whose value is the name of another variable or subroutine.
By ddeerreeffeerreenncciinngg the first variable, you can get at the second one.
Symbolic references are illegal under "use strict "refs"".
symbol table
Where a ccoommppiilleerr remembers symbols. A program like Perl must somehow
remember all the names of all the vvaarriiaabblleess, ffiilleehhaannddlleess, and
ssuubbrroouuttiinneess you’ve used. It does this by placing the names in a
symbol table, which is implemented in Perl using a hhaasshh ttaabbllee. There
is a separate symbol table for each ppaacckkaaggee to give each package its
own nnaammeessppaaccee.
synchronous
Programming in which the orderly sequence of events can be
determined; that is, when things happen one after the other, not at
the same time.
syntactic sugar
An alternative way of writing something more easily; a shortcut.
syntax
From Greek σύνταξις, “with-arrangement”. How things (particularly
symbols) are put together with each other.
syntax tree
An internal representation of your program wherein lower-level
ccoonnssttrruuccttss dangle off the higher-level constructs enclosing them.
syscall
A ffuunnccttiioonn call directly to the ooppeerraattiinngg ssyysstteemm. 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 $!
($ERRNO) variable on failure. Unfortunately, beginning programmers
often confusingly employ the term “system call” to mean what happens
when you call the Perl "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 "syscall"
function, and never for something you would call with Perl’s "system"
function.
TT #
taint checks
The special bookkeeping Perl does to track the flow of external data
through your program and disallow their use in system commands.
tainted
Said of data derived from the grubby hands of a user, and thus unsafe
for a secure program to rely on. Perl does taint checks if you run a
sseettuuiidd (or sseettggiidd) program, or if you use the "–T" switch.
taint mode
Running under the "–T" switch, marking all external data as suspect
and refusing to use it with system commands. See Camel chapter 20,
“Security”.
TCP Short for Transmission Control Protocol. A protocol wrapped around
the Internet Protocol to make an unreliable packet transmission
mechanism appear to the application program to be a reliable ssttrreeaamm
of bytes. (Usually.)
term
Short for a “terminal”—that is, a leaf node of a ssyynnttaaxx ttrreeee. A thing
that functions grammatically as an ooppeerraanndd for the operators in an
expression.
terminator
A cchhaarraacctteerr or ssttrriinngg that marks the end of another string. The $/
variable contains the string that terminates a "readline" operation,
which "chomp" deletes from the end. Not to be confused with
ddeelliimmiitteerrss or sseeppaarraattoorrss. The period at the end of this sentence is a
terminator.
ternary
An ooppeerraattoorr taking three ooppeerraannddss. Sometimes pronounced ttrriinnaarryy.
text
A ssttrriinngg or ffiillee containing primarily printable characters.
thread
Like a forked process, but without ffoorrkk’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.
tie The bond between a magical variable and its implementation class. See
the "tie" function in Camel chapter 27, “Functions” and Camel chapter
14, “Tied Variables”.
titlecase
The case 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.
TMTOWTDI #
There’s More Than One Way To Do It, the Perl Motto. The notion that
there can be more than one valid path to solving a programming
problem in context. (This doesn’t mean that more ways are always
better or that all possible paths are equally desirable—just that
there need not be One True Way.)
token
A morpheme in a programming language, the smallest unit of text with
semantic significance.
tokener
A module that breaks a program text into a sequence of ttookkeennss for
later analysis by a parser.
tokenizing
Splitting up a program text into ttookkeennss. Also known as “lexing”, in
which case you get “lexemes” instead of tokens.
toolbox approach
The notion that, with a complete set of simple tools that work well
together, you can build almost anything you want. Which is fine if
you’re assembling a tricycle, but if you’re building a defranishizing
comboflux regurgalator, you really want your own machine shop in
which to build special tools. Perl is sort of a machine shop.
topic
The thing you’re working on. Structures like "while(<>)", "for",
"foreach", and "given" set the topic for you by assigning to $_, the
default (_t_o_p_i_c) variable.
transliterate
To turn one 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 _π_ο_λ_ύ_χ_ρ_ω_μ_ο_ς transliterates into _p_o_l_y_c_h_r_o_m_o_s but translates into
_m_a_n_y_-_c_o_l_o_r_e_d. See the "tr///" operator in Camel chapter 5, “Pattern
Matching”.
trigger
An event that causes a hhaannddlleerr to be run.
trinary
Not a stellar system with three stars, but an ooppeerraattoorr taking three
ooppeerraannddss. Sometimes pronounced tteerrnnaarryy.
troff
A venerable typesetting language from which Perl derives the name of
its $% variable and which is secretly used in the production of Camel
books.
true
Any scalar value that doesn’t evaluate to 0 or "".
truncating
Emptying a file of existing contents, either automatically when
opening a file for writing or explicitly via the "truncate" function.
type
See ddaattaa ttyyppee and ccllaassss.
type casting
Converting data from one type to another. C permits this. Perl does
not need it. Nor want it.
typedef
A type definition in the C and C++ languages.
typed lexical
A lleexxiiccaall vvaarriiaabbllee lexical>that is declared with a ccllaassss type: "my
Pony $bill".
typeglob
Use of a single identifier, prefixed with "*". For example, *name
stands for any or all of $name, @name, %name, &name, or just "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”.
typemap
A description of how C types may be transformed to and from Perl
types within an eexxtteennssiioonn module written in XXSS.
UU #
UDP User Datagram Protocol, the typical way to send ddaattaaggrraammss over the
Internet.
UID A user ID. Often used in the context of ffiillee or pprroocceessss ownership.
umask
A mask of those ppeerrmmiissssiioonn bbiittss 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 "umask" function.
unary operator
An operator with only one ooppeerraanndd, like "!" or "chdir". Unary
operators are usually prefix operators; that is, they precede their
operand. The "++" and "––" operators can be either prefix or postfix.
(Their position _d_o_e_s change their meanings.)
Unicode
A character set comprising all the major character sets of the world,
more or less. See <http://www.unicode.org>.
Unix
A very large and constantly evolving language with several
alternative and largely incompatible syntaxes, in which anyone can
define anything any way they choose, and usually do. Speakers of this
language think it’s easy to learn because it’s so easily twisted to
one’s own ends, but dialectical differences make tribal
intercommunication nearly impossible, and travelers are often reduced
to a pidgin-like subset of the language. To be universally
understood, a Unix shell programmer must spend years of study in the
art. Many have abandoned this discipline and now communicate via an
Esperanto-like language called Perl.
In ancient times, Unix was also used to refer to some code that a
couple of people at Bell Labs wrote to make use of a PDP-7 computer
that wasn’t doing much of anything else at the time.
uppercase
In Unicode, 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
ttiittlleeccaassee.
VV #
value
An actual piece of data, in contrast to all the variables,
references, keys, indices, operators, and whatnot that you need to
access the value.
variable
A named storage location that can hold any of various kinds of vvaalluuee,
as your program sees fit.
variable interpolation
The iinntteerrppoollaattiioonn of a scalar or array variable into a string.
variadic
Said of a ffuunnccttiioonn that happily receives an indeterminate number of
aaccttuuaall aarrgguummeennttss.
vector
Mathematical jargon for a list of ssccaallaarr vvaalluueess.
virtual
Providing the appearance of something without the reality, as in:
virtual memory is not real memory. (See also mmeemmoorryy.) 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.
void context
A form of ssccaallaarr ccoonntteexxtt in which an eexxpprreessssiioonn is not expected to
return any vvaalluuee at all and is evaluated for its ssiiddee eeffffeeccttss alone.
v-string
A “version” or “vector” ssttrriinngg specified with a "v" followed by a
series of decimal integers in dot notation, for instance,
"v1.20.300.4000". Each number turns into a cchhaarraacctteerr with the
specified ordinal value. (The "v" is optional when there are at least
three integers.)
WW #
warning
A message printed to the "STDERR" stream to the effect that something
might be wrong but isn’t worth blowing up over. See "warn" in Camel
chapter 27, “Functions” and the "warnings" pragma in Camel chapter
28, “Pragmantic Modules”.
watch expression
An expression which, when its value changes, causes a breakpoint in
the Perl debugger.
weak reference
A 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.
whitespace
A cchhaarraacctteerr 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 ɴ-ʙʀ .
word
In normal “computerese”, the piece of data of the size most
efficiently handled by your computer, typically 32 bits or so, give
or take a few powers of 2. In Perl culture, it more often refers to
an alphanumeric iiddeennttiiffiieerr (including underscores), or to a string of
nonwhitespace cchhaarraacctteerrss bounded by whitespace or string boundaries.
working directory
Your current ddiirreeccttoorryy, from which relative pathnames are interpreted
by the ooppeerraattiinngg ssyysstteemm. The operating system knows your current
directory because you told it with a "chdir", or because you started
out in the place where your parent pprroocceessss was when you were born.
wrapper
A program or subroutine that runs some other program or subroutine
for you, modifying some of its input or output to better suit your
purposes.
WYSIWYG #
What You See Is What You Get. Usually used when something that
appears on the screen matches how it will eventually look, like
Perl’s "format" declarations. Also used to mean the opposite of magic
because everything works exactly as it appears, as in the three-
argument form of "open".
XX #
XS An extraordinarily exported, expeditiously excellent, expressly
eXternal Subroutine, executed in existing C or C++ or in an exciting
extension language called (exasperatingly) XS.
XSUB #
An external ssuubbrroouuttiinnee defined in XXSS.
YY #
yacc
Yet Another Compiler Compiler. A parser generator without which Perl
probably would not have existed. See the file _p_e_r_l_y_._y in the Perl
source distribution.
ZZ #
zero width
A subpattern aasssseerrttiioonn matching the nnuullll ssttrriinngg between cchhaarraacctteerrss.
zombie
A process that has died (exited) but whose parent has not yet
received proper notification of its demise by virtue of having called
"wait" or "waitpid". If you "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.
AAUUTTHHOORR AANNDD CCOOPPYYRRIIGGHHTT #
Based on the Glossary of _P_r_o_g_r_a_m_m_i_n_g _P_e_r_l, 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.
perl v5.36.3 2023-02-15 PERLGLOSSARY(1)