[Summary view] [Print] [Text view]

   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 maintenance
 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 at the time of Perl 5.0) can become the new
 884  home of 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 ongoing 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.