| 1 | =head1 NAME |
| 2 | |
| 3 | perlglossary - Perl Glossary |
| 4 | |
| 5 | =head1 DESCRIPTION |
| 6 | |
| 7 | A glossary of terms (technical and otherwise) used in the Perl documentation. |
| 8 | Other useful sources include the Free On-Line Dictionary of Computing |
| 9 | L<http://foldoc.doc.ic.ac.uk/foldoc/index.html>, the Jargon File |
| 10 | L<http://catb.org/~esr/jargon/>, and Wikipedia L<http://www.wikipedia.org/>. |
| 11 | |
| 12 | =head2 A |
| 13 | |
| 14 | =over 4 |
| 15 | |
| 16 | =item accessor methods |
| 17 | |
| 18 | A L</method> used to indirectly inspect or update an L</object>'s |
| 19 | state (its L<instance variables|/instance variable>). |
| 20 | |
| 21 | =item actual arguments |
| 22 | |
| 23 | The L<scalar values|/scalar value> that you supply to a L</function> |
| 24 | or L</subroutine> when you call it. For instance, when you call |
| 25 | C<power("puff")>, the string C<"puff"> is the actual argument. See |
| 26 | also L</argument> and L</formal arguments>. |
| 27 | |
| 28 | =item address operator |
| 29 | |
| 30 | Some languages work directly with the memory addresses of values, but |
| 31 | this can be like playing with fire. Perl provides a set of asbestos |
| 32 | gloves for handling all memory management. The closest to an address |
| 33 | operator in Perl is the backslash operator, but it gives you a L</hard |
| 34 | reference>, which is much safer than a memory address. |
| 35 | |
| 36 | =item algorithm |
| 37 | |
| 38 | A well-defined sequence of steps, clearly enough explained that even a |
| 39 | computer could do them. |
| 40 | |
| 41 | =item alias |
| 42 | |
| 43 | A nickname for something, which behaves in all ways as though you'd |
| 44 | used the original name instead of the nickname. Temporary aliases are |
| 45 | implicitly created in the loop variable for C<foreach> loops, in the |
| 46 | C<$_> variable for L<map|perlfunc/map> or L<grep|perlfunc/grep> |
| 47 | operators, in C<$a> and C<$b> during L<sort|perlfunc/sort>'s |
| 48 | comparison function, and in each element of C<@_> for the L</actual |
| 49 | arguments> of a subroutine call. Permanent aliases are explicitly |
| 50 | created in L<packages|/package> by L<importing|/import> symbols or by |
| 51 | assignment to L<typeglobs|/typeglob>. Lexically scoped aliases for |
| 52 | package variables are explicitly created by the L<our|perlfunc/our> |
| 53 | declaration. |
| 54 | |
| 55 | =item alternatives |
| 56 | |
| 57 | A list of possible choices from which you may select only one, as in |
| 58 | "Would you like door A, B, or C?" Alternatives in regular expressions |
| 59 | are separated with a single vertical bar: C<|>. Alternatives in |
| 60 | normal Perl expressions are separated with a double vertical bar: |
| 61 | C<||>. Logical alternatives in L</Boolean> expressions are separated |
| 62 | with either C<||> or C<or>. |
| 63 | |
| 64 | =item anonymous |
| 65 | |
| 66 | Used to describe a L</referent> that is not directly accessible |
| 67 | through a named L</variable>. Such a referent must be indirectly |
| 68 | accessible through at least one L</hard reference>. When the last |
| 69 | hard reference goes away, the anonymous referent is destroyed without |
| 70 | pity. |
| 71 | |
| 72 | =item architecture |
| 73 | |
| 74 | The kind of computer you're working on, where one "kind" of computer |
| 75 | means all those computers sharing a compatible machine language. |
| 76 | Since Perl programs are (typically) simple text files, not executable |
| 77 | images, a Perl program is much less sensitive to the architecture it's |
| 78 | running on than programs in other languages, such as C, that are |
| 79 | compiled into machine code. See also L</platform> and L</operating |
| 80 | system>. |
| 81 | |
| 82 | =item argument |
| 83 | |
| 84 | A piece of data supplied to a L<program|/executable file>, |
| 85 | L</subroutine>, L</function>, or L</method> to tell it what it's |
| 86 | supposed to do. Also called a "parameter". |
| 87 | |
| 88 | =item ARGV |
| 89 | |
| 90 | The name of the array containing the L</argument> L</vector> from the |
| 91 | command line. If you use the empty C<< E<lt>E<gt> >> operator, L</ARGV> is |
| 92 | the name of both the L</filehandle> used to traverse the arguments and |
| 93 | the L</scalar> containing the name of the current input file. |
| 94 | |
| 95 | =item arithmetical operator |
| 96 | |
| 97 | A L</symbol> such as C<+> or C</> that tells Perl to do the arithmetic |
| 98 | you were supposed to learn in grade school. |
| 99 | |
| 100 | =item array |
| 101 | |
| 102 | An ordered sequence of L<values|/value>, stored such that you can |
| 103 | easily access any of the values using an integer L</subscript> |
| 104 | that specifies the value's L</offset> in the sequence. |
| 105 | |
| 106 | =item array context |
| 107 | |
| 108 | An archaic expression for what is more correctly referred to as |
| 109 | L</list context>. |
| 110 | |
| 111 | =item ASCII |
| 112 | |
| 113 | The American Standard Code for Information Interchange (a 7-bit |
| 114 | character set adequate only for poorly representing English text). |
| 115 | Often used loosely to describe the lowest 128 values of the various |
| 116 | ISO-8859-X character sets, a bunch of mutually incompatible 8-bit |
| 117 | codes best described as half ASCII. See also L</Unicode>. |
| 118 | |
| 119 | =item assertion |
| 120 | |
| 121 | A component of a L</regular expression> that must be true for the |
| 122 | pattern to match but does not necessarily match any characters itself. |
| 123 | Often used specifically to mean a L</zero width> assertion. |
| 124 | |
| 125 | =item assignment |
| 126 | |
| 127 | An L</operator> whose assigned mission in life is to change the value |
| 128 | of a L</variable>. |
| 129 | |
| 130 | =item assignment operator |
| 131 | |
| 132 | Either a regular L</assignment>, or a compound L</operator> composed |
| 133 | of an ordinary assignment and some other operator, that changes the |
| 134 | value of a variable in place, that is, relative to its old value. For |
| 135 | example, C<$a += 2> adds C<2> to C<$a>. |
| 136 | |
| 137 | =item associative array |
| 138 | |
| 139 | See L</hash>. Please. |
| 140 | |
| 141 | =item associativity |
| 142 | |
| 143 | Determines whether you do the left L</operator> first or the right |
| 144 | L</operator> first when you have "A L</operator> B L</operator> C" and |
| 145 | the two operators are of the same precedence. Operators like C<+> are |
| 146 | left associative, while operators like C<**> are right associative. |
| 147 | See L<perlop> for a list of operators and their associativity. |
| 148 | |
| 149 | =item asynchronous |
| 150 | |
| 151 | Said of events or activities whose relative temporal ordering is |
| 152 | indeterminate because too many things are going on at once. Hence, an |
| 153 | asynchronous event is one you didn't know when to expect. |
| 154 | |
| 155 | =item atom |
| 156 | |
| 157 | A L</regular expression> component potentially matching a |
| 158 | L</substring> containing one or more characters and treated as an |
| 159 | indivisible syntactic unit by any following L</quantifier>. (Contrast |
| 160 | with an L</assertion> that matches something of L</zero width> and may |
| 161 | not be quantified.) |
| 162 | |
| 163 | =item atomic operation |
| 164 | |
| 165 | When Democritus gave the word "atom" to the indivisible bits of |
| 166 | matter, he meant literally something that could not be cut: I<a-> |
| 167 | (not) + I<tomos> (cuttable). An atomic operation is an action that |
| 168 | can't be interrupted, not one forbidden in a nuclear-free zone. |
| 169 | |
| 170 | =item attribute |
| 171 | |
| 172 | A new feature that allows the declaration of L<variables|/variable> |
| 173 | and L<subroutines|/subroutine> with modifiers as in C<sub foo : locked |
| 174 | method>. Also, another name for an L</instance variable> of an |
| 175 | L</object>. |
| 176 | |
| 177 | =item autogeneration |
| 178 | |
| 179 | A feature of L</operator overloading> of L<objects|/object>, whereby |
| 180 | the behavior of certain L<operators|/operator> can be reasonably |
| 181 | deduced using more fundamental operators. This assumes that the |
| 182 | overloaded operators will often have the same relationships as the |
| 183 | regular operators. See L<perlop>. |
| 184 | |
| 185 | =item autoincrement |
| 186 | |
| 187 | To add one to something automatically, hence the name of the C<++> |
| 188 | operator. To instead subtract one from something automatically is |
| 189 | known as an "autodecrement". |
| 190 | |
| 191 | =item autoload |
| 192 | |
| 193 | To load on demand. (Also called "lazy" loading.) Specifically, to |
| 194 | call an L<AUTOLOAD|perlsub/Autoloading> subroutine on behalf of an |
| 195 | undefined subroutine. |
| 196 | |
| 197 | =item autosplit |
| 198 | |
| 199 | To split a string automatically, as the B<-a> L</switch> does when |
| 200 | running under B<-p> or B<-n> in order to emulate L</awk>. (See also |
| 201 | the L<AutoSplit> module, which has nothing to do with the B<-a> |
| 202 | switch, but a lot to do with autoloading.) |
| 203 | |
| 204 | =item autovivification |
| 205 | |
| 206 | A Greco-Roman word meaning "to bring oneself to life". In Perl, |
| 207 | storage locations (L<lvalues|/lvalue>) spontaneously generate |
| 208 | themselves as needed, including the creation of any L</hard reference> |
| 209 | values to point to the next level of storage. The assignment |
| 210 | C<$a[5][5][5][5][5] = "quintet"> potentially creates five scalar |
| 211 | storage locations, plus four references (in the first four scalar |
| 212 | locations) pointing to four new anonymous arrays (to hold the last |
| 213 | four scalar locations). But the point of autovivification is that you |
| 214 | don't have to worry about it. |
| 215 | |
| 216 | =item AV |
| 217 | |
| 218 | Short for "array value", which refers to one of Perl's internal data |
| 219 | types that holds an L</array>. The L</AV> type is a subclass of |
| 220 | L</SV>. |
| 221 | |
| 222 | =item awk |
| 223 | |
| 224 | Descriptive editing term--short for "awkward". Also coincidentally |
| 225 | refers to a venerable text-processing language from which Perl derived |
| 226 | some of its high-level ideas. |
| 227 | |
| 228 | =back |
| 229 | |
| 230 | =head2 B |
| 231 | |
| 232 | =over 4 |
| 233 | |
| 234 | =item backreference |
| 235 | |
| 236 | A substring L<captured|/capturing> by a subpattern within |
| 237 | unadorned parentheses in a L</regex>. Backslashed decimal numbers |
| 238 | (C<\1>, C<\2>, etc.) later in the same pattern refer back to the |
| 239 | corresponding subpattern in the current match. Outside the pattern, |
| 240 | the numbered variables (C<$1>, C<$2>, etc.) continue to refer to these |
| 241 | same values, as long as the pattern was the last successful match of |
| 242 | the current dynamic scope. |
| 243 | |
| 244 | =item backtracking |
| 245 | |
| 246 | The practice of saying, "If I had to do it all over, I'd do it |
| 247 | differently," and then actually going back and doing it all over |
| 248 | differently. Mathematically speaking, it's returning from an |
| 249 | unsuccessful recursion on a tree of possibilities. Perl backtracks |
| 250 | when it attempts to match patterns with a L</regular expression>, and |
| 251 | its earlier attempts don't pan out. See L<perlre/Backtracking>. |
| 252 | |
| 253 | =item backward compatibility |
| 254 | |
| 255 | Means you can still run your old program because we didn't break any |
| 256 | of the features or bugs it was relying on. |
| 257 | |
| 258 | =item bareword |
| 259 | |
| 260 | A word sufficiently ambiguous to be deemed illegal under L<use strict |
| 261 | 'subs'|strict/strict subs>. In the absence of that stricture, a |
| 262 | bareword is treated as if quotes were around it. |
| 263 | |
| 264 | =item base class |
| 265 | |
| 266 | A generic L</object> type; that is, a L</class> from which other, more |
| 267 | specific classes are derived genetically by L</inheritance>. Also |
| 268 | called a "superclass" by people who respect their ancestors. |
| 269 | |
| 270 | =item big-endian |
| 271 | |
| 272 | From Swift: someone who eats eggs big end first. Also used of |
| 273 | computers that store the most significant L</byte> of a word at a |
| 274 | lower byte address than the least significant byte. Often considered |
| 275 | superior to little-endian machines. See also L</little-endian>. |
| 276 | |
| 277 | =item binary |
| 278 | |
| 279 | Having to do with numbers represented in base 2. That means there's |
| 280 | basically two numbers, 0 and 1. Also used to describe a "non-text |
| 281 | file", presumably because such a file makes full use of all the binary |
| 282 | bits in its bytes. With the advent of L</Unicode>, this distinction, |
| 283 | already suspect, loses even more of its meaning. |
| 284 | |
| 285 | =item binary operator |
| 286 | |
| 287 | An L</operator> that takes two L<operands|/operand>. |
| 288 | |
| 289 | =item bind |
| 290 | |
| 291 | To assign a specific L</network address> to a L</socket>. |
| 292 | |
| 293 | =item bit |
| 294 | |
| 295 | An integer in the range from 0 to 1, inclusive. The smallest possible |
| 296 | unit of information storage. An eighth of a L</byte> or of a dollar. |
| 297 | (The term "Pieces of Eight" comes from being able to split the old |
| 298 | Spanish dollar into 8 bits, each of which still counted for money. |
| 299 | That's why a 25-cent piece today is still "two bits".) |
| 300 | |
| 301 | =item bit shift |
| 302 | |
| 303 | The movement of bits left or right in a computer word, which has the |
| 304 | effect of multiplying or dividing by a power of 2. |
| 305 | |
| 306 | =item bit string |
| 307 | |
| 308 | A sequence of L<bits|/bit> that is actually being thought of as a |
| 309 | sequence of bits, for once. |
| 310 | |
| 311 | =item bless |
| 312 | |
| 313 | In corporate life, to grant official approval to a thing, as in, "The |
| 314 | VP of Engineering has blessed our WebCruncher project." Similarly in |
| 315 | Perl, to grant official approval to a L</referent> so that it can |
| 316 | function as an L</object>, such as a WebCruncher object. See |
| 317 | L<perlfunc/"bless">. |
| 318 | |
| 319 | =item block |
| 320 | |
| 321 | What a L</process> does when it has to wait for something: "My process |
| 322 | blocked waiting for the disk." As an unrelated noun, it refers to a |
| 323 | large chunk of data, of a size that the L</operating system> likes to |
| 324 | deal with (normally a power of two such as 512 or 8192). Typically |
| 325 | refers to a chunk of data that's coming from or going to a disk file. |
| 326 | |
| 327 | =item BLOCK |
| 328 | |
| 329 | A syntactic construct consisting of a sequence of Perl |
| 330 | L<statements|/statement> that is delimited by braces. The C<if> and |
| 331 | C<while> statements are defined in terms of L<BLOCKs|/BLOCK>, for instance. |
| 332 | Sometimes we also say "block" to mean a lexical scope; that is, a |
| 333 | sequence of statements that act like a L</BLOCK>, such as within an |
| 334 | L<eval|perlfunc/eval> or a file, even though the statements aren't |
| 335 | delimited by braces. |
| 336 | |
| 337 | =item block buffering |
| 338 | |
| 339 | A method of making input and output efficient by passing one L</block> |
| 340 | at a time. By default, Perl does block buffering to disk files. See |
| 341 | L</buffer> and L</command buffering>. |
| 342 | |
| 343 | =item Boolean |
| 344 | |
| 345 | A value that is either L</true> or L</false>. |
| 346 | |
| 347 | =item Boolean context |
| 348 | |
| 349 | A special kind of L</scalar context> used in conditionals to decide |
| 350 | whether the L</scalar value> returned by an expression is L</true> or |
| 351 | L</false>. Does not evaluate as either a string or a number. See |
| 352 | L</context>. |
| 353 | |
| 354 | =item breakpoint |
| 355 | |
| 356 | A spot in your program where you've told the debugger to stop |
| 357 | L<execution|/execute> so you can poke around and see whether anything |
| 358 | is wrong yet. |
| 359 | |
| 360 | =item broadcast |
| 361 | |
| 362 | To send a L</datagram> to multiple destinations simultaneously. |
| 363 | |
| 364 | =item BSD |
| 365 | |
| 366 | A psychoactive drug, popular in the 80s, probably developed at |
| 367 | U. C. Berkeley or thereabouts. Similar in many ways to the |
| 368 | prescription-only medication called "System V", but infinitely more |
| 369 | useful. (Or, at least, more fun.) The full chemical name is |
| 370 | "Berkeley Standard Distribution". |
| 371 | |
| 372 | =item bucket |
| 373 | |
| 374 | A location in a L</hash table> containing (potentially) multiple |
| 375 | entries whose keys "hash" to the same hash value according to its hash |
| 376 | function. (As internal policy, you don't have to worry about it, |
| 377 | unless you're into internals, or policy.) |
| 378 | |
| 379 | =item buffer |
| 380 | |
| 381 | A temporary holding location for data. L<Block buffering|/block |
| 382 | buffering> means that the data is passed on to its destination |
| 383 | whenever the buffer is full. L<Line buffering|/line buffering> means |
| 384 | that it's passed on whenever a complete line is received. L<Command |
| 385 | buffering|/command buffering> means that it's passed every time you do |
| 386 | a L<print|perlfunc/print> command (or equivalent). If your output is |
| 387 | unbuffered, the system processes it one byte at a time without the use |
| 388 | of a holding area. This can be rather inefficient. |
| 389 | |
| 390 | =item built-in |
| 391 | |
| 392 | A L</function> that is predefined in the language. Even when hidden |
| 393 | by L</overriding>, you can always get at a built-in function by |
| 394 | L<qualifying|/qualified> its name with the C<CORE::> pseudo-package. |
| 395 | |
| 396 | =item bundle |
| 397 | |
| 398 | A group of related modules on L</CPAN>. (Also, sometimes refers to a |
| 399 | group of command-line switches grouped into one L</switch cluster>.) |
| 400 | |
| 401 | =item byte |
| 402 | |
| 403 | A piece of data worth eight L<bits|/bit> in most places. |
| 404 | |
| 405 | =item bytecode |
| 406 | |
| 407 | A pidgin-like language spoken among 'droids when they don't wish to |
| 408 | reveal their orientation (see L</endian>). Named after some similar |
| 409 | languages spoken (for similar reasons) between compilers and |
| 410 | interpreters in the late 20th century. These languages are |
| 411 | characterized by representing everything as a |
| 412 | non-architecture-dependent sequence of bytes. |
| 413 | |
| 414 | =back |
| 415 | |
| 416 | =head2 C |
| 417 | |
| 418 | =over 4 |
| 419 | |
| 420 | =item C |
| 421 | |
| 422 | A language beloved by many for its inside-out L</type> definitions, |
| 423 | inscrutable L</precedence> rules, and heavy L</overloading> of the |
| 424 | function-call mechanism. (Well, actually, people first switched to C |
| 425 | because they found lowercase identifiers easier to read than upper.) |
| 426 | Perl is written in C, so it's not surprising that Perl borrowed a few |
| 427 | ideas from it. |
| 428 | |
| 429 | =item C preprocessor |
| 430 | |
| 431 | The typical C compiler's first pass, which processes lines beginning |
| 432 | with C<#> for conditional compilation and macro definition and does |
| 433 | various manipulations of the program text based on the current |
| 434 | definitions. Also known as I<cpp>(1). |
| 435 | |
| 436 | =item call by reference |
| 437 | |
| 438 | An L</argument>-passing mechanism in which the L</formal arguments> |
| 439 | refer directly to the L</actual arguments>, and the L</subroutine> can |
| 440 | change the actual arguments by changing the formal arguments. That |
| 441 | is, the formal argument is an L</alias> for the actual argument. See |
| 442 | also L</call by value>. |
| 443 | |
| 444 | =item call by value |
| 445 | |
| 446 | An L</argument>-passing mechanism in which the L</formal arguments> |
| 447 | refer to a copy of the L</actual arguments>, and the L</subroutine> |
| 448 | cannot change the actual arguments by changing the formal arguments. |
| 449 | See also L</call by reference>. |
| 450 | |
| 451 | =item callback |
| 452 | |
| 453 | A L</handler> that you register with some other part of your program |
| 454 | in the hope that the other part of your program will L</trigger> your |
| 455 | handler when some event of interest transpires. |
| 456 | |
| 457 | =item canonical |
| 458 | |
| 459 | Reduced to a standard form to facilitate comparison. |
| 460 | |
| 461 | =item capturing |
| 462 | |
| 463 | The use of parentheses around a L</subpattern> in a L</regular |
| 464 | expression> to store the matched L</substring> as a L</backreference>. |
| 465 | (Captured strings are also returned as a list in L</list context>.) |
| 466 | |
| 467 | =item character |
| 468 | |
| 469 | A small integer representative of a unit of orthography. |
| 470 | Historically, characters were usually stored as fixed-width integers |
| 471 | (typically in a byte, or maybe two, depending on the character set), |
| 472 | but with the advent of UTF-8, characters are often stored in a |
| 473 | variable number of bytes depending on the size of the integer that |
| 474 | represents the character. Perl manages this transparently for you, |
| 475 | for the most part. |
| 476 | |
| 477 | =item character class |
| 478 | |
| 479 | A square-bracketed list of characters used in a L</regular expression> |
| 480 | to indicate that any character of the set may occur at a given point. |
| 481 | Loosely, any predefined set of characters so used. |
| 482 | |
| 483 | =item character property |
| 484 | |
| 485 | A predefined L</character class> matchable by the C<\p> |
| 486 | L</metasymbol>. Many standard properties are defined for L</Unicode>. |
| 487 | |
| 488 | =item circumfix operator |
| 489 | |
| 490 | An L</operator> that surrounds its L</operand>, like the angle |
| 491 | operator, or parentheses, or a hug. |
| 492 | |
| 493 | =item class |
| 494 | |
| 495 | A user-defined L</type>, implemented in Perl via a L</package> that |
| 496 | provides (either directly or by inheritance) L<methods|/method> (that |
| 497 | is, L<subroutines|/subroutine>) to handle L<instances|/instance> of |
| 498 | the class (its L<objects|/object>). See also L</inheritance>. |
| 499 | |
| 500 | =item class method |
| 501 | |
| 502 | A L</method> whose L</invocant> is a L</package> name, not an |
| 503 | L</object> reference. A method associated with the class as a whole. |
| 504 | |
| 505 | =item client |
| 506 | |
| 507 | In networking, a L</process> that initiates contact with a L</server> |
| 508 | process in order to exchange data and perhaps receive a service. |
| 509 | |
| 510 | =item cloister |
| 511 | |
| 512 | A L</cluster> used to restrict the scope of a L</regular expression |
| 513 | modifier>. |
| 514 | |
| 515 | =item closure |
| 516 | |
| 517 | An L</anonymous> subroutine that, when a reference to it is generated |
| 518 | at run time, keeps track of the identities of externally visible |
| 519 | L<lexical variables|/lexical variable> even after those lexical |
| 520 | variables have supposedly gone out of L</scope>. They're called |
| 521 | "closures" because this sort of behavior gives mathematicians a sense |
| 522 | of closure. |
| 523 | |
| 524 | =item cluster |
| 525 | |
| 526 | A parenthesized L</subpattern> used to group parts of a L</regular |
| 527 | expression> into a single L</atom>. |
| 528 | |
| 529 | =item CODE |
| 530 | |
| 531 | The word returned by the L<ref|perlfunc/ref> function when you apply |
| 532 | it to a reference to a subroutine. See also L</CV>. |
| 533 | |
| 534 | =item code generator |
| 535 | |
| 536 | A system that writes code for you in a low-level language, such as |
| 537 | code to implement the backend of a compiler. See L</program |
| 538 | generator>. |
| 539 | |
| 540 | =item code subpattern |
| 541 | |
| 542 | A L</regular expression> subpattern whose real purpose is to execute |
| 543 | some Perl code, for example, the C<(?{...})> and C<(??{...})> |
| 544 | subpatterns. |
| 545 | |
| 546 | =item collating sequence |
| 547 | |
| 548 | The order into which L<characters|/character> sort. This is used by |
| 549 | L</string> comparison routines to decide, for example, where in this |
| 550 | glossary to put "collating sequence". |
| 551 | |
| 552 | =item command |
| 553 | |
| 554 | In L</shell> programming, the syntactic combination of a program name |
| 555 | and its arguments. More loosely, anything you type to a shell (a |
| 556 | command interpreter) that starts it doing something. Even more |
| 557 | loosely, a Perl L</statement>, which might start with a L</label> and |
| 558 | typically ends with a semicolon. |
| 559 | |
| 560 | =item command buffering |
| 561 | |
| 562 | A mechanism in Perl that lets you store up the output of each Perl |
| 563 | L</command> and then flush it out as a single request to the |
| 564 | L</operating system>. It's enabled by setting the C<$|> |
| 565 | (C<$AUTOFLUSH>) variable to a true value. It's used when you don't |
| 566 | want data sitting around not going where it's supposed to, which may |
| 567 | happen because the default on a L</file> or L</pipe> is to use |
| 568 | L</block buffering>. |
| 569 | |
| 570 | =item command name |
| 571 | |
| 572 | The name of the program currently executing, as typed on the command |
| 573 | line. In C, the L</command> name is passed to the program as the |
| 574 | first command-line argument. In Perl, it comes in separately as |
| 575 | C<$0>. |
| 576 | |
| 577 | =item command-line arguments |
| 578 | |
| 579 | The L<values|/value> you supply along with a program name when you |
| 580 | tell a L</shell> to execute a L</command>. These values are passed to |
| 581 | a Perl program through C<@ARGV>. |
| 582 | |
| 583 | =item comment |
| 584 | |
| 585 | A remark that doesn't affect the meaning of the program. In Perl, a |
| 586 | comment is introduced by a C<#> character and continues to the end of |
| 587 | the line. |
| 588 | |
| 589 | =item compilation unit |
| 590 | |
| 591 | The L</file> (or L</string>, in the case of L<eval|perlfunc/eval>) |
| 592 | that is currently being compiled. |
| 593 | |
| 594 | =item compile phase |
| 595 | |
| 596 | Any time before Perl starts running your main program. See also |
| 597 | L</run phase>. Compile phase is mostly spent in L</compile time>, but |
| 598 | may also be spent in L</run time> when C<BEGIN> blocks, |
| 599 | L<use|perlfunc/use> declarations, or constant subexpressions are being |
| 600 | evaluated. The startup and import code of any L<use|perlfunc/use> |
| 601 | declaration is also run during compile phase. |
| 602 | |
| 603 | =item compile time |
| 604 | |
| 605 | The time when Perl is trying to make sense of your code, as opposed to |
| 606 | when it thinks it knows what your code means and is merely trying to |
| 607 | do what it thinks your code says to do, which is L</run time>. |
| 608 | |
| 609 | =item compiler |
| 610 | |
| 611 | Strictly speaking, a program that munches up another program and spits |
| 612 | out yet another file containing the program in a "more executable" |
| 613 | form, typically containing native machine instructions. The I<perl> |
| 614 | program is not a compiler by this definition, but it does contain a |
| 615 | kind of compiler that takes a program and turns it into a more |
| 616 | executable form (L<syntax trees|/syntax tree>) within the I<perl> |
| 617 | process itself, which the L</interpreter> then interprets. There are, |
| 618 | however, extension L<modules|/module> to get Perl to act more like a |
| 619 | "real" compiler. See L<O>. |
| 620 | |
| 621 | =item composer |
| 622 | |
| 623 | A "constructor" for a L</referent> that isn't really an L</object>, |
| 624 | like an anonymous array or a hash (or a sonata, for that matter). For |
| 625 | example, a pair of braces acts as a composer for a hash, and a pair of |
| 626 | brackets acts as a composer for an array. See L<perlref/Making |
| 627 | References>. |
| 628 | |
| 629 | =item concatenation |
| 630 | |
| 631 | The process of gluing one cat's nose to another cat's tail. Also, a |
| 632 | similar operation on two L<strings|/string>. |
| 633 | |
| 634 | =item conditional |
| 635 | |
| 636 | Something "iffy". See L</Boolean context>. |
| 637 | |
| 638 | =item connection |
| 639 | |
| 640 | In telephony, the temporary electrical circuit between the caller's |
| 641 | and the callee's phone. In networking, the same kind of temporary |
| 642 | circuit between a L</client> and a L</server>. |
| 643 | |
| 644 | =item construct |
| 645 | |
| 646 | As a noun, a piece of syntax made up of smaller pieces. As a |
| 647 | transitive verb, to create an L</object> using a L</constructor>. |
| 648 | |
| 649 | =item constructor |
| 650 | |
| 651 | Any L</class method>, instance L</method>, or L</subroutine> |
| 652 | that composes, initializes, blesses, and returns an L</object>. |
| 653 | Sometimes we use the term loosely to mean a L</composer>. |
| 654 | |
| 655 | =item context |
| 656 | |
| 657 | The surroundings, or environment. The context given by the |
| 658 | surrounding code determines what kind of data a particular |
| 659 | L</expression> is expected to return. The three primary contexts are |
| 660 | L</list context>, L</scalar context>, and L</void context>. Scalar |
| 661 | context is sometimes subdivided into L</Boolean context>, L</numeric |
| 662 | context>, L</string context>, and L</void context>. There's also a |
| 663 | "don't care" scalar context (which is dealt with in Programming Perl, |
| 664 | Third Edition, Chapter 2, "Bits and Pieces" if you care). |
| 665 | |
| 666 | =item continuation |
| 667 | |
| 668 | The treatment of more than one physical L</line> as a single logical |
| 669 | line. L</Makefile> lines are continued by putting a backslash before |
| 670 | the L</newline>. Mail headers as defined by RFC 822 are continued by |
| 671 | putting a space or tab I<after> the newline. In general, lines in |
| 672 | Perl do not need any form of continuation mark, because L</whitespace> |
| 673 | (including newlines) is gleefully ignored. Usually. |
| 674 | |
| 675 | =item core dump |
| 676 | |
| 677 | The corpse of a L</process>, in the form of a file left in the |
| 678 | L</working directory> of the process, usually as a result of certain |
| 679 | kinds of fatal error. |
| 680 | |
| 681 | =item CPAN |
| 682 | |
| 683 | The Comprehensive Perl Archive Network. (See L<perlfaq2/What modules and extensions are available for Perl? What is CPAN? What does CPANE<sol>srcE<sol>... mean?>). |
| 684 | |
| 685 | =item cracker |
| 686 | |
| 687 | Someone who breaks security on computer systems. A cracker may be a |
| 688 | true L</hacker> or only a L</script kiddie>. |
| 689 | |
| 690 | =item current package |
| 691 | |
| 692 | The L</package> in which the current statement is compiled. Scan |
| 693 | backwards in the text of your program through the current L<lexical |
| 694 | scope|/lexical scoping> or any enclosing lexical scopes till you find |
| 695 | a package declaration. That's your current package name. |
| 696 | |
| 697 | =item current working directory |
| 698 | |
| 699 | See L</working directory>. |
| 700 | |
| 701 | =item currently selected output channel |
| 702 | |
| 703 | The last L</filehandle> that was designated with |
| 704 | L<select|perlfunc/select>(C<FILEHANDLE>); L</STDOUT>, if no filehandle |
| 705 | has been selected. |
| 706 | |
| 707 | =item CV |
| 708 | |
| 709 | An internal "code value" typedef, holding a L</subroutine>. The L</CV> |
| 710 | type is a subclass of L</SV>. |
| 711 | |
| 712 | =back |
| 713 | |
| 714 | =head2 D |
| 715 | |
| 716 | =over 4 |
| 717 | |
| 718 | =item dangling statement |
| 719 | |
| 720 | A bare, single L</statement>, without any braces, hanging off an C<if> |
| 721 | or C<while> conditional. C allows them. Perl doesn't. |
| 722 | |
| 723 | =item data structure |
| 724 | |
| 725 | How your various pieces of data relate to each other and what shape |
| 726 | they make when you put them all together, as in a rectangular table or |
| 727 | a triangular-shaped tree. |
| 728 | |
| 729 | =item data type |
| 730 | |
| 731 | A set of possible values, together with all the operations that know |
| 732 | how to deal with those values. For example, a numeric data type has a |
| 733 | certain set of numbers that you can work with and various mathematical |
| 734 | operations that you can do on the numbers but would make little sense |
| 735 | on, say, a string such as C<"Kilroy">. Strings have their own |
| 736 | operations, such as L</concatenation>. Compound types made of a |
| 737 | number of smaller pieces generally have operations to compose and |
| 738 | decompose them, and perhaps to rearrange them. L<Objects|/object> |
| 739 | that model things in the real world often have operations that |
| 740 | correspond to real activities. For instance, if you model an |
| 741 | elevator, your elevator object might have an C<open_door()> |
| 742 | L</method>. |
| 743 | |
| 744 | =item datagram |
| 745 | |
| 746 | A packet of data, such as a L</UDP> message, that (from the viewpoint |
| 747 | of the programs involved) can be sent independently over the network. |
| 748 | (In fact, all packets are sent independently at the L</IP> level, but |
| 749 | L</stream> protocols such as L</TCP> hide this from your program.) |
| 750 | |
| 751 | =item DBM |
| 752 | |
| 753 | Stands for "Data Base Management" routines, a set of routines that |
| 754 | emulate an L</associative array> using disk files. The routines use a |
| 755 | dynamic hashing scheme to locate any entry with only two disk |
| 756 | accesses. DBM files allow a Perl program to keep a persistent |
| 757 | L</hash> across multiple invocations. You can L<tie|perlfunc/tie> |
| 758 | your hash variables to various DBM implementations--see L<AnyDBM_File> |
| 759 | and L<DB_File>. |
| 760 | |
| 761 | =item declaration |
| 762 | |
| 763 | An L</assertion> that states something exists and perhaps describes |
| 764 | what it's like, without giving any commitment as to how or where |
| 765 | you'll use it. A declaration is like the part of your recipe that |
| 766 | says, "two cups flour, one large egg, four or five tadpoles..." See |
| 767 | L</statement> for its opposite. Note that some declarations also |
| 768 | function as statements. Subroutine declarations also act as |
| 769 | definitions if a body is supplied. |
| 770 | |
| 771 | =item decrement |
| 772 | |
| 773 | To subtract a value from a variable, as in "decrement C<$x>" (meaning |
| 774 | to remove 1 from its value) or "decrement C<$x> by 3". |
| 775 | |
| 776 | =item default |
| 777 | |
| 778 | A L</value> chosen for you if you don't supply a value of your own. |
| 779 | |
| 780 | =item defined |
| 781 | |
| 782 | Having a meaning. Perl thinks that some of the things people try to |
| 783 | do are devoid of meaning, in particular, making use of variables that |
| 784 | have never been given a L</value> and performing certain operations on |
| 785 | data that isn't there. For example, if you try to read data past the |
| 786 | end of a file, Perl will hand you back an undefined value. See also |
| 787 | L</false> and L<perlfunc/defined>. |
| 788 | |
| 789 | =item delimiter |
| 790 | |
| 791 | A L</character> or L</string> that sets bounds to an arbitrarily-sized |
| 792 | textual object, not to be confused with a L</separator> or |
| 793 | L</terminator>. "To delimit" really just means "to surround" or "to |
| 794 | enclose" (like these parentheses are doing). |
| 795 | |
| 796 | =item deprecated modules and features |
| 797 | |
| 798 | Deprecated modules and features are those which were part of a stable |
| 799 | release, but later found to be subtly flawed, and which should be avoided. |
| 800 | They are subject to removal and/or bug-incompatible reimplementation in |
| 801 | the next major release (but they will be preserved through maintainance |
| 802 | releases). Deprecation warnings are issued under B<-w> or C<use |
| 803 | diagnostics>, and notices are found in L<perldelta>s, as well as various |
| 804 | other PODs. Coding practices that misuse features, such as C<my $foo if |
| 805 | 0>, can also be deprecated. |
| 806 | |
| 807 | =item dereference |
| 808 | |
| 809 | A fancy computer science term meaning "to follow a L</reference> to |
| 810 | what it points to". The "de" part of it refers to the fact that |
| 811 | you're taking away one level of L</indirection>. |
| 812 | |
| 813 | =item derived class |
| 814 | |
| 815 | A L</class> that defines some of its L<methods|/method> in terms of a |
| 816 | more generic class, called a L</base class>. Note that classes aren't |
| 817 | classified exclusively into base classes or derived classes: a class |
| 818 | can function as both a derived class and a base class simultaneously, |
| 819 | which is kind of classy. |
| 820 | |
| 821 | =item descriptor |
| 822 | |
| 823 | See L</file descriptor>. |
| 824 | |
| 825 | =item destroy |
| 826 | |
| 827 | To deallocate the memory of a L</referent> (first triggering its |
| 828 | C<DESTROY> method, if it has one). |
| 829 | |
| 830 | =item destructor |
| 831 | |
| 832 | A special L</method> that is called when an L</object> is thinking |
| 833 | about L<destroying|/destroy> itself. A Perl program's C<DESTROY> |
| 834 | method doesn't do the actual destruction; Perl just |
| 835 | L<triggers|/trigger> the method in case the L</class> wants to do any |
| 836 | associated cleanup. |
| 837 | |
| 838 | =item device |
| 839 | |
| 840 | A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a |
| 841 | joystick or a mouse) attached to your computer, that the L</operating |
| 842 | system> tries to make look like a L</file> (or a bunch of files). |
| 843 | Under Unix, these fake files tend to live in the I</dev> directory. |
| 844 | |
| 845 | =item directive |
| 846 | |
| 847 | A L</pod> directive. See L<perlpod>. |
| 848 | |
| 849 | =item directory |
| 850 | |
| 851 | A special file that contains other files. Some L<operating |
| 852 | systems|/operating system> call these "folders", "drawers", or |
| 853 | "catalogs". |
| 854 | |
| 855 | =item directory handle |
| 856 | |
| 857 | A name that represents a particular instance of opening a directory to |
| 858 | read it, until you close it. See the L<opendir|perlfunc/opendir> |
| 859 | function. |
| 860 | |
| 861 | =item dispatch |
| 862 | |
| 863 | To send something to its correct destination. Often used |
| 864 | metaphorically to indicate a transfer of programmatic control to a |
| 865 | destination selected algorithmically, often by lookup in a table of |
| 866 | function L<references|/reference> or, in the case of object |
| 867 | L<methods|/method>, by traversing the inheritance tree looking for the |
| 868 | most specific definition for the method. |
| 869 | |
| 870 | =item distribution |
| 871 | |
| 872 | A standard, bundled release of a system of software. The default |
| 873 | usage implies source code is included. If that is not the case, it |
| 874 | will be called a "binary-only" distribution. |
| 875 | |
| 876 | =item (to be) dropped modules |
| 877 | |
| 878 | When Perl 5 was first released (see L<perlhistory>), several modules were |
| 879 | included, which have now fallen out of common use. It has been suggested |
| 880 | that these modules should be removed, since the distribution became rather |
| 881 | large, and the common criterion for new module additions is now limited to |
| 882 | modules that help to build, test, and extend perl itself. Furthermore, |
| 883 | the CPAN (which didn't exist by the time of Perl 5.0) can become a new |
| 884 | home dropped modules. Dropping modules is currently not an option, but |
| 885 | further developments may clear the last barriers. |
| 886 | |
| 887 | =item dweomer |
| 888 | |
| 889 | An enchantment, illusion, phantasm, or jugglery. Said when Perl's |
| 890 | magical L</dwimmer> effects don't do what you expect, but rather seem |
| 891 | to be the product of arcane dweomercraft, sorcery, or wonder working. |
| 892 | [From Old English] |
| 893 | |
| 894 | =item dwimmer |
| 895 | |
| 896 | DWIM is an acronym for "Do What I Mean", the principle that something |
| 897 | should just do what you want it to do without an undue amount of fuss. |
| 898 | A bit of code that does "dwimming" is a "dwimmer". Dwimming can |
| 899 | require a great deal of behind-the-scenes magic, which (if it doesn't |
| 900 | stay properly behind the scenes) is called a L</dweomer> instead. |
| 901 | |
| 902 | =item dynamic scoping |
| 903 | |
| 904 | Dynamic scoping works over a dynamic scope, making variables visible |
| 905 | throughout the rest of the L</block> in which they are first used and |
| 906 | in any L<subroutines|/subroutine> that are called by the rest of the |
| 907 | block. Dynamically scoped variables can have their values temporarily |
| 908 | changed (and implicitly restored later) by a L<local|perlfunc/local> |
| 909 | operator. (Compare L</lexical scoping>.) Used more loosely to mean |
| 910 | how a subroutine that is in the middle of calling another subroutine |
| 911 | "contains" that subroutine at L</run time>. |
| 912 | |
| 913 | =back |
| 914 | |
| 915 | =head2 E |
| 916 | |
| 917 | =over 4 |
| 918 | |
| 919 | =item eclectic |
| 920 | |
| 921 | Derived from many sources. Some would say I<too> many. |
| 922 | |
| 923 | =item element |
| 924 | |
| 925 | A basic building block. When you're talking about an L</array>, it's |
| 926 | one of the items that make up the array. |
| 927 | |
| 928 | =item embedding |
| 929 | |
| 930 | When something is contained in something else, particularly when that |
| 931 | might be considered surprising: "I've embedded a complete Perl |
| 932 | interpreter in my editor!" |
| 933 | |
| 934 | =item empty subclass test |
| 935 | |
| 936 | The notion that an empty L</derived class> should behave exactly like |
| 937 | its L</base class>. |
| 938 | |
| 939 | =item en passant |
| 940 | |
| 941 | When you change a L</value> as it is being copied. [From French, "in |
| 942 | passing", as in the exotic pawn-capturing maneuver in chess.] |
| 943 | |
| 944 | =item encapsulation |
| 945 | |
| 946 | The veil of abstraction separating the L</interface> from the |
| 947 | L</implementation> (whether enforced or not), which mandates that all |
| 948 | access to an L</object>'s state be through L<methods|/method> alone. |
| 949 | |
| 950 | =item endian |
| 951 | |
| 952 | See L</little-endian> and L</big-endian>. |
| 953 | |
| 954 | =item environment |
| 955 | |
| 956 | The collective set of L<environment variables|/environment variable> |
| 957 | your L</process> inherits from its parent. Accessed via C<%ENV>. |
| 958 | |
| 959 | =item environment variable |
| 960 | |
| 961 | A mechanism by which some high-level agent such as a user can pass its |
| 962 | preferences down to its future offspring (child L<processes|/process>, |
| 963 | grandchild processes, great-grandchild processes, and so on). Each |
| 964 | environment variable is a L</key>/L</value> pair, like one entry in a |
| 965 | L</hash>. |
| 966 | |
| 967 | =item EOF |
| 968 | |
| 969 | End of File. Sometimes used metaphorically as the terminating string |
| 970 | of a L</here document>. |
| 971 | |
| 972 | =item errno |
| 973 | |
| 974 | The error number returned by a L</syscall> when it fails. Perl refers |
| 975 | to the error by the name C<$!> (or C<$OS_ERROR> if you use the English |
| 976 | module). |
| 977 | |
| 978 | =item error |
| 979 | |
| 980 | See L</exception> or L</fatal error>. |
| 981 | |
| 982 | =item escape sequence |
| 983 | |
| 984 | See L</metasymbol>. |
| 985 | |
| 986 | =item exception |
| 987 | |
| 988 | A fancy term for an error. See L</fatal error>. |
| 989 | |
| 990 | =item exception handling |
| 991 | |
| 992 | The way a program responds to an error. The exception handling |
| 993 | mechanism in Perl is the L<eval|perlfunc/eval> operator. |
| 994 | |
| 995 | =item exec |
| 996 | |
| 997 | To throw away the current L</process>'s program and replace it with |
| 998 | another without exiting the process or relinquishing any resources |
| 999 | held (apart from the old memory image). |
| 1000 | |
| 1001 | =item executable file |
| 1002 | |
| 1003 | A L</file> that is specially marked to tell the L</operating system> |
| 1004 | that it's okay to run this file as a program. Usually shortened to |
| 1005 | "executable". |
| 1006 | |
| 1007 | =item execute |
| 1008 | |
| 1009 | To run a L<program|/executable file> or L</subroutine>. (Has nothing |
| 1010 | to do with the L<kill|perlfunc/kill> built-in, unless you're trying to |
| 1011 | run a L</signal handler>.) |
| 1012 | |
| 1013 | =item execute bit |
| 1014 | |
| 1015 | The special mark that tells the operating system it can run this |
| 1016 | program. There are actually three execute bits under Unix, and which |
| 1017 | bit gets used depends on whether you own the file singularly, |
| 1018 | collectively, or not at all. |
| 1019 | |
| 1020 | =item exit status |
| 1021 | |
| 1022 | See L</status>. |
| 1023 | |
| 1024 | =item export |
| 1025 | |
| 1026 | To make symbols from a L</module> available for L</import> by other modules. |
| 1027 | |
| 1028 | =item expression |
| 1029 | |
| 1030 | Anything you can legally say in a spot where a L</value> is required. |
| 1031 | Typically composed of L<literals|/literal>, L<variables|/variable>, |
| 1032 | L<operators|/operator>, L<functions|/function>, and L</subroutine> |
| 1033 | calls, not necessarily in that order. |
| 1034 | |
| 1035 | =item extension |
| 1036 | |
| 1037 | A Perl module that also pulls in compiled C or C++ code. More |
| 1038 | generally, any experimental option that can be compiled into Perl, |
| 1039 | such as multithreading. |
| 1040 | |
| 1041 | =back |
| 1042 | |
| 1043 | =head2 F |
| 1044 | |
| 1045 | =over 4 |
| 1046 | |
| 1047 | =item false |
| 1048 | |
| 1049 | In Perl, any value that would look like C<""> or C<"0"> if evaluated |
| 1050 | in a string context. Since undefined values evaluate to C<"">, all |
| 1051 | undefined values are false, but not all false values are undefined. |
| 1052 | |
| 1053 | =item FAQ |
| 1054 | |
| 1055 | Frequently Asked Question (although not necessarily frequently |
| 1056 | answered, especially if the answer appears in the Perl FAQ shipped |
| 1057 | standard with Perl). |
| 1058 | |
| 1059 | =item fatal error |
| 1060 | |
| 1061 | An uncaught L</exception>, which causes termination of the L</process> |
| 1062 | after printing a message on your L</standard error> stream. Errors |
| 1063 | that happen inside an L<eval|perlfunc/eval> are not fatal. Instead, |
| 1064 | the L<eval|perlfunc/eval> terminates after placing the exception |
| 1065 | message in the C<$@> (C<$EVAL_ERROR>) variable. You can try to |
| 1066 | provoke a fatal error with the L<die|perlfunc/die> operator (known as |
| 1067 | throwing or raising an exception), but this may be caught by a |
| 1068 | dynamically enclosing L<eval|perlfunc/eval>. If not caught, the |
| 1069 | L<die|perlfunc/die> becomes a fatal error. |
| 1070 | |
| 1071 | =item field |
| 1072 | |
| 1073 | A single piece of numeric or string data that is part of a longer |
| 1074 | L</string>, L</record>, or L</line>. Variable-width fields are usually |
| 1075 | split up by L<separators|/separator> (so use L<split|perlfunc/split> to |
| 1076 | extract the fields), while fixed-width fields are usually at fixed |
| 1077 | positions (so use L<unpack|perlfunc/unpack>). L<Instance |
| 1078 | variables|/instance variable> are also known as fields. |
| 1079 | |
| 1080 | =item FIFO |
| 1081 | |
| 1082 | First In, First Out. See also L</LIFO>. Also, a nickname for a |
| 1083 | L</named pipe>. |
| 1084 | |
| 1085 | =item file |
| 1086 | |
| 1087 | A named collection of data, usually stored on disk in a L</directory> |
| 1088 | in a L</filesystem>. Roughly like a document, if you're into office |
| 1089 | metaphors. In modern filesystems, you can actually give a file more |
| 1090 | than one name. Some files have special properties, like directories |
| 1091 | and devices. |
| 1092 | |
| 1093 | =item file descriptor |
| 1094 | |
| 1095 | The little number the L</operating system> uses to keep track of which |
| 1096 | opened L</file> you're talking about. Perl hides the file descriptor |
| 1097 | inside a L</standard IE<sol>O> stream and then attaches the stream to |
| 1098 | a L</filehandle>. |
| 1099 | |
| 1100 | =item file test operator |
| 1101 | |
| 1102 | A built-in unary operator that you use to determine whether something |
| 1103 | is L</true> about a file, such as C<-o $filename> to test whether |
| 1104 | you're the owner of the file. |
| 1105 | |
| 1106 | =item fileglob |
| 1107 | |
| 1108 | A "wildcard" match on L<filenames|/filename>. See the |
| 1109 | L<glob|perlfunc/glob> function. |
| 1110 | |
| 1111 | =item filehandle |
| 1112 | |
| 1113 | An identifier (not necessarily related to the real name of a file) |
| 1114 | that represents a particular instance of opening a file until you |
| 1115 | close it. If you're going to open and close several different files |
| 1116 | in succession, it's fine to open each of them with the same |
| 1117 | filehandle, so you don't have to write out separate code to process |
| 1118 | each file. |
| 1119 | |
| 1120 | =item filename |
| 1121 | |
| 1122 | One name for a file. This name is listed in a L</directory>, and you |
| 1123 | can use it in an L<open|perlfunc/open> to tell the L</operating |
| 1124 | system> exactly which file you want to open, and associate the file |
| 1125 | with a L</filehandle> which will carry the subsequent identity of that |
| 1126 | file in your program, until you close it. |
| 1127 | |
| 1128 | =item filesystem |
| 1129 | |
| 1130 | A set of L<directories|/directory> and L<files|/file> residing on a |
| 1131 | partition of the disk. Sometimes known as a "partition". You can |
| 1132 | change the file's name or even move a file around from directory to |
| 1133 | directory within a filesystem without actually moving the file itself, |
| 1134 | at least under Unix. |
| 1135 | |
| 1136 | =item filter |
| 1137 | |
| 1138 | A program designed to take a L</stream> of input and transform it into |
| 1139 | a stream of output. |
| 1140 | |
| 1141 | =item flag |
| 1142 | |
| 1143 | We tend to avoid this term because it means so many things. It may |
| 1144 | mean a command-line L</switch> that takes no argument |
| 1145 | itself (such as Perl's B<-n> and B<-p> |
| 1146 | flags) or, less frequently, a single-bit indicator (such as the |
| 1147 | C<O_CREAT> and C<O_EXCL> flags used in |
| 1148 | L<sysopen|perlfunc/sysopen>). |
| 1149 | |
| 1150 | =item floating point |
| 1151 | |
| 1152 | A method of storing numbers in "scientific notation", such that the |
| 1153 | precision of the number is independent of its magnitude (the decimal |
| 1154 | point "floats"). Perl does its numeric work with floating-point |
| 1155 | numbers (sometimes called "floats"), when it can't get away with |
| 1156 | using L<integers|/integer>. Floating-point numbers are mere |
| 1157 | approximations of real numbers. |
| 1158 | |
| 1159 | =item flush |
| 1160 | |
| 1161 | The act of emptying a L</buffer>, often before it's full. |
| 1162 | |
| 1163 | =item FMTEYEWTK |
| 1164 | |
| 1165 | Far More Than Everything You Ever Wanted To Know. An exhaustive |
| 1166 | treatise on one narrow topic, something of a super-L</FAQ>. See Tom |
| 1167 | for far more. |
| 1168 | |
| 1169 | =item fork |
| 1170 | |
| 1171 | To create a child L</process> identical to the parent process at its |
| 1172 | moment of conception, at least until it gets ideas of its own. A |
| 1173 | thread with protected memory. |
| 1174 | |
| 1175 | =item formal arguments |
| 1176 | |
| 1177 | The generic names by which a L</subroutine> knows its |
| 1178 | L<arguments|/argument>. In many languages, formal arguments are |
| 1179 | always given individual names, but in Perl, the formal arguments are |
| 1180 | just the elements of an array. The formal arguments to a Perl program |
| 1181 | are C<$ARGV[0]>, C<$ARGV[1]>, and so on. Similarly, the formal |
| 1182 | arguments to a Perl subroutine are C<$_[0]>, C<$_[1]>, and so on. You |
| 1183 | may give the arguments individual names by assigning the values to a |
| 1184 | L<my|perlfunc/my> list. See also L</actual arguments>. |
| 1185 | |
| 1186 | =item format |
| 1187 | |
| 1188 | A specification of how many spaces and digits and things to put |
| 1189 | somewhere so that whatever you're printing comes out nice and pretty. |
| 1190 | |
| 1191 | =item freely available |
| 1192 | |
| 1193 | Means you don't have to pay money to get it, but the copyright on it |
| 1194 | may still belong to someone else (like Larry). |
| 1195 | |
| 1196 | =item freely redistributable |
| 1197 | |
| 1198 | Means you're not in legal trouble if you give a bootleg copy of it to |
| 1199 | your friends and we find out about it. In fact, we'd rather you gave |
| 1200 | a copy to all your friends. |
| 1201 | |
| 1202 | =item freeware |
| 1203 | |
| 1204 | Historically, any software that you give away, particularly if you |
| 1205 | make the source code available as well. Now often called C<open |
| 1206 | source software>. Recently there has been a trend to use the term in |
| 1207 | contradistinction to L</open source software>, to refer only to free |
| 1208 | software released under the Free Software Foundation's GPL (General |
| 1209 | Public License), but this is difficult to justify etymologically. |
| 1210 | |
| 1211 | =item function |
| 1212 | |
| 1213 | Mathematically, a mapping of each of a set of input values to a |
| 1214 | particular output value. In computers, refers to a L</subroutine> or |
| 1215 | L</operator> that returns a L</value>. It may or may not have input |
| 1216 | values (called L<arguments|/argument>). |
| 1217 | |
| 1218 | =item funny character |
| 1219 | |
| 1220 | Someone like Larry, or one of his peculiar friends. Also refers to |
| 1221 | the strange prefixes that Perl requires as noun markers on its |
| 1222 | variables. |
| 1223 | |
| 1224 | =item garbage collection |
| 1225 | |
| 1226 | A misnamed feature--it should be called, "expecting your mother to |
| 1227 | pick up after you". Strictly speaking, Perl doesn't do this, but it |
| 1228 | relies on a reference-counting mechanism to keep things tidy. |
| 1229 | However, we rarely speak strictly and will often refer to the |
| 1230 | reference-counting scheme as a form of garbage collection. (If it's |
| 1231 | any comfort, when your interpreter exits, a "real" garbage collector |
| 1232 | runs to make sure everything is cleaned up if you've been messy with |
| 1233 | circular references and such.) |
| 1234 | |
| 1235 | =back |
| 1236 | |
| 1237 | =head2 G |
| 1238 | |
| 1239 | =over 4 |
| 1240 | |
| 1241 | =item GID |
| 1242 | |
| 1243 | Group ID--in Unix, the numeric group ID that the L</operating system> |
| 1244 | uses to identify you and members of your L</group>. |
| 1245 | |
| 1246 | =item glob |
| 1247 | |
| 1248 | Strictly, the shell's C<*> character, which will match a "glob" of |
| 1249 | characters when you're trying to generate a list of filenames. |
| 1250 | Loosely, the act of using globs and similar symbols to do pattern |
| 1251 | matching. See also L</fileglob> and L</typeglob>. |
| 1252 | |
| 1253 | =item global |
| 1254 | |
| 1255 | Something you can see from anywhere, usually used of |
| 1256 | L<variables|/variable> and L<subroutines|/subroutine> that are visible |
| 1257 | everywhere in your program. In Perl, only certain special variables |
| 1258 | are truly global--most variables (and all subroutines) exist only in |
| 1259 | the current L</package>. Global variables can be declared with |
| 1260 | L<our|perlfunc/our>. See L<perlfunc/our>. |
| 1261 | |
| 1262 | =item global destruction |
| 1263 | |
| 1264 | The L</garbage collection> of globals (and the running of any |
| 1265 | associated object destructors) that takes place when a Perl |
| 1266 | L</interpreter> is being shut down. Global destruction should not be |
| 1267 | confused with the Apocalypse, except perhaps when it should. |
| 1268 | |
| 1269 | =item glue language |
| 1270 | |
| 1271 | A language such as Perl that is good at hooking things together that |
| 1272 | weren't intended to be hooked together. |
| 1273 | |
| 1274 | =item granularity |
| 1275 | |
| 1276 | The size of the pieces you're dealing with, mentally speaking. |
| 1277 | |
| 1278 | =item greedy |
| 1279 | |
| 1280 | A L</subpattern> whose L</quantifier> wants to match as many things as |
| 1281 | possible. |
| 1282 | |
| 1283 | =item grep |
| 1284 | |
| 1285 | Originally from the old Unix editor command for "Globally search for a |
| 1286 | Regular Expression and Print it", now used in the general sense of any |
| 1287 | kind of search, especially text searches. Perl has a built-in |
| 1288 | L<grep|perlfunc/grep> function that searches a list for elements |
| 1289 | matching any given criterion, whereas the I<grep>(1) program searches |
| 1290 | for lines matching a L</regular expression> in one or more files. |
| 1291 | |
| 1292 | =item group |
| 1293 | |
| 1294 | A set of users of which you are a member. In some operating systems |
| 1295 | (like Unix), you can give certain file access permissions to other |
| 1296 | members of your group. |
| 1297 | |
| 1298 | =item GV |
| 1299 | |
| 1300 | An internal "glob value" typedef, holding a L</typeglob>. The L</GV> |
| 1301 | type is a subclass of L</SV>. |
| 1302 | |
| 1303 | =back |
| 1304 | |
| 1305 | =head2 H |
| 1306 | |
| 1307 | =over 4 |
| 1308 | |
| 1309 | =item hacker |
| 1310 | |
| 1311 | Someone who is brilliantly persistent in solving technical problems, |
| 1312 | whether these involve golfing, fighting orcs, or programming. Hacker |
| 1313 | is a neutral term, morally speaking. Good hackers are not to be |
| 1314 | confused with evil L<crackers|/cracker> or clueless L<script |
| 1315 | kiddies|/script kiddie>. If you confuse them, we will presume that |
| 1316 | you are either evil or clueless. |
| 1317 | |
| 1318 | =item handler |
| 1319 | |
| 1320 | A L</subroutine> or L</method> that is called by Perl when your |
| 1321 | program needs to respond to some internal event, such as a L</signal>, |
| 1322 | or an encounter with an operator subject to L</operator overloading>. |
| 1323 | See also L</callback>. |
| 1324 | |
| 1325 | =item hard reference |
| 1326 | |
| 1327 | A L</scalar> L</value> containing the actual address of a |
| 1328 | L</referent>, such that the referent's L</reference> count accounts |
| 1329 | for it. (Some hard references are held internally, such as the |
| 1330 | implicit reference from one of a L</typeglob>'s variable slots to its |
| 1331 | corresponding referent.) A hard reference is different from a |
| 1332 | L</symbolic reference>. |
| 1333 | |
| 1334 | =item hash |
| 1335 | |
| 1336 | An unordered association of L</key>/L</value> pairs, stored such that |
| 1337 | you can easily use a string L</key> to look up its associated data |
| 1338 | L</value>. This glossary is like a hash, where the word to be defined |
| 1339 | is the key, and the definition is the value. A hash is also sometimes |
| 1340 | septisyllabically called an "associative array", which is a pretty |
| 1341 | good reason for simply calling it a "hash" instead. |
| 1342 | |
| 1343 | =item hash table |
| 1344 | |
| 1345 | A data structure used internally by Perl for implementing associative |
| 1346 | arrays (hashes) efficiently. See also L</bucket>. |
| 1347 | |
| 1348 | =item header file |
| 1349 | |
| 1350 | A file containing certain required definitions that you must include |
| 1351 | "ahead" of the rest of your program to do certain obscure operations. |
| 1352 | A C header file has a I<.h> extension. Perl doesn't really have |
| 1353 | header files, though historically Perl has sometimes used translated |
| 1354 | I<.h> files with a I<.ph> extension. See L<perlfunc/require>. |
| 1355 | (Header files have been superseded by the L</module> mechanism.) |
| 1356 | |
| 1357 | =item here document |
| 1358 | |
| 1359 | So called because of a similar construct in L<shells|/shell> that |
| 1360 | pretends that the L<lines|/line> following the L</command> are a |
| 1361 | separate L</file> to be fed to the command, up to some terminating |
| 1362 | string. In Perl, however, it's just a fancy form of quoting. |
| 1363 | |
| 1364 | =item hexadecimal |
| 1365 | |
| 1366 | A number in base 16, "hex" for short. The digits for 10 through 16 |
| 1367 | are customarily represented by the letters C<a> through C<f>. |
| 1368 | Hexadecimal constants in Perl start with C<0x>. See also |
| 1369 | L<perlfunc/hex>. |
| 1370 | |
| 1371 | =item home directory |
| 1372 | |
| 1373 | The directory you are put into when you log in. On a Unix system, the |
| 1374 | name is often placed into C<$ENV{HOME}> or C<$ENV{LOGDIR}> by |
| 1375 | I<login>, but you can also find it with C<(getpwuid($E<lt>))[7]>. |
| 1376 | (Some platforms do not have a concept of a home directory.) |
| 1377 | |
| 1378 | =item host |
| 1379 | |
| 1380 | The computer on which a program or other data resides. |
| 1381 | |
| 1382 | =item hubris |
| 1383 | |
| 1384 | Excessive pride, the sort of thing Zeus zaps you for. Also the |
| 1385 | quality that makes you write (and maintain) programs that other people |
| 1386 | won't want to say bad things about. Hence, the third great virtue of |
| 1387 | a programmer. See also L</laziness> and L</impatience>. |
| 1388 | |
| 1389 | =item HV |
| 1390 | |
| 1391 | Short for a "hash value" typedef, which holds Perl's internal |
| 1392 | representation of a hash. The L</HV> type is a subclass of L</SV>. |
| 1393 | |
| 1394 | =back |
| 1395 | |
| 1396 | =head2 I |
| 1397 | |
| 1398 | =over 4 |
| 1399 | |
| 1400 | =item identifier |
| 1401 | |
| 1402 | A legally formed name for most anything in which a computer program |
| 1403 | might be interested. Many languages (including Perl) allow |
| 1404 | identifiers that start with a letter and contain letters and digits. |
| 1405 | Perl also counts the underscore character as a valid letter. (Perl |
| 1406 | also has more complicated names, such as L</qualified> names.) |
| 1407 | |
| 1408 | =item impatience |
| 1409 | |
| 1410 | The anger you feel when the computer is being lazy. This makes you |
| 1411 | write programs that don't just react to your needs, but actually |
| 1412 | anticipate them. Or at least that pretend to. Hence, the second |
| 1413 | great virtue of a programmer. See also L</laziness> and L</hubris>. |
| 1414 | |
| 1415 | =item implementation |
| 1416 | |
| 1417 | How a piece of code actually goes about doing its job. Users of the |
| 1418 | code should not count on implementation details staying the same |
| 1419 | unless they are part of the published L</interface>. |
| 1420 | |
| 1421 | =item import |
| 1422 | |
| 1423 | To gain access to symbols that are exported from another module. See |
| 1424 | L<perlfunc/use>. |
| 1425 | |
| 1426 | =item increment |
| 1427 | |
| 1428 | To increase the value of something by 1 (or by some other number, if |
| 1429 | so specified). |
| 1430 | |
| 1431 | =item indexing |
| 1432 | |
| 1433 | In olden days, the act of looking up a L</key> in an actual index |
| 1434 | (such as a phone book), but now merely the act of using any kind of |
| 1435 | key or position to find the corresponding L</value>, even if no index |
| 1436 | is involved. Things have degenerated to the point that Perl's |
| 1437 | L<index|perlfunc/index> function merely locates the position (index) |
| 1438 | of one string in another. |
| 1439 | |
| 1440 | =item indirect filehandle |
| 1441 | |
| 1442 | An L</expression> that evaluates to something that can be used as a |
| 1443 | L</filehandle>: a L</string> (filehandle name), a L</typeglob>, a |
| 1444 | typeglob L</reference>, or a low-level L</IO> object. |
| 1445 | |
| 1446 | =item indirect object |
| 1447 | |
| 1448 | In English grammar, a short noun phrase between a verb and its direct |
| 1449 | object indicating the beneficiary or recipient of the action. In |
| 1450 | Perl, C<print STDOUT "$foo\n";> can be understood as "verb |
| 1451 | indirect-object object" where L</STDOUT> is the recipient of the |
| 1452 | L<print|perlfunc/print> action, and C<"$foo"> is the object being |
| 1453 | printed. Similarly, when invoking a L</method>, you might place the |
| 1454 | invocant between the method and its arguments: |
| 1455 | |
| 1456 | $gollum = new Pathetic::Creature "Smeagol"; |
| 1457 | give $gollum "Fisssssh!"; |
| 1458 | give $gollum "Precious!"; |
| 1459 | |
| 1460 | =item indirect object slot |
| 1461 | |
| 1462 | The syntactic position falling between a method call and its arguments |
| 1463 | when using the indirect object invocation syntax. (The slot is |
| 1464 | distinguished by the absence of a comma between it and the next |
| 1465 | argument.) L</STDERR> is in the indirect object slot here: |
| 1466 | |
| 1467 | print STDERR "Awake! Awake! Fear, Fire, |
| 1468 | Foes! Awake!\n"; |
| 1469 | |
| 1470 | =item indirection |
| 1471 | |
| 1472 | If something in a program isn't the value you're looking for but |
| 1473 | indicates where the value is, that's indirection. This can be done |
| 1474 | with either L<symbolic references|/symbolic reference> or L<hard |
| 1475 | references|/hard reference>. |
| 1476 | |
| 1477 | =item infix |
| 1478 | |
| 1479 | An L</operator> that comes in between its L<operands|/operand>, such |
| 1480 | as multiplication in C<24 * 7>. |
| 1481 | |
| 1482 | =item inheritance |
| 1483 | |
| 1484 | What you get from your ancestors, genetically or otherwise. If you |
| 1485 | happen to be a L</class>, your ancestors are called L<base |
| 1486 | classes|/base class> and your descendants are called L<derived |
| 1487 | classes|/derived class>. See L</single inheritance> and L</multiple |
| 1488 | inheritance>. |
| 1489 | |
| 1490 | =item instance |
| 1491 | |
| 1492 | Short for "an instance of a class", meaning an L</object> of that L</class>. |
| 1493 | |
| 1494 | =item instance variable |
| 1495 | |
| 1496 | An L</attribute> of an L</object>; data stored with the particular |
| 1497 | object rather than with the class as a whole. |
| 1498 | |
| 1499 | =item integer |
| 1500 | |
| 1501 | A number with no fractional (decimal) part. A counting number, like |
| 1502 | 1, 2, 3, and so on, but including 0 and the negatives. |
| 1503 | |
| 1504 | =item interface |
| 1505 | |
| 1506 | The services a piece of code promises to provide forever, in contrast to |
| 1507 | its L</implementation>, which it should feel free to change whenever it |
| 1508 | likes. |
| 1509 | |
| 1510 | =item interpolation |
| 1511 | |
| 1512 | The insertion of a scalar or list value somewhere in the middle of |
| 1513 | another value, such that it appears to have been there all along. In |
| 1514 | Perl, variable interpolation happens in double-quoted strings and |
| 1515 | patterns, and list interpolation occurs when constructing the list of |
| 1516 | values to pass to a list operator or other such construct that takes a |
| 1517 | L</LIST>. |
| 1518 | |
| 1519 | =item interpreter |
| 1520 | |
| 1521 | Strictly speaking, a program that reads a second program and does what |
| 1522 | the second program says directly without turning the program into a |
| 1523 | different form first, which is what L<compilers|/compiler> do. Perl |
| 1524 | is not an interpreter by this definition, because it contains a kind |
| 1525 | of compiler that takes a program and turns it into a more executable |
| 1526 | form (L<syntax trees|/syntax tree>) within the I<perl> process itself, |
| 1527 | which the Perl L</run time> system then interprets. |
| 1528 | |
| 1529 | =item invocant |
| 1530 | |
| 1531 | The agent on whose behalf a L</method> is invoked. In a L</class> |
| 1532 | method, the invocant is a package name. In an L</instance> method, |
| 1533 | the invocant is an object reference. |
| 1534 | |
| 1535 | =item invocation |
| 1536 | |
| 1537 | The act of calling up a deity, daemon, program, method, subroutine, or |
| 1538 | function to get it do what you think it's supposed to do. We usually |
| 1539 | "call" subroutines but "invoke" methods, since it sounds cooler. |
| 1540 | |
| 1541 | =item I/O |
| 1542 | |
| 1543 | Input from, or output to, a L</file> or L</device>. |
| 1544 | |
| 1545 | =item IO |
| 1546 | |
| 1547 | An internal I/O object. Can also mean L</indirect object>. |
| 1548 | |
| 1549 | =item IP |
| 1550 | |
| 1551 | Internet Protocol, or Intellectual Property. |
| 1552 | |
| 1553 | =item IPC |
| 1554 | |
| 1555 | Interprocess Communication. |
| 1556 | |
| 1557 | =item is-a |
| 1558 | |
| 1559 | A relationship between two L<objects|/object> in which one object is |
| 1560 | considered to be a more specific version of the other, generic object: |
| 1561 | "A camel is a mammal." Since the generic object really only exists in |
| 1562 | a Platonic sense, we usually add a little abstraction to the notion of |
| 1563 | objects and think of the relationship as being between a generic |
| 1564 | L</base class> and a specific L</derived class>. Oddly enough, |
| 1565 | Platonic classes don't always have Platonic relationships--see |
| 1566 | L</inheritance>. |
| 1567 | |
| 1568 | =item iteration |
| 1569 | |
| 1570 | Doing something repeatedly. |
| 1571 | |
| 1572 | =item iterator |
| 1573 | |
| 1574 | A special programming gizmo that keeps track of where you are in |
| 1575 | something that you're trying to iterate over. The C<foreach> loop in |
| 1576 | Perl contains an iterator; so does a hash, allowing you to |
| 1577 | L<each|perlfunc/each> through it. |
| 1578 | |
| 1579 | =item IV |
| 1580 | |
| 1581 | The integer four, not to be confused with six, Tom's favorite editor. |
| 1582 | IV also means an internal Integer Value of the type a L</scalar> can |
| 1583 | hold, not to be confused with an L</NV>. |
| 1584 | |
| 1585 | =back |
| 1586 | |
| 1587 | =head2 J |
| 1588 | |
| 1589 | =over 4 |
| 1590 | |
| 1591 | =item JAPH |
| 1592 | |
| 1593 | "Just Another Perl Hacker," a clever but cryptic bit of Perl code that |
| 1594 | when executed, evaluates to that string. Often used to illustrate a |
| 1595 | particular Perl feature, and something of an ungoing Obfuscated Perl |
| 1596 | Contest seen in Usenix signatures. |
| 1597 | |
| 1598 | =back |
| 1599 | |
| 1600 | =head2 K |
| 1601 | |
| 1602 | =over 4 |
| 1603 | |
| 1604 | =item key |
| 1605 | |
| 1606 | The string index to a L</hash>, used to look up the L</value> |
| 1607 | associated with that key. |
| 1608 | |
| 1609 | =item keyword |
| 1610 | |
| 1611 | See L</reserved words>. |
| 1612 | |
| 1613 | =back |
| 1614 | |
| 1615 | =head2 L |
| 1616 | |
| 1617 | =over 4 |
| 1618 | |
| 1619 | =item label |
| 1620 | |
| 1621 | A name you give to a L</statement> so that you can talk about that |
| 1622 | statement elsewhere in the program. |
| 1623 | |
| 1624 | =item laziness |
| 1625 | |
| 1626 | The quality that makes you go to great effort to reduce overall energy |
| 1627 | expenditure. It makes you write labor-saving programs that other |
| 1628 | people will find useful, and document what you wrote so you don't have |
| 1629 | to answer so many questions about it. Hence, the first great virtue |
| 1630 | of a programmer. Also hence, this book. See also L</impatience> and |
| 1631 | L</hubris>. |
| 1632 | |
| 1633 | =item left shift |
| 1634 | |
| 1635 | A L</bit shift> that multiplies the number by some power of 2. |
| 1636 | |
| 1637 | =item leftmost longest |
| 1638 | |
| 1639 | The preference of the L</regular expression> engine to match the |
| 1640 | leftmost occurrence of a L</pattern>, then given a position at which a |
| 1641 | match will occur, the preference for the longest match (presuming the |
| 1642 | use of a L</greedy> quantifier). See L<perlre> for I<much> more on |
| 1643 | this subject. |
| 1644 | |
| 1645 | =item lexeme |
| 1646 | |
| 1647 | Fancy term for a L</token>. |
| 1648 | |
| 1649 | =item lexer |
| 1650 | |
| 1651 | Fancy term for a L</tokener>. |
| 1652 | |
| 1653 | =item lexical analysis |
| 1654 | |
| 1655 | Fancy term for L</tokenizing>. |
| 1656 | |
| 1657 | =item lexical scoping |
| 1658 | |
| 1659 | Looking at your I<Oxford English Dictionary> through a microscope. |
| 1660 | (Also known as L</static scoping>, because dictionaries don't change |
| 1661 | very fast.) Similarly, looking at variables stored in a private |
| 1662 | dictionary (namespace) for each scope, which are visible only from |
| 1663 | their point of declaration down to the end of the lexical scope in |
| 1664 | which they are declared. --Syn. L</static scoping>. |
| 1665 | --Ant. L</dynamic scoping>. |
| 1666 | |
| 1667 | =item lexical variable |
| 1668 | |
| 1669 | A L</variable> subject to L</lexical scoping>, declared by |
| 1670 | L<my|perlfunc/my>. Often just called a "lexical". (The |
| 1671 | L<our|perlfunc/our> declaration declares a lexically scoped name for a |
| 1672 | global variable, which is not itself a lexical variable.) |
| 1673 | |
| 1674 | =item library |
| 1675 | |
| 1676 | Generally, a collection of procedures. In ancient days, referred to a |
| 1677 | collection of subroutines in a I<.pl> file. In modern times, refers |
| 1678 | more often to the entire collection of Perl L<modules|/module> on your |
| 1679 | system. |
| 1680 | |
| 1681 | =item LIFO |
| 1682 | |
| 1683 | Last In, First Out. See also L</FIFO>. A LIFO is usually called a |
| 1684 | L</stack>. |
| 1685 | |
| 1686 | =item line |
| 1687 | |
| 1688 | In Unix, a sequence of zero or more non-newline characters terminated |
| 1689 | with a L</newline> character. On non-Unix machines, this is emulated |
| 1690 | by the C library even if the underlying L</operating system> has |
| 1691 | different ideas. |
| 1692 | |
| 1693 | =item line buffering |
| 1694 | |
| 1695 | Used by a L</standard IE<sol>O> output stream that flushes its |
| 1696 | L</buffer> after every L</newline>. Many standard I/O libraries |
| 1697 | automatically set up line buffering on output that is going to the |
| 1698 | terminal. |
| 1699 | |
| 1700 | =item line number |
| 1701 | |
| 1702 | The number of lines read previous to this one, plus 1. Perl keeps a |
| 1703 | separate line number for each source or input file it opens. The |
| 1704 | current source file's line number is represented by C<__LINE__>. The |
| 1705 | current input line number (for the file that was most recently read |
| 1706 | via C<< E<lt>FHE<gt> >>) is represented by the C<$.> |
| 1707 | (C<$INPUT_LINE_NUMBER>) variable. Many error messages report both |
| 1708 | values, if available. |
| 1709 | |
| 1710 | =item link |
| 1711 | |
| 1712 | Used as a noun, a name in a L</directory>, representing a L</file>. A |
| 1713 | given file can have multiple links to it. It's like having the same |
| 1714 | phone number listed in the phone directory under different names. As |
| 1715 | a verb, to resolve a partially compiled file's unresolved symbols into |
| 1716 | a (nearly) executable image. Linking can generally be static or |
| 1717 | dynamic, which has nothing to do with static or dynamic scoping. |
| 1718 | |
| 1719 | =item LIST |
| 1720 | |
| 1721 | A syntactic construct representing a comma-separated list of |
| 1722 | expressions, evaluated to produce a L</list value>. Each |
| 1723 | L</expression> in a L</LIST> is evaluated in L</list context> and |
| 1724 | interpolated into the list value. |
| 1725 | |
| 1726 | =item list |
| 1727 | |
| 1728 | An ordered set of scalar values. |
| 1729 | |
| 1730 | =item list context |
| 1731 | |
| 1732 | The situation in which an L</expression> is expected by its |
| 1733 | surroundings (the code calling it) to return a list of values rather |
| 1734 | than a single value. Functions that want a L</LIST> of arguments tell |
| 1735 | those arguments that they should produce a list value. See also |
| 1736 | L</context>. |
| 1737 | |
| 1738 | =item list operator |
| 1739 | |
| 1740 | An L</operator> that does something with a list of values, such as |
| 1741 | L<join|perlfunc/join> or L<grep|perlfunc/grep>. Usually used for |
| 1742 | named built-in operators (such as L<print|perlfunc/print>, |
| 1743 | L<unlink|perlfunc/unlink>, and L<system|perlfunc/system>) that do not |
| 1744 | require parentheses around their L</argument> list. |
| 1745 | |
| 1746 | =item list value |
| 1747 | |
| 1748 | An unnamed list of temporary scalar values that may be passed around |
| 1749 | within a program from any list-generating function to any function or |
| 1750 | construct that provides a L</list context>. |
| 1751 | |
| 1752 | =item literal |
| 1753 | |
| 1754 | A token in a programming language such as a number or L</string> that |
| 1755 | gives you an actual L</value> instead of merely representing possible |
| 1756 | values as a L</variable> does. |
| 1757 | |
| 1758 | =item little-endian |
| 1759 | |
| 1760 | From Swift: someone who eats eggs little end first. Also used of |
| 1761 | computers that store the least significant L</byte> of a word at a |
| 1762 | lower byte address than the most significant byte. Often considered |
| 1763 | superior to big-endian machines. See also L</big-endian>. |
| 1764 | |
| 1765 | =item local |
| 1766 | |
| 1767 | Not meaning the same thing everywhere. A global variable in Perl can |
| 1768 | be localized inside a L<dynamic scope|/dynamic scoping> via the |
| 1769 | L<local|perlfunc/local> operator. |
| 1770 | |
| 1771 | =item logical operator |
| 1772 | |
| 1773 | Symbols representing the concepts "and", "or", "xor", and "not". |
| 1774 | |
| 1775 | =item lookahead |
| 1776 | |
| 1777 | An L</assertion> that peeks at the string to the right of the current |
| 1778 | match location. |
| 1779 | |
| 1780 | =item lookbehind |
| 1781 | |
| 1782 | An L</assertion> that peeks at the string to the left of the current |
| 1783 | match location. |
| 1784 | |
| 1785 | =item loop |
| 1786 | |
| 1787 | A construct that performs something repeatedly, like a roller coaster. |
| 1788 | |
| 1789 | =item loop control statement |
| 1790 | |
| 1791 | Any statement within the body of a loop that can make a loop |
| 1792 | prematurely stop looping or skip an L</iteration>. Generally you |
| 1793 | shouldn't try this on roller coasters. |
| 1794 | |
| 1795 | =item loop label |
| 1796 | |
| 1797 | A kind of key or name attached to a loop (or roller coaster) so that |
| 1798 | loop control statements can talk about which loop they want to |
| 1799 | control. |
| 1800 | |
| 1801 | =item lvaluable |
| 1802 | |
| 1803 | Able to serve as an L</lvalue>. |
| 1804 | |
| 1805 | =item lvalue |
| 1806 | |
| 1807 | Term used by language lawyers for a storage location you can assign a |
| 1808 | new L</value> to, such as a L</variable> or an element of an |
| 1809 | L</array>. The "l" is short for "left", as in the left side of an |
| 1810 | assignment, a typical place for lvalues. An L</lvaluable> function or |
| 1811 | expression is one to which a value may be assigned, as in C<pos($x) = |
| 1812 | 10>. |
| 1813 | |
| 1814 | =item lvalue modifier |
| 1815 | |
| 1816 | An adjectival pseudofunction that warps the meaning of an L</lvalue> |
| 1817 | in some declarative fashion. Currently there are three lvalue |
| 1818 | modifiers: L<my|perlfunc/my>, L<our|perlfunc/our>, and |
| 1819 | L<local|perlfunc/local>. |
| 1820 | |
| 1821 | =back |
| 1822 | |
| 1823 | =head2 M |
| 1824 | |
| 1825 | =over 4 |
| 1826 | |
| 1827 | =item magic |
| 1828 | |
| 1829 | Technically speaking, any extra semantics attached to a variable such |
| 1830 | as C<$!>, C<$0>, C<%ENV>, or C<%SIG>, or to any tied variable. |
| 1831 | Magical things happen when you diddle those variables. |
| 1832 | |
| 1833 | =item magical increment |
| 1834 | |
| 1835 | An L</increment> operator that knows how to bump up alphabetics as |
| 1836 | well as numbers. |
| 1837 | |
| 1838 | =item magical variables |
| 1839 | |
| 1840 | Special variables that have side effects when you access them or |
| 1841 | assign to them. For example, in Perl, changing elements of the |
| 1842 | C<%ENV> array also changes the corresponding environment variables |
| 1843 | that subprocesses will use. Reading the C<$!> variable gives you the |
| 1844 | current system error number or message. |
| 1845 | |
| 1846 | =item Makefile |
| 1847 | |
| 1848 | A file that controls the compilation of a program. Perl programs |
| 1849 | don't usually need a L</Makefile> because the Perl compiler has plenty |
| 1850 | of self-control. |
| 1851 | |
| 1852 | =item man |
| 1853 | |
| 1854 | The Unix program that displays online documentation (manual pages) for |
| 1855 | you. |
| 1856 | |
| 1857 | =item manpage |
| 1858 | |
| 1859 | A "page" from the manuals, typically accessed via the I<man>(1) |
| 1860 | command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of |
| 1861 | BUGS, and so on, and is typically longer than a page. There are |
| 1862 | manpages documenting L<commands|/command>, L<syscalls|/syscall>, |
| 1863 | L</library> L<functions|/function>, L<devices|/device>, |
| 1864 | L<protocols|/protocol>, L<files|/file>, and such. In this book, we |
| 1865 | call any piece of standard Perl documentation (like I<perlop> or |
| 1866 | I<perldelta>) a manpage, no matter what format it's installed in on |
| 1867 | your system. |
| 1868 | |
| 1869 | =item matching |
| 1870 | |
| 1871 | See L</pattern matching>. |
| 1872 | |
| 1873 | =item member data |
| 1874 | |
| 1875 | See L</instance variable>. |
| 1876 | |
| 1877 | =item memory |
| 1878 | |
| 1879 | This always means your main memory, not your disk. Clouding the issue |
| 1880 | is the fact that your machine may implement L</virtual> memory; that |
| 1881 | is, it will pretend that it has more memory than it really does, and |
| 1882 | it'll use disk space to hold inactive bits. This can make it seem |
| 1883 | like you have a little more memory than you really do, but it's not a |
| 1884 | substitute for real memory. The best thing that can be said about |
| 1885 | virtual memory is that it lets your performance degrade gradually |
| 1886 | rather than suddenly when you run out of real memory. But your |
| 1887 | program can die when you run out of virtual memory too, if you haven't |
| 1888 | thrashed your disk to death first. |
| 1889 | |
| 1890 | =item metacharacter |
| 1891 | |
| 1892 | A L</character> that is I<not> supposed to be treated normally. Which |
| 1893 | characters are to be treated specially as metacharacters varies |
| 1894 | greatly from context to context. Your L</shell> will have certain |
| 1895 | metacharacters, double-quoted Perl L<strings|/string> have other |
| 1896 | metacharacters, and L</regular expression> patterns have all the |
| 1897 | double-quote metacharacters plus some extra ones of their own. |
| 1898 | |
| 1899 | =item metasymbol |
| 1900 | |
| 1901 | Something we'd call a L</metacharacter> except that it's a sequence of |
| 1902 | more than one character. Generally, the first character in the |
| 1903 | sequence must be a true metacharacter to get the other characters in |
| 1904 | the metasymbol to misbehave along with it. |
| 1905 | |
| 1906 | =item method |
| 1907 | |
| 1908 | A kind of action that an L</object> can take if you tell it to. See |
| 1909 | L<perlobj>. |
| 1910 | |
| 1911 | =item minimalism |
| 1912 | |
| 1913 | The belief that "small is beautiful." Paradoxically, if you say |
| 1914 | something in a small language, it turns out big, and if you say it in |
| 1915 | a big language, it turns out small. Go figure. |
| 1916 | |
| 1917 | =item mode |
| 1918 | |
| 1919 | In the context of the L<stat> syscall, refers to the field holding |
| 1920 | the L</permission bits> and the type of the L</file>. |
| 1921 | |
| 1922 | =item modifier |
| 1923 | |
| 1924 | See L</statement modifier>, L</regular expression modifier>, and |
| 1925 | L</lvalue modifier>, not necessarily in that order. |
| 1926 | |
| 1927 | =item module |
| 1928 | |
| 1929 | A L</file> that defines a L</package> of (almost) the same name, which |
| 1930 | can either L</export> symbols or function as an L</object> class. (A |
| 1931 | module's main I<.pm> file may also load in other files in support of |
| 1932 | the module.) See the L<use|perlfunc/use> built-in. |
| 1933 | |
| 1934 | =item modulus |
| 1935 | |
| 1936 | An integer divisor when you're interested in the remainder instead of |
| 1937 | the quotient. |
| 1938 | |
| 1939 | =item monger |
| 1940 | |
| 1941 | Short for Perl Monger, a purveyor of Perl. |
| 1942 | |
| 1943 | =item mortal |
| 1944 | |
| 1945 | A temporary value scheduled to die when the current statement |
| 1946 | finishes. |
| 1947 | |
| 1948 | =item multidimensional array |
| 1949 | |
| 1950 | An array with multiple subscripts for finding a single element. Perl |
| 1951 | implements these using L<references|/reference>--see L<perllol> and |
| 1952 | L<perldsc>. |
| 1953 | |
| 1954 | =item multiple inheritance |
| 1955 | |
| 1956 | The features you got from your mother and father, mixed together |
| 1957 | unpredictably. (See also L</inheritance>, and L</single |
| 1958 | inheritance>.) In computer languages (including Perl), the notion |
| 1959 | that a given class may have multiple direct ancestors or L<base |
| 1960 | classes|/base class>. |
| 1961 | |
| 1962 | =back |
| 1963 | |
| 1964 | =head2 N |
| 1965 | |
| 1966 | =over 4 |
| 1967 | |
| 1968 | =item named pipe |
| 1969 | |
| 1970 | A L</pipe> with a name embedded in the L</filesystem> so that it can |
| 1971 | be accessed by two unrelated L<processes|/process>. |
| 1972 | |
| 1973 | =item namespace |
| 1974 | |
| 1975 | A domain of names. You needn't worry about whether the names in one |
| 1976 | such domain have been used in another. See L</package>. |
| 1977 | |
| 1978 | =item network address |
| 1979 | |
| 1980 | The most important attribute of a socket, like your telephone's |
| 1981 | telephone number. Typically an IP address. See also L</port>. |
| 1982 | |
| 1983 | =item newline |
| 1984 | |
| 1985 | A single character that represents the end of a line, with the ASCII |
| 1986 | value of 012 octal under Unix (but 015 on a Mac), and represented by |
| 1987 | C<\n> in Perl strings. For Windows machines writing text files, and |
| 1988 | for certain physical devices like terminals, the single newline gets |
| 1989 | automatically translated by your C library into a line feed and a |
| 1990 | carriage return, but normally, no translation is done. |
| 1991 | |
| 1992 | =item NFS |
| 1993 | |
| 1994 | Network File System, which allows you to mount a remote filesystem as |
| 1995 | if it were local. |
| 1996 | |
| 1997 | =item null character |
| 1998 | |
| 1999 | A character with the ASCII value of zero. It's used by C to terminate |
| 2000 | strings, but Perl allows strings to contain a null. |
| 2001 | |
| 2002 | =item null list |
| 2003 | |
| 2004 | A L</list value> with zero elements, represented in Perl by C<()>. |
| 2005 | |
| 2006 | =item null string |
| 2007 | |
| 2008 | A L</string> containing no characters, not to be confused with a |
| 2009 | string containing a L</null character>, which has a positive length |
| 2010 | and is L</true>. |
| 2011 | |
| 2012 | =item numeric context |
| 2013 | |
| 2014 | The situation in which an expression is expected by its surroundings |
| 2015 | (the code calling it) to return a number. See also L</context> and |
| 2016 | L</string context>. |
| 2017 | |
| 2018 | =item NV |
| 2019 | |
| 2020 | Short for Nevada, no part of which will ever be confused with |
| 2021 | civilization. NV also means an internal floating-point Numeric Value |
| 2022 | of the type a L</scalar> can hold, not to be confused with an L</IV>. |
| 2023 | |
| 2024 | =item nybble |
| 2025 | |
| 2026 | Half a L</byte>, equivalent to one L</hexadecimal> digit, and worth |
| 2027 | four L<bits|/bit>. |
| 2028 | |
| 2029 | =back |
| 2030 | |
| 2031 | =head2 O |
| 2032 | |
| 2033 | =over 4 |
| 2034 | |
| 2035 | =item object |
| 2036 | |
| 2037 | An L</instance> of a L</class>. Something that "knows" what |
| 2038 | user-defined type (class) it is, and what it can do because of what |
| 2039 | class it is. Your program can request an object to do things, but the |
| 2040 | object gets to decide whether it wants to do them or not. Some |
| 2041 | objects are more accommodating than others. |
| 2042 | |
| 2043 | =item octal |
| 2044 | |
| 2045 | A number in base 8. Only the digits 0 through 7 are allowed. Octal |
| 2046 | constants in Perl start with 0, as in 013. See also the |
| 2047 | L<oct|perlfunc/oct> function. |
| 2048 | |
| 2049 | =item offset |
| 2050 | |
| 2051 | How many things you have to skip over when moving from the beginning |
| 2052 | of a string or array to a specific position within it. Thus, the |
| 2053 | minimum offset is zero, not one, because you don't skip anything to |
| 2054 | get to the first item. |
| 2055 | |
| 2056 | =item one-liner |
| 2057 | |
| 2058 | An entire computer program crammed into one line of text. |
| 2059 | |
| 2060 | =item open source software |
| 2061 | |
| 2062 | Programs for which the source code is freely available and freely |
| 2063 | redistributable, with no commercial strings attached. For a more |
| 2064 | detailed definition, see L<http://www.opensource.org/osd.html>. |
| 2065 | |
| 2066 | =item operand |
| 2067 | |
| 2068 | An L</expression> that yields a L</value> that an L</operator> |
| 2069 | operates on. See also L</precedence>. |
| 2070 | |
| 2071 | =item operating system |
| 2072 | |
| 2073 | A special program that runs on the bare machine and hides the gory |
| 2074 | details of managing L<processes|/process> and L<devices|/device>. |
| 2075 | Usually used in a looser sense to indicate a particular culture of |
| 2076 | programming. The loose sense can be used at varying levels of |
| 2077 | specificity. At one extreme, you might say that all versions of Unix |
| 2078 | and Unix-lookalikes are the same operating system (upsetting many |
| 2079 | people, especially lawyers and other advocates). At the other |
| 2080 | extreme, you could say this particular version of this particular |
| 2081 | vendor's operating system is different from any other version of this |
| 2082 | or any other vendor's operating system. Perl is much more portable |
| 2083 | across operating systems than many other languages. See also |
| 2084 | L</architecture> and L</platform>. |
| 2085 | |
| 2086 | =item operator |
| 2087 | |
| 2088 | A gizmo that transforms some number of input values to some number of |
| 2089 | output values, often built into a language with a special syntax or |
| 2090 | symbol. A given operator may have specific expectations about what |
| 2091 | L<types|/type> of data you give as its arguments |
| 2092 | (L<operands|/operand>) and what type of data you want back from it. |
| 2093 | |
| 2094 | =item operator overloading |
| 2095 | |
| 2096 | A kind of L</overloading> that you can do on built-in |
| 2097 | L<operators|/operator> to make them work on L<objects|/object> as if |
| 2098 | the objects were ordinary scalar values, but with the actual semantics |
| 2099 | supplied by the object class. This is set up with the L<overload> |
| 2100 | L</pragma>. |
| 2101 | |
| 2102 | =item options |
| 2103 | |
| 2104 | See either L<switches|/switch> or L</regular expression modifier>. |
| 2105 | |
| 2106 | =item overloading |
| 2107 | |
| 2108 | Giving additional meanings to a symbol or construct. Actually, all |
| 2109 | languages do overloading to one extent or another, since people are |
| 2110 | good at figuring out things from L</context>. |
| 2111 | |
| 2112 | =item overriding |
| 2113 | |
| 2114 | Hiding or invalidating some other definition of the same name. (Not |
| 2115 | to be confused with L</overloading>, which adds definitions that must |
| 2116 | be disambiguated some other way.) To confuse the issue further, we use |
| 2117 | the word with two overloaded definitions: to describe how you can |
| 2118 | define your own L</subroutine> to hide a built-in L</function> of the |
| 2119 | same name (see L<perlsub/Overriding Built-in Functions>) and to |
| 2120 | describe how you can define a replacement L</method> in a L</derived |
| 2121 | class> to hide a L</base class>'s method of the same name (see |
| 2122 | L<perlobj>). |
| 2123 | |
| 2124 | =item owner |
| 2125 | |
| 2126 | The one user (apart from the superuser) who has absolute control over |
| 2127 | a L</file>. A file may also have a L</group> of users who may |
| 2128 | exercise joint ownership if the real owner permits it. See |
| 2129 | L</permission bits>. |
| 2130 | |
| 2131 | =back |
| 2132 | |
| 2133 | =head2 P |
| 2134 | |
| 2135 | =over 4 |
| 2136 | |
| 2137 | =item package |
| 2138 | |
| 2139 | A L</namespace> for global L<variables|/variable>, |
| 2140 | L<subroutines|/subroutine>, and the like, such that they can be kept |
| 2141 | separate from like-named L<symbols|/symbol> in other namespaces. In a |
| 2142 | sense, only the package is global, since the symbols in the package's |
| 2143 | symbol table are only accessible from code compiled outside the |
| 2144 | package by naming the package. But in another sense, all package |
| 2145 | symbols are also globals--they're just well-organized globals. |
| 2146 | |
| 2147 | =item pad |
| 2148 | |
| 2149 | Short for L</scratchpad>. |
| 2150 | |
| 2151 | =item parameter |
| 2152 | |
| 2153 | See L</argument>. |
| 2154 | |
| 2155 | =item parent class |
| 2156 | |
| 2157 | See L</base class>. |
| 2158 | |
| 2159 | =item parse tree |
| 2160 | |
| 2161 | See L</syntax tree>. |
| 2162 | |
| 2163 | =item parsing |
| 2164 | |
| 2165 | The subtle but sometimes brutal art of attempting to turn your |
| 2166 | possibly malformed program into a valid L</syntax tree>. |
| 2167 | |
| 2168 | =item patch |
| 2169 | |
| 2170 | To fix by applying one, as it were. In the realm of hackerdom, a |
| 2171 | listing of the differences between two versions of a program as might |
| 2172 | be applied by the I<patch>(1) program when you want to fix a bug or |
| 2173 | upgrade your old version. |
| 2174 | |
| 2175 | =item PATH |
| 2176 | |
| 2177 | The list of L<directories|/directory> the system searches to find a |
| 2178 | program you want to L</execute>. The list is stored as one of your |
| 2179 | L<environment variables|/environment variable>, accessible in Perl as |
| 2180 | C<$ENV{PATH}>. |
| 2181 | |
| 2182 | =item pathname |
| 2183 | |
| 2184 | A fully qualified filename such as I</usr/bin/perl>. Sometimes |
| 2185 | confused with L</PATH>. |
| 2186 | |
| 2187 | =item pattern |
| 2188 | |
| 2189 | A template used in L</pattern matching>. |
| 2190 | |
| 2191 | =item pattern matching |
| 2192 | |
| 2193 | Taking a pattern, usually a L</regular expression>, and trying the |
| 2194 | pattern various ways on a string to see whether there's any way to |
| 2195 | make it fit. Often used to pick interesting tidbits out of a file. |
| 2196 | |
| 2197 | =item permission bits |
| 2198 | |
| 2199 | Bits that the L</owner> of a file sets or unsets to allow or disallow |
| 2200 | access to other people. These flag bits are part of the L</mode> word |
| 2201 | returned by the L<stat|perlfunc/stat> built-in when you ask about a |
| 2202 | file. On Unix systems, you can check the I<ls>(1) manpage for more |
| 2203 | information. |
| 2204 | |
| 2205 | =item Pern |
| 2206 | |
| 2207 | What you get when you do C<Perl++> twice. Doing it only once will |
| 2208 | curl your hair. You have to increment it eight times to shampoo your |
| 2209 | hair. Lather, rinse, iterate. |
| 2210 | |
| 2211 | =item pipe |
| 2212 | |
| 2213 | A direct L</connection> that carries the output of one L</process> to |
| 2214 | the input of another without an intermediate temporary file. Once the |
| 2215 | pipe is set up, the two processes in question can read and write as if |
| 2216 | they were talking to a normal file, with some caveats. |
| 2217 | |
| 2218 | =item pipeline |
| 2219 | |
| 2220 | A series of L<processes|/process> all in a row, linked by |
| 2221 | L<pipes|/pipe>, where each passes its output stream to the next. |
| 2222 | |
| 2223 | =item platform |
| 2224 | |
| 2225 | The entire hardware and software context in which a program runs. A |
| 2226 | program written in a platform-dependent language might break if you |
| 2227 | change any of: machine, operating system, libraries, compiler, or |
| 2228 | system configuration. The I<perl> interpreter has to be compiled |
| 2229 | differently for each platform because it is implemented in C, but |
| 2230 | programs written in the Perl language are largely |
| 2231 | platform-independent. |
| 2232 | |
| 2233 | =item pod |
| 2234 | |
| 2235 | The markup used to embed documentation into your Perl code. See |
| 2236 | L<perlpod>. |
| 2237 | |
| 2238 | =item pointer |
| 2239 | |
| 2240 | A L</variable> in a language like C that contains the exact memory |
| 2241 | location of some other item. Perl handles pointers internally so you |
| 2242 | don't have to worry about them. Instead, you just use symbolic |
| 2243 | pointers in the form of L<keys|/key> and L</variable> names, or L<hard |
| 2244 | references|/hard reference>, which aren't pointers (but act like |
| 2245 | pointers and do in fact contain pointers). |
| 2246 | |
| 2247 | =item polymorphism |
| 2248 | |
| 2249 | The notion that you can tell an L</object> to do something generic, |
| 2250 | and the object will interpret the command in different ways depending |
| 2251 | on its type. [E<lt>Gk many shapes] |
| 2252 | |
| 2253 | =item port |
| 2254 | |
| 2255 | The part of the address of a TCP or UDP socket that directs packets to |
| 2256 | the correct process after finding the right machine, something like |
| 2257 | the phone extension you give when you reach the company operator. |
| 2258 | Also, the result of converting code to run on a different platform |
| 2259 | than originally intended, or the verb denoting this conversion. |
| 2260 | |
| 2261 | =item portable |
| 2262 | |
| 2263 | Once upon a time, C code compilable under both BSD and SysV. In |
| 2264 | general, code that can be easily converted to run on another |
| 2265 | L</platform>, where "easily" can be defined however you like, and |
| 2266 | usually is. Anything may be considered portable if you try hard |
| 2267 | enough. See I<mobile home> or I<London Bridge>. |
| 2268 | |
| 2269 | =item porter |
| 2270 | |
| 2271 | Someone who "carries" software from one L</platform> to another. |
| 2272 | Porting programs written in platform-dependent languages such as C can |
| 2273 | be difficult work, but porting programs like Perl is very much worth |
| 2274 | the agony. |
| 2275 | |
| 2276 | =item POSIX |
| 2277 | |
| 2278 | The Portable Operating System Interface specification. |
| 2279 | |
| 2280 | =item postfix |
| 2281 | |
| 2282 | An L</operator> that follows its L</operand>, as in C<$x++>. |
| 2283 | |
| 2284 | =item pp |
| 2285 | |
| 2286 | An internal shorthand for a "push-pop" code, that is, C code |
| 2287 | implementing Perl's stack machine. |
| 2288 | |
| 2289 | =item pragma |
| 2290 | |
| 2291 | A standard module whose practical hints and suggestions are received |
| 2292 | (and possibly ignored) at compile time. Pragmas are named in all |
| 2293 | lowercase. |
| 2294 | |
| 2295 | =item precedence |
| 2296 | |
| 2297 | The rules of conduct that, in the absence of other guidance, determine |
| 2298 | what should happen first. For example, in the absence of parentheses, |
| 2299 | you always do multiplication before addition. |
| 2300 | |
| 2301 | =item prefix |
| 2302 | |
| 2303 | An L</operator> that precedes its L</operand>, as in C<++$x>. |
| 2304 | |
| 2305 | =item preprocessing |
| 2306 | |
| 2307 | What some helper L</process> did to transform the incoming data into a |
| 2308 | form more suitable for the current process. Often done with an |
| 2309 | incoming L</pipe>. See also L</C preprocessor>. |
| 2310 | |
| 2311 | =item procedure |
| 2312 | |
| 2313 | A L</subroutine>. |
| 2314 | |
| 2315 | =item process |
| 2316 | |
| 2317 | An instance of a running program. Under multitasking systems like |
| 2318 | Unix, two or more separate processes could be running the same program |
| 2319 | independently at the same time--in fact, the L<fork|perlfunc/fork> |
| 2320 | function is designed to bring about this happy state of affairs. |
| 2321 | Under other operating systems, processes are sometimes called |
| 2322 | "threads", "tasks", or "jobs", often with slight nuances in meaning. |
| 2323 | |
| 2324 | =item program generator |
| 2325 | |
| 2326 | A system that algorithmically writes code for you in a high-level |
| 2327 | language. See also L</code generator>. |
| 2328 | |
| 2329 | =item progressive matching |
| 2330 | |
| 2331 | L<Pattern matching|/pattern matching> that picks up where it left off before. |
| 2332 | |
| 2333 | =item property |
| 2334 | |
| 2335 | See either L</instance variable> or L</character property>. |
| 2336 | |
| 2337 | =item protocol |
| 2338 | |
| 2339 | In networking, an agreed-upon way of sending messages back and forth |
| 2340 | so that neither correspondent will get too confused. |
| 2341 | |
| 2342 | =item prototype |
| 2343 | |
| 2344 | An optional part of a L</subroutine> declaration telling the Perl |
| 2345 | compiler how many and what flavor of arguments may be passed as |
| 2346 | L</actual arguments>, so that you can write subroutine calls that |
| 2347 | parse much like built-in functions. (Or don't parse, as the case may |
| 2348 | be.) |
| 2349 | |
| 2350 | =item pseudofunction |
| 2351 | |
| 2352 | A construct that sometimes looks like a function but really isn't. |
| 2353 | Usually reserved for L</lvalue> modifiers like L<my|perlfunc/my>, for |
| 2354 | L</context> modifiers like L<scalar|perlfunc/scalar>, and for the |
| 2355 | pick-your-own-quotes constructs, C<q//>, C<qq//>, C<qx//>, C<qw//>, |
| 2356 | C<qr//>, C<m//>, C<s///>, C<y///>, and C<tr///>. |
| 2357 | |
| 2358 | =item pseudohash |
| 2359 | |
| 2360 | A reference to an array whose initial element happens to hold a |
| 2361 | reference to a hash. You can treat a pseudohash reference as either |
| 2362 | an array reference or a hash reference. |
| 2363 | |
| 2364 | =item pseudoliteral |
| 2365 | |
| 2366 | An L</operator> that looks something like a L</literal>, such as the |
| 2367 | output-grabbing operator, C<`>I<C<command>>C<`>. |
| 2368 | |
| 2369 | =item public domain |
| 2370 | |
| 2371 | Something not owned by anybody. Perl is copyrighted and is thus |
| 2372 | I<not> in the public domain--it's just L</freely available> and |
| 2373 | L</freely redistributable>. |
| 2374 | |
| 2375 | =item pumpkin |
| 2376 | |
| 2377 | A notional "baton" handed around the Perl community indicating who is |
| 2378 | the lead integrator in some arena of development. |
| 2379 | |
| 2380 | =item pumpking |
| 2381 | |
| 2382 | A L</pumpkin> holder, the person in charge of pumping the pump, or at |
| 2383 | least priming it. Must be willing to play the part of the Great |
| 2384 | Pumpkin now and then. |
| 2385 | |
| 2386 | =item PV |
| 2387 | |
| 2388 | A "pointer value", which is Perl Internals Talk for a C<char*>. |
| 2389 | |
| 2390 | =back |
| 2391 | |
| 2392 | =head2 Q |
| 2393 | |
| 2394 | =over 4 |
| 2395 | |
| 2396 | =item qualified |
| 2397 | |
| 2398 | Possessing a complete name. The symbol C<$Ent::moot> is qualified; |
| 2399 | C<$moot> is unqualified. A fully qualified filename is specified from |
| 2400 | the top-level directory. |
| 2401 | |
| 2402 | =item quantifier |
| 2403 | |
| 2404 | A component of a L</regular expression> specifying how many times the |
| 2405 | foregoing L</atom> may occur. |
| 2406 | |
| 2407 | =back |
| 2408 | |
| 2409 | =head2 R |
| 2410 | |
| 2411 | =over 4 |
| 2412 | |
| 2413 | =item readable |
| 2414 | |
| 2415 | With respect to files, one that has the proper permission bit set to |
| 2416 | let you access the file. With respect to computer programs, one |
| 2417 | that's written well enough that someone has a chance of figuring out |
| 2418 | what it's trying to do. |
| 2419 | |
| 2420 | =item reaping |
| 2421 | |
| 2422 | The last rites performed by a parent L</process> on behalf of a |
| 2423 | deceased child process so that it doesn't remain a L</zombie>. See |
| 2424 | the L<wait|perlfunc/wait> and L<waitpid|perlfunc/waitpid> function |
| 2425 | calls. |
| 2426 | |
| 2427 | =item record |
| 2428 | |
| 2429 | A set of related data values in a L</file> or L</stream>, often |
| 2430 | associated with a unique L</key> field. In Unix, often commensurate |
| 2431 | with a L</line>, or a blank-line-terminated set of lines (a |
| 2432 | "paragraph"). Each line of the I</etc/passwd> file is a record, keyed |
| 2433 | on login name, containing information about that user. |
| 2434 | |
| 2435 | =item recursion |
| 2436 | |
| 2437 | The art of defining something (at least partly) in terms of itself, |
| 2438 | which is a naughty no-no in dictionaries but often works out okay in |
| 2439 | computer programs if you're careful not to recurse forever, which is |
| 2440 | like an infinite loop with more spectacular failure modes. |
| 2441 | |
| 2442 | =item reference |
| 2443 | |
| 2444 | Where you look to find a pointer to information somewhere else. (See |
| 2445 | L</indirection>.) References come in two flavors, L<symbolic |
| 2446 | references|/symbolic reference> and L<hard references|/hard |
| 2447 | reference>. |
| 2448 | |
| 2449 | =item referent |
| 2450 | |
| 2451 | Whatever a reference refers to, which may or may not have a name. |
| 2452 | Common types of referents include scalars, arrays, hashes, and |
| 2453 | subroutines. |
| 2454 | |
| 2455 | =item regex |
| 2456 | |
| 2457 | See L</regular expression>. |
| 2458 | |
| 2459 | =item regular expression |
| 2460 | |
| 2461 | A single entity with various interpretations, like an elephant. To a |
| 2462 | computer scientist, it's a grammar for a little language in which some |
| 2463 | strings are legal and others aren't. To normal people, it's a pattern |
| 2464 | you can use to find what you're looking for when it varies from case |
| 2465 | to case. Perl's regular expressions are far from regular in the |
| 2466 | theoretical sense, but in regular use they work quite well. Here's a |
| 2467 | regular expression: C</Oh s.*t./>. This will match strings like "C<Oh |
| 2468 | say can you see by the dawn's early light>" and "C<Oh sit!>". See |
| 2469 | L<perlre>. |
| 2470 | |
| 2471 | =item regular expression modifier |
| 2472 | |
| 2473 | An option on a pattern or substitution, such as C</i> to render the |
| 2474 | pattern case insensitive. See also L</cloister>. |
| 2475 | |
| 2476 | =item regular file |
| 2477 | |
| 2478 | A L</file> that's not a L</directory>, a L</device>, a named L</pipe> |
| 2479 | or L</socket>, or a L</symbolic link>. Perl uses the C<-f> file test |
| 2480 | operator to identify regular files. Sometimes called a "plain" file. |
| 2481 | |
| 2482 | =item relational operator |
| 2483 | |
| 2484 | An L</operator> that says whether a particular ordering relationship |
| 2485 | is L</true> about a pair of L<operands|/operand>. Perl has both |
| 2486 | numeric and string relational operators. See L</collating sequence>. |
| 2487 | |
| 2488 | =item reserved words |
| 2489 | |
| 2490 | A word with a specific, built-in meaning to a L</compiler>, such as |
| 2491 | C<if> or L<delete|perlfunc/delete>. In many languages (not Perl), |
| 2492 | it's illegal to use reserved words to name anything else. (Which is |
| 2493 | why they're reserved, after all.) In Perl, you just can't use them to |
| 2494 | name L<labels|/label> or L<filehandles|/filehandle>. Also called |
| 2495 | "keywords". |
| 2496 | |
| 2497 | =item return value |
| 2498 | |
| 2499 | The L</value> produced by a L</subroutine> or L</expression> when |
| 2500 | evaluated. In Perl, a return value may be either a L</list> or a |
| 2501 | L</scalar>. |
| 2502 | |
| 2503 | =item RFC |
| 2504 | |
| 2505 | Request For Comment, which despite the timid connotations is the name |
| 2506 | of a series of important standards documents. |
| 2507 | |
| 2508 | =item right shift |
| 2509 | |
| 2510 | A L</bit shift> that divides a number by some power of 2. |
| 2511 | |
| 2512 | =item root |
| 2513 | |
| 2514 | The superuser (UID == 0). Also, the top-level directory of the |
| 2515 | filesystem. |
| 2516 | |
| 2517 | =item RTFM |
| 2518 | |
| 2519 | What you are told when someone thinks you should Read The Fine Manual. |
| 2520 | |
| 2521 | =item run phase |
| 2522 | |
| 2523 | Any time after Perl starts running your main program. See also |
| 2524 | L</compile phase>. Run phase is mostly spent in L</run time> but may |
| 2525 | also be spent in L</compile time> when L<require|perlfunc/require>, |
| 2526 | L<do|perlfunc/do> C<FILE>, or L<eval|perlfunc/eval> C<STRING> |
| 2527 | operators are executed or when a substitution uses the C</ee> |
| 2528 | modifier. |
| 2529 | |
| 2530 | =item run time |
| 2531 | |
| 2532 | The time when Perl is actually doing what your code says to do, as |
| 2533 | opposed to the earlier period of time when it was trying to figure out |
| 2534 | whether what you said made any sense whatsoever, which is L</compile |
| 2535 | time>. |
| 2536 | |
| 2537 | =item run-time pattern |
| 2538 | |
| 2539 | A pattern that contains one or more variables to be interpolated |
| 2540 | before parsing the pattern as a L</regular expression>, and that |
| 2541 | therefore cannot be analyzed at compile time, but must be re-analyzed |
| 2542 | each time the pattern match operator is evaluated. Run-time patterns |
| 2543 | are useful but expensive. |
| 2544 | |
| 2545 | =item RV |
| 2546 | |
| 2547 | A recreational vehicle, not to be confused with vehicular recreation. |
| 2548 | RV also means an internal Reference Value of the type a L</scalar> can |
| 2549 | hold. See also L</IV> and L</NV> if you're not confused yet. |
| 2550 | |
| 2551 | =item rvalue |
| 2552 | |
| 2553 | A L</value> that you might find on the right side of an |
| 2554 | L</assignment>. See also L</lvalue>. |
| 2555 | |
| 2556 | =back |
| 2557 | |
| 2558 | =head2 S |
| 2559 | |
| 2560 | =over 4 |
| 2561 | |
| 2562 | =item scalar |
| 2563 | |
| 2564 | A simple, singular value; a number, L</string>, or L</reference>. |
| 2565 | |
| 2566 | =item scalar context |
| 2567 | |
| 2568 | The situation in which an L</expression> is expected by its |
| 2569 | surroundings (the code calling it) to return a single L</value> rather |
| 2570 | than a L</list> of values. See also L</context> and L</list context>. |
| 2571 | A scalar context sometimes imposes additional constraints on the |
| 2572 | return value--see L</string context> and L</numeric context>. |
| 2573 | Sometimes we talk about a L</Boolean context> inside conditionals, but |
| 2574 | this imposes no additional constraints, since any scalar value, |
| 2575 | whether numeric or L</string>, is already true or false. |
| 2576 | |
| 2577 | =item scalar literal |
| 2578 | |
| 2579 | A number or quoted L</string>--an actual L</value> in the text of your |
| 2580 | program, as opposed to a L</variable>. |
| 2581 | |
| 2582 | =item scalar value |
| 2583 | |
| 2584 | A value that happens to be a L</scalar> as opposed to a L</list>. |
| 2585 | |
| 2586 | =item scalar variable |
| 2587 | |
| 2588 | A L</variable> prefixed with C<$> that holds a single value. |
| 2589 | |
| 2590 | =item scope |
| 2591 | |
| 2592 | How far away you can see a variable from, looking through one. Perl |
| 2593 | has two visibility mechanisms: it does L</dynamic scoping> of |
| 2594 | L<local|perlfunc/local> L<variables|/variable>, meaning that the rest |
| 2595 | of the L</block>, and any L<subroutines|/subroutine> that are called |
| 2596 | by the rest of the block, can see the variables that are local to the |
| 2597 | block. Perl does L</lexical scoping> of L<my|perlfunc/my> variables, |
| 2598 | meaning that the rest of the block can see the variable, but other |
| 2599 | subroutines called by the block I<cannot> see the variable. |
| 2600 | |
| 2601 | =item scratchpad |
| 2602 | |
| 2603 | The area in which a particular invocation of a particular file or |
| 2604 | subroutine keeps some of its temporary values, including any lexically |
| 2605 | scoped variables. |
| 2606 | |
| 2607 | =item script |
| 2608 | |
| 2609 | A text L</file> that is a program intended to be L<executed|/execute> |
| 2610 | directly rather than L<compiled|/compiler> to another form of file |
| 2611 | before execution. Also, in the context of L</Unicode>, a writing |
| 2612 | system for a particular language or group of languages, such as Greek, |
| 2613 | Bengali, or Klingon. |
| 2614 | |
| 2615 | =item script kiddie |
| 2616 | |
| 2617 | A L</cracker> who is not a L</hacker>, but knows just enough to run |
| 2618 | canned scripts. A cargo-cult programmer. |
| 2619 | |
| 2620 | =item sed |
| 2621 | |
| 2622 | A venerable Stream EDitor from which Perl derives some of its ideas. |
| 2623 | |
| 2624 | =item semaphore |
| 2625 | |
| 2626 | A fancy kind of interlock that prevents multiple L<threads|/thread> or |
| 2627 | L<processes|/process> from using up the same resources simultaneously. |
| 2628 | |
| 2629 | =item separator |
| 2630 | |
| 2631 | A L</character> or L</string> that keeps two surrounding strings from |
| 2632 | being confused with each other. The L<split|perlfunc/split> function |
| 2633 | works on separators. Not to be confused with L<delimiters|/delimiter> |
| 2634 | or L<terminators|/terminator>. The "or" in the previous sentence |
| 2635 | separated the two alternatives. |
| 2636 | |
| 2637 | =item serialization |
| 2638 | |
| 2639 | Putting a fancy L</data structure> into linear order so that it can be |
| 2640 | stored as a L</string> in a disk file or database or sent through a |
| 2641 | L</pipe>. Also called marshalling. |
| 2642 | |
| 2643 | =item server |
| 2644 | |
| 2645 | In networking, a L</process> that either advertises a L</service> or |
| 2646 | just hangs around at a known location and waits for L<clients|/client> |
| 2647 | who need service to get in touch with it. |
| 2648 | |
| 2649 | =item service |
| 2650 | |
| 2651 | Something you do for someone else to make them happy, like giving them |
| 2652 | the time of day (or of their life). On some machines, well-known |
| 2653 | services are listed by the L<getservent|perlfunc/getservent> function. |
| 2654 | |
| 2655 | =item setgid |
| 2656 | |
| 2657 | Same as L</setuid>, only having to do with giving away L</group> |
| 2658 | privileges. |
| 2659 | |
| 2660 | =item setuid |
| 2661 | |
| 2662 | Said of a program that runs with the privileges of its L</owner> |
| 2663 | rather than (as is usually the case) the privileges of whoever is |
| 2664 | running it. Also describes the bit in the mode word (L</permission |
| 2665 | bits>) that controls the feature. This bit must be explicitly set by |
| 2666 | the owner to enable this feature, and the program must be carefully |
| 2667 | written not to give away more privileges than it ought to. |
| 2668 | |
| 2669 | =item shared memory |
| 2670 | |
| 2671 | A piece of L</memory> accessible by two different |
| 2672 | L<processes|/process> who otherwise would not see each other's memory. |
| 2673 | |
| 2674 | =item shebang |
| 2675 | |
| 2676 | Irish for the whole McGillicuddy. In Perl culture, a portmanteau of |
| 2677 | "sharp" and "bang", meaning the C<#!> sequence that tells the system |
| 2678 | where to find the interpreter. |
| 2679 | |
| 2680 | =item shell |
| 2681 | |
| 2682 | A L</command>-line L</interpreter>. The program that interactively |
| 2683 | gives you a prompt, accepts one or more L<lines|/line> of input, and |
| 2684 | executes the programs you mentioned, feeding each of them their proper |
| 2685 | L<arguments|/argument> and input data. Shells can also execute |
| 2686 | scripts containing such commands. Under Unix, typical shells include |
| 2687 | the Bourne shell (I</bin/sh>), the C shell (I</bin/csh>), and the Korn |
| 2688 | shell (I</bin/ksh>). Perl is not strictly a shell because it's not |
| 2689 | interactive (although Perl programs can be interactive). |
| 2690 | |
| 2691 | =item side effects |
| 2692 | |
| 2693 | Something extra that happens when you evaluate an L</expression>. |
| 2694 | Nowadays it can refer to almost anything. For example, evaluating a |
| 2695 | simple assignment statement typically has the "side effect" of |
| 2696 | assigning a value to a variable. (And you thought assigning the value |
| 2697 | was your primary intent in the first place!) Likewise, assigning a |
| 2698 | value to the special variable C<$|> (C<$AUTOFLUSH>) has the side |
| 2699 | effect of forcing a flush after every L<write|perlfunc/write> or |
| 2700 | L<print|perlfunc/print> on the currently selected filehandle. |
| 2701 | |
| 2702 | =item signal |
| 2703 | |
| 2704 | A bolt out of the blue; that is, an event triggered by the |
| 2705 | L</operating system>, probably when you're least expecting it. |
| 2706 | |
| 2707 | =item signal handler |
| 2708 | |
| 2709 | A L</subroutine> that, instead of being content to be called in the |
| 2710 | normal fashion, sits around waiting for a bolt out of the blue before |
| 2711 | it will deign to L</execute>. Under Perl, bolts out of the blue are |
| 2712 | called signals, and you send them with the L<kill|perlfunc/kill> |
| 2713 | built-in. See L<perlvar/%SIG> and L<perlipc/Signals>. |
| 2714 | |
| 2715 | =item single inheritance |
| 2716 | |
| 2717 | The features you got from your mother, if she told you that you don't |
| 2718 | have a father. (See also L</inheritance> and L</multiple |
| 2719 | inheritance>.) In computer languages, the notion that |
| 2720 | L<classes|/class> reproduce asexually so that a given class can only |
| 2721 | have one direct ancestor or L</base class>. Perl supplies no such |
| 2722 | restriction, though you may certainly program Perl that way if you |
| 2723 | like. |
| 2724 | |
| 2725 | =item slice |
| 2726 | |
| 2727 | A selection of any number of L<elements|/element> from a L</list>, |
| 2728 | L</array>, or L</hash>. |
| 2729 | |
| 2730 | =item slurp |
| 2731 | |
| 2732 | To read an entire L</file> into a L</string> in one operation. |
| 2733 | |
| 2734 | =item socket |
| 2735 | |
| 2736 | An endpoint for network communication among multiple |
| 2737 | L<processes|/process> that works much like a telephone or a post |
| 2738 | office box. The most important thing about a socket is its L</network |
| 2739 | address> (like a phone number). Different kinds of sockets have |
| 2740 | different kinds of addresses--some look like filenames, and some |
| 2741 | don't. |
| 2742 | |
| 2743 | =item soft reference |
| 2744 | |
| 2745 | See L</symbolic reference>. |
| 2746 | |
| 2747 | =item source filter |
| 2748 | |
| 2749 | A special kind of L</module> that does L</preprocessing> on your |
| 2750 | script just before it gets to the L</tokener>. |
| 2751 | |
| 2752 | =item stack |
| 2753 | |
| 2754 | A device you can put things on the top of, and later take them back |
| 2755 | off in the opposite order in which you put them on. See L</LIFO>. |
| 2756 | |
| 2757 | =item standard |
| 2758 | |
| 2759 | Included in the official Perl distribution, as in a standard module, a |
| 2760 | standard tool, or a standard Perl L</manpage>. |
| 2761 | |
| 2762 | =item standard error |
| 2763 | |
| 2764 | The default output L</stream> for nasty remarks that don't belong in |
| 2765 | L</standard output>. Represented within a Perl program by the |
| 2766 | L</filehandle> L</STDERR>. You can use this stream explicitly, but the |
| 2767 | L<die|perlfunc/die> and L<warn|perlfunc/warn> built-ins write to your |
| 2768 | standard error stream automatically. |
| 2769 | |
| 2770 | =item standard I/O |
| 2771 | |
| 2772 | A standard C library for doing L<buffered|/buffer> input and output to |
| 2773 | the L</operating system>. (The "standard" of standard I/O is only |
| 2774 | marginally related to the "standard" of standard input and output.) |
| 2775 | In general, Perl relies on whatever implementation of standard I/O a |
| 2776 | given operating system supplies, so the buffering characteristics of a |
| 2777 | Perl program on one machine may not exactly match those on another |
| 2778 | machine. Normally this only influences efficiency, not semantics. If |
| 2779 | your standard I/O package is doing block buffering and you want it to |
| 2780 | L</flush> the buffer more often, just set the C<$|> variable to a true |
| 2781 | value. |
| 2782 | |
| 2783 | =item standard input |
| 2784 | |
| 2785 | The default input L</stream> for your program, which if possible |
| 2786 | shouldn't care where its data is coming from. Represented within a |
| 2787 | Perl program by the L</filehandle> L</STDIN>. |
| 2788 | |
| 2789 | =item standard output |
| 2790 | |
| 2791 | The default output L</stream> for your program, which if possible |
| 2792 | shouldn't care where its data is going. Represented within a Perl |
| 2793 | program by the L</filehandle> L</STDOUT>. |
| 2794 | |
| 2795 | =item stat structure |
| 2796 | |
| 2797 | A special internal spot in which Perl keeps the information about the |
| 2798 | last L</file> on which you requested information. |
| 2799 | |
| 2800 | =item statement |
| 2801 | |
| 2802 | A L</command> to the computer about what to do next, like a step in a |
| 2803 | recipe: "Add marmalade to batter and mix until mixed." A statement is |
| 2804 | distinguished from a L</declaration>, which doesn't tell the computer |
| 2805 | to do anything, but just to learn something. |
| 2806 | |
| 2807 | =item statement modifier |
| 2808 | |
| 2809 | A L</conditional> or L</loop> that you put after the L</statement> |
| 2810 | instead of before, if you know what we mean. |
| 2811 | |
| 2812 | =item static |
| 2813 | |
| 2814 | Varying slowly compared to something else. (Unfortunately, everything |
| 2815 | is relatively stable compared to something else, except for certain |
| 2816 | elementary particles, and we're not so sure about them.) In |
| 2817 | computers, where things are supposed to vary rapidly, "static" has a |
| 2818 | derogatory connotation, indicating a slightly dysfunctional |
| 2819 | L</variable>, L</subroutine>, or L</method>. In Perl culture, the |
| 2820 | word is politely avoided. |
| 2821 | |
| 2822 | =item static method |
| 2823 | |
| 2824 | No such thing. See L</class method>. |
| 2825 | |
| 2826 | =item static scoping |
| 2827 | |
| 2828 | No such thing. See L</lexical scoping>. |
| 2829 | |
| 2830 | =item static variable |
| 2831 | |
| 2832 | No such thing. Just use a L</lexical variable> in a scope larger than |
| 2833 | your L</subroutine>. |
| 2834 | |
| 2835 | =item status |
| 2836 | |
| 2837 | The L</value> returned to the parent L</process> when one of its child |
| 2838 | processes dies. This value is placed in the special variable C<$?>. |
| 2839 | Its upper eight L<bits|/bit> are the exit status of the defunct |
| 2840 | process, and its lower eight bits identify the signal (if any) that |
| 2841 | the process died from. On Unix systems, this status value is the same |
| 2842 | as the status word returned by I<wait>(2). See L<perlfunc/system>. |
| 2843 | |
| 2844 | =item STDERR |
| 2845 | |
| 2846 | See L</standard error>. |
| 2847 | |
| 2848 | =item STDIN |
| 2849 | |
| 2850 | See L</standard input>. |
| 2851 | |
| 2852 | =item STDIO |
| 2853 | |
| 2854 | See L</standard IE<sol>O>. |
| 2855 | |
| 2856 | =item STDOUT |
| 2857 | |
| 2858 | See L</standard output>. |
| 2859 | |
| 2860 | =item stream |
| 2861 | |
| 2862 | A flow of data into or out of a process as a steady sequence of bytes |
| 2863 | or characters, without the appearance of being broken up into packets. |
| 2864 | This is a kind of L</interface>--the underlying L</implementation> may |
| 2865 | well break your data up into separate packets for delivery, but this |
| 2866 | is hidden from you. |
| 2867 | |
| 2868 | =item string |
| 2869 | |
| 2870 | A sequence of characters such as "He said !@#*&%@#*?!". A string does |
| 2871 | not have to be entirely printable. |
| 2872 | |
| 2873 | =item string context |
| 2874 | |
| 2875 | The situation in which an expression is expected by its surroundings |
| 2876 | (the code calling it) to return a L</string>. See also L</context> |
| 2877 | and L</numeric context>. |
| 2878 | |
| 2879 | =item stringification |
| 2880 | |
| 2881 | The process of producing a L</string> representation of an abstract |
| 2882 | object. |
| 2883 | |
| 2884 | =item struct |
| 2885 | |
| 2886 | C keyword introducing a structure definition or name. |
| 2887 | |
| 2888 | =item structure |
| 2889 | |
| 2890 | See L</data structure>. |
| 2891 | |
| 2892 | =item subclass |
| 2893 | |
| 2894 | See L</derived class>. |
| 2895 | |
| 2896 | =item subpattern |
| 2897 | |
| 2898 | A component of a L</regular expression> pattern. |
| 2899 | |
| 2900 | =item subroutine |
| 2901 | |
| 2902 | A named or otherwise accessible piece of program that can be invoked |
| 2903 | from elsewhere in the program in order to accomplish some sub-goal of |
| 2904 | the program. A subroutine is often parameterized to accomplish |
| 2905 | different but related things depending on its input |
| 2906 | L<arguments|/argument>. If the subroutine returns a meaningful |
| 2907 | L</value>, it is also called a L</function>. |
| 2908 | |
| 2909 | =item subscript |
| 2910 | |
| 2911 | A L</value> that indicates the position of a particular L</array> |
| 2912 | L</element> in an array. |
| 2913 | |
| 2914 | =item substitution |
| 2915 | |
| 2916 | Changing parts of a string via the C<s///> operator. (We avoid use of |
| 2917 | this term to mean L</variable interpolation>.) |
| 2918 | |
| 2919 | =item substring |
| 2920 | |
| 2921 | A portion of a L</string>, starting at a certain L</character> |
| 2922 | position (L</offset>) and proceeding for a certain number of |
| 2923 | characters. |
| 2924 | |
| 2925 | =item superclass |
| 2926 | |
| 2927 | See L</base class>. |
| 2928 | |
| 2929 | =item superuser |
| 2930 | |
| 2931 | The person whom the L</operating system> will let do almost anything. |
| 2932 | Typically your system administrator or someone pretending to be your |
| 2933 | system administrator. On Unix systems, the L</root> user. On Windows |
| 2934 | systems, usually the Administrator user. |
| 2935 | |
| 2936 | =item SV |
| 2937 | |
| 2938 | Short for "scalar value". But within the Perl interpreter every |
| 2939 | L</referent> is treated as a member of a class derived from SV, in an |
| 2940 | object-oriented sort of way. Every L</value> inside Perl is passed |
| 2941 | around as a C language C<SV*> pointer. The SV L</struct> knows its |
| 2942 | own "referent type", and the code is smart enough (we hope) not to try |
| 2943 | to call a L</hash> function on a L</subroutine>. |
| 2944 | |
| 2945 | =item switch |
| 2946 | |
| 2947 | An option you give on a command line to influence the way your program |
| 2948 | works, usually introduced with a minus sign. The word is also used as |
| 2949 | a nickname for a L</switch statement>. |
| 2950 | |
| 2951 | =item switch cluster |
| 2952 | |
| 2953 | The combination of multiple command-line switches (e.g., B<-a -b -c>) |
| 2954 | into one switch (e.g., B<-abc>). Any switch with an additional |
| 2955 | L</argument> must be the last switch in a cluster. |
| 2956 | |
| 2957 | =item switch statement |
| 2958 | |
| 2959 | A program technique that lets you evaluate an L</expression> and then, |
| 2960 | based on the value of the expression, do a multiway branch to the |
| 2961 | appropriate piece of code for that value. Also called a "case |
| 2962 | structure", named after the similar Pascal construct. Most switch |
| 2963 | statements in Perl are spelled C<for>. See L<perlsyn/Basic BLOCKs and |
| 2964 | Switch Statements>. |
| 2965 | |
| 2966 | =item symbol |
| 2967 | |
| 2968 | Generally, any L</token> or L</metasymbol>. Often used more |
| 2969 | specifically to mean the sort of name you might find in a L</symbol |
| 2970 | table>. |
| 2971 | |
| 2972 | =item symbol table |
| 2973 | |
| 2974 | Where a L</compiler> remembers symbols. A program like Perl must |
| 2975 | somehow remember all the names of all the L<variables|/variable>, |
| 2976 | L<filehandles|/filehandle>, and L<subroutines|/subroutine> you've |
| 2977 | used. It does this by placing the names in a symbol table, which is |
| 2978 | implemented in Perl using a L</hash table>. There is a separate |
| 2979 | symbol table for each L</package> to give each package its own |
| 2980 | L</namespace>. |
| 2981 | |
| 2982 | =item symbolic debugger |
| 2983 | |
| 2984 | A program that lets you step through the L<execution|/execute> of your |
| 2985 | program, stopping or printing things out here and there to see whether |
| 2986 | anything has gone wrong, and if so, what. The "symbolic" part just |
| 2987 | means that you can talk to the debugger using the same symbols with |
| 2988 | which your program is written. |
| 2989 | |
| 2990 | =item symbolic link |
| 2991 | |
| 2992 | An alternate filename that points to the real L</filename>, which in |
| 2993 | turn points to the real L</file>. Whenever the L</operating system> |
| 2994 | is trying to parse a L</pathname> containing a symbolic link, it |
| 2995 | merely substitutes the new name and continues parsing. |
| 2996 | |
| 2997 | =item symbolic reference |
| 2998 | |
| 2999 | A variable whose value is the name of another variable or subroutine. |
| 3000 | By L<dereferencing|/dereference> the first variable, you can get at |
| 3001 | the second one. Symbolic references are illegal under L<use strict |
| 3002 | 'refs'|strict/strict refs>. |
| 3003 | |
| 3004 | =item synchronous |
| 3005 | |
| 3006 | Programming in which the orderly sequence of events can be determined; |
| 3007 | that is, when things happen one after the other, not at the same time. |
| 3008 | |
| 3009 | =item syntactic sugar |
| 3010 | |
| 3011 | An alternative way of writing something more easily; a shortcut. |
| 3012 | |
| 3013 | =item syntax |
| 3014 | |
| 3015 | From Greek, "with-arrangement". How things (particularly symbols) are |
| 3016 | put together with each other. |
| 3017 | |
| 3018 | =item syntax tree |
| 3019 | |
| 3020 | An internal representation of your program wherein lower-level |
| 3021 | L<constructs|/construct> dangle off the higher-level constructs |
| 3022 | enclosing them. |
| 3023 | |
| 3024 | =item syscall |
| 3025 | |
| 3026 | A L</function> call directly to the L</operating system>. Many of the |
| 3027 | important subroutines and functions you use aren't direct system |
| 3028 | calls, but are built up in one or more layers above the system call |
| 3029 | level. In general, Perl programmers don't need to worry about the |
| 3030 | distinction. However, if you do happen to know which Perl functions |
| 3031 | are really syscalls, you can predict which of these will set the C<$!> |
| 3032 | (C<$ERRNO>) variable on failure. Unfortunately, beginning programmers |
| 3033 | often confusingly employ the term "system call" to mean what happens |
| 3034 | when you call the Perl L<system|perlfunc/system> function, which |
| 3035 | actually involves many syscalls. To avoid any confusion, we nearly |
| 3036 | always use say "syscall" for something you could call indirectly via |
| 3037 | Perl's L<syscall|perlfunc/syscall> function, and never for something |
| 3038 | you would call with Perl's L<system|perlfunc/system> function. |
| 3039 | |
| 3040 | =back |
| 3041 | |
| 3042 | =head2 T |
| 3043 | |
| 3044 | =over 4 |
| 3045 | |
| 3046 | =item tainted |
| 3047 | |
| 3048 | Said of data derived from the grubby hands of a user and thus unsafe |
| 3049 | for a secure program to rely on. Perl does taint checks if you run a |
| 3050 | L</setuid> (or L</setgid>) program, or if you use the B<-T> switch. |
| 3051 | |
| 3052 | =item TCP |
| 3053 | |
| 3054 | Short for Transmission Control Protocol. A protocol wrapped around |
| 3055 | the Internet Protocol to make an unreliable packet transmission |
| 3056 | mechanism appear to the application program to be a reliable |
| 3057 | L</stream> of bytes. (Usually.) |
| 3058 | |
| 3059 | =item term |
| 3060 | |
| 3061 | Short for a "terminal", that is, a leaf node of a L</syntax tree>. A |
| 3062 | thing that functions grammatically as an L</operand> for the operators |
| 3063 | in an expression. |
| 3064 | |
| 3065 | =item terminator |
| 3066 | |
| 3067 | A L</character> or L</string> that marks the end of another string. |
| 3068 | The C<$/> variable contains the string that terminates a |
| 3069 | L<readline|perlfunc/readline> operation, which L<chomp|perlfunc/chomp> |
| 3070 | deletes from the end. Not to be confused with |
| 3071 | L<delimiters|/delimiter> or L<separators|/separator>. The period at |
| 3072 | the end of this sentence is a terminator. |
| 3073 | |
| 3074 | =item ternary |
| 3075 | |
| 3076 | An L</operator> taking three L<operands|/operand>. Sometimes |
| 3077 | pronounced L</trinary>. |
| 3078 | |
| 3079 | =item text |
| 3080 | |
| 3081 | A L</string> or L</file> containing primarily printable characters. |
| 3082 | |
| 3083 | =item thread |
| 3084 | |
| 3085 | Like a forked process, but without L</fork>'s inherent memory |
| 3086 | protection. A thread is lighter weight than a full process, in that a |
| 3087 | process could have multiple threads running around in it, all fighting |
| 3088 | over the same process's memory space unless steps are taken to protect |
| 3089 | threads from each other. See L<threads>. |
| 3090 | |
| 3091 | =item tie |
| 3092 | |
| 3093 | The bond between a magical variable and its implementation class. See |
| 3094 | L<perlfunc/tie> and L<perltie>. |
| 3095 | |
| 3096 | =item TMTOWTDI |
| 3097 | |
| 3098 | There's More Than One Way To Do It, the Perl Motto. The notion that |
| 3099 | there can be more than one valid path to solving a programming problem |
| 3100 | in context. (This doesn't mean that more ways are always better or |
| 3101 | that all possible paths are equally desirable--just that there need |
| 3102 | not be One True Way.) Pronounced TimToady. |
| 3103 | |
| 3104 | =item token |
| 3105 | |
| 3106 | A morpheme in a programming language, the smallest unit of text with |
| 3107 | semantic significance. |
| 3108 | |
| 3109 | =item tokener |
| 3110 | |
| 3111 | A module that breaks a program text into a sequence of |
| 3112 | L<tokens|/token> for later analysis by a parser. |
| 3113 | |
| 3114 | =item tokenizing |
| 3115 | |
| 3116 | Splitting up a program text into L<tokens|/token>. Also known as |
| 3117 | "lexing", in which case you get "lexemes" instead of tokens. |
| 3118 | |
| 3119 | =item toolbox approach |
| 3120 | |
| 3121 | The notion that, with a complete set of simple tools that work well |
| 3122 | together, you can build almost anything you want. Which is fine if |
| 3123 | you're assembling a tricycle, but if you're building a defranishizing |
| 3124 | comboflux regurgalator, you really want your own machine shop in which |
| 3125 | to build special tools. Perl is sort of a machine shop. |
| 3126 | |
| 3127 | =item transliterate |
| 3128 | |
| 3129 | To turn one string representation into another by mapping each |
| 3130 | character of the source string to its corresponding character in the |
| 3131 | result string. See |
| 3132 | L<perlop/trE<sol>SEARCHLISTE<sol>REPLACEMENTLISTE<sol>cds>. |
| 3133 | |
| 3134 | =item trigger |
| 3135 | |
| 3136 | An event that causes a L</handler> to be run. |
| 3137 | |
| 3138 | =item trinary |
| 3139 | |
| 3140 | Not a stellar system with three stars, but an L</operator> taking |
| 3141 | three L<operands|/operand>. Sometimes pronounced L</ternary>. |
| 3142 | |
| 3143 | =item troff |
| 3144 | |
| 3145 | A venerable typesetting language from which Perl derives the name of |
| 3146 | its C<$%> variable and which is secretly used in the production of |
| 3147 | Camel books. |
| 3148 | |
| 3149 | =item true |
| 3150 | |
| 3151 | Any scalar value that doesn't evaluate to 0 or C<"">. |
| 3152 | |
| 3153 | =item truncating |
| 3154 | |
| 3155 | Emptying a file of existing contents, either automatically when |
| 3156 | opening a file for writing or explicitly via the |
| 3157 | L<truncate|perlfunc/truncate> function. |
| 3158 | |
| 3159 | =item type |
| 3160 | |
| 3161 | See L</data type> and L</class>. |
| 3162 | |
| 3163 | =item type casting |
| 3164 | |
| 3165 | Converting data from one type to another. C permits this. Perl does |
| 3166 | not need it. Nor want it. |
| 3167 | |
| 3168 | =item typed lexical |
| 3169 | |
| 3170 | A L</lexical variable> that is declared with a L</class> type: C<my |
| 3171 | Pony $bill>. |
| 3172 | |
| 3173 | =item typedef |
| 3174 | |
| 3175 | A type definition in the C language. |
| 3176 | |
| 3177 | =item typeglob |
| 3178 | |
| 3179 | Use of a single identifier, prefixed with C<*>. For example, C<*name> |
| 3180 | stands for any or all of C<$name>, C<@name>, C<%name>, C<&name>, or |
| 3181 | just C<name>. How you use it determines whether it is interpreted as |
| 3182 | all or only one of them. See L<perldata/Typeglobs and Filehandles>. |
| 3183 | |
| 3184 | =item typemap |
| 3185 | |
| 3186 | A description of how C types may be transformed to and from Perl types |
| 3187 | within an L</extension> module written in L</XS>. |
| 3188 | |
| 3189 | =back |
| 3190 | |
| 3191 | =head2 U |
| 3192 | |
| 3193 | =over 4 |
| 3194 | |
| 3195 | =item UDP |
| 3196 | |
| 3197 | User Datagram Protocol, the typical way to send L<datagrams|/datagram> |
| 3198 | over the Internet. |
| 3199 | |
| 3200 | =item UID |
| 3201 | |
| 3202 | A user ID. Often used in the context of L</file> or L</process> |
| 3203 | ownership. |
| 3204 | |
| 3205 | =item umask |
| 3206 | |
| 3207 | A mask of those L</permission bits> that should be forced off when |
| 3208 | creating files or directories, in order to establish a policy of whom |
| 3209 | you'll ordinarily deny access to. See the L<umask|perlfunc/umask> |
| 3210 | function. |
| 3211 | |
| 3212 | =item unary operator |
| 3213 | |
| 3214 | An operator with only one L</operand>, like C<!> or |
| 3215 | L<chdir|perlfunc/chdir>. Unary operators are usually prefix |
| 3216 | operators; that is, they precede their operand. The C<++> and C<--> |
| 3217 | operators can be either prefix or postfix. (Their position I<does> |
| 3218 | change their meanings.) |
| 3219 | |
| 3220 | =item Unicode |
| 3221 | |
| 3222 | A character set comprising all the major character sets of the world, |
| 3223 | more or less. See L<http://www.unicode.org>. |
| 3224 | |
| 3225 | =item Unix |
| 3226 | |
| 3227 | A very large and constantly evolving language with several alternative |
| 3228 | and largely incompatible syntaxes, in which anyone can define anything |
| 3229 | any way they choose, and usually do. Speakers of this language think |
| 3230 | it's easy to learn because it's so easily twisted to one's own ends, |
| 3231 | but dialectical differences make tribal intercommunication nearly |
| 3232 | impossible, and travelers are often reduced to a pidgin-like subset of |
| 3233 | the language. To be universally understood, a Unix shell programmer |
| 3234 | must spend years of study in the art. Many have abandoned this |
| 3235 | discipline and now communicate via an Esperanto-like language called |
| 3236 | Perl. |
| 3237 | |
| 3238 | In ancient times, Unix was also used to refer to some code that a |
| 3239 | couple of people at Bell Labs wrote to make use of a PDP-7 computer |
| 3240 | that wasn't doing much of anything else at the time. |
| 3241 | |
| 3242 | =back |
| 3243 | |
| 3244 | =head2 V |
| 3245 | |
| 3246 | =over 4 |
| 3247 | |
| 3248 | =item value |
| 3249 | |
| 3250 | An actual piece of data, in contrast to all the variables, references, |
| 3251 | keys, indexes, operators, and whatnot that you need to access the |
| 3252 | value. |
| 3253 | |
| 3254 | =item variable |
| 3255 | |
| 3256 | A named storage location that can hold any of various kinds of |
| 3257 | L</value>, as your program sees fit. |
| 3258 | |
| 3259 | =item variable interpolation |
| 3260 | |
| 3261 | The L</interpolation> of a scalar or array variable into a string. |
| 3262 | |
| 3263 | =item variadic |
| 3264 | |
| 3265 | Said of a L</function> that happily receives an indeterminate number |
| 3266 | of L</actual arguments>. |
| 3267 | |
| 3268 | =item vector |
| 3269 | |
| 3270 | Mathematical jargon for a list of L<scalar values|/scalar value>. |
| 3271 | |
| 3272 | =item virtual |
| 3273 | |
| 3274 | Providing the appearance of something without the reality, as in: |
| 3275 | virtual memory is not real memory. (See also L</memory>.) The |
| 3276 | opposite of "virtual" is "transparent", which means providing the |
| 3277 | reality of something without the appearance, as in: Perl handles the |
| 3278 | variable-length UTF-8 character encoding transparently. |
| 3279 | |
| 3280 | =item void context |
| 3281 | |
| 3282 | A form of L</scalar context> in which an L</expression> is not |
| 3283 | expected to return any L</value> at all and is evaluated for its |
| 3284 | L</side effects> alone. |
| 3285 | |
| 3286 | =item v-string |
| 3287 | |
| 3288 | A "version" or "vector" L</string> specified with a C<v> followed by a |
| 3289 | series of decimal integers in dot notation, for instance, |
| 3290 | C<v1.20.300.4000>. Each number turns into a L</character> with the |
| 3291 | specified ordinal value. (The C<v> is optional when there are at |
| 3292 | least three integers.) |
| 3293 | |
| 3294 | =back |
| 3295 | |
| 3296 | =head2 W |
| 3297 | |
| 3298 | =over 4 |
| 3299 | |
| 3300 | =item warning |
| 3301 | |
| 3302 | A message printed to the L</STDERR> stream to the effect that something |
| 3303 | might be wrong but isn't worth blowing up over. See L<perlfunc/warn> |
| 3304 | and the L<warnings> pragma. |
| 3305 | |
| 3306 | =item watch expression |
| 3307 | |
| 3308 | An expression which, when its value changes, causes a breakpoint in |
| 3309 | the Perl debugger. |
| 3310 | |
| 3311 | =item whitespace |
| 3312 | |
| 3313 | A L</character> that moves your cursor but doesn't otherwise put |
| 3314 | anything on your screen. Typically refers to any of: space, tab, line |
| 3315 | feed, carriage return, or form feed. |
| 3316 | |
| 3317 | =item word |
| 3318 | |
| 3319 | In normal "computerese", the piece of data of the size most |
| 3320 | efficiently handled by your computer, typically 32 bits or so, give or |
| 3321 | take a few powers of 2. In Perl culture, it more often refers to an |
| 3322 | alphanumeric L</identifier> (including underscores), or to a string of |
| 3323 | nonwhitespace L<characters|/character> bounded by whitespace or string |
| 3324 | boundaries. |
| 3325 | |
| 3326 | =item working directory |
| 3327 | |
| 3328 | Your current L</directory>, from which relative pathnames are |
| 3329 | interpreted by the L</operating system>. The operating system knows |
| 3330 | your current directory because you told it with a |
| 3331 | L<chdir|perlfunc/chdir> or because you started out in the place where |
| 3332 | your parent L</process> was when you were born. |
| 3333 | |
| 3334 | =item wrapper |
| 3335 | |
| 3336 | A program or subroutine that runs some other program or subroutine for |
| 3337 | you, modifying some of its input or output to better suit your |
| 3338 | purposes. |
| 3339 | |
| 3340 | =item WYSIWYG |
| 3341 | |
| 3342 | What You See Is What You Get. Usually used when something that |
| 3343 | appears on the screen matches how it will eventually look, like Perl's |
| 3344 | L<format|perlfunc/format> declarations. Also used to mean the |
| 3345 | opposite of magic because everything works exactly as it appears, as |
| 3346 | in the three-argument form of L<open|perlfunc/open>. |
| 3347 | |
| 3348 | =back |
| 3349 | |
| 3350 | =head2 X |
| 3351 | |
| 3352 | =over 4 |
| 3353 | |
| 3354 | =item XS |
| 3355 | |
| 3356 | An extraordinarily exported, expeditiously excellent, expressly |
| 3357 | eXternal Subroutine, executed in existing C or C++ or in an exciting |
| 3358 | new extension language called (exasperatingly) XS. Examine L<perlxs> |
| 3359 | for the exact explanation or L<perlxstut> for an exemplary unexacting |
| 3360 | one. |
| 3361 | |
| 3362 | =item XSUB |
| 3363 | |
| 3364 | An external L</subroutine> defined in L</XS>. |
| 3365 | |
| 3366 | =back |
| 3367 | |
| 3368 | =head2 Y |
| 3369 | |
| 3370 | =over 4 |
| 3371 | |
| 3372 | =item yacc |
| 3373 | |
| 3374 | Yet Another Compiler Compiler. A parser generator without which Perl |
| 3375 | probably would not have existed. See the file I<perly.y> in the Perl |
| 3376 | source distribution. |
| 3377 | |
| 3378 | =back |
| 3379 | |
| 3380 | =head2 Z |
| 3381 | |
| 3382 | =over 4 |
| 3383 | |
| 3384 | =item zero width |
| 3385 | |
| 3386 | A subpattern L</assertion> matching the L</null string> between |
| 3387 | L<characters|/character>. |
| 3388 | |
| 3389 | =item zombie |
| 3390 | |
| 3391 | A process that has died (exited) but whose parent has not yet received |
| 3392 | proper notification of its demise by virtue of having called |
| 3393 | L<wait|perlfunc/wait> or L<waitpid|perlfunc/waitpid>. If you |
| 3394 | L<fork|perlfunc/fork>, you must clean up after your child processes |
| 3395 | when they exit, or else the process table will fill up and your system |
| 3396 | administrator will Not Be Happy with you. |
| 3397 | |
| 3398 | =back |
| 3399 | |
| 3400 | =head1 AUTHOR AND COPYRIGHT |
| 3401 | |
| 3402 | Based on the Glossary of Programming Perl, Third Edition, |
| 3403 | by Larry Wall, Tom Christiansen & Jon Orwant. |
| 3404 | Copyright (c) 2000, 1996, 1991 O'Reilly Media, Inc. |
| 3405 | This document may be distributed under the same terms as Perl itself. |