diff options
Diffstat (limited to 'upstream/mageia-cauldron/man1/perlglossary.1')
| -rw-r--r-- | upstream/mageia-cauldron/man1/perlglossary.1 | 3678 |
1 files changed, 3678 insertions, 0 deletions
diff --git a/upstream/mageia-cauldron/man1/perlglossary.1 b/upstream/mageia-cauldron/man1/perlglossary.1 new file mode 100644 index 00000000..7f57973f --- /dev/null +++ b/upstream/mageia-cauldron/man1/perlglossary.1 @@ -0,0 +1,3678 @@ +.\" -*- mode: troff; coding: utf-8 -*- +.\" Automatically generated by Pod::Man 5.01 (Pod::Simple 3.43) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. +.ie n \{\ +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds C` +. ds C' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is >0, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.\" +.\" Avoid warning from groff about undefined register 'F'. +.de IX +.. +.nr rF 0 +.if \n(.g .if rF .nr rF 1 +.if (\n(rF:(\n(.g==0)) \{\ +. if \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. if !\nF==2 \{\ +. nr % 0 +. nr F 2 +. \} +. \} +.\} +.rr rF +.\" ======================================================================== +.\" +.IX Title "PERLGLOSSARY 1" +.TH PERLGLOSSARY 1 2023-11-28 "perl v5.38.2" "Perl Programmers Reference Guide" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH NAME +perlglossary \- Perl Glossary +.SH VERSION +.IX Header "VERSION" +version 5.20210520 +.SH DESCRIPTION +.IX Header "DESCRIPTION" +A glossary of terms (technical and otherwise) used in the Perl +documentation, derived from the Glossary of \fIProgramming +Perl\fR, Fourth Edition. Words or phrases in bold are defined elsewhere in +this glossary. +.PP +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/>. +.SS A +.IX Subsection "A" +.IP "accessor methods" 4 +.IX Item "accessor methods" +A \fBmethod\fR used to +indirectly inspect or update an \fBobject\fR’s state (its \fBinstance +variables\fR). +.IX Xref "accessor methods, defined methods, accessor" +.IP "actual arguments" 4 +.IX Item "actual arguments" +The \fBscalar values\fR that you supply +to a \fBfunction\fR or \fBsubroutine\fR when you call it. For instance, when you +call \f(CWpower("puff")\fR, the string \f(CW"puff"\fR is the actual argument. See also +\&\fBargument\fR and \fBformal arguments\fR. +.IX Xref "actual arguments arguments, actual" +.IP "address operator" 4 +.IX Item "address operator" +Some languages work directly with the memory addresses of +values, but this can be like playing with fire. Perl provides a set of +asbestos gloves for handling all memory management. The closest to an +address operator in Perl is the backslash operator, but it gives you a +\&\fBhard reference\fR, which is much safer than a memory address. +.IX Xref "address operator" +.IP algorithm 4 +.IX Item "algorithm" +A well-defined sequence of steps, explained clearly +enough that even a computer could do them. +.IX Xref "algorithms (term)" +.IP alias 4 +.IX Item "alias" +A nickname for something, which behaves in all ways as +though you’d used the original name instead of the nickname. Temporary +aliases are implicitly created in the loop variable for \f(CW\*(C`foreach\*(C'\fR loops, in +the \f(CW$_\fR variable for \f(CW\*(C`map\*(C'\fR or \f(CW\*(C`grep\*(C'\fR operators, in \f(CW$a\fR and \f(CW$b\fR +during \f(CW\*(C`sort\*(C'\fR’s comparison function, and in each element of \f(CW@_\fR for the +\&\fBactual arguments\fR of a subroutine call. Permanent aliases are explicitly +created in \fBpackages\fR by \fBimporting\fR symbols or by assignment to +\&\fBtypeglobs\fR. Lexically scoped aliases for package variables are explicitly +created by the \f(CW\*(C`our\*(C'\fR declaration. +.IX Xref "aliases, defined" +.IP alphabetic 4 +.IX Item "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. +.IX Xref "alphabetic sort" +.IP alternatives 4 +.IX Item "alternatives" +A list of possible choices from which you may +select only one, as in, “Would you like door A, B, or C?” Alternatives in +regular expressions are separated with a single vertical bar: \f(CW\*(C`|\*(C'\fR. +Alternatives in normal Perl expressions are separated with a double vertical +bar: \f(CW\*(C`||\*(C'\fR. Logical alternatives in \fBBoolean\fR expressions are separated +with either \f(CW\*(C`||\*(C'\fR or \f(CW\*(C`or\*(C'\fR. +.IX Xref "alternative characters" +.IP anonymous 4 +.IX Item "anonymous" +Used to describe a \fBreferent\fR +that is not directly accessible through a named \fBvariable\fR. Such a referent +must be indirectly accessible through at least one \fBhard reference\fR. When +the last hard reference goes away, the anonymous referent is destroyed +without pity. +.IX Xref "anonymous referents referents, anonymous" +.IP application 4 +.IX Item "application" +A bigger, fancier sort of \fBprogram\fR with a fancier +name so people don’t realize they are using a program. +.IX Xref "applications (term)" +.IP architecture 4 +.IX Item "architecture" +The kind of computer you’re working on, where one “kind of +computer” means all those computers sharing a compatible machine language. +Since Perl programs are (typically) simple text files, not executable +images, a Perl program is much less sensitive to the architecture it’s +running on than programs in other languages, such as C, that are \fBcompiled\fR +into machine code. See also \fBplatform\fR and \fBoperating system\fR. +.IX Xref "architecture" +.IP argument 4 +.IX Item "argument" +A piece of data supplied to a \fBprogram\fR, +\&\fBsubroutine\fR, \fBfunction\fR, or \fBmethod\fR to tell it what it’s supposed to +do. Also called a “parameter”. +.IX Xref "arguments, defined" +.IP ARGV 4 +.IX Item "ARGV" +The name of the array containing the \fBargument\fR \fBvector\fR +from the command line. If you use the empty \f(CW\*(C`<>\*(C'\fR operator, \f(CW\*(C`ARGV\*(C'\fR +is the name of both the \fBfilehandle\fR used to traverse the arguments and the +\&\fBscalar\fR containing the name of the current input file. +.IX Xref "ARGV filehandle" +.IP "arithmetical operator" 4 +.IX Item "arithmetical operator" +A \fBsymbol\fR such as \f(CW\*(C`+\*(C'\fR or \f(CW\*(C`/\*(C'\fR that tells +Perl to do the arithmetic you were supposed to learn in grade school. +.IX Xref "arithmetic operators, about" +.IP array 4 +.IX Item "array" +An ordered sequence of \fBvalues\fR, stored such that you can +easily access any of the values using an \fIinteger subscript\fR that specifies +the value’s \fBoffset\fR in the sequence. +.IX Xref "arrays, defined" +.IP "array context" 4 +.IX Item "array context" +An archaic expression for what is more correctly referred to +as \fBlist context\fR. +.IX Xref "array context" +.IP "Artistic License" 4 +.IX Item "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>). +.IX Xref "Artistic License Wall, Larry" +.IP ASCII 4 +.IX Item "ASCII" +The American Standard Code for +Information Interchange (a 7\-bit character set adequate only for poorly +representing English text). Often used loosely to describe the lowest 128 +values of the various ISO\-8859\-X character sets, a bunch of mutually +incompatible 8\-bit codes best described as half ASCII. See also \fBUnicode\fR. +.IX Xref "ASCII (American Standard Code for Information Interchange) American Standard Code for Information Interchange (ASCII)" +.IP assertion 4 +.IX Item "assertion" +A component of a \fBregular expression\fR that must be true for the pattern to +match but does not necessarily match any characters itself. Often used +specifically to mean a \fBzero-width\fR assertion. +.IX Xref "assertions (in regexes), defined regular expressions, assertions in" +.IP assignment 4 +.IX Item "assignment" +An \fBoperator\fR whose assigned mission in life is to +change the value of a \fBvariable\fR. +.IX Xref "assignments, defined" +.IP "assignment operator" 4 +.IX Item "assignment operator" +Either a regular \fBassignment\fR or a compound +\&\fBoperator\fR 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, \f(CW\*(C`$a += 2\*(C'\fR adds \f(CW2\fR to \f(CW$a\fR. +.IX Xref "assignment operators, about" +.IP "associative array" 4 +.IX Item "associative array" +See \fBhash\fR. Please. The term associative array is the +old Perl 4 term for a \fBhash\fR. Some languages call it a dictionary. +.IX Xref "associative arrays" +.IP associativity 4 +.IX Item "associativity" +Determines whether you do the left \fBoperator\fR first or the +right \fBoperator\fR first when you have “A \fBoperator\fR B \fBoperator\fR C”, and +the two operators are of the same precedence. Operators like \f(CW\*(C`+\*(C'\fR are left +associative, while operators like \f(CW\*(C`**\*(C'\fR are right associative. See Camel +chapter 3, “Unary and Binary Operators” for a list of operators and their +associativity. +.IX Xref "associativity" +.IP asynchronous 4 +.IX Item "asynchronous" +Said of events or activities whose relative +temporal ordering is indeterminate because too many things are going on at +once. Hence, an asynchronous event is one you didn’t know when to expect. +.IX Xref "asynchronous event processing" +.IP atom 4 +.IX Item "atom" +A \fBregular expression\fR component potentially matching a +\&\fBsubstring\fR containing one or more characters and treated as an indivisible +syntactic unit by any following \fBquantifier\fR. (Contrast with an +\&\fBassertion\fR that matches something of \fBzero width\fR and may not be quantified.) +.IX Xref "atoms" +.IP "atomic operation" 4 +.IX Item "atomic operation" +When Democritus gave the word “atom” to the indivisible +bits of matter, he meant literally something that could not be cut: \fIἀ\-\fR +(not) + \fI\-τομος\fR (cuttable). An atomic operation is an action that can’t be +interrupted, not one forbidden in a nuclear-free zone. +.IX Xref "atomic operation" +.IP attribute 4 +.IX Item "attribute" +A new feature that allows the declaration of +\&\fBvariables\fR and \fBsubroutines\fR with modifiers, as in \f(CW\*(C`sub foo : locked +method\*(C'\fR. Also another name for an \fBinstance variable\fR of an \fBobject\fR. +.IX Xref "attribute feature" +.IP autogeneration 4 +.IX Item "autogeneration" +A feature of \fBoperator overloading\fR of \fBobjects\fR, +whereby the behavior of certain \fBoperators\fR 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”. +.IX Xref "autogeneration, about" +.IP autoincrement 4 +.IX Item "autoincrement" +To add one to something automatically, hence the name +of the \f(CW\*(C`++\*(C'\fR operator. To instead subtract one from something automatically +is known as an “autodecrement”. +.IX Xref "autoincrement (term)" +.IP autoload 4 +.IX Item "autoload" +To load on demand. (Also called “lazy” loading.) +Specifically, to call an \f(CW\*(C`AUTOLOAD\*(C'\fR subroutine on behalf of an undefined +subroutine. +.IX Xref "autoloading, defined" +.IP autosplit 4 +.IX Item "autosplit" +To split a string automatically, as the \fI–a\fR \fBswitch\fR +does when running under \fI–p\fR or \fI–n\fR in order to emulate \fBawk\fR. (See also +the \f(CW\*(C`AutoSplit\*(C'\fR module, which has nothing to do with the +\&\f(CW\*(C`–a\*(C'\fR switch but a lot to do with autoloading.) +.IX Xref "autosplit (term) AutoSplit module" +.IP autovivification 4 +.IX Item "autovivification" +A Graeco-Roman word meaning “to bring oneself to life”. +In Perl, storage locations (\fBlvalues\fR) spontaneously generate themselves as +needed, including the creation of any \fBhard reference\fR values to point to +the next level of storage. The assignment \f(CW\*(C`$a[5][5][5][5][5] = "quintet"\*(C'\fR +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. +.IX Xref "autovivification" +.IP AV 4 +.IX Item "AV" +Short for “array +value”, which refers to one of Perl’s internal data types that holds an +\&\fBarray\fR. The \f(CW\*(C`AV\*(C'\fR type is a subclass of \fBSV\fR. +.IX Xref "AV (array value) array value (AV) values, array" +.IP awk 4 +.IX Item "awk" +Descriptive editing term—short for “awkward”. Also +coincidentally refers to a venerable text-processing language from which +Perl derived some of its high-level ideas. +.IX Xref "awk (editing term)" +.SS B +.IX Subsection "B" +.IP backreference 4 +.IX Item "backreference" +A substring \fBcaptured\fR +by a subpattern within unadorned parentheses in a \fBregex\fR. Backslashed +decimal numbers (\f(CW\*(C`\e1\*(C'\fR, \f(CW\*(C`\e2\*(C'\fR, etc.) later in the same pattern refer back to +the corresponding subpattern in the current match. Outside the pattern, the +numbered variables (\f(CW$1\fR, \f(CW$2\fR, etc.) continue to refer to these same +values, as long as the pattern was the last successful match of the current +\&\fBdynamic scope\fR. +.IX Xref "backreferences, about references, backreferences" +.IP backtracking 4 +.IX Item "backtracking" +The practice of saying, “If I had to do it all over, I’d do +it differently,” and then actually going back and doing it all over +differently. Mathematically speaking, it’s returning from an unsuccessful +recursion on a tree of possibilities. Perl backtracks when it attempts to +match patterns with a \fBregular expression\fR, and its earlier attempts don’t +pan out. See the section “The Little Engine That /Couldn(n’t)” in Camel +chapter 5, “Pattern Matching”. +.IX Xref "backtracking" +.IP "backward compatibility" 4 +.IX Item "backward compatibility" +Means you can still run your old program +because we didn’t break any of the features or bugs it was relying on. +.IX Xref "backward compatibility, defined" +.IP bareword 4 +.IX Item "bareword" +A word sufficiently ambiguous to be deemed illegal under +\&\f(CW\*(C`use strict \*(Aqsubs\*(Aq\*(C'\fR. In the absence of that stricture, a bareword is +treated as if quotes were around it. +.IX Xref "barewords, about" +.IP "base class" 4 +.IX Item "base class" +A generic \fBobject\fR type; that is, a \fBclass\fR +from which other, more specific classes are derived genetically by +\&\fBinheritance\fR. Also called a +“superclass” by people who respect their ancestors. +.IX Xref "base classes classes, base superclasses classes, superclasses" +.IP big-endian 4 +.IX Item "big-endian" +From Swift: someone who +eats eggs big end first. Also used of computers that store the most +significant \fBbyte\fR of a word at a lower byte address than the least +significant byte. Often considered superior to little-endian machines. See +also \fBlittle-endian\fR. +.IX Xref "big–endian, defined endianness, big–endian" +.IP binary 4 +.IX Item "binary" +Having to do with numbers represented in base 2. That means +there’s basically two numbers: 0 and 1. Also used to describe a file of +“nontext”, presumably because such a file makes full use of all the binary +bits in its bytes. With the advent of \fBUnicode\fR, this distinction, already +suspect, loses even more of its meaning. +.IX Xref "binary (term)" +.IP "binary operator" 4 +.IX Item "binary operator" +An \fBoperator\fR that takes two \fBoperands\fR. +.IX Xref "binary operators, about" +.IP bind 4 +.IX Item "bind" +To assign a specific \fBnetwork address\fR to a \fBsocket\fR. +.IX Xref "bind (term)" +.IP bit 4 +.IX Item "bit" +An integer in the range from 0 to 1, inclusive. The smallest +possible unit of information storage. An eighth of a \fBbyte\fR 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”.) +.IX Xref "bits, defined" +.IP "bit shift" 4 +.IX Item "bit shift" +The movement of bits left or right in a +computer word, which has the effect of multiplying or dividing by a +power of 2. +.IX Xref "bit–shift operators, defined" +.IP "bit string" 4 +.IX Item "bit string" +A sequence of \fBbits\fR that is actually being thought of as a +sequence of bits, for once. +.IX Xref "bit string" +.IP bless 4 +.IX Item "bless" +In corporate life, to grant official +approval to a thing, as in, “The VP of Engineering has blessed our +WebCruncher project.” Similarly, in Perl, to grant official approval to a +\&\fBreferent\fR so that it can function as an \fBobject\fR, such as a WebCruncher +object. See the \f(CW\*(C`bless\*(C'\fR function in Camel chapter 27, “Functions”. +.IX Xref "bless function, about bless (term)" +.IP block 4 +.IX Item "block" +What a \fBprocess\fR 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 \fBoperating system\fR 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. +.IX Xref "blocks, defined" +.IP BLOCK 4 +.IX Item "BLOCK" +A syntactic construct +consisting of a sequence of Perl \fBstatements\fR that is delimited by braces. +The \f(CW\*(C`if\*(C'\fR and \f(CW\*(C`while\*(C'\fR statements are defined in terms of \fR\f(CI\*(C`BLOCK\*(C'\fR\fI\fRs, for +instance. Sometimes we also say “block” to mean a lexical scope; that is, a +sequence of statements that acts like a \fI\fR\f(CI\*(C`BLOCK\*(C'\fR\fI\fR, such as within an +\&\f(CW\*(C`eval\*(C'\fR or a file, even though the statements aren’t delimited by braces. +.IX Xref "BLOCK construct, about constructs, BLOCK" +.IP "block buffering" 4 +.IX Item "block buffering" +A method of making input and output +efficient by passing one \fBblock\fR at a time. By default, Perl does block +buffering to disk files. See \fBbuffer\fR and \fBcommand buffering\fR. +.IX Xref "block buffering buffering, block" +.IP Boolean 4 +.IX Item "Boolean" +A value that is either \fBtrue\fR or +\&\fBfalse\fR. +.IX Xref "Boolean values values, Boolean" +.IP "Boolean context" 4 +.IX Item "Boolean context" +A special kind of \fBscalar +context\fR used in conditionals to decide whether the \fBscalar value\fR returned +by an expression is \fBtrue\fR or \fBfalse\fR. Does not evaluate as either a +string or a number. See \fBcontext\fR. +.IX Xref "Boolean context, about context, Boolean" +.IP breakpoint 4 +.IX Item "breakpoint" +A spot in your program where you’ve told the debugger +to stop \fBexecution\fR so you can poke around and see whether anything is +wrong yet. +.IX Xref "breakpoints, defined" +.IP broadcast 4 +.IX Item "broadcast" +To send a \fBdatagram\fR to multiple destinations +simultaneously. +.IX Xref "broadcast (networking term)" +.IP BSD 4 +.IX Item "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”. +.IX Xref "BSD (Berkeley Standard Distribution) Berkeley Standard Distribution (BSD)" +.IP bucket 4 +.IX Item "bucket" +A location in a \fBhash table\fR 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.) +.IX Xref "buckets (term)" +.IP buffer 4 +.IX Item "buffer" +A temporary holding location for data. Data that are +\&\fBBlock buffering\fR means that the data is passed on to its destination +whenever the buffer is full. \fBLine buffering\fR means that it’s passed on +whenever a complete line is received. \fBCommand buffering\fR means that it’s +passed every time you do a \f(CW\*(C`print\*(C'\fR 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. +.IX Xref "buffers, defined" +.IP built-in 4 +.IX Item "built-in" +A \fBfunction\fR that is predefined in the +language. Even when hidden by \fBoverriding\fR, you can always get at a built\- +in function by \fBqualifying\fR its name with the \f(CW\*(C`CORE::\*(C'\fR pseudopackage. +.IX Xref "built–in functions, about" +.IP bundle 4 +.IX Item "bundle" +A group of related modules on \fBCPAN\fR. (Also sometimes +refers to a group of command-line switches grouped into one \fBswitch +cluster\fR.) +.IX Xref "bundles (term)" +.IP byte 4 +.IX Item "byte" +A piece of data worth eight \fBbits\fR in most places. +.IX Xref "bytes (term)" +.IP bytecode 4 +.IX Item "bytecode" +A pidgin-like lingo spoken among ’droids when they don’t wish to reveal +their orientation (see \fBendian\fR). 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. +.SS C +.IX Subsection "C" +.IP C 4 +.IX Item "C" +A language beloved by many for its inside-out \fBtype\fR +definitions, inscrutable \fBprecedence\fR rules, and heavy \fBoverloading\fR 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. +.IX Xref "C language, about" +.IP cache 4 +.IX Item "cache" +A data repository. Instead of computing expensive answers +several times, compute it once and save the result. +.IX Xref "cache (term)" +.IP callback 4 +.IX Item "callback" +A \fBhandler\fR that you register with some other part of your +program in the hope that the other part of your program will \fBtrigger\fR your +handler when some event of interest transpires. +.IX Xref "callbacks" +.IP "call by reference" 4 +.IX Item "call by reference" +An \fBargument\fR\-passing mechanism in which the \fBformal arguments\fR refer directly to the +\&\fBactual arguments\fR, and the \fBsubroutine\fR can change the actual arguments +by changing the formal arguments. That is, the formal argument is an +\&\fBalias\fR for the actual argument. See also \fBcall by value\fR. +.IX Xref "call by reference references, call by reference mechanism" +.IP "call by value" 4 +.IX Item "call by value" +An \fBargument\fR\-passing mechanism in which the \fBformal +arguments\fR refer to a copy of the \fBactual arguments\fR, and the +\&\fBsubroutine\fR cannot change the actual arguments by changing the formal +arguments. See also \fBcall by reference\fR. +.IX Xref "call by value" +.IP canonical 4 +.IX Item "canonical" +Reduced to a standard form to facilitate comparison. +.IX Xref "canonical (term)" +.IP "capture variables" 4 +.IX Item "capture variables" +The variables—such as \f(CW$1\fR and +\&\f(CW$2\fR, and \f(CW\*(C`%+\*(C'\fR and \f(CW\*(C`%– \*(C'\fR—that hold the text remembered in a pattern +match. See Camel chapter 5, “Pattern Matching”. +.IX Xref "capture variables variables, capture" +.IP capturing 4 +.IX Item "capturing" +The use of parentheses around a \fBsubpattern\fR in a +\&\fBregular expression\fR to store the matched \fBsubstring\fR as a +\&\fBbackreference\fR. (Captured strings are also returned as a list in \fBlist +context\fR.) See Camel chapter 5, “Pattern Matching”. +.IX Xref "capturing in pattern matching subpatterns, capturing pattern matching, capturing in" +.IP "cargo cult" 4 +.IX Item "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 \fIThe Gods Must Be Crazy\fR. +.IX Xref "cargo cult" +.IP case 4 +.IX Item "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: \fBlowercase\fR (\fBcharacter property\fR \f(CW\*(C`\ep{lower}\*(C'\fR), \fBtitlecase\fR +(\f(CW\*(C`\ep{title}\*(C'\fR), and \fBuppercase\fR (\f(CW\*(C`\ep{upper}\*(C'\fR). A fourth casemapping called +\&\fBfoldcase\fR is not itself a distinct case, but it is used internally to +implement \fBcasefolding\fR. Not all letters have case, and some nonletters +have case. +.IX Xref "case (character) characters, case considerations" +.IP casefolding 4 +.IX Item "casefolding" +Comparing or matching a string case-insensitively. In Perl, it +is implemented with the \f(CW\*(C`/i\*(C'\fR pattern modifier, the \f(CW\*(C`fc\*(C'\fR function, and the +\&\f(CW\*(C`\eF\*(C'\fR double-quote translation escape. +.IX Xref "casefolding" +.IP casemapping 4 +.IX Item "casemapping" +The process of converting a string to one of the four Unicode +\&\fBcasemaps\fR; in Perl, it is implemented with the \f(CW\*(C`fc\*(C'\fR, \f(CW\*(C`lc\*(C'\fR, \f(CW\*(C`ucfirst\*(C'\fR, +and \f(CW\*(C`uc\*(C'\fR functions. +.IX Xref "casemapping" +.IP character 4 +.IX Item "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 +\&\fBcodepoint\fR. +.IX Xref "characters, defined" +.IP "character class" 4 +.IX Item "character class" +A square-bracketed list of +characters used in a \fBregular expression\fR to indicate that any character +of the set may occur at a given point. Loosely, any predefined set of +characters so used. +.IX Xref "character classes, about classes, character" +.IP "character property" 4 +.IX Item "character property" +A predefined \fBcharacter class\fR matchable by the \f(CW\*(C`\ep\*(C'\fR +or \f(CW\*(C`\eP\*(C'\fR \fBmetasymbol\fR. \fBUnicode\fR defines hundreds of standard properties +for every possible codepoint, and Perl defines a few of its own, too. +.IX Xref "character property" +.IP "circumfix operator" 4 +.IX Item "circumfix operator" +An \fBoperator\fR that surrounds its \fBoperand\fR, like the +angle operator, or parentheses, or a hug. +.IX Xref "circumfix operator" +.IP class 4 +.IX Item "class" +A user-defined \fBtype\fR, implemented in Perl via a +\&\fBpackage\fR that provides (either directly or by inheritance) \fBmethods\fR +(that is, \fBsubroutines\fR) to handle \fBinstances\fR of the class (its +\&\fBobjects\fR). See also \fBinheritance\fR. +.IX Xref "classes, defined" +.IP "class method" 4 +.IX Item "class method" +A \fBmethod\fR whose \fBinvocant\fR is a +\&\fBpackage\fR name, not an \fBobject\fR reference. A method associated with the +class as a whole. Also see \fBinstance method\fR. +.IX Xref "class methods methods, class" +.IP client 4 +.IX Item "client" +In networking, a \fBprocess\fR that +initiates contact with a \fBserver\fR process in order to exchange data and +perhaps receive a service. +.IX Xref "clients, defined processes, client" +.IP closure 4 +.IX Item "closure" +An \fBanonymous\fR subroutine +that, when a reference to it is generated at runtime, keeps track of the +identities of externally visible \fBlexical variables\fR, even after those +lexical variables have supposedly gone out of \fBscope\fR. They’re called +“closures” because this sort of behavior gives mathematicians a sense of +closure. +.IX Xref "closure subroutines subroutines, closure" +.IP cluster 4 +.IX Item "cluster" +A parenthesized \fBsubpattern\fR +used to group parts of a \fBregular expression\fR into a single \fBatom\fR. +.IX Xref "clusters, defined subpatterns, cluster" +.IP CODE 4 +.IX Item "CODE" +The word returned by the \f(CW\*(C`ref\*(C'\fR +function when you apply it to a reference to a subroutine. See also \fBCV\fR. +.IX Xref "CODE (ref function) ref function, about" +.IP "code generator" 4 +.IX Item "code generator" +A system that writes code for you in a low-level +language, such as code to implement the backend of a compiler. See \fBprogram +generator\fR. +.IX Xref "code generators, defined" +.IP codepoint 4 +.IX Item "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 \fBordinals\fR. +.IX Xref "codepoints, about" +.IP "code subpattern" 4 +.IX Item "code subpattern" +A \fBregular expression\fR subpattern +whose real purpose is to execute some Perl code—for example, the \f(CW\*(C`(?{...})\*(C'\fR +and \f(CW\*(C`(??{...})\*(C'\fR subpatterns. +.IX Xref "code subpatterns subpatterns, code" +.IP "collating sequence" 4 +.IX Item "collating sequence" +The order into which \fBcharacters\fR +sort. This is used by \fBstring\fR comparison routines to decide, for example, +where in this glossary to put “collating sequence”. +.IX Xref "collating sequence collating sequence" +.IP co-maintainer 4 +.IX Item "co-maintainer" +A person with permissions to index a \fBnamespace\fR in +\&\fBPAUSE\fR. Anyone can upload any namespace, but only primary and +co-maintainers get their contributions indexed. +.IX Xref "co–maintainers" +.IP "combining character" 4 +.IX Item "combining character" +Any character with the +General Category of Combining Mark (\f(CW\*(C`\ep{GC=M}\*(C'\fR), 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 \fBgrapheme\fR. Most but not all diacritics are combining +characters, and vice versa. +.IX Xref "combining characters characters, combining" +.IP command 4 +.IX Item "command" +In \fBshell\fR 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 \fBstatement\fR, which might start with a \fBlabel\fR and typically ends with +a semicolon. +.IX Xref "commands, defined" +.IP "command buffering" 4 +.IX Item "command buffering" +A mechanism in Perl that lets you +store up the output of each Perl \fBcommand\fR and then flush it out as a +single request to the \fBoperating system\fR. It’s enabled by setting the \f(CW$|\fR +(\f(CW$AUTOFLUSH\fR) 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 \fBfile\fR or \fBpipe\fR is to use \fBblock buffering\fR. +.IX Xref "command buffering buffering, command" +.IP "command-line arguments" 4 +.IX Item "command-line arguments" +The \fBvalues\fR you supply +along with a program name when you tell a \fBshell\fR to execute a \fBcommand\fR. +These values are passed to a Perl program through \f(CW@ARGV\fR. +.IX Xref "command–line arguments arguments, command–line" +.IP "command name" 4 +.IX Item "command name" +The name of the program currently executing, as typed on the +command line. In C, the \fBcommand\fR name is passed to the program as the +first command-line argument. In Perl, it comes in separately as \f(CW$0\fR. +.IX Xref "command names" +.IP comment 4 +.IX Item "comment" +A remark that doesn’t affect the meaning of the program. +In Perl, a comment is introduced by a \f(CW\*(C`#\*(C'\fR character and continues to the +end of the line. +.IX Xref "comments, defined" +.IP "compilation unit" 4 +.IX Item "compilation unit" +The \fBfile\fR (or \fBstring\fR, in the case of \f(CW\*(C`eval\*(C'\fR) that +is currently being \fBcompiled\fR. +.IX Xref "compilation units" +.IP compile 4 +.IX Item "compile" +The process of turning source code into a machine-usable form. See \fBcompile +phase\fR. +.IP "compile phase" 4 +.IX Item "compile phase" +Any time before Perl starts running your main +program. See also \fBrun phase\fR. Compile phase is mostly spent in \fBcompile +time\fR, but may also be spent in \fBruntime\fR when \f(CW\*(C`BEGIN\*(C'\fR blocks, \f(CW\*(C`use\*(C'\fR or +\&\f(CW\*(C`no\*(C'\fR declarations, or constant subexpressions are being evaluated. The +startup and import code of any \f(CW\*(C`use\*(C'\fR declaration is also run during +compile phase. +.IX Xref "compile phase, defined" +.IP compiler 4 +.IX Item "compiler" +Strictly speaking, a program that munches +up another program and spits out yet another file containing the program in +a “more executable” form, typically containing native machine instructions. +The \fIperl\fR 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 (\fBsyntax trees\fR) within the \fIperl\fR process itself, which +the \fBinterpreter\fR then interprets. There are, however, extension \fBmodules\fR +to get Perl to act more like a “real” compiler. See Camel chapter 16, +“Compiling”. +.IX Xref "compilers and compiling, about" +.IP "compile time" 4 +.IX Item "compile time" +The time when Perl is trying to make sense of your +code, as opposed to when it thinks it knows what your code means and is +merely trying to do what it thinks your code says to do, which is \fBruntime\fR. +.IX Xref "compile time, defined" +.IP composer 4 +.IX Item "composer" +A “constructor” for a \fBreferent\fR that isn’t really an +\&\fBobject\fR, 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”. +.IX Xref "composers, about" +.IP concatenation 4 +.IX Item "concatenation" +The process of gluing one +cat’s nose to another cat’s tail. Also a similar operation on two +\&\fBstrings\fR. +.IX Xref "concatenating strings strings, concatenating" +.IP conditional 4 +.IX Item "conditional" +Something “iffy”. See \fBBoolean context\fR. +.IX Xref "conditional (term)" +.IP connection 4 +.IX Item "connection" +In telephony, the temporary electrical circuit between +the caller’s and the callee’s phone. In networking, the same kind of +temporary circuit between a \fBclient\fR and a \fBserver\fR. +.IX Xref "connections (term)" +.IP construct 4 +.IX Item "construct" +As a noun, a piece of syntax made up of smaller +pieces. As a transitive verb, to create an \fBobject\fR using a \fBconstructor\fR. +.IX Xref "constructs, defined" +.IP constructor 4 +.IX Item "constructor" +Any \fBclass method\fR, \fBinstance\fR, or \fBsubroutine\fR +that composes, initializes, blesses, and returns an \fBobject\fR. Sometimes we +use the term loosely to mean a \fBcomposer\fR. +.IX Xref "constructors, defined" +.IP context 4 +.IX Item "context" +The surroundings or environment. The context given by the +surrounding code determines what kind of data a particular \fBexpression\fR is +expected to return. The three primary contexts are \fBlist context\fR, +\&\fBscalar\fR, and \fBvoid context\fR. Scalar context is sometimes subdivided into +\&\fBBoolean context\fR, \fBnumeric context\fR, \fBstring context\fR, and \fBvoid +context\fR. There’s also a “don’t care” context (which is dealt with in Camel +chapter 2, “Bits and Pieces”, if you care). +.IX Xref "context, about" +.IP continuation 4 +.IX Item "continuation" +The treatment of more than one physical \fBline\fR as a +single logical line. \fBMakefile\fR lines are continued by putting a backslash +before the \fBnewline\fR. Mail headers, as defined by RFC 822, are +continued by putting a space or tab \fIafter\fR the newline. In general, lines +in Perl do not need any form of continuation mark, because \fBwhitespace\fR +(including newlines) is gleefully ignored. Usually. +.IX Xref "continuation lines RFC 822" +.IP "core dump" 4 +.IX Item "core dump" +The corpse of a \fBprocess\fR, in the form of a file left in the +\&\fBworking directory\fR of the process, usually as a result of certain kinds +of fatal errors. +.IX Xref "core dump" +.IP CPAN 4 +.IX Item "CPAN" +The Comprehensive Perl Archive Network. (See the Camel Preface +and Camel chapter 19, “CPAN” for details.) +.IX Xref "Comprehensive Perl Archive Network CPAN (Comprehensive Perl Archive Network), about" +.IP "C preprocessor" 4 +.IX Item "C preprocessor" +The typical C compiler’s first pass, which processes lines +beginning with \f(CW\*(C`#\*(C'\fR for conditional compilation and macro definition, and +does various manipulations of the program text based on the current +definitions. Also known as \fIcpp\fR(1). +.IX Xref "C preprocessor" +.IP cracker 4 +.IX Item "cracker" +Someone who breaks security on computer systems. A cracker may +be a true \fBhacker\fR or only a \fBscript kiddie\fR. +.IX Xref "crackers" +.IP "currently selected output channel" 4 +.IX Item "currently selected output channel" +The last \fBfilehandle\fR that was +designated with \f(CWselect(FILEHANDLE)\fR; \f(CW\*(C`STDOUT\*(C'\fR, if no filehandle has +been selected. +.IX Xref "currently selected output channel" +.IP "current package" 4 +.IX Item "current package" +The \fBpackage\fR in which the current statement is +\&\fBcompiled\fR. Scan backward in the text of your program through the current +\&\fBlexical scope\fR or any enclosing lexical scopes until you find a package +declaration. That’s your current package name. +.IX Xref "current package" +.IP "current working directory" 4 +.IX Item "current working directory" +See \fBworking directory\fR. +.IX Xref "current working directory" +.IP CV 4 +.IX Item "CV" +In academia, a curriculum vitæ, a fancy kind of résumé. In Perl, an internal “code value” typedef holding a +\&\fBsubroutine\fR. The \f(CW\*(C`CV\*(C'\fR type is a subclass of \fBSV\fR. +.IX Xref "CV (code value) code value (CV)" +.SS D +.IX Subsection "D" +.IP "dangling statement" 4 +.IX Item "dangling statement" +A bare, single \fBstatement\fR, +without any braces, hanging off an \f(CW\*(C`if\*(C'\fR or \f(CW\*(C`while\*(C'\fR conditional. C allows +them. Perl doesn’t. +.IX Xref "dangling statements statements, dangling" +.IP datagram 4 +.IX Item "datagram" +A packet of data, such as a \fBUDP\fR 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 \fBIP\fR level, +but \fBstream\fR protocols such as \fBTCP\fR hide this from your program.) +.IX Xref "datagrams, defined" +.IP "data structure" 4 +.IX Item "data structure" +How your various pieces of data relate to each +other and what shape they make when you put them all together, as in a +rectangular table or a triangular tree. +.IX Xref "data structures, defined" +.IP "data type" 4 +.IX Item "data type" +A set of possible values, together with all the +operations that know how to deal with those values. For example, a numeric +data type has a certain set of numbers that you can work with, as well as +various mathematical operations that you can do on the numbers, but would +make little sense on, say, a string such as \f(CW"Kilroy"\fR. Strings have their +own operations, such as \fBconcatenation\fR. Compound types made of a number of +smaller pieces generally have operations to compose and decompose them, and +perhaps to rearrange them. \fBObjects\fR 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 \f(CW\*(C`open_door\*(C'\fR +\&\fBmethod\fR. +.IX Xref "data types, defined" +.IP DBM 4 +.IX Item "DBM" +Stands for “Database Management” routines, a set of routines that emulate an +\&\fBassociative array\fR 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 \fBhash\fR across multiple invocations. You +can \f(CW\*(C`tie\*(C'\fR your hash variables to various DBM implementations. +.IX Xref "DBM (Database Management) routines Database Management (DBM) routines" +.IP declaration 4 +.IX Item "declaration" +An \fBassertion\fR 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 +\&\fBstatement\fR for its opposite. Note that some declarations also function +as statements. Subroutine declarations also act as definitions if a body +is supplied. +.IX Xref "declarations, defined" +.IP declarator 4 +.IX Item "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 +\&\f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, or \f(CW\*(C`state\*(C'\fR to denote that you want something other than +the default. +.IX Xref "declarators" +.IP decrement 4 +.IX Item "decrement" +To subtract a value from a +variable, as in “decrement \f(CW$x\fR” (meaning to remove 1 from its value) or +“decrement \f(CW$x\fR by 3”. +.IX Xref "decrementing values values, decrementing" +.IP default 4 +.IX Item "default" +A \fBvalue\fR chosen for you if you don’t +supply a value of your own. +.IX Xref "default values values, default" +.IP defined 4 +.IX Item "defined" +Having a meaning. Perl thinks that some of the things +people try to do are devoid of meaning; in particular, making use of +variables that have never been given a \fBvalue\fR 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 +\&\fBfalse\fR and the \f(CW\*(C`defined\*(C'\fR entry in Camel chapter 27, “Functions”. +.IX Xref "defined (term)" +.IP delimiter 4 +.IX Item "delimiter" +A \fBcharacter\fR or \fBstring\fR that sets bounds to an +arbitrarily sized textual object, not to be confused with a \fBseparator\fR or +\&\fBterminator\fR. “To delimit” really just means “to surround” or “to enclose” +(like these parentheses are doing). +.IX Xref "delimiters (term)" +.IP dereference 4 +.IX Item "dereference" +A fancy computer science term +meaning “to follow a \fBreference\fR to what it points to”. The “de” part of it +refers to the fact that you’re taking away one level of \fBindirection\fR. +.IX Xref "dereference (term) references, dereference" +.IP "derived class" 4 +.IX Item "derived class" +A \fBclass\fR that defines some of its \fBmethods\fR in terms of a more generic class, +called a \fBbase class\fR. 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. +.IX Xref "derived classes classes, derived subclasses classes, subclasses" +.IP descriptor 4 +.IX Item "descriptor" +See \fBfile descriptor\fR. +.IP destroy 4 +.IX Item "destroy" +To deallocate the memory of a \fBreferent\fR (first triggering +its \f(CW\*(C`DESTROY\*(C'\fR method, if it has one). +.IX Xref "destroy (term)" +.IP destructor 4 +.IX Item "destructor" +A special \fBmethod\fR that is called +when an \fBobject\fR is thinking about \fBdestroying\fR itself. A Perl program’s +\&\f(CW\*(C`DESTROY\*(C'\fR method doesn’t do the actual destruction; Perl just \fBtriggers\fR +the method in case the \fBclass\fR wants to do any associated cleanup. +.IX Xref "destructor method methods, destructor" +.IP device 4 +.IX Item "device" +A whiz-bang hardware gizmo (like a disk or tape drive or a +modem or a joystick or a mouse) attached to your computer, which the +\&\fBoperating system\fR tries to make look like a \fBfile\fR (or a bunch of files). +Under Unix, these fake files tend to live in the \fI/dev\fR directory. +.IX Xref "devices (term)" +.IP directive 4 +.IX Item "directive" +A \fBpod\fR directive. See Camel chapter 23, “Plain Old +Documentation”. +.IX Xref "directives, defined" +.IP directory 4 +.IX Item "directory" +A special file that contains other files. Some +\&\fBoperating systems\fR call these “folders”, “drawers”, “catalogues”, or +“catalogs”. +.IX Xref "directories, defined" +.IP "directory handle" 4 +.IX Item "directory handle" +A name that represents a particular instance of opening a +directory to read it, until you close it. See the \f(CW\*(C`opendir\*(C'\fR function. +.IX Xref "directory handle" +.IP discipline 4 +.IX Item "discipline" +Some people need this and some people avoid it. +For Perl, it’s an old way to say \fBI/O layer\fR. +.IX Xref "discipline (I O layer)" +.IP dispatch 4 +.IX Item "dispatch" +To send something to its correct destination. Often used +metaphorically to indicate a transfer of programmatic control to a +destination selected algorithmically, often by lookup in a table of function +\&\fBreferences\fR or, in the case of object \fBmethods\fR, by traversing the +inheritance tree looking for the most specific definition for the method. +.IX Xref "dispatching" +.IP distribution 4 +.IX Item "distribution" +A standard, bundled release of a system of +software. The default usage implies source code is included. If that is not +the case, it will be called a “binary\-only” distribution. +.IX Xref "distributions, defined" +.IP dual-lived 4 +.IX Item "dual-lived" +Some modules live both in the +\&\fBStandard Library\fR and on \fBCPAN\fR. These modules might be developed on two +tracks as people modify either version. The trend currently is to untangle +these situations. +.IX Xref "dual–lived modules modules, dual–lived" +.IP dweomer 4 +.IX Item "dweomer" +An enchantment, illusion, phantasm, or jugglery. Said when Perl’s +magical \fBdwimmer\fR effects don’t do what you expect, but rather seem to be +the product of arcane \fIdweomercraft\fR, sorcery, or wonder working. [From +Middle English.] +.IX Xref "dweomer" +.IP dwimmer 4 +.IX Item "dwimmer" +DWIM is +an acronym for “Do What I Mean”, the principle that something +should just do what you want it to do without an undue amount of fuss. A bit +of code that does “dwimming” is a “dwimmer”. Dwimming can require a great +deal of behind-the-scenes magic, which (if it doesn’t stay properly behind +the scenes) is called a \fBdweomer\fR instead. +.IX Xref "DWIM (Do What I Mean) principle Do What I Mean (DWIM) principle dwimming" +.IP "dynamic scoping" 4 +.IX Item "dynamic scoping" +Dynamic scoping works over a \fBdynamic +scope\fR, making variables visible throughout the rest of the \fBblock\fR in +which they are first used and in any \fBsubroutines\fR that are called by the +rest of the block. Dynamically scoped variables can have their values +temporarily changed (and implicitly restored later) by a \f(CW\*(C`local\*(C'\fR operator. +(Compare \fBlexical scoping\fR.) Used more loosely to mean how a subroutine +that is in the middle of calling another subroutine “contains” that +subroutine at \fBruntime\fR. +.IX Xref "dynamic scope scopes, dynamic" +.SS E +.IX Subsection "E" +.IP eclectic 4 +.IX Item "eclectic" +Derived from many sources. Some would say \fItoo\fR many. +.IX Xref "eclectic (term)" +.IP element 4 +.IX Item "element" +A basic building block. When you’re talking about an +\&\fBarray\fR, it’s one of the items that make up the array. +.IX Xref "elements, about" +.IP embedding 4 +.IX Item "embedding" +When something is contained in something else, +particularly when that might be considered surprising: “I’ve embedded a +complete Perl interpreter in my editor!” +.IX Xref "embedding (term)" +.IP "empty subclass test" 4 +.IX Item "empty subclass test" +The notion that an empty \fBderived class\fR should +behave exactly like its \fBbase class\fR. +.IX Xref "empty subclass test" +.IP encapsulation 4 +.IX Item "encapsulation" +The veil of abstraction separating the \fBinterface\fR +from the \fBimplementation\fR (whether enforced or not), which mandates that +all access to an \fBobject\fR’s state be through \fBmethods\fR alone. +.IX Xref "encapsulation (term)" +.IP endian 4 +.IX Item "endian" +See \fBlittle-endian\fR and \fBbig-endian\fR. +.IP "en passant" 4 +.IX Item "en passant" +When you change a \fBvalue\fR as it is being copied. [From +French “in passing”, as in the exotic pawn-capturing maneuver in chess.] +.IX Xref "en passant (term)" +.IP environment 4 +.IX Item "environment" +The collective set of \fBenvironment variables\fR your +\&\fBprocess\fR inherits from its parent. Accessed via \f(CW%ENV\fR. +.IX Xref "environment (term)" +.IP "environment variable" 4 +.IX Item "environment variable" +A mechanism by which some high-level agent such as a user can pass its +preferences down to its future offspring (child \fBprocesses\fR, grandchild +processes, great-grandchild processes, and so on). Each environment +variable is a \fBkey\fR/\fBvalue\fR pair, like one entry in a \fBhash\fR. +.IX Xref "environment variables variables, environment environment variables" +.IP EOF 4 +.IX Item "EOF" +End of File. Sometimes used +metaphorically as the terminating string of a \fBhere document\fR. +.IX Xref "End of File (EOF) EOF (End of File)" +.IP errno 4 +.IX Item "errno" +The error number returned by a +\&\fBsyscall\fR when it fails. Perl refers to the error by the name \f(CW$!\fR (or +\&\f(CW$OS_ERROR\fR if you use the English module). +.IX Xref "errno (error number) error number (errno)" +.IP error 4 +.IX Item "error" +See \fBexception\fR or \fBfatal error\fR. +.IP "escape sequence" 4 +.IX Item "escape sequence" +See \fBmetasymbol\fR. +.IP exception 4 +.IX Item "exception" +A fancy term for an error. See \fBfatal error\fR. +.IP "exception handling" 4 +.IX Item "exception handling" +The way a program responds to an error. The +exception-handling mechanism in Perl is the \f(CW\*(C`eval\*(C'\fR operator. +.IX Xref "exception handling, defined" +.IP exec 4 +.IX Item "exec" +To throw away the current \fBprocess\fR’s program and replace +it with another, without exiting the process or relinquishing any resources +held (apart from the old memory image). +.IX Xref "exec function" +.IP "executable file" 4 +.IX Item "executable file" +A \fBfile\fR that is specially marked to +tell the \fBoperating system\fR that it’s okay to run this file as a program. +Usually shortened to “executable”. +.IX Xref "executable files files, executable" +.IP execute 4 +.IX Item "execute" +To run a \fBprogram\fR or \fBsubroutine\fR. (Has nothing to do +with the \f(CW\*(C`kill\*(C'\fR built-in, unless you’re trying to run a \fBsignal handler\fR.) +.IX Xref "execute (term)" +.IP "execute bit" 4 +.IX Item "execute bit" +The special mark that tells the operating system it can run +this program. There are actually three execute bits under Unix, and which +bit gets used depends on whether you own the file singularly, collectively, +or not at all. +.IX Xref "execute bit" +.IP "exit status" 4 +.IX Item "exit status" +See \fBstatus\fR. +.IP exploit 4 +.IX Item "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. +.IX Xref "exploits, security" +.IP export 4 +.IX Item "export" +To make symbols from a \fBmodule\fR available for +\&\fBimport\fR by other modules. +.IX Xref "exporting, defined" +.IP expression 4 +.IX Item "expression" +Anything you can legally say in a spot +where a \fBvalue\fR is required. Typically composed of \fBliterals\fR, +\&\fBvariables\fR, \fBoperators\fR, \fBfunctions\fR, and \fBsubroutine\fR calls, not +necessarily in that order. +.IX Xref "expressions, defined expressions" +.IP extension 4 +.IX Item "extension" +A Perl module that also pulls in \fBcompiled\fR C or C++ +code. More generally, any experimental option that can be \fBcompiled\fR into +Perl, such as multithreading. +.IX Xref "extensions, defined" +.SS F +.IX Subsection "F" +.IP false 4 +.IX Item "false" +In Perl, any value that would look like \f(CW""\fR +or \f(CW"0"\fR if evaluated in a string context. Since undefined values evaluate +to \f(CW""\fR, all undefined values are false, but not all false values are +undefined. +.IX Xref "false values values, false" +.IP FAQ 4 +.IX Item "FAQ" +Frequently Asked Question (although not necessarily +frequently answered, especially if the answer appears in the Perl FAQ +shipped standard with Perl). +.IX Xref "FAQ (Frequently Asked Question) Frequently Asked Question (FAQ)" +.IP "fatal error" 4 +.IX Item "fatal error" +An uncaught \fBexception\fR, which causes termination of the +\&\fBprocess\fR after printing a message on your \fBstandard error\fR stream. Errors +that happen inside an \f(CW\*(C`eval\*(C'\fR are not fatal. Instead, the \f(CW\*(C`eval\*(C'\fR terminates +after placing the exception message in the \f(CW$@\fR (\f(CW$EVAL_ERROR\fR) variable. +You can try to provoke a fatal error with the \f(CW\*(C`die\*(C'\fR operator (known as +throwing or raising an exception), but this may be caught by a dynamically +enclosing \f(CW\*(C`eval\*(C'\fR. If not caught, the \f(CW\*(C`die\*(C'\fR becomes a fatal error. +.IX Xref "fatal errors" +.IP "feeping creaturism" 4 +.IX Item "feeping creaturism" +A spoonerism of “creeping +featurism”, noting the biological urge to add just one more feature to +a program. +.IX Xref "feeping creaturism creeping featurism" +.IP field 4 +.IX Item "field" +A single piece of numeric or string data that is part of a +longer \fBstring\fR, \fBrecord\fR, or \fBline\fR. Variable-width fields are usually +split up by \fBseparators\fR (so use \f(CW\*(C`split\*(C'\fR to extract the fields), while +fixed-width fields are usually at fixed positions (so use \f(CW\*(C`unpack\*(C'\fR). +\&\fBInstance variables\fR are also known as “fields”. +.IX Xref "fields (term)" +.IP FIFO 4 +.IX Item "FIFO" +First In, First Out. See also \fBLIFO\fR. Also a nickname for a \fBnamed pipe\fR. +.IX Xref "First In, First Out (FIFO) FIFO (First In, First Out)" +.IP file 4 +.IX Item "file" +A named collection of data, usually stored on disk in a +\&\fBdirectory\fR in a \fBfilesystem\fR. 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. +.IX Xref "files, defined" +.IP "file descriptor" 4 +.IX Item "file descriptor" +The little number the \fBoperating +system\fR uses to keep track of which opened \fBfile\fR you’re talking about. +Perl hides the file descriptor inside a \fBstandard I/O\fR stream and then +attaches the stream to a \fBfilehandle\fR. +.IX Xref "file descriptors descriptors, file" +.IP fileglob 4 +.IX Item "fileglob" +A “wildcard” match on \fBfilenames\fR. See the \f(CW\*(C`glob\*(C'\fR function. +.IX Xref "fileglobs" +.IP filehandle 4 +.IX Item "filehandle" +An identifier (not necessarily related to the real +name of a file) that represents a particular instance of opening a file, +until you close it. If you’re going to open and close several different +files in succession, it’s fine to open each of them with the same +filehandle, so you don’t have to write out separate code to process each +file. +.IX Xref "filehandles, about" +.IP filename 4 +.IX Item "filename" +One name for a file. This name is listed in a +\&\fBdirectory\fR. You can use it in an \f(CW\*(C`open\*(C'\fR to tell the \fBoperating system\fR +exactly which file you want to open, and associate the file with a +\&\fBfilehandle\fR, which will carry the subsequent identity of that file in +your program, until you close it. +.IX Xref "filenames, about" +.IP filesystem 4 +.IX Item "filesystem" +A set of \fBdirectories\fR and \fBfiles\fR 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. +.IX Xref "filesystems, defined" +.IP "file test operator" 4 +.IX Item "file test operator" +A built-in unary operator that you use to +determine whether something is \fBtrue\fR about a file, such as \f(CW–o +$filename\fR to test whether you’re the owner of the file. +.IX Xref "file test operators, about" +.IP filter 4 +.IX Item "filter" +A program designed to take a \fBstream\fR of input and +transform it into a stream of output. +.IX Xref "filters, defined" +.IP first-come 4 +.IX Item "first-come" +The first \fBPAUSE\fR +author to upload a \fBnamespace\fR automatically becomes the \fBprimary +maintainer\fR for that namespace. The “first come” permissions distinguish a +\&\fBprimary maintainer\fR who was assigned that role from one who received it +automatically. +.IX Xref "first–come permissions permissions, first–come" +.IP flag 4 +.IX Item "flag" +We tend to avoid this term because it means so many things. +It may mean a command-line \fBswitch\fR that takes no argument itself (such as +Perl’s \f(CW\*(C`–n\*(C'\fR and \f(CW\*(C`–p\*(C'\fR flags) or, less frequently, a single-bit indicator +(such as the \f(CW\*(C`O_CREAT\*(C'\fR and \f(CW\*(C`O_EXCL\*(C'\fR flags used in \f(CW\*(C`sysopen\*(C'\fR). Sometimes +informally used to refer to certain regex modifiers. +.IX Xref "flags (term)" +.IP "floating point" 4 +.IX Item "floating point" +A method of storing +numbers in “scientific notation”, such that the precision of the number is +independent of its magnitude (the decimal point “floats”). Perl does its +numeric work with floating-point numbers (sometimes called “floats”) when +it can’t get away with using \fBintegers\fR. Floating-point numbers are mere +approximations of real numbers. +.IX Xref "floating point methods methods, floating point" +.IP flush 4 +.IX Item "flush" +The act of emptying a \fBbuffer\fR, +often before it’s full. +.IX Xref "flushing buffers buffers, flushing" +.IP FMTEYEWTK 4 +.IX Item "FMTEYEWTK" +Far More Than Everything You Ever Wanted To Know. An +exhaustive treatise on one narrow topic, something of a super\-\fBFAQ\fR. See +Tom for far more. +.IX Xref "FMTEYEWTK acronym" +.IP foldcase 4 +.IX Item "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 \fBlowercase\fR variant (using a partially decomposed \fBnormalization\fR form +for certain codepoints) created specifically to resolve this. +.IX Xref "foldcase (term)" +.IP fork 4 +.IX Item "fork" +To create a child \fBprocess\fR +identical to the parent process at its moment of conception, at least until +it gets ideas of its own. A thread with protected memory. +.IX Xref "forking processes processes, forking" +.IP "formal arguments" 4 +.IX Item "formal arguments" +The generic names by which a +\&\fBsubroutine\fR knows its \fBarguments\fR. 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 +\&\f(CW$ARGV[0]\fR, \f(CW$ARGV[1]\fR, and so on. Similarly, the formal arguments to a +Perl subroutine are \f(CW$_[0]\fR, \f(CW$_[1]\fR, and so on. You may give the +arguments individual names by assigning the values to a \f(CW\*(C`my\*(C'\fR list. See +also \fBactual arguments\fR. +.IX Xref "formal arguments arguments, formal" +.IP format 4 +.IX Item "format" +A specification of how many spaces and digits and things +to put somewhere so that whatever you’re printing comes out nice and +pretty. +.IX Xref "formats, defined" +.IP "freely available" 4 +.IX Item "freely available" +Means you don’t have to pay money to get it, but +the copyright on it may still belong to someone else (like Larry). +.IX Xref "freely available (term)" +.IP "freely redistributable" 4 +.IX Item "freely redistributable" +Means you’re not in legal trouble if you +give a bootleg copy of it to your friends and we find out about it. In +fact, we’d rather you gave a copy to all your friends. +.IX Xref "freely redistributable (term)" +.IP freeware 4 +.IX Item "freeware" +Historically, any software that you give away, +particularly if you make the source code available as well. Now often +called \fBopen source software\fR. Recently there has been a trend to use the +term in contradistinction to \fBopen source software\fR, to refer only to free +software released under the Free Software +Foundation’s GPL (General Public License), but this is difficult to justify +etymologically. +.IX Xref "freeware (term) Free Software Foundation" +.IP function 4 +.IX Item "function" +Mathematically, a mapping of each of a set of input +values to a particular output value. In computers, refers to a +\&\fBsubroutine\fR or \fBoperator\fR that returns a \fBvalue\fR. It may or may not +have input values (called \fBarguments\fR). +.IX Xref "functions, about" +.IP "funny character" 4 +.IX Item "funny character" +Someone like Larry, or one of his +peculiar friends. Also refers to the strange prefixes that Perl requires as +noun markers on its variables. +.IX Xref "funny characters characters, funny" +.SS G +.IX Subsection "G" +.IP "garbage collection" 4 +.IX Item "garbage collection" +A misnamed feature—it should be called, +“expecting your mother to pick up after you”. Strictly speaking, Perl +doesn’t do this, but it relies on a reference-counting mechanism to keep +things tidy. However, we rarely speak strictly and will often refer to the +reference-counting scheme as a form of garbage collection. (If it’s any +comfort, when your interpreter exits, a “real” garbage collector runs to +make sure everything is cleaned up if you’ve been messy with circular +references and such.) +.IX Xref "garbage collection, defined" +.IP GID 4 +.IX Item "GID" +Group ID—in Unix, the numeric group ID +that the \fBoperating system\fR uses to identify you and members of your +\&\fBgroup\fR. +.IX Xref "GID (Group ID) Group ID (GID)" +.IP glob 4 +.IX Item "glob" +Strictly, the shell’s \f(CW\*(C`*\*(C'\fR 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 \fBfileglob\fR and \fBtypeglob\fR. +.IX Xref "glob (* character)" +.IP global 4 +.IX Item "global" +Something you can see from anywhere, usually used of +\&\fBvariables\fR and \fBsubroutines\fR 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 \fBpackage\fR. +Global variables can be declared with \f(CW\*(C`our\*(C'\fR. See “Global Declarations” in +Camel chapter 4, “Statements and Declarations”. +.IX Xref "global (term)" +.IP "global destruction" 4 +.IX Item "global destruction" +The \fBgarbage collection\fR of globals (and the running +of any associated object destructors) that takes place when a Perl +\&\fBinterpreter\fR is being shut down. Global destruction should not be +confused with the Apocalypse, except perhaps when it should. +.IX Xref "global destruction" +.IP "glue language" 4 +.IX Item "glue language" +A language such as Perl that is good at hooking things +together that weren’t intended to be hooked together. +.IX Xref "glue language" +.IP granularity 4 +.IX Item "granularity" +The size of the pieces you’re dealing with, mentally +speaking. +.IX Xref "granularity" +.IP grapheme 4 +.IX Item "grapheme" +A graphene is an allotrope of carbon arranged in a +hexagonal crystal lattice one atom thick. A \fBgrapheme\fR, or more fully, a +\&\fIgrapheme cluster string\fR is a single user-visible \fBcharacter\fR, which may +in turn be several characters (\fBcodepoints\fR) 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 \fBnormalization\fR. +.IX Xref "graphemes, defined" +.IP greedy 4 +.IX Item "greedy" +A \fBsubpattern\fR whose +\&\fBquantifier\fR wants to match as many things as possible. +.IX Xref "greedy subpatterns subpatterns, greedy" +.IP grep 4 +.IX Item "grep" +Originally from the old Unix editor command for “Globally +search for a Regular Expression and Print it”, now used in the general +sense of any kind of search, especially text searches. Perl has a built-in +\&\f(CW\*(C`grep\*(C'\fR function that searches a list for elements matching any given +criterion, whereas the \fBgrep\fR(1) program searches for lines matching a +\&\fBregular expression\fR in one or more files. +.IX Xref "grep function" +.IP group 4 +.IX Item "group" +A set of users of which you are a member. In some +operating systems (like Unix), you can give certain file access permissions +to other members of your group. +.IX Xref "groups, defined" +.IP GV 4 +.IX Item "GV" +An internal “glob value” typedef, +holding a \fBtypeglob\fR. The \f(CW\*(C`GV\*(C'\fR type is a subclass of \fBSV\fR. +.IX Xref "GV (glob value) glob value (GV)" +.SS H +.IX Subsection "H" +.IP hacker 4 +.IX Item "hacker" +Someone who is brilliantly persistent in solving technical +problems, whether these involve golfing, fighting orcs, or programming. +Hacker is a neutral term, morally speaking. Good hackers are not to be +confused with evil \fBcrackers\fR or clueless \fBscript kiddies\fR. If you +confuse them, we will presume that you are either evil or clueless. +.IX Xref "hackers" +.IP handler 4 +.IX Item "handler" +A \fBsubroutine\fR or \fBmethod\fR that Perl calls when your +program needs to respond to some internal event, such as a \fBsignal\fR, or an +encounter with an operator subject to \fBoperator overloading\fR. See also +\&\fBcallback\fR. +.IX Xref "handlers, defined" +.IP "hard reference" 4 +.IX Item "hard reference" +A \fBscalar\fR \fBvalue\fR containing +the actual address of a \fBreferent\fR, such that the referent’s \fBreference\fR +count accounts for it. (Some hard references are held internally, such as +the implicit reference from one of a \fBtypeglob\fR’s variable slots to its +corresponding referent.) A hard reference is different from a \fBsymbolic +reference\fR. +.IX Xref "hard references, about references, hard" +.IP hash 4 +.IX Item "hash" +An unordered association of \fBkey\fR/\fBvalue\fR pairs, stored such that you can easily use a string \fBkey\fR to +look up its associated data \fBvalue\fR. 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. +.IX Xref "hashes, about key value pairs, about" +.IP "hash table" 4 +.IX Item "hash table" +A data structure used internally by Perl for implementing +associative arrays (hashes) efficiently. See also \fBbucket\fR. +.IX Xref "hash tables" +.IP "header file" 4 +.IX Item "header file" +A file containing certain required +definitions that you must include “ahead” of the rest of your program to do +certain obscure operations. A C header file has a \fI.h\fR extension. Perl +doesn’t really have header files, though historically Perl has sometimes +used translated \fI.h\fR files with a \fI.ph\fR extension. See \f(CW\*(C`require\*(C'\fR in +Camel chapter 27, “Functions”. (Header files have been superseded by the +\&\fBmodule\fR mechanism.) +.IX Xref "header files files, header" +.IP "here document" 4 +.IX Item "here document" +So called because of a similar construct in \fBshells\fR that +pretends that the \fBlines\fR following the \fBcommand\fR are a separate \fBfile\fR +to be fed to the command, up to some terminating string. In Perl, however, +it’s just a fancy form of quoting. +.IX Xref "here documents" +.IP hexadecimal 4 +.IX Item "hexadecimal" +A number in base 16, “hex” for short. The digits for 10 +through 15 are customarily represented by the letters \f(CW\*(C`a\*(C'\fR through \f(CW\*(C`f\*(C'\fR. +Hexadecimal constants in Perl start with \f(CW\*(C`0x\*(C'\fR. See also the \f(CW\*(C`hex\*(C'\fR +function in Camel chapter 27, “Functions”. +.IX Xref "hexadecimals" +.IP "home directory" 4 +.IX Item "home directory" +The directory you are put into when +you log in. On a Unix system, the name is often placed into \f(CW$ENV{HOME}\fR +or \f(CW$ENV{LOGDIR}\fR by \fIlogin\fR, but you can also find it with +\&\f(CW\*(C`(get\*(C'\fR\f(CW\*(C`pwuid($<))[7]\*(C'\fR. (Some platforms do not have a concept of a +home directory.) +.IX Xref "home directory directories, home" +.IP host 4 +.IX Item "host" +The computer on which a program or other data resides. +.IX Xref "host computers" +.IP hubris 4 +.IX Item "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 \fBlaziness\fR and \fBimpatience\fR. +.IX Xref "hubris quality" +.IP HV 4 +.IX Item "HV" +Short for a “hash value” typedef, which +holds Perl’s internal representation of a hash. The \f(CW\*(C`HV\*(C'\fR type is a +subclass of \fBSV\fR. +.IX Xref "HV (hash value) hash value (HV)" +.SS I +.IX Subsection "I" +.IP identifier 4 +.IX Item "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 \fBqualified\fR names.) +.IX Xref "identifiers, defined" +.IP impatience 4 +.IX Item "impatience" +The anger you feel when the computer is being lazy. +This makes you write programs that don’t just react to your needs, but +actually anticipate them. Or at least that pretend to. Hence, the second +great virtue of a programmer. See also \fBlaziness\fR and \fBhubris\fR. +.IX Xref "impatience quality" +.IP implementation 4 +.IX Item "implementation" +How a piece of code actually goes about doing its +job. Users of the code should not count on implementation details staying +the same unless they are part of the published \fBinterface\fR. +.IX Xref "implementation (term)" +.IP import 4 +.IX Item "import" +To gain access to symbols that are exported from another +module. See \f(CW\*(C`use\*(C'\fR in Camel chapter 27, “Functions”. +.IX Xref "import (term)" +.IP increment 4 +.IX Item "increment" +To increase the value of +something by 1 (or by some other number, if so specified). +.IX Xref "incrementing values values, incrementing" +.IP indexing 4 +.IX Item "indexing" +In olden days, the act of looking up a \fBkey\fR 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 \fBvalue\fR, even if no +index is involved. Things have degenerated to the point that Perl’s +\&\f(CW\*(C`index\*(C'\fR function merely locates the position (index) of one string in +another. +.IX Xref "indexing (term)" +.IP "indirect filehandle" 4 +.IX Item "indirect filehandle" +An \fBexpression\fR that +evaluates to something that can be used as a \fBfilehandle\fR: a \fBstring\fR +(filehandle name), a \fBtypeglob\fR, a typeglob \fBreference\fR, or a low-level +\&\fBIO\fR object. +.IX Xref "indirect filehandles filehandles, indirect" +.IP indirection 4 +.IX Item "indirection" +If something in a program isn’t the value you’re +looking for but indicates where the value is, that’s indirection. This can +be done with either \fBsymbolic references\fR or \fBhard\fR. +.IX Xref "indirection (term)" +.IP "indirect object" 4 +.IX Item "indirect object" +In English grammar, a short +noun phrase between a verb and its direct object indicating the beneficiary +or recipient of the action. In Perl, \f(CW\*(C`print STDOUT "$foo\en";\*(C'\fR can be +understood as “verb indirect-object object”, where \f(CW\*(C`STDOUT\*(C'\fR is the +recipient of the \f(CW\*(C`print\*(C'\fR action, and \f(CW"$foo"\fR is the object being +printed. Similarly, when invoking a \fBmethod\fR, you might place the +invocant in the dative slot between the method and its arguments: +.IX Xref "indirect objects, defined objects, indirect" +.Sp +.Vb 3 +\& $gollum = new Pathetic::Creature "Sméagol"; +\& give $gollum "Fisssssh!"; +\& give $gollum "Precious!"; +.Ve +.IP "indirect object slot" 4 +.IX Item "indirect object slot" +The syntactic position falling between a method call +and its arguments when using the indirect object invocation syntax. (The +slot is distinguished by the absence of a comma between it and the next +argument.) \f(CW\*(C`STDERR\*(C'\fR is in the indirect object slot here: +.IX Xref "indirect object slot" +.Sp +.Vb 1 +\& print STDERR "Awake! Awake! Fear, Fire, Foes! Awake!\en"; +.Ve +.IP infix 4 +.IX Item "infix" +An \fBoperator\fR that comes in between its \fBoperands\fR, +such as multiplication in \f(CW\*(C`24 * 7\*(C'\fR. +.IX Xref "infix operators" +.IP inheritance 4 +.IX Item "inheritance" +What you get from your ancestors, genetically or +otherwise. If you happen to be a \fBclass\fR, your ancestors are called \fBbase +classes\fR and your descendants are called \fBderived classes\fR. See \fBsingle +inheritance\fR and \fBmultiple inheritance\fR. +.IX Xref "inheritance, defined" +.IP instance 4 +.IX Item "instance" +Short for “an instance of a class”, meaning an \fBobject\fR +of that \fBclass\fR. +.IX Xref "instances (term)" +.IP "instance data" 4 +.IX Item "instance data" +See \fBinstance variable\fR. +.IX Xref "instance data" +.IP "instance method" 4 +.IX Item "instance method" +A \fBmethod\fR of an \fBobject\fR, as +opposed to a \fBclass method\fR. +.IX Xref "instance methods methods, instance" +.Sp +A \fBmethod\fR whose \fBinvocant\fR is an \fBobject\fR, not a \fBpackage\fR 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 \fBclass method\fR. +.IP "instance variable" 4 +.IX Item "instance variable" +An \fBattribute\fR of an \fBobject\fR; data stored with the particular object rather than with the class +as a whole. +.IX Xref "instance variables, defined variables, instance" +.IP integer 4 +.IX Item "integer" +A number with no fractional (decimal) part. A counting +number, like 1, 2, 3, and so on, but including 0 and the negatives. +.IX Xref "integers (term)" +.IP interface 4 +.IX Item "interface" +The services a piece of code promises to provide +forever, in contrast to its \fBimplementation\fR, which it should feel free to +change whenever it likes. +.IX Xref "interfaces (term)" +.IP interpolation 4 +.IX Item "interpolation" +The insertion of a scalar or list value somewhere +in the middle of another value, such that it appears to have been there all +along. In Perl, variable interpolation happens in double-quoted strings and +patterns, and list interpolation occurs when constructing the list of +values to pass to a list operator or other such construct that takes a +\&\fR\f(CI\*(C`LIST\*(C'\fR\fI\fR. +.IX Xref "interpolation, defined" +.IP interpreter 4 +.IX Item "interpreter" +Strictly speaking, a program that reads a second +program and does what the second program says directly without turning the +program into a different form first, which is what \fBcompilers\fR 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 +(\fBsyntax trees\fR) within the \fIperl\fR process itself, which the Perl +\&\fBruntime\fR system then interprets. +.IX Xref "interpreters, defined" +.IP invocant 4 +.IX Item "invocant" +The agent on whose behalf a \fBmethod\fR is invoked. In a +\&\fBclass\fR method, the invocant is a package name. In an \fBinstance\fR method, +the invocant is an object reference. +.IX Xref "invocants, defined" +.IP invocation 4 +.IX Item "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. +.IX Xref "invocation, method" +.IP I/O 4 +.IX Item "I/O" +Input from, or output to, a \fBfile\fR or \fBdevice\fR. +.IX Xref "I O (Input Output), defined Input Output (I O), defined" +.IP IO 4 +.IX Item "IO" +An internal I/O object. Can also mean \fBindirect object\fR. +.IP "I/O layer" 4 +.IX Item "I/O layer" +One of the filters between the data and what you get as input +or what you end up with as output. +.IX Xref "I O layer" +.IP IPA 4 +.IX Item "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. +.IX Xref "International Phonetic Alphabet (IPA) IPA (International Phonetic Alphabet)" +.IP IP 4 +.IX Item "IP" +Internet Protocol, or +Intellectual +Property. +.IX Xref "Internet Protocol (IP) IP (Internet Protocol) IP (Intellectual Property) Intellectual Property (IP)" +.IP IPC 4 +.IX Item "IPC" +Interprocess Communication. +.IX Xref "Interprocess Communication IPC (Interprocess Communication), about communication" +.IP is-a 4 +.IX Item "is-a" +A relationship between two \fBobjects\fR 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 \fBbase +class\fR and a specific \fBderived class\fR. Oddly enough, Platonic classes +don’t always have Platonic relationships—see \fBinheritance\fR. +.IX Xref "is–a relationship" +.IP iteration 4 +.IX Item "iteration" +Doing something repeatedly. +.IX Xref "iteration" +.IP iterator 4 +.IX Item "iterator" +A special programming gizmo that keeps track of where you are +in something that you’re trying to iterate over. The \f(CW\*(C`foreach\*(C'\fR loop in +Perl contains an iterator; so does a hash, allowing you to \f(CW\*(C`each\*(C'\fR through +it. +.IX Xref "iterators" +.IP IV 4 +.IX Item "IV" +The integer four, not to be +confused with six, Tom’s favorite editor. IV also means an internal Integer +Value of the type a \fBscalar\fR can hold, not to be confused with an \fBNV\fR. +.IX Xref "IV (Integer Value) Integer Value (IV)" +.SS J +.IX Subsection "J" +.IP JAPH 4 +.IX Item "JAPH" +“Just Another Perl Hacker”, a clever but cryptic bit of Perl +code that, when executed, evaluates to that string. Often used to +illustrate a particular Perl feature, and something of an ongoing +Obfuscated Perl Contest seen in USENET signatures. +.IX Xref "JAPH acronym" +.SS K +.IX Subsection "K" +.IP key 4 +.IX Item "key" +The string index to a \fBhash\fR, used to look up the \fBvalue\fR +associated with that key. +.IX Xref "keys, defined" +.IP keyword 4 +.IX Item "keyword" +See \fBreserved words\fR. +.SS L +.IX Subsection "L" +.IP label 4 +.IX Item "label" +A name you give to a \fBstatement\fR so that you can talk +about that statement elsewhere in the program. +.IX Xref "labels, defined" +.IP laziness 4 +.IX Item "laziness" +The quality that makes you go to great effort to reduce +overall energy expenditure. It makes you write labor-saving programs that +other people will find useful, and 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 \fBimpatience\fR and +\&\fBhubris\fR. +.IX Xref "laziness quality" +.IP "leftmost longest" 4 +.IX Item "leftmost longest" +The preference of the \fBregular expression\fR engine to match the +leftmost occurrence of a \fBpattern\fR, then given a position at which a match +will occur, the preference for the longest match (presuming the use of a +\&\fBgreedy\fR quantifier). See Camel chapter 5, “Pattern Matching” for \fImuch\fR +more on this subject. +.IX Xref "leftmost longest preference regular expressions, leftmost longest preference" +.IP "left shift" 4 +.IX Item "left shift" +A \fBbit shift\fR that multiplies the +number by some power of 2. +.IX Xref "left shift (<<) bit operator bit–shift operators, left shift << (left shift) bit operator" +.IP lexeme 4 +.IX Item "lexeme" +Fancy term for a \fBtoken\fR. +.IX Xref "lexeme (token)" +.IP lexer 4 +.IX Item "lexer" +Fancy term for a \fBtokener\fR. +.IX Xref "lexer (tokener)" +.IP "lexical analysis" 4 +.IX Item "lexical analysis" +Fancy term for \fBtokenizing\fR. +.IX Xref "lexical analysis" +.IP "lexical scoping" 4 +.IX Item "lexical scoping" +Looking at your \fIOxford English +Dictionary\fR through a microscope. (Also known as \fBstatic scoping\fR, 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. +\&\fBstatic scoping\fR. —Ant. \fBdynamic scoping\fR. +.IX Xref "lexical scopes, defined scopes static scopes scopes, static" +.IP "lexical variable" 4 +.IX Item "lexical variable" +A \fBvariable\fR subject to +\&\fBlexical scoping\fR, declared by \f(CW\*(C`my\*(C'\fR. Often just called a “lexical”. (The +\&\f(CW\*(C`our\*(C'\fR declaration declares a lexically scoped name for a global variable, +which is not itself a lexical variable.) +.IX Xref "lexical variables, about variables, lexical" +.IP library 4 +.IX Item "library" +Generally, a collection of procedures. In ancient +days, referred to a collection of subroutines in a \fI.pl\fR file. In modern +times, refers more often to the entire collection of Perl \fBmodules\fR on +your system. +.IX Xref "libraries, defined" +.IP LIFO 4 +.IX Item "LIFO" +Last In, First Out. See also \fBFIFO\fR. A LIFO is usually called a +\&\fBstack\fR. +.IX Xref "Last In, First Out (LIFO) LIFO (Last In, First Out) stacks, defined" +.IP line 4 +.IX Item "line" +In Unix, a sequence of zero or more nonnewline characters +terminated with a \fBnewline\fR character. On non-Unix machines, this is +emulated by the C library even if the underlying \fBoperating system\fR has +different ideas. +.IX Xref "line (term)" +.IP linebreak 4 +.IX Item "linebreak" +A \fBgrapheme\fR consisting of either a carriage return followed +by a line feed or any character with the Unicode Vertical Space \fBcharacter +property\fR. +.IX Xref "linebreaks" +.IP "line buffering" 4 +.IX Item "line buffering" +Used by a \fBstandard I/O\fR output stream that +flushes its \fBbuffer\fR after every \fBnewline\fR. Many standard I/O libraries +automatically set up line buffering on output that is going to the terminal. +.IX Xref "line buffering buffering, line" +.IP "line number" 4 +.IX Item "line number" +The number of lines read previous to this one, plus 1. Perl +keeps a separate line number for each source or input file it opens. The +current source file’s line number is represented by \f(CW\*(C`_\|_LINE_\|_\*(C'\fR. The +current input line number (for the file that was most recently read via +\&\f(CW\*(C`<FH>\*(C'\fR) is represented by the \f(CW$.\fR (\f(CW$INPUT_LINE_NUMBER\fR) +variable. Many error messages report both values, if available. +.IX Xref "line number" +.IP link 4 +.IX Item "link" +Used as a noun, a name in a \fBdirectory\fR that represents a +\&\fBfile\fR. 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 \fBcompiled\fR 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. +.IX Xref "links, defined" +.IP LIST 4 +.IX Item "LIST" +A syntactic construct representing a +comma\- separated list of expressions, evaluated to produce a \fBlist value\fR. +Each \fBexpression\fR in a \fR\f(CI\*(C`LIST\*(C'\fR\fI\fR is evaluated in \fBlist context\fR and +interpolated into the list value. +.IX Xref "LIST construct constructs, LIST" +.IP list 4 +.IX Item "list" +An ordered set of scalar values. +.IX Xref "lists, defined" +.IP "list context" 4 +.IX Item "list context" +The situation in which an \fBexpression\fR is +expected by its surroundings (the code calling it) to return a list of +values rather than a single value. Functions that want a \fR\f(CI\*(C`LIST\*(C'\fR\fI\fR of +arguments tell those arguments that they should produce a list value. See +also \fBcontext\fR. +.IX Xref "list context context, list" +.IP "list operator" 4 +.IX Item "list operator" +An \fBoperator\fR that does something with a list of +values, such as \f(CW\*(C`join\*(C'\fR or \f(CW\*(C`grep\*(C'\fR. Usually used for named built-in +operators (such as \f(CW\*(C`print\*(C'\fR, \f(CW\*(C`unlink\*(C'\fR, and \f(CW\*(C`system\*(C'\fR) that do not require +parentheses around their \fBargument\fR list. +.IX Xref "list operators, about" +.IP "list value" 4 +.IX Item "list value" +An unnamed list of temporary scalar +values that may be passed around within a program from any list-generating +function to any function or construct that provides a \fBlist context\fR. +.IX Xref "list values, about values, list" +.IP literal 4 +.IX Item "literal" +A token in a programming language, such as a number or +\&\fBstring\fR, that gives you an actual \fBvalue\fR instead of merely representing +possible values as a \fBvariable\fR does. +.IX Xref "literals, defined" +.IP little-endian 4 +.IX Item "little-endian" +From Swift: someone +who eats eggs little end first. Also used of computers that store the least +significant \fBbyte\fR of a word at a lower byte address than the most +significant byte. Often considered superior to big-endian machines. See +also \fBbig-endian\fR. +.IX Xref "little–endian, defined endianness, little–endian" +.IP local 4 +.IX Item "local" +Not meaning the same thing everywhere. A global +variable in Perl can be localized inside a \fBdynamic scope\fR via the +\&\f(CW\*(C`local\*(C'\fR operator. +.IX Xref "local operator, about" +.IP "logical operator" 4 +.IX Item "logical operator" +Symbols representing the concepts “and”, “or”, +“xor”, and “not”. +.IX Xref "logical operators, about" +.IP lookahead 4 +.IX Item "lookahead" +An \fBassertion\fR that peeks at the string to the right of the current match location. +.IX Xref "lookahead assertions assertions (in regexes), lookahead" +.IP lookbehind 4 +.IX Item "lookbehind" +An \fBassertion\fR that peeks at the string to the left of the current match +location. +.IX Xref "lookbehind assertions assertions (in regexes), lookbehind" +.IP loop 4 +.IX Item "loop" +A construct that +performs something repeatedly, like a roller coaster. +.IX Xref "loop constructs and statements, about constructs, loop" +.IP "loop control statement" 4 +.IX Item "loop control statement" +Any statement within the body of a loop that can +make a loop prematurely stop looping or skip an \fBiteration\fR. Generally, +you shouldn’t try this on roller coasters. +.IX Xref "statements, loop control" +.IP "loop label" 4 +.IX Item "loop label" +A kind of key or name attached to a loop (or +roller coaster) so that loop control statements can talk about which loop +they want to control. +.IX Xref "loop labels labels, loop" +.IP lowercase 4 +.IX Item "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. +.IX Xref "lowercase characters characters, lowercase" +.IP lvaluable 4 +.IX Item "lvaluable" +Able to serve as an \fBlvalue\fR. +.IX Xref "lvaluable function functions, lvaluable" +.IP lvalue 4 +.IX Item "lvalue" +Term used by language lawyers for a +storage location you can assign a new \fBvalue\fR to, such as a \fBvariable\fR or +an element of an \fBarray\fR. The “l” is short for “left”, as in the left side +of an assignment, a typical place for lvalues. An \fBlvaluable\fR function or +expression is one to which a value may be assigned, as in \f(CW\*(C`pos($x) = 10\*(C'\fR. +.IX Xref "lvalue (term) values, lvalue" +.IP "lvalue modifier" 4 +.IX Item "lvalue modifier" +An adjectival pseudofunction that +warps the meaning of an \fBlvalue\fR in some declarative fashion. Currently +there are three lvalue modifiers: \f(CW\*(C`my\*(C'\fR, \f(CW\*(C`our\*(C'\fR, and \f(CW\*(C`local\*(C'\fR. +.IX Xref "lvalue modifier modifiers, lvalue" +.SS M +.IX Subsection "M" +.IP magic 4 +.IX Item "magic" +Technically speaking, any extra semantics attached to a +variable such as \f(CW$!\fR, \f(CW$0\fR, \f(CW%ENV\fR, or \f(CW%SIG\fR, or to any tied +variable. Magical things happen when you diddle those variables. +.IX Xref "magic (term)" +.IP "magical increment" 4 +.IX Item "magical increment" +An \fBincrement\fR operator that knows how to +bump up ASCII alphabetics as well as numbers. +.IX Xref "magical increment operator" +.IP "magical variables" 4 +.IX Item "magical variables" +Special variables that have side +effects when you access them or assign to them. For example, in Perl, +changing elements of the \f(CW%ENV\fR array also changes the corresponding +environment variables that subprocesses will use. Reading the \f(CW$!\fR +variable gives you the current system error number or message. +.IX Xref "magical variables variables, magical" +.IP Makefile 4 +.IX Item "Makefile" +A file that controls the compilation of a program. Perl programs +don’t usually need a \fBMakefile\fR because the Perl compiler has plenty of +self-control. +.IX Xref "Makefile" +.IP man 4 +.IX Item "man" +The Unix program that displays online documentation +(manual pages) for you. +.IX Xref "man program (Unix)" +.IP manpage 4 +.IX Item "manpage" +A “page” from the manuals, typically accessed via the +\&\fIman\fR(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 \fBcommands\fR, \fBsyscalls\fR, \fBlibrary\fR \fBfunctions\fR, \fBdevices\fR, +\&\fBprotocols\fR, \fBfiles\fR, 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. +.IX Xref "manpages, defined" +.IP matching 4 +.IX Item "matching" +See \fBpattern matching\fR. +.IX Xref "matching" +.IP "member data" 4 +.IX Item "member data" +See \fBinstance variable\fR. +.IX Xref "member data" +.IP memory 4 +.IX Item "memory" +This always means your main memory, not your disk. +Clouding the issue is the fact that your machine may implement +\&\fBvirtual\fR 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. +.IX Xref "memory, defined" +.IP metacharacter 4 +.IX Item "metacharacter" +A \fBcharacter\fR that is \fInot\fR supposed to be treated normally. Which characters +are to be treated specially as metacharacters varies greatly from context to +context. Your \fBshell\fR will have certain metacharacters, double-quoted Perl +\&\fBstrings\fR have other metacharacters, +and \fBregular expression\fR patterns have all the double-quote metacharacters plus +some extra ones of their own. +.IX Xref "metacharacters, about characters, regex metacharacters regular expressions, metacharacters and" +.IP metasymbol 4 +.IX Item "metasymbol" +Something we’d call a +\&\fBmetacharacter\fR 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. +.IX Xref "metasymbols, about escape sequences" +.IP method 4 +.IX Item "method" +A kind of action that an \fBobject\fR can take if you tell +it to. See Camel chapter 12, “Objects”. +.IX Xref "methods, defined" +.IP "method resolution order" 4 +.IX Item "method resolution order" +The path Perl takes through \f(CW@INC\fR. By default, this is a double depth first +search, once looking for defined methods and once for \f(CW\*(C`AUTOLOAD\*(C'\fR. However, +Perl lets you configure this with \f(CW\*(C`mro\*(C'\fR. +.IX Xref "method resolution order (mro) mro (method resolution order)" +.IP minicpan 4 +.IX Item "minicpan" +A CPAN mirror that includes just the latest versions for each +distribution, probably created with \f(CW\*(C`CPAN::Mini\*(C'\fR. See +Camel chapter 19, “CPAN”. +.IX Xref "minicpan, defined CPAN (Comprehensive Perl Archive Network), minicpan and CPAN::Mini module" +.IP minimalism 4 +.IX Item "minimalism" +The belief that “small is beautiful”. Paradoxically, if you +say something in a small language, it turns out big, and if you say it in a +big language, it turns out small. Go figure. +.IX Xref "minimalism" +.IP mode 4 +.IX Item "mode" +In the context of the \fIstat\fR(2) syscall, refers to the field +holding the \fBpermission bits\fR and the type of the \fBfile\fR. +.IX Xref "mode" +.IP modifier 4 +.IX Item "modifier" +See \fBstatement modifier\fR, \fBregular expression\fR, and +\&\fBlvalue\fR, not necessarily in that order. +.IX Xref "modifiers, defined" +.IP module 4 +.IX Item "module" +A \fBfile\fR that defines a \fBpackage\fR of (almost) the same +name, which can either \fBexport\fR symbols or function as an \fBobject\fR class. +(A module’s main \fI.pm\fR file may also load in other files in support of the +module.) See the \f(CW\*(C`use\*(C'\fR built-in. +.IX Xref "modules, defined" +.IP modulus 4 +.IX Item "modulus" +An integer divisor when +you’re interested in the remainder instead of the quotient. +.IX Xref "modulus (%) operator % (modulus) operator" +.IP mojibake 4 +.IX Item "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 [\f(CW\*(C`modʑibake\*(C'\fR] in +standard \fBIPA\fR phonetics, or approximately “moh\-jee\-bah\-keh”. +.IX Xref "mojibake" +.IP monger 4 +.IX Item "monger" +Short for one member of \fBPerl mongers\fR, a +purveyor of Perl. +.IX Xref "mongers, Perl Perl mongers" +.IP mortal 4 +.IX Item "mortal" +A temporary value scheduled to die when the +current statement finishes. +.IX Xref "mortal value values, mortal" +.IP mro 4 +.IX Item "mro" +See \fBmethod resolution order\fR. +.IP "multidimensional array" 4 +.IX Item "multidimensional array" +An array with multiple +subscripts for finding a single element. Perl implements these using +\&\fBreferences\fR—see Camel chapter 9, “Data Structures”. +.IX Xref "multidimensional arrays arrays, multidimensional" +.IP "multiple inheritance" 4 +.IX Item "multiple inheritance" +The features you got from +your mother and father, mixed together unpredictably. (See also +\&\fBinheritance\fR and \fBsingle inheritance\fR.) In computer languages (including +Perl), it is the notion that a given class may have multiple direct +ancestors or \fBbase classes\fR. +.IX Xref "multiple inheritance inheritance, multiple" +.SS N +.IX Subsection "N" +.IP "named pipe" 4 +.IX Item "named pipe" +A \fBpipe\fR with a name embedded in the +\&\fBfilesystem\fR so that it can be accessed by two unrelated \fBprocesses\fR. +.IX Xref "named pipes pipes, names" +.IP namespace 4 +.IX Item "namespace" +A domain of names. You needn’t worry about whether the +names in one such domain have been used in another. See \fBpackage\fR. +.IX Xref "namespaces, about" +.IP NaN 4 +.IX Item "NaN" +Not a number. The value Perl uses +for certain invalid or inexpressible floating-point operations. +.IX Xref "NaN (not a number) not a number (NaN)" +.IP "network address" 4 +.IX Item "network address" +The most important attribute of a socket, like your +telephone’s telephone number. Typically an IP address. See also \fBport\fR. +.IX Xref "network address" +.IP newline 4 +.IX Item "newline" +A single character that +represents the end of a line, with the ASCII value of 012 octal under Unix +(but 015 on a Mac), and represented by \f(CW\*(C`\en\*(C'\fR 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. +.IX Xref "newline character characters, newline" +.IP NFS 4 +.IX Item "NFS" +Network File System, which allows you to mount a remote filesystem as if it were local. +.IX Xref "NFS (Network File System) Network File System (NFS)" +.IP normalization 4 +.IX Item "normalization" +Converting a text string into an alternate but equivalent +\&\fBcanonical\fR (or compatible) representation that can then be compared for +equivalence. Unicode recognizes four different normalization forms: NFD, +NFC, NFKD, and NFKC. +.IX Xref "normalization" +.IP "null character" 4 +.IX Item "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. +.IX Xref "null character characters, null" +.IP "null list" 4 +.IX Item "null list" +A \fBlist value\fR with zero elements, represented +in Perl by \f(CW\*(C`()\*(C'\fR. +.IX Xref "null lists lists, null" +.IP "null string" 4 +.IX Item "null string" +A \fBstring\fR containing no characters, not to +be confused with a string containing a \fBnull character\fR, which has a +positive length and is \fBtrue\fR. +.IX Xref "null strings strings, null" +.IP "numeric context" 4 +.IX Item "numeric context" +The situation in which an expression +is expected by its surroundings (the code calling it) to return a number. +See also \fBcontext\fR and \fBstring context\fR. +.IX Xref "numeric context context, numeric" +.IP numification 4 +.IX Item "numification" +(Sometimes spelled \fInummification\fR and \fInummify\fR.) Perl lingo +for implicit conversion into a number; the related verb is \fInumify\fR. +\&\fINumification\fR is intended to rhyme with \fImummification\fR, and \fInumify\fR with +\&\fImummify\fR. It is unrelated to English \fInumen\fR, \fInumina\fR, \fInuminous\fR. We +originally forgot the extra \fIm\fR a long time ago, and some people got used to +our funny spelling, and so just as with \f(CW\*(C`HTTP_REFERER\*(C'\fR’s own missing letter, +our weird spelling has stuck around. +.IX Xref "numification" +.IP NV 4 +.IX Item "NV" +Short for Nevada, no part of +which will ever be confused with civilization. NV also means an internal +floating\- point Numeric Value of the type a \fBscalar\fR can hold, not to be +confused with an \fBIV\fR. +.IX Xref "Numeric Value (NV) NV (Numeric Value)" +.IP nybble 4 +.IX Item "nybble" +Half a \fBbyte\fR, equivalent to one \fBhexadecimal\fR digit, and worth +four \fBbits\fR. +.IX Xref "nybble" +.SS O +.IX Subsection "O" +.IP object 4 +.IX Item "object" +An \fBinstance\fR of a \fBclass\fR. 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. +.IX Xref "objects, defined" +.IP octal 4 +.IX Item "octal" +A number in base 8. Only the digits 0 through 7 are allowed. Octal +constants in Perl start with 0, as in 013. See also the \f(CW\*(C`oct\*(C'\fR function. +.IX Xref "octals" +.IP offset 4 +.IX Item "offset" +How many things you have to skip +over when moving from the beginning of a string or array to a specific +position within it. Thus, the minimum offset is zero, not one, because you +don’t skip anything to get to the first item. +.IX Xref "offsets in strings strings, offsets in" +.IP one-liner 4 +.IX Item "one-liner" +An entire computer program crammed into one line of +text. +.IX Xref "one–liner programs" +.IP "open source software" 4 +.IX Item "open source software" +Programs for which the source code is freely +available and freely redistributable, with no commercial strings attached. +For a more detailed definition, see <http://www.opensource.org/osd.html>. +.IX Xref "open source software" +.IP operand 4 +.IX Item "operand" +An \fBexpression\fR that yields a \fBvalue\fR that an +\&\fBoperator\fR operates on. See also \fBprecedence\fR. +.IX Xref "operands (term)" +.IP "operating system" 4 +.IX Item "operating system" +A special program that runs on the bare +machine and hides the gory details of managing \fBprocesses\fR and \fBdevices\fR. +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 +\&\fBarchitecture\fR and \fBplatform\fR. +.IX Xref "operating systems, defined" +.IP operator 4 +.IX Item "operator" +A gizmo that transforms some number of input values to +some number of output values, often built into a language with a special +syntax or symbol. A given operator may have specific expectations about +what \fBtypes\fR of data you give as its arguments (\fBoperands\fR) and what type +of data you want back from it. +.IX Xref "operators, about" +.IP "operator overloading" 4 +.IX Item "operator overloading" +A kind of +\&\fBoverloading\fR that you can do on built-in \fBoperators\fR to make them work +on \fBobjects\fR 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 \fBpragma\fR—see Camel chapter 13, “Overloading”. +.IX Xref "operator overloading, about overloading, operator" +.IP options 4 +.IX Item "options" +See either \fBswitches\fR or \fBregular expression modifiers\fR. +.IX Xref "options" +.IP ordinal 4 +.IX Item "ordinal" +An abstract character’s integer value. Same thing as +\&\fBcodepoint\fR. +.IX Xref "ordinals (term)" +.IP overloading 4 +.IX Item "overloading" +Giving additional meanings to a symbol or construct. +Actually, all languages do overloading to one extent or another, since +people are good at figuring out things from \fBcontext\fR. +.IX Xref "overloading, defined" +.IP overriding 4 +.IX Item "overriding" +Hiding or invalidating some other definition of the +same name. (Not to be confused with \fBoverloading\fR, 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 \fBsubroutine\fR to hide a built-in \fBfunction\fR 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 \fBmethod\fR in a +\&\fBderived class\fR to hide a \fBbase class\fR’s method of the same name (see +Camel chapter 12, “Objects”). +.IX Xref "overriding, defined" +.IP owner 4 +.IX Item "owner" +The one user (apart from the +superuser) who has absolute control over a \fBfile\fR. A file may also have a +\&\fBgroup\fR of users who may exercise joint ownership if the real owner +permits it. See \fBpermission bits\fR. +.IX Xref "ownership, file files, ownership of" +.SS P +.IX Subsection "P" +.IP package 4 +.IX Item "package" +A \fBnamespace\fR for global \fBvariables\fR, \fBsubroutines\fR, +and the like, such that they can be kept separate from like-named +\&\fBsymbols\fR 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 \fBcompiled\fR outside the package by naming the package. But in another +sense, all package symbols are also globals—they’re just well-organized +globals. +.IX Xref "packages, defined" +.IP pad 4 +.IX Item "pad" +Short for \fBscratchpad\fR. +.IX Xref "pads (scratchpads)" +.IP parameter 4 +.IX Item "parameter" +See \fBargument\fR. +.IX Xref "parameters" +.IP "parent class" 4 +.IX Item "parent class" +See \fBbase class\fR. +.IX Xref "parent classes classes, parent" +.IP "parse tree" 4 +.IX Item "parse tree" +See \fBsyntax tree\fR. +.IX Xref "parse tree" +.IP parsing 4 +.IX Item "parsing" +The subtle but sometimes brutal art of attempting to turn +your possibly malformed program into a valid \fBsyntax tree\fR. +.IX Xref "parsing, about" +.IP patch 4 +.IX Item "patch" +To fix by applying one, as it were. In the realm of hackerdom, a +listing of the differences between two versions of a program as might be +applied by the \fBpatch\fR(1) program when you want to fix a bug or upgrade +your old version. +.IX Xref "patches" +.IP PATH 4 +.IX Item "PATH" +The list of +\&\fBdirectories\fR the system searches to find a program you want to +\&\fBexecute\fR. The list is stored as one of your \fBenvironment variables\fR, +accessible in Perl as \f(CW$ENV{PATH}\fR. +.IX Xref "PATH environment variable variables, environment" +.IP pathname 4 +.IX Item "pathname" +A fully qualified filename such as \fI/usr/bin/perl\fR. Sometimes +confused with \f(CW\*(C`PATH\*(C'\fR. +.IX Xref "pathname" +.IP pattern 4 +.IX Item "pattern" +A template used in \fBpattern matching\fR. +.IX Xref "patterns, defined" +.IP "pattern matching" 4 +.IX Item "pattern matching" +Taking a pattern, usually a \fBregular +expression\fR, 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. +.IX Xref "pattern matching, about" +.IP PAUSE 4 +.IX Item "PAUSE" +The Perl Authors Upload SErver (<http://pause.perl.org>), the gateway +for \fBmodules\fR on their way to \fBCPAN\fR. +.IX Xref "Perl Authors Upload SErver (PAUSE) PAUSE (Perl Authors Upload SErver)" +.IP "Perl mongers" 4 +.IX Item "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>. +.IX Xref "Perl mongers mongers, Perl" +.IP "permission bits" 4 +.IX Item "permission bits" +Bits that the \fBowner\fR of a file sets +or unsets to allow or disallow access to other people. These flag bits are +part of the \fBmode\fR word returned by the \f(CW\*(C`stat\*(C'\fR built-in when you ask +about a file. On Unix systems, you can check the \fIls\fR(1) manpage for more +information. +.IX Xref "permission bits bits, permission" +.IP Pern 4 +.IX Item "Pern" +What you get when you do \f(CW\*(C`Perl++\*(C'\fR twice. Doing it only once +will curl your hair. You have to increment it eight times to shampoo your +hair. Lather, rinse, iterate. +.IX Xref "Pern (term)" +.IP pipe 4 +.IX Item "pipe" +A direct \fBconnection\fR that carries the output of one +\&\fBprocess\fR 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. +.IX Xref "pipes, defined" +.IP pipeline 4 +.IX Item "pipeline" +A series of \fBprocesses\fR all in a row, linked by \fBpipes\fR, where +each passes its output stream to the next. +.IX Xref "pipeline" +.IP platform 4 +.IX Item "platform" +The entire hardware and software context in which a +program runs. A program written in a platform-dependent language might +break if you change any of the following: machine, operating system, +libraries, compiler, or system configuration. The \fIperl\fR interpreter has +to be \fBcompiled\fR differently for each platform because it is implemented +in C, but programs written in the Perl language are largely platform +independent. +.IX Xref "platforms, defined" +.IP pod 4 +.IX Item "pod" +The markup +used to embed documentation into your Perl code. Pod stands for “Plain old +documentation”. See Camel chapter 23, “Plain Old Documentation”. +.IX Xref "pod (plain old documentation), about plain old documentation" +.IP "pod command" 4 +.IX Item "pod command" +A sequence, such as \f(CW\*(C`=head1\*(C'\fR, that denotes +the start of a \fBpod\fR section. +.IX Xref "pod commands commands, pod" +.IP pointer 4 +.IX Item "pointer" +A \fBvariable\fR 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 \fBkeys\fR and \fBvariable\fR names, or \fBhard references\fR, which +aren’t pointers (but act like pointers and do in fact contain pointers). +.IX Xref "pointers" +.IP polymorphism 4 +.IX Item "polymorphism" +The notion that you can tell an \fBobject\fR to do something +generic, and the object will interpret the command in different ways +depending on its type. [< Greek πολυ\- + μορϕή, many forms.] +.IX Xref "polymorphism" +.IP port 4 +.IX Item "port" +The part of the address of a TCP or UDP socket that directs +packets to the correct process after finding the right machine, something +like the phone extension you give when you reach the company operator. Also +the result of converting code to run on a different platform than +originally intended, or the verb denoting this conversion. +.IX Xref "ports (term)" +.IP portable 4 +.IX Item "portable" +Once upon a time, C code compilable under both BSD and +SysV. In general, code that can be easily converted to run on another +\&\fBplatform\fR, 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. +.IX Xref "portability, about" +.IP porter 4 +.IX Item "porter" +Someone who “carries” software from one \fBplatform\fR 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. +.IX Xref "porters" +.IP possessive 4 +.IX Item "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 \fInonbacktrackable\fR. +.IX Xref "possessive (term)" +.IP POSIX 4 +.IX Item "POSIX" +The Portable Operating System Interface +specification. +.IX Xref "Portable Operating System Interface (POSIX), about POSIX (Portable Operating System Interface), about" +.IP postfix 4 +.IX Item "postfix" +An \fBoperator\fR that follows its \fBoperand\fR, as in +\&\f(CW\*(C`$x++\*(C'\fR. +.IX Xref "postfix operator" +.IP pp 4 +.IX Item "pp" +An internal shorthand for a +“push\- pop” code; that is, C code implementing Perl’s stack machine. +.IX Xref "pp (push–pop) code push–pop (pp) code" +.IP pragma 4 +.IX Item "pragma" +A standard module whose practical hints and +suggestions are received (and possibly ignored) at compile time. Pragmas +are named in all lowercase. +.IX Xref "pragmas, about modules" +.IP precedence 4 +.IX Item "precedence" +The rules of +conduct that, in the absence of other guidance, determine what should +happen first. For example, in the absence of parentheses, you always do +multiplication before addition. +.IX Xref "precedence rules, about operators, precedence rules" +.IP prefix 4 +.IX Item "prefix" +An \fBoperator\fR that precedes its \fBoperand\fR, as in +\&\f(CW\*(C`++$x\*(C'\fR. +.IX Xref "prefix operators" +.IP preprocessing 4 +.IX Item "preprocessing" +What some helper \fBprocess\fR did to transform the incoming +data into a form more suitable for the current process. Often done with an +incoming \fBpipe\fR. See also \fBC preprocessor\fR. +.IX Xref "preprocessing" +.IP "primary maintainer" 4 +.IX Item "primary maintainer" +The author that PAUSE allows to assign \fBco-maintainer\fR +permissions to a \fBnamespace\fR. A primary maintainer can give up this +distinction by assigning it to another PAUSE author. See Camel chapter 19, +“CPAN”. +.IX Xref "primary maintainer" +.IP procedure 4 +.IX Item "procedure" +A \fBsubroutine\fR. +.IX Xref "procedures, defined" +.IP process 4 +.IX Item "process" +An instance of a running program. Under multitasking +systems like Unix, two or more separate processes could be running the same +program independently at the same time—in fact, the \f(CW\*(C`fork\*(C'\fR 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. +.IX Xref "processes, defined" +.IP program 4 +.IX Item "program" +See \fBscript\fR. +.IP "program generator" 4 +.IX Item "program generator" +A system that algorithmically writes code for you in a +high-level language. See also \fBcode generator\fR. +.IX Xref "program generators" +.IP "progressive matching" 4 +.IX Item "progressive matching" +\&\fBPattern matching\fR matching>that picks up where it left off before. +.IX Xref "progressive matching pattern matching, progressive matching" +.IP property 4 +.IX Item "property" +See either \fBinstance variable\fR or \fBcharacter property\fR. +.IX Xref "property" +.IP protocol 4 +.IX Item "protocol" +In networking, an agreed-upon way of sending messages +back and forth so that neither correspondent will get too confused. +.IX Xref "protocols (term)" +.IP prototype 4 +.IX Item "prototype" +An optional part of a \fBsubroutine\fR declaration telling +the Perl compiler how many and what flavor of arguments may be passed as +\&\fBactual arguments\fR, so you can write subroutine calls that parse much like +built-in functions. (Or don’t parse, as the case may be.) +.IX Xref "prototypes, about" +.IP pseudofunction 4 +.IX Item "pseudofunction" +A construct that sometimes looks like a function but really +isn’t. Usually reserved for \fBlvalue\fR modifiers like \f(CW\*(C`my\*(C'\fR, for \fBcontext\fR +modifiers like \f(CW\*(C`scalar\*(C'\fR, and for the pick-your-own-quotes constructs, +\&\f(CW\*(C`q//\*(C'\fR, \f(CW\*(C`qq//\*(C'\fR, \f(CW\*(C`qx//\*(C'\fR, \f(CW\*(C`qw//\*(C'\fR, \f(CW\*(C`qr//\*(C'\fR, \f(CW\*(C`m//\*(C'\fR, \f(CW\*(C`s///\*(C'\fR, \f(CW\*(C`y///\*(C'\fR, and +\&\f(CW\*(C`tr///\*(C'\fR. +.IX Xref "pseudofunctions constructs, pseudofunctions functions, pseudofunctions" +.IP pseudohash 4 +.IX Item "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. +.IX Xref "pseudohashes hashes, pseudohashes" +.IP pseudoliteral 4 +.IX Item "pseudoliteral" +An \fBoperator\fR X\f(CW\*(C`that looks something like a \fR\f(CBliteral\fR\f(CW, +such as the output\-grabbing operator, <literal +moreinfo="none"\*(C'\fR`>\fR\f(CI\*(C`command\*(C'\fR\fI\fR\f(CW\*(C`\`\*(C'\fR. +.IX Xref "pseudoliterals" +.IP "public domain" 4 +.IX Item "public domain" +Something not owned by anybody. Perl is copyrighted and is +thus \fInot\fR in the public domain—it’s just \fBfreely available\fR and \fBfreely +redistributable\fR. +.IX Xref "public domain" +.IP pumpkin 4 +.IX Item "pumpkin" +A notional “baton” handed around the Perl community +indicating who is the lead integrator in some arena of development. +.IX Xref "pumpkin (term)" +.IP pumpking 4 +.IX Item "pumpking" +A \fBpumpkin\fR 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. +.IX Xref "pumpking" +.IP PV 4 +.IX Item "PV" +A “pointer value”, which is Perl +Internals Talk for a \f(CW\*(C`char*\*(C'\fR. +.IX Xref "PV (pointer value) pointer value (PV)" +.SS Q +.IX Subsection "Q" +.IP qualified 4 +.IX Item "qualified" +Possessing a complete name. The symbol \f(CW$Ent::moot\fR is +qualified; \f(CW$moot\fR is unqualified. A fully qualified filename is specified +from the top-level directory. +.IX Xref "qualified (term)" +.IP quantifier 4 +.IX Item "quantifier" +A component of a \fBregular expression\fR specifying how +many times the foregoing \fBatom\fR may occur. +.IX Xref "quantifiers, about" +.SS R +.IX Subsection "R" +.IP "race condition" 4 +.IX Item "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 \fBexploit\fR. +.IX Xref "race conditions, defined" +.IP readable 4 +.IX Item "readable" +With respect to files, one that has the proper permission +bit set to let you access the file. With respect to computer programs, one +that’s written well enough that someone has a chance of figuring out what +it’s trying to do. +.IX Xref "readable (term)" +.IP reaping 4 +.IX Item "reaping" +The last rites performed by a parent \fBprocess\fR +on behalf of a deceased child process so that it doesn’t remain a +\&\fBzombie\fR. See the \f(CW\*(C`wait\*(C'\fR and \f(CW\*(C`waitpid\*(C'\fR function calls. +.IX Xref "reaping zombie processes" +.IP record 4 +.IX Item "record" +A set of related data values in a \fBfile\fR or \fBstream\fR, +often associated with a unique \fBkey\fR field. In Unix, often commensurate +with a \fBline\fR, or a blank\-line–terminated set of lines (a “paragraph”). +Each line of the \fI/etc/passwd\fR file is a record, keyed on login name, +containing information about that user. +.IX Xref "records, defined" +.IP recursion 4 +.IX Item "recursion" +The art of defining something (at least partly) in +terms of itself, which is a naughty no-no in dictionaries but often works +out okay in computer programs if you’re careful not to recurse forever +(which is like an infinite loop with more spectacular failure modes). +.IX Xref "recursion, defined" +.IP reference 4 +.IX Item "reference" +Where you look to find a pointer to information +somewhere else. (See \fBindirection\fR.) References come in two flavors: +\&\fBsymbolic references\fR and \fBhard references\fR. +.IX Xref "references, about" +.IP referent 4 +.IX Item "referent" +Whatever a reference refers to, which may or may not +have a name. Common types of referents include scalars, arrays, hashes, and +subroutines. +.IX Xref "referents, defined" +.IP regex 4 +.IX Item "regex" +See \fBregular expression\fR. +.IP "regular expression" 4 +.IX Item "regular expression" +A single entity with various +interpretations, like an elephant. To a computer scientist, it’s a grammar +for a little language in which some strings are legal and others aren’t. To +normal people, it’s a pattern you can use to find what you’re looking for +when it varies from case to case. Perl’s regular expressions are far from +regular in the theoretical sense, but in regular use they work quite well. +Here’s a regular expression: \f(CW\*(C`/Oh s.*t./\*(C'\fR. This will match strings like +“\f(CW\*(C`Oh say can you see by the dawn\*(Aqs early light\*(C'\fR” and “\f(CW\*(C`Oh sit!\*(C'\fR”. See +Camel chapter 5, “Pattern Matching”. +.IX Xref "regular expressions, defined" +.IP "regular expression modifier" 4 +.IX Item "regular expression modifier" +An option on a pattern or substitution, such as \f(CW\*(C`/i\*(C'\fR to render the pattern +case\- insensitive. +.IX Xref "regular expression modifiers modifiers, regular expression" +.IP "regular file" 4 +.IX Item "regular file" +A \fBfile\fR that’s not a \fBdirectory\fR, a +\&\fBdevice\fR, a named \fBpipe\fR or \fBsocket\fR, or a \fBsymbolic link\fR. Perl uses +the \f(CW\*(C`–f\*(C'\fR file test operator to identify regular files. Sometimes called a +“plain” file. +.IX Xref "regular files files, regular" +.IP "relational operator" 4 +.IX Item "relational operator" +An \fBoperator\fR that says whether a particular +ordering relationship is \fBtrue\fR about a pair of \fBoperands\fR. Perl has both +numeric and string relational operators. See \fBcollating sequence\fR. +.IX Xref "relational operators" +.IP "reserved words" 4 +.IX Item "reserved words" +A word with a specific, built-in meaning +to a \fBcompiler\fR, such as \f(CW\*(C`if\*(C'\fR or \f(CW\*(C`delete\*(C'\fR. 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 +\&\fBlabels\fR or \fBfilehandles\fR. Also called “keywords”. +.IX Xref "reserved words keywords (term)" +.IP "return value" 4 +.IX Item "return value" +The \fBvalue\fR produced by a \fBsubroutine\fR +or \fBexpression\fR when evaluated. In Perl, a return value may be either a +\&\fBlist\fR or a \fBscalar\fR. +.IX Xref "return values values, return" +.IP RFC 4 +.IX Item "RFC" +Request For Comment, which despite the timid connotations is the name of a series of +important standards documents. +.IX Xref "Request For Comment (RFC) RFC (Request For Comment)" +.IP "right shift" 4 +.IX Item "right shift" +A \fBbit shift\fR that divides +a number by some power of 2. +.IX Xref "right shift (>>) bit operator bit–shift operators, right shift >> (right shift) bit operator" +.IP role 4 +.IX Item "role" +A name for a concrete set of behaviors. A role is a way to +add behavior to a class without inheritance. +.IX Xref "roles (term)" +.IP root 4 +.IX Item "root" +The superuser (\f(CW\*(C`UID\*(C'\fR == 0). Also the top-level directory of +the filesystem. +.IX Xref "root (term)" +.IP RTFM 4 +.IX Item "RTFM" +What you are told when someone thinks you should Read The +Fine Manual. +.IX Xref "RTFM acronym" +.IP "run phase" 4 +.IX Item "run phase" +Any time after Perl starts running your main program. +See also \fBcompile phase\fR. Run phase is mostly spent in \fBruntime\fR but may +also be spent in \fBcompile time\fR when \f(CW\*(C`require\*(C'\fR, \f(CW\*(C`do\*(C'\fR \fR\f(CI\*(C`FILE\*(C'\fR\fI\fR, or +\&\f(CW\*(C`eval\*(C'\fR \fI\fR\f(CI\*(C`STRING\*(C'\fR\fI\fR operators are executed, or when a substitution uses +the \f(CW\*(C`/ee\*(C'\fR modifier. +.IX Xref "run phase, defined" +.IP runtime 4 +.IX Item "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 \fBcompile time\fR. +.IX Xref "runtime (term), defined" +.IP "runtime pattern" 4 +.IX Item "runtime pattern" +A pattern that contains one or more +variables to be interpolated before parsing the pattern as a \fBregular +expression\fR, 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. +.IX Xref "runtime patterns patterns, runtime" +.IP RV 4 +.IX Item "RV" +A recreational vehicle, not +to be confused with vehicular recreation. RV also means an internal +Reference Value of the type a \fBscalar\fR can hold. See also \fBIV\fR and \fBNV\fR +if you’re not confused yet. +.IX Xref "Reference Value (RV) RV (Reference Value)" +.IP rvalue 4 +.IX Item "rvalue" +A \fBvalue\fR that you might find on the +right side of an \fBassignment\fR. See also \fBlvalue\fR. +.IX Xref "rvalue (term) values, rvalue" +.SS S +.IX Subsection "S" +.IP sandbox 4 +.IX Item "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”. +.IX Xref "sandbox, defined" +.IP scalar 4 +.IX Item "scalar" +A simple, singular value; a number, \fBstring\fR, or +\&\fBreference\fR. +.IX Xref "scalars, defined" +.IP "scalar context" 4 +.IX Item "scalar context" +The situation in which an +\&\fBexpression\fR is expected by its surroundings (the code calling it) to +return a single \fBvalue\fR rather than a \fBlist\fR of values. See also +\&\fBcontext\fR and \fBlist context\fR. A scalar context sometimes imposes +additional constraints on the return value—see \fBstring context\fR and +\&\fBnumeric context\fR. Sometimes we talk about a \fBBoolean context\fR inside +conditionals, but this imposes no additional constraints, since any scalar +value, whether numeric or \fBstring\fR, is already true or false. +.IX Xref "scalar context, about context, scalar" +.IP "scalar literal" 4 +.IX Item "scalar literal" +A number or quoted \fBstring\fR—an actual +\&\fBvalue\fR in the text of your program, as opposed to a \fBvariable\fR. +.IX Xref "scalar literals literals, scalar" +.IP "scalar value" 4 +.IX Item "scalar value" +A value that happens to be a +\&\fBscalar\fR as opposed to a \fBlist\fR. +.IX Xref "scalar values, about values, scalar SV" +.IP "scalar variable" 4 +.IX Item "scalar variable" +A \fBvariable\fR prefixed with +\&\f(CW\*(C`$\*(C'\fR that holds a single value. +.IX Xref "scalar variables, defined variables, scalar" +.IP scope 4 +.IX Item "scope" +From how far away you can see a variable, looking through +one. Perl has two visibility mechanisms. It does \fBdynamic scoping\fR of +\&\f(CW\*(C`local\*(C'\fR \fBvariables\fR, meaning that the rest of the \fBblock\fR, and any +\&\fBsubroutines\fR that are called by the rest of the block, can see the +variables that are local to the block. Perl does \fBlexical scoping\fR of +\&\f(CW\*(C`my\*(C'\fR variables, meaning that the rest of the block can see the variable, +but other subroutines called by the block \fIcannot\fR see the variable. +.IX Xref "scopes, defined" +.IP scratchpad 4 +.IX Item "scratchpad" +The area in which a particular invocation of a particular +file or subroutine keeps some of its temporary values, including any +lexically scoped variables. +.IX Xref "scratchpads" +.IP script 4 +.IX Item "script" +A text \fBfile\fR that is a program +intended to be \fBexecuted\fR directly rather than \fBcompiled\fR to another form +of file before \fBexecution\fR. +.IX Xref "scripts (term) programs, defined" +.Sp +Also, in the context of \fBUnicode\fR, a writing system for a particular +language or group of languages, such as Greek, Bengali, or Tengwar. +.IP "script kiddie" 4 +.IX Item "script kiddie" +A \fBcracker\fR who is not a \fBhacker\fR but knows just enough +to run canned scripts. A \fBcargo-cult\fR programmer. +.IX Xref "script kiddie" +.IP sed 4 +.IX Item "sed" +A venerable Stream EDitor from +which Perl derives some of its ideas. +.IX Xref "sed (Stream EDitor) Stream EDitor (sed)" +.IP semaphore 4 +.IX Item "semaphore" +A fancy kind of interlock that prevents multiple \fBthreads\fR or +\&\fBprocesses\fR from using up the same resources simultaneously. +.IX Xref "semaphore" +.IP separator 4 +.IX Item "separator" +A \fBcharacter\fR or \fBstring\fR that keeps two surrounding strings from being +confused with each other. The \f(CW\*(C`split\*(C'\fR function works on separators. Not to be confused with \fBdelimiters\fR +or \fBterminators\fR. The “or” in the previous sentence separated the two +alternatives. +.IX Xref "separators characters, separators strings, separators split function, separators and" +.IP serialization 4 +.IX Item "serialization" +Putting a fancy \fBdata structure\fR into +linear order so that it can be stored as a \fBstring\fR in a disk file or +database, or sent through a \fBpipe\fR. Also called marshalling. +.IX Xref "serialization marshalling (term)" +.IP server 4 +.IX Item "server" +In networking, a \fBprocess\fR that +either advertises a \fBservice\fR or just hangs around at a known location and +waits for \fBclients\fR who need service to get in touch with it. +.IX Xref "servers, defined processes, server" +.IP service 4 +.IX Item "service" +Something you do for someone else to make them happy, +like giving them the time of day (or of their life). On some machines, +well-known services are listed by the \f(CW\*(C`getservent\*(C'\fR +function. +.IX Xref "services (term) getservent function" +.IP setgid 4 +.IX Item "setgid" +Same as \fBsetuid\fR, only having to do with giving +away \fBgroup\fR privileges. +.IX Xref "setgid program, about" +.IP setuid 4 +.IX Item "setuid" +Said of a program that runs with the privileges of +its \fBowner\fR rather than (as is usually the case) the privileges of whoever +is running it. Also describes the bit in the mode word (\fBpermission bits\fR) +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. +.IX Xref "setuid program, about" +.IP "shared memory" 4 +.IX Item "shared memory" +A piece of \fBmemory\fR accessible by two +different \fBprocesses\fR who otherwise would not see each other’s memory. +.IX Xref "shared memory memory, shared" +.IP shebang 4 +.IX Item "shebang" +Irish for the whole McGillicuddy. In Perl culture, a +portmanteau of “sharp” and “bang”, meaning the \f(CW\*(C`#!\*(C'\fR sequence that tells +the system where to find the interpreter. +.IX Xref "shebang (term)" +.IP shell 4 +.IX Item "shell" +A \fBcommand\fR\-line \fBinterpreter\fR. The program that +interactively gives you a prompt, accepts one or more \fBlines\fR of input, +and executes the programs you mentioned, feeding each of them their proper +\&\fBarguments\fR and input data. Shells can also execute scripts containing +such commands. Under Unix, typical shells include the Bourne shell +(\fI/bin/sh\fR), the C shell (\fI/bin/csh\fR), and the Korn shell (\fI/bin/ksh\fR). +Perl is not strictly a shell because it’s not interactive (although Perl +programs can be interactive). +.IX Xref "shell program, defined" +.IP "side effects" 4 +.IX Item "side effects" +Something extra that happens when you evaluate an +\&\fBexpression\fR. 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 \f(CW$|\fR (\f(CW$AUTOFLUSH\fR) has the side effect of forcing a +flush after every \f(CW\*(C`write\*(C'\fR or \f(CW\*(C`print\*(C'\fR on the currently selected +filehandle. +.IX Xref "side effects" +.IP sigil 4 +.IX Item "sigil" +A glyph used in magic. Or, for Perl, the symbol in front +of a variable name, such as \f(CW\*(C`$\*(C'\fR, \f(CW\*(C`@\*(C'\fR, and \f(CW\*(C`%\*(C'\fR. +.IX Xref "sigils, defined" +.IP signal 4 +.IX Item "signal" +A bolt out of the blue; that is, an +event triggered by the \fBoperating system\fR, probably when you’re least +expecting it. +.IX Xref "signals and signal handling, about" +.IP "signal handler" 4 +.IX Item "signal handler" +A \fBsubroutine\fR 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 \fBexecute\fR. Under Perl, bolts out of the blue +are called signals, and you send them with the \f(CW\*(C`kill\*(C'\fR built-in. See the +\&\f(CW%SIG\fR hash in Camel chapter 25, “Special Names” and the section “Signals” +in Camel chapter 15, “Interprocess Communication”. +.IX Xref "handlers, signal" +.IP "single inheritance" 4 +.IX Item "single inheritance" +The features you got from your +mother, if she told you that you don’t have a father. (See also +\&\fBinheritance\fR and \fBmultiple inheritance\fR.) In computer languages, the +idea that \fBclasses\fR reproduce asexually so that a given class can only +have one direct ancestor or \fBbase class\fR. Perl supplies no such +restriction, though you may certainly program Perl that way if you like. +.IX Xref "single inheritance inheritance, single" +.IP slice 4 +.IX Item "slice" +A selection of any number of +\&\fBelements\fR from a \fBlist\fR, \fBarray\fR, or \fBhash\fR. +.IX Xref "slices of elements elements, slices of" +.IP slurp 4 +.IX Item "slurp" +To read an entire \fBfile\fR into a \fBstring\fR in one operation. +.IX Xref "slurp (term)" +.IP socket 4 +.IX Item "socket" +An endpoint for network communication among multiple +\&\fBprocesses\fR that works much like a telephone or a post office box. The +most important thing about a socket is its \fBnetwork address\fR (like a phone +number). Different kinds of sockets have different kinds of addresses—some +look like filenames, and some don’t. +.IX Xref "sockets, defined" +.IP "soft reference" 4 +.IX Item "soft reference" +See \fBsymbolic reference\fR. +.IX Xref "soft references references, soft" +.IP "source filter" 4 +.IX Item "source filter" +A special kind of \fBmodule\fR that does +\&\fBpreprocessing\fR on your script just before it gets to the \fBtokener\fR. +.IX Xref "source filters filters, source" +.IP stack 4 +.IX Item "stack" +A device you can put things on the top of, and later take +them back off in the opposite order in which you put them on. See \fBLIFO\fR. +.IX Xref "stacks, defined" +.IP standard 4 +.IX Item "standard" +Included in the official Perl distribution, as in a +standard module, a standard tool, or a standard Perl \fBmanpage\fR. +.IX Xref "standard (term)" +.IP "standard error" 4 +.IX Item "standard error" +The default output \fBstream\fR for nasty remarks that don’t belong in +\&\fBstandard output\fR. Represented within a Perl program by the output> \fBfilehandle\fR \f(CW\*(C`STDERR\*(C'\fR. You can use this +stream explicitly, but the \f(CW\*(C`die\*(C'\fR and \f(CW\*(C`warn\*(C'\fR built-ins write to your +standard error stream automatically (unless trapped or otherwise +intercepted). +.IX Xref "STDERR filehandle, about" +.IP "standard input" 4 +.IX Item "standard input" +The default input \fBstream\fR for your program, +which if possible shouldn’t care where its data is coming from. Represented +within a Perl program by the \fBfilehandle\fR \f(CW\*(C`STDIN\*(C'\fR. +.IX Xref "STDIN filehandle, about" +.IP "standard I/O" 4 +.IX Item "standard I/O" +A standard C library for doing \fBbuffered\fR input +and output to the \fBoperating system\fR. (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 \fBflush\fR the buffer +more often, just set the \f(CW$|\fR variable to a true value. +.IX Xref "standard I O I O (Input Output), standard Input Output (I O), standard STDIO filehandle" +.IP "Standard Library" 4 +.IX Item "Standard Library" +Everything that comes with the official +\&\fIperl\fR distribution. Some vendor versions of \fIperl\fR change their +distributions, leaving out some parts or including extras. See also +\&\fBdual-lived\fR. +.IX Xref "Standard Perl Library, about" +.IP "standard output" 4 +.IX Item "standard output" +The default output \fBstream\fR for your program, +which if possible shouldn’t care where its data is going. Represented +within a Perl program by the \fBfilehandle\fR \f(CW\*(C`STDOUT\*(C'\fR. +.IX Xref "STDOUT filehandle, about" +.IP statement 4 +.IX Item "statement" +A \fBcommand\fR 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 \fBdeclaration\fR, which doesn’t tell the +computer to do anything, but just to learn something. +.IX Xref "statements, about" +.IP "statement modifier" 4 +.IX Item "statement modifier" +A \fBconditional\fR or +\&\fBloop\fR that you put after the \fBstatement\fR instead of before, if you know +what we mean. +.IX Xref "statement modifiers, about modifiers, statement" +.IP static 4 +.IX Item "static" +Varying slowly compared to something else. (Unfortunately, +everything is relatively stable compared to something else, except for +certain elementary particles, and we’re not so sure about them.) In +computers, where things are supposed to vary rapidly, “static” has a +derogatory connotation, indicating a slightly dysfunctional \fBvariable\fR, +\&\fBsubroutine\fR, or \fBmethod\fR. In Perl culture, the word is politely avoided. +.IX Xref "static (term)" +.Sp +If you’re a C or C++ programmer, you might be looking for Perl’s \f(CW\*(C`state\*(C'\fR +keyword. +.IP "static method" 4 +.IX Item "static method" +No such thing. See \fBclass method\fR. +.IX Xref "static methods methods, static" +.IP "static scoping" 4 +.IX Item "static scoping" +No such thing. See \fBlexical scoping\fR. +.IP "static variable" 4 +.IX Item "static variable" +No such thing. Just use a \fBlexical +variable\fR in a scope larger than your \fBsubroutine\fR, or declare it with +\&\f(CW\*(C`state\*(C'\fR instead of with \f(CW\*(C`my\*(C'\fR. +.IX Xref "static variables variables, static" +.IP "stat structure" 4 +.IX Item "stat structure" +A special internal spot +in which Perl keeps the information about the last \fBfile\fR on which you +requested information. +.IX Xref "stat structure data structures, stat structure" +.IP status 4 +.IX Item "status" +The \fBvalue\fR returned to the +parent \fBprocess\fR when one of its child processes dies. This value is +placed in the special variable \f(CW$?\fR. Its upper eight \fBbits\fR 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 \fIwait\fR(2). See \f(CW\*(C`system\*(C'\fR in Camel +chapter 27, “Functions”. +.IX Xref "status value values, status exit status" +.IP STDERR 4 +.IX Item "STDERR" +See \fBstandard error\fR. +.IP STDIN 4 +.IX Item "STDIN" +See \fBstandard input\fR. +.IP STDIO 4 +.IX Item "STDIO" +See \fBstandard I/O\fR. +.IP STDOUT 4 +.IX Item "STDOUT" +See \fBstandard output\fR. +.IP stream 4 +.IX Item "stream" +A flow of data into or out of +a process as a steady sequence of bytes or characters, without the +appearance of being broken up into packets. This is a kind of +\&\fBinterface\fR—the underlying \fBimplementation\fR may well break your data up +into separate packets for delivery, but this is hidden from you. +.IX Xref "streaming data processes, streaming data" +.IP string 4 +.IX Item "string" +A sequence of characters such as “He said !@#*&%@#*?!”. +A string does not have to be entirely printable. +.IX Xref "strings, defined" +.IP "string context" 4 +.IX Item "string context" +The situation in which an expression is +expected by its surroundings (the code calling it) to return a \fBstring\fR. +See also \fBcontext\fR and \fBnumeric context\fR. +.IX Xref "string context context, string" +.IP stringification 4 +.IX Item "stringification" +The process of producing a \fBstring\fR representation of an +abstract object. +.IX Xref "stringification" +.IP struct 4 +.IX Item "struct" +C keyword introducing a structure definition or name. +.IX Xref "struct keyword" +.IP structure 4 +.IX Item "structure" +See \fBdata structure\fR. +.IX Xref "structures" +.IP subclass 4 +.IX Item "subclass" +See \fBderived class\fR. +.IP subpattern 4 +.IX Item "subpattern" +A component of a \fBregular expression\fR pattern. +.IX Xref "subpatterns, defined" +.IP subroutine 4 +.IX Item "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 +\&\fBarguments\fR. If the subroutine returns a meaningful \fBvalue\fR, it is also +called a \fBfunction\fR. +.IX Xref "subroutines, defined" +.IP subscript 4 +.IX Item "subscript" +A \fBvalue\fR that indicates the position of a particular +\&\fBarray\fR \fBelement\fR in an array. +.IX Xref "subscripts" +.IP substitution 4 +.IX Item "substitution" +Changing parts of a string via the \f(CW\*(C`s///\*(C'\fR +operator. (We avoid use of this term to mean \fBvariable interpolation\fR.) +.IX Xref "substitution (s ) operator, about strings, substitution in s (substitution) operator, about" +.IP substring 4 +.IX Item "substring" +A portion of a \fBstring\fR, starting at a certain +\&\fBcharacter\fR position (\fBoffset\fR) and proceeding for a certain number of +characters. +.IX Xref "substrings (term)" +.IP superclass 4 +.IX Item "superclass" +See \fBbase class\fR. +.IP superuser 4 +.IX Item "superuser" +The person whom the \fBoperating system\fR will let do almost +anything. Typically your system administrator or someone pretending to be +your system administrator. On Unix systems, the \fBroot\fR user. On Windows +systems, usually the Administrator user. +.IX Xref "superusers" +.IP SV 4 +.IX Item "SV" +Short for “scalar value”. But +within the Perl interpreter, every \fBreferent\fR is treated as a member of a +class derived from SV, in an object-oriented sort of way. Every \fBvalue\fR +inside Perl is passed around as a C language \f(CW\*(C`SV*\*(C'\fR pointer. The SV +\&\fBstruct\fR knows its own “referent type”, and the code is smart enough (we +hope) not to try to call a \fBhash\fR function on a \fBsubroutine\fR. +.IX Xref "scalar values, about values, scalar" +.IP switch 4 +.IX Item "switch" +An option you give on a command line to +influence the way your program works, usually introduced with a minus sign. +The word is also used as a nickname for a \fBswitch statement\fR. +.IX Xref "switches, about switches" +.IP "switch cluster" 4 +.IX Item "switch cluster" +The combination of multiple command\- +line switches (\fIe.g.\fR, \f(CW\*(C`–a –b –c\*(C'\fR) into one switch (\fIe.g.\fR, \f(CW\*(C`–abc\*(C'\fR). +Any switch with an additional \fBargument\fR must be the last switch in a +cluster. +.IX Xref "switch clusters clusters, switch" +.IP "switch statement" 4 +.IX Item "switch statement" +A program technique that lets you +evaluate an \fBexpression\fR 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 \f(CW\*(C`given\*(C'\fR. See “The \f(CW\*(C`given\*(C'\fR +statement” in Camel chapter 4, “Statements and Declarations”. +.IX Xref "switch statement statements, switch" +.IP symbol 4 +.IX Item "symbol" +Generally, any \fBtoken\fR or \fBmetasymbol\fR. Often used +more specifically to mean the sort of name you might find in a \fBsymbol +table\fR. +.IX Xref "symbols symbols" +.IP "symbolic debugger" 4 +.IX Item "symbolic debugger" +A program that lets you step through +the \fBexecution\fR 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. +.IX Xref "symbolic debugger debugger, about" +.IP "symbolic link" 4 +.IX Item "symbolic link" +An alternate filename that points to the +real \fBfilename\fR, which in turn points to the real \fBfile\fR. Whenever the +\&\fBoperating system\fR is trying to parse a \fBpathname\fR containing a symbolic +link, it merely substitutes the new name and continues parsing. +.IX Xref "symbolic links links, symbolic" +.IP "symbolic reference" 4 +.IX Item "symbolic reference" +A variable whose value is the +name of another variable or subroutine. By \fBdereferencing\fR the first +variable, you can get at the second one. Symbolic references are illegal +under \f(CW\*(C`use strict "refs"\*(C'\fR. +.IX Xref "symbolic references references, symbolic" +.IP "symbol table" 4 +.IX Item "symbol table" +Where a \fBcompiler\fR remembers symbols. A program +like Perl must somehow remember all the names of all the \fBvariables\fR, +\&\fBfilehandles\fR, and \fBsubroutines\fR you’ve used. It does this by placing the +names in a symbol table, which is implemented in Perl using a \fBhash +table\fR. There is a separate symbol table for each \fBpackage\fR to give each +package its own \fBnamespace\fR. +.IX Xref "symbol tables, about" +.IP synchronous 4 +.IX Item "synchronous" +Programming in which the orderly sequence of events +can be determined; that is, when things happen one after the other, not at +the same time. +.IX Xref "synchronous (term)" +.IP "syntactic sugar" 4 +.IX Item "syntactic sugar" +An alternative way of writing something more easily; a +shortcut. +.IX Xref "syntactic sugar" +.IP syntax 4 +.IX Item "syntax" +From Greek σύνταξις, “with\-arrangement”. How things +(particularly symbols) are put together with each other. +.IX Xref "syntax, about" +.IP "syntax tree" 4 +.IX Item "syntax tree" +An internal representation of your program wherein +lower-level \fBconstructs\fR dangle off the higher-level constructs enclosing +them. +.IX Xref "syntax tree" +.IP syscall 4 +.IX Item "syscall" +A \fBfunction\fR call directly to the \fBoperating +system\fR. 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 \f(CW$!\fR +(\f(CW$ERRNO\fR) variable on failure. Unfortunately, beginning programmers often +confusingly employ the term “system call” to mean what happens when you +call the Perl \f(CW\*(C`system\*(C'\fR function, which actually involves many syscalls. To +avoid any confusion, we nearly always say “syscall” for something you could +call indirectly via Perl’s \f(CW\*(C`syscall\*(C'\fR function, and never for something you +would call with Perl’s \f(CW\*(C`system\*(C'\fR function. +.IX Xref "syscall function, about" +.SS T +.IX Subsection "T" +.IP "taint checks" 4 +.IX Item "taint checks" +The special bookkeeping Perl does to track the flow +of external data through your program and disallow their use in system +commands. +.IX Xref "taint checks, about" +.IP tainted 4 +.IX Item "tainted" +Said of data derived from the grubby hands of a user, +and thus unsafe for a secure program to rely on. Perl does taint checks if +you run a \fBsetuid\fR (or \fBsetgid\fR) program, or if you use the \f(CW\*(C`–T\*(C'\fR switch. +.IX Xref "tainted data, about" +.IP "taint mode" 4 +.IX Item "taint mode" +Running under the \f(CW\*(C`–T\*(C'\fR switch, marking all external data as +suspect and refusing to use it with system commands. See Camel chapter 20, +“Security”. +.IX Xref "taint mode" +.IP TCP 4 +.IX Item "TCP" +Short for Transmission Control Protocol. A protocol wrapped around the +Internet Protocol to make an unreliable packet transmission mechanism +appear to the application program to be a reliable \fBstream\fR of bytes. +(Usually.) +.IX Xref "TCP (Transmission Control Protocol) Transmission Control Protocol (TCP)" +.IP term 4 +.IX Item "term" +Short for a “terminal”—that is, a leaf node of a \fBsyntax +tree\fR. A thing that functions grammatically as an \fBoperand\fR for the +operators in an expression. +.IX Xref "terms, defined" +.IP terminator 4 +.IX Item "terminator" +A \fBcharacter\fR or \fBstring\fR that marks the end of another string. The \f(CW$/\fR +variable contains the string that terminates a \f(CW\*(C`readline\*(C'\fR operation, which +\&\f(CW\*(C`chomp\*(C'\fR deletes from the end. Not to be confused with \fBdelimiters\fR or +\&\fBseparators\fR. The period at the end of this sentence is a terminator. +.IX Xref "terminators (term) characters, terminators strings, terminators in" +.IP ternary 4 +.IX Item "ternary" +An \fBoperator\fR taking three \fBoperands\fR. Sometimes +pronounced \fBtrinary\fR. +.IX Xref "ternary operators" +.IP text 4 +.IX Item "text" +A \fBstring\fR or \fBfile\fR containing primarily printable characters. +.IX Xref "text, defined strings, text files, text text" +.IP thread 4 +.IX Item "thread" +Like a forked process, but without \fBfork\fR’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. +.IX Xref "threads (term)" +.IP tie 4 +.IX Item "tie" +The bond between a magical variable and its +implementation class. See the \f(CW\*(C`tie\*(C'\fR function in Camel chapter 27, +“Functions” and Camel chapter 14, “Tied Variables”. +.IX Xref "tied variables, about" +.IP titlecase 4 +.IX Item "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. +.IX Xref "titlecase characters characters, titlecase" +.IP TMTOWTDI 4 +.IX Item "TMTOWTDI" +There’s More Than One Way To Do It, the Perl Motto. The +notion that there can be more than one valid path to solving a programming +problem in context. (This doesn’t mean that more ways are always better or +that all possible paths are equally desirable—just that there need not be +One True Way.) +.IX Xref "TMTOWTDI acronym" +.IP token 4 +.IX Item "token" +A morpheme in a programming language, the smallest unit +of text with semantic significance. +.IX Xref "tokens, defined" +.IP tokener 4 +.IX Item "tokener" +A module that breaks a program text into a sequence of +\&\fBtokens\fR for later analysis by a parser. +.IX Xref "tokeners, defined" +.IP tokenizing 4 +.IX Item "tokenizing" +Splitting up a program text into \fBtokens\fR. Also known as +“lexing”, in which case you get “lexemes” instead of tokens. +.IX Xref "tokenizing" +.IP "toolbox approach" 4 +.IX Item "toolbox approach" +The notion that, with a complete set of simple tools +that work well together, you can build almost anything you want. Which is +fine if you’re assembling a tricycle, but if you’re building a +defranishizing comboflux regurgalator, you really want your own machine +shop in which to build special tools. Perl is sort of a machine shop. +.IX Xref "toolbox approach" +.IP topic 4 +.IX Item "topic" +The thing you’re working on. Structures like +\&\f(CWwhile(<>)\fR, \f(CW\*(C`for\*(C'\fR, \f(CW\*(C`foreach\*(C'\fR, and \f(CW\*(C`given\*(C'\fR set the topic for +you by assigning to \f(CW$_\fR, the default (\fItopic\fR) variable. +.IX Xref "topics (term)" +.IP transliterate 4 +.IX Item "transliterate" +To turn one string +representation into another by mapping each character of the source string +to its corresponding character in the result string. Not to be confused +with translation: for example, Greek \fIπολύχρωμος\fR transliterates into +\&\fIpolychromos\fR but translates into \fImany-colored\fR. See the \f(CW\*(C`tr///\*(C'\fR +operator in Camel chapter 5, “Pattern Matching”. +.IX Xref "tr (transliteration) operator, about strings, transliteration of transliteration (tr ) operator, about" +.IP trigger 4 +.IX Item "trigger" +An event that causes a \fBhandler\fR to be run. +.IX Xref "triggers (term)" +.IP trinary 4 +.IX Item "trinary" +Not a stellar system with three stars, but an +\&\fBoperator\fR taking three \fBoperands\fR. Sometimes pronounced \fBternary\fR. +.IX Xref "trinary operators" +.IP troff 4 +.IX Item "troff" +A venerable typesetting language from which Perl derives +the name of its \f(CW$%\fR variable and which is secretly used in the production +of Camel books. +.IX Xref "troff language" +.IP true 4 +.IX Item "true" +Any scalar value that doesn’t evaluate to 0 or +\&\f(CW""\fR. +.IX Xref "true values values, true" +.IP truncating 4 +.IX Item "truncating" +Emptying a file of existing +contents, either automatically when opening a file for writing or +explicitly via the \f(CW\*(C`truncate\*(C'\fR function. +.IX Xref "truncate function files, truncating" +.IP type 4 +.IX Item "type" +See \fBdata type\fR and \fBclass\fR. +.IX Xref "type" +.IP "type casting" 4 +.IX Item "type casting" +Converting data from one type to another. C permits this. +Perl does not need it. Nor want it. +.IX Xref "type casting" +.IP typedef 4 +.IX Item "typedef" +A type definition in the C and C++ languages. +.IX Xref "typedef" +.IP "typed lexical" 4 +.IX Item "typed lexical" +A \fBlexical variable\fR lexical>that is declared with a \fBclass\fR +type: \f(CW\*(C`my Pony $bill\*(C'\fR. +.IX Xref "typed lexicals lexical variables, typed lexicals variables, variable" +.IP typeglob 4 +.IX Item "typeglob" +Use of a single identifier, prefixed with \f(CW\*(C`*\*(C'\fR. For +example, \f(CW*name\fR stands for any or all of \f(CW$name\fR, \f(CW@name\fR, \f(CW%name\fR, +\&\f(CW&name\fR, or just \f(CW\*(C`name\*(C'\fR. 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”. +.IX Xref "typeglobs, defined" +.IP typemap 4 +.IX Item "typemap" +A description of how C types may be transformed to and from Perl +types within an \fBextension\fR module written in \fBXS\fR. +.IX Xref "typemap" +.SS U +.IX Subsection "U" +.IP UDP 4 +.IX Item "UDP" +User Datagram Protocol, the typical way to send +\&\fBdatagrams\fR over the Internet. +.IX Xref "User Datagram Protocol (UDP) UDP (User Datagram Protocol) datagrams, UDP support" +.IP UID 4 +.IX Item "UID" +A user ID. Often used in the context of +\&\fBfile\fR or \fBprocess\fR ownership. +.IX Xref "UID (user ID) user ID (UID)" +.IP umask 4 +.IX Item "umask" +A mask of those \fBpermission bits\fR 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 \f(CW\*(C`umask\*(C'\fR function. +.IX Xref "umask function" +.IP "unary operator" 4 +.IX Item "unary operator" +An operator with only one \fBoperand\fR, like \f(CW\*(C`!\*(C'\fR or +\&\f(CW\*(C`chdir\*(C'\fR. Unary operators are usually prefix operators; that is, they +precede their operand. The \f(CW\*(C`++\*(C'\fR and \f(CW\*(C`––\*(C'\fR operators can be either prefix +or postfix. (Their position \fIdoes\fR change their meanings.) +.IX Xref "unary operators, about" +.IP Unicode 4 +.IX Item "Unicode" +A character set comprising all the major character sets of +the world, more or less. See <http://www.unicode.org>. +.IX Xref "Unicode, about" +.IP Unix 4 +.IX Item "Unix" +A very large and constantly evolving language with several +alternative and largely incompatible syntaxes, in which anyone can define +anything any way they choose, and usually do. Speakers of this language +think it’s easy to learn because it’s so easily twisted to one’s own ends, +but dialectical differences make tribal intercommunication nearly +impossible, and travelers are often reduced to a pidgin-like subset of the +language. To be universally understood, a Unix shell programmer must spend +years of study in the art. Many have abandoned this discipline and now +communicate via an Esperanto-like language called Perl. +.IX Xref "Unix language" +.Sp +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. +.IP uppercase 4 +.IX Item "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 \fBtitlecase\fR. +.IX Xref "uppercase characters characters, uppercase" +.SS V +.IX Subsection "V" +.IP value 4 +.IX Item "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. +.IX Xref "values, defined" +.IP variable 4 +.IX Item "variable" +A named storage location that can hold any +of various kinds of \fBvalue\fR, as your program sees fit. +.IX Xref "variables, defined variables" +.IP "variable interpolation" 4 +.IX Item "variable interpolation" +The \fBinterpolation\fR of +a scalar or array variable into a string. +.IX Xref "variable interpolation interpolation, variable" +.IP variadic 4 +.IX Item "variadic" +Said of a \fBfunction\fR that happily receives an +indeterminate number of \fBactual arguments\fR. +.IX Xref "variadic (term)" +.IP vector 4 +.IX Item "vector" +Mathematical jargon for a list of \fBscalar values\fR. +.IX Xref "vectors" +.IP virtual 4 +.IX Item "virtual" +Providing the appearance of something without the reality, +as in: virtual memory is not real memory. (See also \fBmemory\fR.) 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. +.IX Xref "virtual (term)" +.IP "void context" 4 +.IX Item "void context" +A form of \fBscalar context\fR in which an +\&\fBexpression\fR is not expected to return any \fBvalue\fR at all and is +evaluated for its \fBside effects\fR alone. +.IX Xref "void context context, void" +.IP v\-string 4 +.IX Item "v-string" +A “version” or “vector” \fBstring\fR +specified with a \f(CW\*(C`v\*(C'\fR followed by a series of decimal integers in dot +notation, for instance, \f(CW\*(C`v1.20.300.4000\*(C'\fR. Each number turns into a +\&\fBcharacter\fR with the specified ordinal value. (The \f(CW\*(C`v\*(C'\fR is optional when +there are at least three integers.) +.IX Xref "v–strings strings, v–strings" +.SS W +.IX Subsection "W" +.IP warning 4 +.IX Item "warning" +A message printed to the \f(CW\*(C`STDERR\*(C'\fR stream to the effect that something might be +wrong but isn’t worth blowing up over. See \f(CW\*(C`warn\*(C'\fR in Camel chapter 27, +“Functions” and the \f(CW\*(C`warnings\*(C'\fR pragma in Camel chapter 28, “Pragmantic +Modules”. +.IX Xref "warning messages STDERR filehandle, warning messages and" +.IP "watch expression" 4 +.IX Item "watch expression" +An expression which, when its value +changes, causes a breakpoint in the Perl debugger. +.IX Xref "watch expression expressions, watch" +.IP "weak reference" 4 +.IX Item "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. +.IX Xref "weak references references, weak" +.IP whitespace 4 +.IX Item "whitespace" +A \fBcharacter\fR 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 ɴ\-ʙʀ . +.IX Xref "whitespace characters characters, whitespace" +.IP word 4 +.IX Item "word" +In normal “computerese”, the piece of data of the size most +efficiently handled by your computer, typically 32 bits or so, give or take a +few powers of 2. In Perl culture, it more often refers to an alphanumeric +\&\fBidentifier\fR (including underscores), or to a string of nonwhitespace +\&\fBcharacters\fR bounded by whitespace or string boundaries. +.IX Xref "words (term)" +.IP "working directory" 4 +.IX Item "working directory" +Your current \fBdirectory\fR, from +which relative pathnames are interpreted by the \fBoperating system\fR. The +operating system knows your current directory because you told it with a +\&\f(CW\*(C`chdir\*(C'\fR, or because you started out in the place where your parent +\&\fBprocess\fR was when you were born. +.IX Xref "working directory directories, working" +.IP wrapper 4 +.IX Item "wrapper" +A program or subroutine that runs some other program or +subroutine for you, modifying some of its input or output to better suit +your purposes. +.IX Xref "wrappers (term)" +.IP WYSIWYG 4 +.IX Item "WYSIWYG" +What You See Is What You Get. Usually used when something +that appears on the screen matches how it will eventually look, like Perl’s +\&\f(CW\*(C`format\*(C'\fR declarations. Also used to mean the opposite of magic because +everything works exactly as it appears, as in the three\- argument form of +\&\f(CW\*(C`open\*(C'\fR. +.IX Xref "WYSIWYG acronym" +.SS X +.IX Subsection "X" +.IP XS 4 +.IX Item "XS" +An extraordinarily +exported, expeditiously excellent, expressly eXternal Subroutine, executed +in existing C or C++ or in an exciting extension language called +(exasperatingly) XS. +.IX Xref "XS (eXternal Subroutine) eXternal Subroutine (XS)" +.IP XSUB 4 +.IX Item "XSUB" +An external \fBsubroutine\fR defined in \fBXS\fR. +.IX Xref "XSUB (term)" +.SS Y +.IX Subsection "Y" +.IP yacc 4 +.IX Item "yacc" +Yet Another Compiler Compiler. A parser generator without +which Perl probably would not have existed. See the file \fIperly.y\fR in the +Perl source distribution. +.IX Xref "yacc acronym" +.SS Z +.IX Subsection "Z" +.IP "zero width" 4 +.IX Item "zero width" +A subpattern \fBassertion\fR matching the \fBnull +string\fR between \fBcharacters\fR. +.IX Xref "zero–width assertions subpatterns, zero–width assertions assertions (in regexes), zero–width" +.IP zombie 4 +.IX Item "zombie" +A process that has died (exited) but +whose parent has not yet received proper notification of its demise by +virtue of having called \f(CW\*(C`wait\*(C'\fR or \f(CW\*(C`waitpid\*(C'\fR. If you \f(CW\*(C`fork\*(C'\fR, 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. +.IX Xref "zombie processes processes, zombie" +.SH "AUTHOR AND COPYRIGHT" +.IX Header "AUTHOR AND COPYRIGHT" +Based on the Glossary of \fIProgramming Perl\fR, 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. |