Avoid a possible race condition where a parallel make might
[perl.git] / pod / perlglossary.pod
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 sometimes 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 In modern Perl, calling methods this way is often considered bad practice and
1461 to be avoided.
1462
1463 =item indirect object slot
1464
1465 The syntactic position falling between a method call and its arguments
1466 when using the indirect object invocation syntax.  (The slot is
1467 distinguished by the absence of a comma between it and the next
1468 argument.) L</STDERR> is in the indirect object slot here:
1469
1470   print STDERR "Awake!  Awake!  Fear, Fire,
1471       Foes!  Awake!\n";
1472
1473 =item indirection
1474
1475 If something in a program isn't the value you're looking for but
1476 indicates where the value is, that's indirection.  This can be done
1477 with either L<symbolic references|/symbolic reference> or L<hard
1478 references|/hard reference>.
1479
1480 =item infix
1481
1482 An L</operator> that comes in between its L<operands|/operand>, such
1483 as multiplication in C<24 * 7>.
1484
1485 =item inheritance
1486
1487 What you get from your ancestors, genetically or otherwise.  If you
1488 happen to be a L</class>, your ancestors are called L<base
1489 classes|/base class> and your descendants are called L<derived
1490 classes|/derived class>.  See L</single inheritance> and L</multiple
1491 inheritance>.
1492
1493 =item instance
1494
1495 Short for "an instance of a class", meaning an L</object> of that L</class>.
1496
1497 =item instance variable
1498
1499 An L</attribute> of an L</object>; data stored with the particular
1500 object rather than with the class as a whole.
1501
1502 =item integer
1503
1504 A number with no fractional (decimal) part.  A counting number, like
1505 1, 2, 3, and so on, but including 0 and the negatives.
1506
1507 =item interface
1508
1509 The services a piece of code promises to provide forever, in contrast to
1510 its L</implementation>, which it should feel free to change whenever it
1511 likes.
1512
1513 =item interpolation
1514
1515 The insertion of a scalar or list value somewhere in the middle of
1516 another value, such that it appears to have been there all along.  In
1517 Perl, variable interpolation happens in double-quoted strings and
1518 patterns, and list interpolation occurs when constructing the list of
1519 values to pass to a list operator or other such construct that takes a
1520 L</LIST>.
1521
1522 =item interpreter
1523
1524 Strictly speaking, a program that reads a second program and does what
1525 the second program says directly without turning the program into a
1526 different form first, which is what L<compilers|/compiler> do.  Perl
1527 is not an interpreter by this definition, because it contains a kind
1528 of compiler that takes a program and turns it into a more executable
1529 form (L<syntax trees|/syntax tree>) within the I<perl> process itself,
1530 which the Perl L</run time> system then interprets.
1531
1532 =item invocant
1533
1534 The agent on whose behalf a L</method> is invoked.  In a L</class>
1535 method, the invocant is a package name.  In an L</instance> method,
1536 the invocant is an object reference.
1537
1538 =item invocation
1539
1540 The act of calling up a deity, daemon, program, method, subroutine, or
1541 function to get it do what you think it's supposed to do.  We usually
1542 "call" subroutines but "invoke" methods, since it sounds cooler.
1543
1544 =item I/O
1545
1546 Input from, or output to, a L</file> or L</device>.
1547
1548 =item IO
1549
1550 An internal I/O object.  Can also mean L</indirect object>.
1551
1552 =item IP
1553
1554 Internet Protocol, or Intellectual Property.
1555
1556 =item IPC
1557
1558 Interprocess Communication.
1559
1560 =item is-a
1561
1562 A relationship between two L<objects|/object> in which one object is
1563 considered to be a more specific version of the other, generic object:
1564 "A camel is a mammal."  Since the generic object really only exists in
1565 a Platonic sense, we usually add a little abstraction to the notion of
1566 objects and think of the relationship as being between a generic
1567 L</base class> and a specific L</derived class>.  Oddly enough,
1568 Platonic classes don't always have Platonic relationships--see
1569 L</inheritance>.
1570
1571 =item iteration
1572
1573 Doing something repeatedly.
1574
1575 =item iterator
1576
1577 A special programming gizmo that keeps track of where you are in
1578 something that you're trying to iterate over.  The C<foreach> loop in
1579 Perl contains an iterator; so does a hash, allowing you to
1580 L<each|perlfunc/each> through it.
1581
1582 =item IV
1583
1584 The integer four, not to be confused with six, Tom's favorite editor.
1585 IV also means an internal Integer Value of the type a L</scalar> can
1586 hold, not to be confused with an L</NV>.
1587
1588 =back
1589
1590 =head2 J
1591
1592 =over 4
1593
1594 =item JAPH
1595
1596 "Just Another Perl Hacker," a clever but cryptic bit of Perl code that
1597 when executed, evaluates to that string.  Often used to illustrate a
1598 particular Perl feature, and something of an ongoing Obfuscated Perl
1599 Contest seen in Usenix signatures.
1600
1601 =back
1602
1603 =head2 K
1604
1605 =over 4
1606
1607 =item key
1608
1609 The string index to a L</hash>, used to look up the L</value>
1610 associated with that key.
1611
1612 =item keyword
1613
1614 See L</reserved words>.
1615
1616 =back
1617
1618 =head2 L
1619
1620 =over 4
1621
1622 =item label
1623
1624 A name you give to a L</statement> so that you can talk about that
1625 statement elsewhere in the program.
1626
1627 =item laziness
1628
1629 The quality that makes you go to great effort to reduce overall energy
1630 expenditure.  It makes you write labor-saving programs that other
1631 people will find useful, and document what you wrote so you don't have
1632 to answer so many questions about it.  Hence, the first great virtue
1633 of a programmer.  Also hence, this book.  See also L</impatience> and
1634 L</hubris>.
1635
1636 =item left shift
1637
1638 A L</bit shift> that multiplies the number by some power of 2.
1639
1640 =item leftmost longest
1641
1642 The preference of the L</regular expression> engine to match the
1643 leftmost occurrence of a L</pattern>, then given a position at which a
1644 match will occur, the preference for the longest match (presuming the
1645 use of a L</greedy> quantifier).  See L<perlre> for I<much> more on
1646 this subject.
1647
1648 =item lexeme
1649
1650 Fancy term for a L</token>.
1651
1652 =item lexer
1653
1654 Fancy term for a L</tokener>.
1655
1656 =item lexical analysis
1657
1658 Fancy term for L</tokenizing>.
1659
1660 =item lexical scoping
1661
1662 Looking at your I<Oxford English Dictionary> through a microscope.
1663 (Also known as L</static scoping>, because dictionaries don't change
1664 very fast.)  Similarly, looking at variables stored in a private
1665 dictionary (namespace) for each scope, which are visible only from
1666 their point of declaration down to the end of the lexical scope in
1667 which they are declared.  --Syn. L</static scoping>.
1668 --Ant. L</dynamic scoping>.
1669
1670 =item lexical variable
1671
1672 A L</variable> subject to L</lexical scoping>, declared by
1673 L<my|perlfunc/my>.  Often just called a "lexical".  (The
1674 L<our|perlfunc/our> declaration declares a lexically scoped name for a
1675 global variable, which is not itself a lexical variable.)
1676
1677 =item library
1678
1679 Generally, a collection of procedures.  In ancient days, referred to a
1680 collection of subroutines in a I<.pl> file.  In modern times, refers
1681 more often to the entire collection of Perl L<modules|/module> on your
1682 system.
1683
1684 =item LIFO
1685
1686 Last In, First Out.  See also L</FIFO>.  A LIFO is usually called a
1687 L</stack>.
1688
1689 =item line
1690
1691 In Unix, a sequence of zero or more non-newline characters terminated
1692 with a L</newline> character.  On non-Unix machines, this is emulated
1693 by the C library even if the underlying L</operating system> has
1694 different ideas.
1695
1696 =item line buffering
1697
1698 Used by a L</standard IE<sol>O> output stream that flushes its
1699 L</buffer> after every L</newline>.  Many standard I/O libraries
1700 automatically set up line buffering on output that is going to the
1701 terminal.
1702
1703 =item line number
1704
1705 The number of lines read previous to this one, plus 1.  Perl keeps a
1706 separate line number for each source or input file it opens.  The
1707 current source file's line number is represented by C<__LINE__>.  The
1708 current input line number (for the file that was most recently read
1709 via C<< E<lt>FHE<gt> >>) is represented by the C<$.>
1710 (C<$INPUT_LINE_NUMBER>) variable.  Many error messages report both
1711 values, if available.
1712
1713 =item link
1714
1715 Used as a noun, a name in a L</directory>, representing a L</file>.  A
1716 given file can have multiple links to it.  It's like having the same
1717 phone number listed in the phone directory under different names.  As
1718 a verb, to resolve a partially compiled file's unresolved symbols into
1719 a (nearly) executable image.  Linking can generally be static or
1720 dynamic, which has nothing to do with static or dynamic scoping.
1721
1722 =item LIST
1723
1724 A syntactic construct representing a comma-separated list of
1725 expressions, evaluated to produce a L</list value>.  Each
1726 L</expression> in a L</LIST> is evaluated in L</list context> and
1727 interpolated into the list value.
1728
1729 =item list
1730
1731 An ordered set of scalar values.
1732
1733 =item list context
1734
1735 The situation in which an L</expression> is expected by its
1736 surroundings (the code calling it) to return a list of values rather
1737 than a single value.  Functions that want a L</LIST> of arguments tell
1738 those arguments that they should produce a list value.  See also
1739 L</context>.
1740
1741 =item list operator
1742
1743 An L</operator> that does something with a list of values, such as
1744 L<join|perlfunc/join> or L<grep|perlfunc/grep>.  Usually used for
1745 named built-in operators (such as L<print|perlfunc/print>,
1746 L<unlink|perlfunc/unlink>, and L<system|perlfunc/system>) that do not
1747 require parentheses around their L</argument> list.
1748
1749 =item list value
1750
1751 An unnamed list of temporary scalar values that may be passed around
1752 within a program from any list-generating function to any function or
1753 construct that provides a L</list context>.
1754
1755 =item literal
1756
1757 A token in a programming language such as a number or L</string> that
1758 gives you an actual L</value> instead of merely representing possible
1759 values as a L</variable> does.
1760
1761 =item little-endian
1762
1763 From Swift: someone who eats eggs little end first.  Also used of
1764 computers that store the least significant L</byte> of a word at a
1765 lower byte address than the most significant byte.  Often considered
1766 superior to big-endian machines.  See also L</big-endian>.
1767
1768 =item local
1769
1770 Not meaning the same thing everywhere.  A global variable in Perl can
1771 be localized inside a L<dynamic scope|/dynamic scoping> via the
1772 L<local|perlfunc/local> operator.
1773
1774 =item logical operator
1775
1776 Symbols representing the concepts "and", "or", "xor", and "not".
1777
1778 =item lookahead
1779
1780 An L</assertion> that peeks at the string to the right of the current
1781 match location.
1782
1783 =item lookbehind
1784
1785 An L</assertion> that peeks at the string to the left of the current
1786 match location.
1787
1788 =item loop
1789
1790 A construct that performs something repeatedly, like a roller coaster.
1791
1792 =item loop control statement
1793
1794 Any statement within the body of a loop that can make a loop
1795 prematurely stop looping or skip an L</iteration>.  Generally you
1796 shouldn't try this on roller coasters.
1797
1798 =item loop label
1799
1800 A kind of key or name attached to a loop (or roller coaster) so that
1801 loop control statements can talk about which loop they want to
1802 control.
1803
1804 =item lvaluable
1805
1806 Able to serve as an L</lvalue>.
1807
1808 =item lvalue
1809
1810 Term used by language lawyers for a storage location you can assign a
1811 new L</value> to, such as a L</variable> or an element of an
1812 L</array>.  The "l" is short for "left", as in the left side of an
1813 assignment, a typical place for lvalues.  An L</lvaluable> function or
1814 expression is one to which a value may be assigned, as in C<pos($x) =
1815 10>.
1816
1817 =item lvalue modifier
1818
1819 An adjectival pseudofunction that warps the meaning of an L</lvalue>
1820 in some declarative fashion.  Currently there are three lvalue
1821 modifiers: L<my|perlfunc/my>, L<our|perlfunc/our>, and
1822 L<local|perlfunc/local>.
1823
1824 =back
1825
1826 =head2 M
1827
1828 =over 4
1829
1830 =item magic
1831
1832 Technically speaking, any extra semantics attached to a variable such
1833 as C<$!>, C<$0>, C<%ENV>, or C<%SIG>, or to any tied variable.
1834 Magical things happen when you diddle those variables.
1835
1836 =item magical increment
1837
1838 An L</increment> operator that knows how to bump up alphabetics as
1839 well as numbers.
1840
1841 =item magical variables
1842
1843 Special variables that have side effects when you access them or
1844 assign to them.  For example, in Perl, changing elements of the
1845 C<%ENV> array also changes the corresponding environment variables
1846 that subprocesses will use.  Reading the C<$!> variable gives you the
1847 current system error number or message.
1848
1849 =item Makefile
1850
1851 A file that controls the compilation of a program.  Perl programs
1852 don't usually need a L</Makefile> because the Perl compiler has plenty
1853 of self-control.
1854
1855 =item man
1856
1857 The Unix program that displays online documentation (manual pages) for
1858 you.
1859
1860 =item manpage
1861
1862 A "page" from the manuals, typically accessed via the I<man>(1)
1863 command.  A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
1864 BUGS, and so on, and is typically longer than a page.  There are
1865 manpages documenting L<commands|/command>, L<syscalls|/syscall>,
1866 L</library> L<functions|/function>, L<devices|/device>,
1867 L<protocols|/protocol>, L<files|/file>, and such.  In this book, we
1868 call any piece of standard Perl documentation (like I<perlop> or
1869 I<perldelta>) a manpage, no matter what format it's installed in on
1870 your system.
1871
1872 =item matching
1873
1874 See L</pattern matching>.
1875
1876 =item member data
1877
1878 See L</instance variable>.
1879
1880 =item memory
1881
1882 This always means your main memory, not your disk.  Clouding the issue
1883 is the fact that your machine may implement L</virtual> memory; that
1884 is, it will pretend that it has more memory than it really does, and
1885 it'll use disk space to hold inactive bits.  This can make it seem
1886 like you have a little more memory than you really do, but it's not a
1887 substitute for real memory.  The best thing that can be said about
1888 virtual memory is that it lets your performance degrade gradually
1889 rather than suddenly when you run out of real memory.  But your
1890 program can die when you run out of virtual memory too, if you haven't
1891 thrashed your disk to death first.
1892
1893 =item metacharacter
1894
1895 A L</character> that is I<not> supposed to be treated normally.  Which
1896 characters are to be treated specially as metacharacters varies
1897 greatly from context to context.  Your L</shell> will have certain
1898 metacharacters, double-quoted Perl L<strings|/string> have other
1899 metacharacters, and L</regular expression> patterns have all the
1900 double-quote metacharacters plus some extra ones of their own.
1901
1902 =item metasymbol
1903
1904 Something we'd call a L</metacharacter> except that it's a sequence of
1905 more than one character.  Generally, the first character in the
1906 sequence must be a true metacharacter to get the other characters in
1907 the metasymbol to misbehave along with it.
1908
1909 =item method
1910
1911 A kind of action that an L</object> can take if you tell it to.  See
1912 L<perlobj>.
1913
1914 =item minimalism
1915
1916 The belief that "small is beautiful."  Paradoxically, if you say
1917 something in a small language, it turns out big, and if you say it in
1918 a big language, it turns out small.  Go figure.
1919
1920 =item mode
1921
1922 In the context of the L<stat> syscall, refers to the field holding
1923 the L</permission bits> and the type of the L</file>.
1924
1925 =item modifier
1926
1927 See L</statement modifier>, L</regular expression modifier>, and
1928 L</lvalue modifier>, not necessarily in that order.
1929
1930 =item module
1931
1932 A L</file> that defines a L</package> of (almost) the same name, which
1933 can either L</export> symbols or function as an L</object> class.  (A
1934 module's main I<.pm> file may also load in other files in support of
1935 the module.)  See the L<use|perlfunc/use> built-in.
1936
1937 =item modulus
1938
1939 An integer divisor when you're interested in the remainder instead of
1940 the quotient.
1941
1942 =item monger
1943
1944 Short for Perl Monger, a purveyor of Perl.
1945
1946 =item mortal
1947
1948 A temporary value scheduled to die when the current statement
1949 finishes.
1950
1951 =item multidimensional array
1952
1953 An array with multiple subscripts for finding a single element.  Perl
1954 implements these using L<references|/reference>--see L<perllol> and
1955 L<perldsc>.
1956
1957 =item multiple inheritance
1958
1959 The features you got from your mother and father, mixed together
1960 unpredictably.  (See also L</inheritance>, and L</single
1961 inheritance>.)  In computer languages (including Perl), the notion
1962 that a given class may have multiple direct ancestors or L<base
1963 classes|/base class>.
1964
1965 =back
1966
1967 =head2 N
1968
1969 =over 4
1970
1971 =item named pipe
1972
1973 A L</pipe> with a name embedded in the L</filesystem> so that it can
1974 be accessed by two unrelated L<processes|/process>.
1975
1976 =item namespace
1977
1978 A domain of names.  You needn't worry about whether the names in one
1979 such domain have been used in another.  See L</package>.
1980
1981 =item network address
1982
1983 The most important attribute of a socket, like your telephone's
1984 telephone number.  Typically an IP address.  See also L</port>.
1985
1986 =item newline
1987
1988 A single character that represents the end of a line, with the ASCII
1989 value of 012 octal under Unix (but 015 on a Mac), and represented by
1990 C<\n> in Perl strings.  For Windows machines writing text files, and
1991 for certain physical devices like terminals, the single newline gets
1992 automatically translated by your C library into a line feed and a
1993 carriage return, but normally, no translation is done.
1994
1995 =item NFS
1996
1997 Network File System, which allows you to mount a remote filesystem as
1998 if it were local.
1999
2000 =item null character
2001
2002 A character with the ASCII value of zero.  It's used by C to terminate
2003 strings, but Perl allows strings to contain a null.
2004
2005 =item null list
2006
2007 A L</list value> with zero elements, represented in Perl by C<()>.
2008
2009 =item null string
2010
2011 A L</string> containing no characters, not to be confused with a
2012 string containing a L</null character>, which has a positive length
2013 and is L</true>.
2014
2015 =item numeric context
2016
2017 The situation in which an expression is expected by its surroundings
2018 (the code calling it) to return a number.  See also L</context> and
2019 L</string context>.
2020
2021 =item NV
2022
2023 Short for Nevada, no part of which will ever be confused with
2024 civilization.  NV also means an internal floating-point Numeric Value
2025 of the type a L</scalar> can hold, not to be confused with an L</IV>.
2026
2027 =item nybble
2028
2029 Half a L</byte>, equivalent to one L</hexadecimal> digit, and worth
2030 four L<bits|/bit>.
2031
2032 =back
2033
2034 =head2 O
2035
2036 =over 4
2037
2038 =item object
2039
2040 An L</instance> of a L</class>.  Something that "knows" what
2041 user-defined type (class) it is, and what it can do because of what
2042 class it is.  Your program can request an object to do things, but the
2043 object gets to decide whether it wants to do them or not.  Some
2044 objects are more accommodating than others.
2045
2046 =item octal
2047
2048 A number in base 8.  Only the digits 0 through 7 are allowed.  Octal
2049 constants in Perl start with 0, as in 013.  See also the
2050 L<oct|perlfunc/oct> function.
2051
2052 =item offset
2053
2054 How many things you have to skip over when moving from the beginning
2055 of a string or array to a specific position within it.  Thus, the
2056 minimum offset is zero, not one, because you don't skip anything to
2057 get to the first item.
2058
2059 =item one-liner
2060
2061 An entire computer program crammed into one line of text.
2062
2063 =item open source software
2064
2065 Programs for which the source code is freely available and freely
2066 redistributable, with no commercial strings attached.  For a more
2067 detailed definition, see L<http://www.opensource.org/osd.html>.
2068
2069 =item operand
2070
2071 An L</expression> that yields a L</value> that an L</operator>
2072 operates on.  See also L</precedence>.
2073
2074 =item operating system
2075
2076 A special program that runs on the bare machine and hides the gory
2077 details of managing L<processes|/process> and L<devices|/device>.
2078 Usually used in a looser sense to indicate a particular culture of
2079 programming.  The loose sense can be used at varying levels of
2080 specificity.  At one extreme, you might say that all versions of Unix
2081 and Unix-lookalikes are the same operating system (upsetting many
2082 people, especially lawyers and other advocates).  At the other
2083 extreme, you could say this particular version of this particular
2084 vendor's operating system is different from any other version of this
2085 or any other vendor's operating system.  Perl is much more portable
2086 across operating systems than many other languages.  See also
2087 L</architecture> and L</platform>.
2088
2089 =item operator
2090
2091 A gizmo that transforms some number of input values to some number of
2092 output values, often built into a language with a special syntax or
2093 symbol.  A given operator may have specific expectations about what
2094 L<types|/type> of data you give as its arguments
2095 (L<operands|/operand>) and what type of data you want back from it.
2096
2097 =item operator overloading
2098
2099 A kind of L</overloading> that you can do on built-in
2100 L<operators|/operator> to make them work on L<objects|/object> as if
2101 the objects were ordinary scalar values, but with the actual semantics
2102 supplied by the object class.  This is set up with the L<overload>
2103 L</pragma>.
2104
2105 =item options
2106
2107 See either L<switches|/switch> or L</regular expression modifier>.
2108
2109 =item overloading
2110
2111 Giving additional meanings to a symbol or construct.  Actually, all
2112 languages do overloading to one extent or another, since people are
2113 good at figuring out things from L</context>.
2114
2115 =item overriding
2116
2117 Hiding or invalidating some other definition of the same name.  (Not
2118 to be confused with L</overloading>, which adds definitions that must
2119 be disambiguated some other way.) To confuse the issue further, we use
2120 the word with two overloaded definitions: to describe how you can
2121 define your own L</subroutine> to hide a built-in L</function> of the
2122 same name (see L<perlsub/Overriding Built-in Functions>) and to
2123 describe how you can define a replacement L</method> in a L</derived
2124 class> to hide a L</base class>'s method of the same name (see
2125 L<perlobj>).
2126
2127 =item owner
2128
2129 The one user (apart from the superuser) who has absolute control over
2130 a L</file>.  A file may also have a L</group> of users who may
2131 exercise joint ownership if the real owner permits it.  See
2132 L</permission bits>.
2133
2134 =back
2135
2136 =head2 P
2137
2138 =over 4
2139
2140 =item package
2141
2142 A L</namespace> for global L<variables|/variable>,
2143 L<subroutines|/subroutine>, and the like, such that they can be kept
2144 separate from like-named L<symbols|/symbol> in other namespaces.  In a
2145 sense, only the package is global, since the symbols in the package's
2146 symbol table are only accessible from code compiled outside the
2147 package by naming the package.  But in another sense, all package
2148 symbols are also globals--they're just well-organized globals.
2149
2150 =item pad
2151
2152 Short for L</scratchpad>.
2153
2154 =item parameter
2155
2156 See L</argument>.
2157
2158 =item parent class
2159
2160 See L</base class>.
2161
2162 =item parse tree
2163
2164 See L</syntax tree>.
2165
2166 =item parsing
2167
2168 The subtle but sometimes brutal art of attempting to turn your
2169 possibly malformed program into a valid L</syntax tree>.
2170
2171 =item patch
2172
2173 To fix by applying one, as it were.  In the realm of hackerdom, a
2174 listing of the differences between two versions of a program as might
2175 be applied by the I<patch>(1) program when you want to fix a bug or
2176 upgrade your old version.
2177
2178 =item PATH
2179
2180 The list of L<directories|/directory> the system searches to find a
2181 program you want to L</execute>.  The list is stored as one of your
2182 L<environment variables|/environment variable>, accessible in Perl as
2183 C<$ENV{PATH}>.
2184
2185 =item pathname
2186
2187 A fully qualified filename such as I</usr/bin/perl>.  Sometimes
2188 confused with L</PATH>.
2189
2190 =item pattern
2191
2192 A template used in L</pattern matching>.
2193
2194 =item pattern matching
2195
2196 Taking a pattern, usually a L</regular expression>, and trying the
2197 pattern various ways on a string to see whether there's any way to
2198 make it fit.  Often used to pick interesting tidbits out of a file.
2199
2200 =item permission bits
2201
2202 Bits that the L</owner> of a file sets or unsets to allow or disallow
2203 access to other people.  These flag bits are part of the L</mode> word
2204 returned by the L<stat|perlfunc/stat> built-in when you ask about a
2205 file.  On Unix systems, you can check the I<ls>(1) manpage for more
2206 information.
2207
2208 =item Pern
2209
2210 What you get when you do C<Perl++> twice.  Doing it only once will
2211 curl your hair.  You have to increment it eight times to shampoo your
2212 hair.  Lather, rinse, iterate.
2213
2214 =item pipe
2215
2216 A direct L</connection> that carries the output of one L</process> to
2217 the input of another without an intermediate temporary file.  Once the
2218 pipe is set up, the two processes in question can read and write as if
2219 they were talking to a normal file, with some caveats.
2220
2221 =item pipeline
2222
2223 A series of L<processes|/process> all in a row, linked by
2224 L<pipes|/pipe>, where each passes its output stream to the next.
2225
2226 =item platform
2227
2228 The entire hardware and software context in which a program runs.  A
2229  program written in a platform-dependent language might break if you
2230 change any of: machine, operating system, libraries, compiler, or
2231 system configuration.  The I<perl> interpreter has to be compiled
2232 differently for each platform because it is implemented in C, but
2233 programs written in the Perl language are largely
2234 platform-independent.
2235
2236 =item pod
2237
2238 The markup used to embed documentation into your Perl code.  See
2239 L<perlpod>.
2240
2241 =item pointer
2242
2243 A L</variable> in a language like C that contains the exact memory
2244 location of some other item.  Perl handles pointers internally so you
2245 don't have to worry about them.  Instead, you just use symbolic
2246 pointers in the form of L<keys|/key> and L</variable> names, or L<hard
2247 references|/hard reference>, which aren't pointers (but act like
2248 pointers and do in fact contain pointers).
2249
2250 =item polymorphism
2251
2252 The notion that you can tell an L</object> to do something generic,
2253 and the object will interpret the command in different ways depending
2254 on its type.  [E<lt>Gk many shapes]
2255
2256 =item port
2257
2258 The part of the address of a TCP or UDP socket that directs packets to
2259 the correct process after finding the right machine, something like
2260 the phone extension you give when you reach the company operator.
2261 Also, the result of converting code to run on a different platform
2262 than originally intended, or the verb denoting this conversion.
2263
2264 =item portable
2265
2266 Once upon a time, C code compilable under both BSD and SysV.  In
2267 general, code that can be easily converted to run on another
2268 L</platform>, where "easily" can be defined however you like, and
2269 usually is.  Anything may be considered portable if you try hard
2270 enough.  See I<mobile home> or I<London Bridge>.
2271
2272 =item porter
2273
2274 Someone who "carries" software from one L</platform> to another.
2275 Porting programs written in platform-dependent languages such as C can
2276 be difficult work, but porting programs like Perl is very much worth
2277 the agony.
2278
2279 =item POSIX
2280
2281 The Portable Operating System Interface specification.
2282
2283 =item postfix
2284
2285 An L</operator> that follows its L</operand>, as in C<$x++>.
2286
2287 =item pp
2288
2289 An internal shorthand for a "push-pop" code, that is, C code
2290 implementing Perl's stack machine.
2291
2292 =item pragma
2293
2294 A standard module whose practical hints and suggestions are received
2295 (and possibly ignored) at compile time.  Pragmas are named in all
2296 lowercase.
2297
2298 =item precedence
2299
2300 The rules of conduct that, in the absence of other guidance, determine
2301 what should happen first.  For example, in the absence of parentheses,
2302 you always do multiplication before addition.
2303
2304 =item prefix
2305
2306 An L</operator> that precedes its L</operand>, as in C<++$x>.
2307
2308 =item preprocessing
2309
2310 What some helper L</process> did to transform the incoming data into a
2311 form more suitable for the current process.  Often done with an
2312 incoming L</pipe>.  See also L</C preprocessor>.
2313
2314 =item procedure
2315
2316 A L</subroutine>.
2317
2318 =item process
2319
2320 An instance of a running program.  Under multitasking systems like
2321 Unix, two or more separate processes could be running the same program
2322 independently at the same time--in fact, the L<fork|perlfunc/fork>
2323 function is designed to bring about this happy state of affairs.
2324 Under other operating systems, processes are sometimes called
2325 "threads", "tasks", or "jobs", often with slight nuances in meaning.
2326
2327 =item program generator
2328
2329 A system that algorithmically writes code for you in a high-level
2330 language.  See also L</code generator>.
2331
2332 =item progressive matching
2333
2334 L<Pattern matching|/pattern matching> that picks up where it left off before.
2335
2336 =item property
2337
2338 See either L</instance variable> or L</character property>.
2339
2340 =item protocol
2341
2342 In networking, an agreed-upon way of sending messages back and forth
2343 so that neither correspondent will get too confused.
2344
2345 =item prototype
2346
2347 An optional part of a L</subroutine> declaration telling the Perl
2348 compiler how many and what flavor of arguments may be passed as
2349 L</actual arguments>, so that you can write subroutine calls that
2350 parse much like built-in functions.  (Or don't parse, as the case may
2351 be.)
2352
2353 =item pseudofunction
2354
2355 A construct that sometimes looks like a function but really isn't.
2356 Usually reserved for L</lvalue> modifiers like L<my|perlfunc/my>, for
2357 L</context> modifiers like L<scalar|perlfunc/scalar>, and for the
2358 pick-your-own-quotes constructs, C<q//>, C<qq//>, C<qx//>, C<qw//>,
2359 C<qr//>, C<m//>, C<s///>, C<y///>, and C<tr///>.
2360
2361 =item pseudohash
2362
2363 A reference to an array whose initial element happens to hold a
2364 reference to a hash.  You can treat a pseudohash reference as either
2365 an array reference or a hash reference.
2366
2367 =item pseudoliteral
2368
2369 An L</operator> that looks something like a L</literal>, such as the
2370 output-grabbing operator, C<`>I<C<command>>C<`>.
2371
2372 =item public domain
2373
2374 Something not owned by anybody.  Perl is copyrighted and is thus
2375 I<not> in the public domain--it's just L</freely available> and
2376 L</freely redistributable>.
2377
2378 =item pumpkin
2379
2380 A notional "baton" handed around the Perl community indicating who is
2381 the lead integrator in some arena of development.
2382
2383 =item pumpking
2384
2385 A L</pumpkin> holder, the person in charge of pumping the pump, or at
2386 least priming it.  Must be willing to play the part of the Great
2387 Pumpkin now and then.
2388
2389 =item PV
2390
2391 A "pointer value", which is Perl Internals Talk for a C<char*>.
2392
2393 =back
2394
2395 =head2 Q
2396
2397 =over 4
2398
2399 =item qualified
2400
2401 Possessing a complete name.  The symbol C<$Ent::moot> is qualified;
2402 C<$moot> is unqualified.  A fully qualified filename is specified from
2403 the top-level directory.
2404
2405 =item quantifier
2406
2407 A component of a L</regular expression> specifying how many times the
2408 foregoing L</atom> may occur.
2409
2410 =back
2411
2412 =head2 R
2413
2414 =over 4
2415
2416 =item readable
2417
2418 With respect to files, one that has the proper permission bit set to
2419 let you access the file.  With respect to computer programs, one
2420 that's written well enough that someone has a chance of figuring out
2421 what it's trying to do.
2422
2423 =item reaping
2424
2425 The last rites performed by a parent L</process> on behalf of a
2426 deceased child process so that it doesn't remain a L</zombie>.  See
2427 the L<wait|perlfunc/wait> and L<waitpid|perlfunc/waitpid> function
2428 calls.
2429
2430 =item record
2431
2432 A set of related data values in a L</file> or L</stream>, often
2433 associated with a unique L</key> field.  In Unix, often commensurate
2434 with a L</line>, or a blank-line-terminated set of lines (a
2435 "paragraph").  Each line of the I</etc/passwd> file is a record, keyed
2436 on login name, containing information about that user.
2437
2438 =item recursion
2439
2440 The art of defining something (at least partly) in terms of itself,
2441 which is a naughty no-no in dictionaries but often works out okay in
2442 computer programs if you're careful not to recurse forever, which is
2443 like an infinite loop with more spectacular failure modes.
2444
2445 =item reference
2446
2447 Where you look to find a pointer to information somewhere else.  (See
2448 L</indirection>.)  References come in two flavors, L<symbolic
2449 references|/symbolic reference> and L<hard references|/hard
2450 reference>.
2451
2452 =item referent
2453
2454 Whatever a reference refers to, which may or may not have a name.
2455 Common types of referents include scalars, arrays, hashes, and
2456 subroutines.
2457
2458 =item regex
2459
2460 See L</regular expression>.
2461
2462 =item regular expression
2463
2464 A single entity with various interpretations, like an elephant.  To a
2465 computer scientist, it's a grammar for a little language in which some
2466 strings are legal and others aren't.  To normal people, it's a pattern
2467 you can use to find what you're looking for when it varies from case
2468 to case.  Perl's regular expressions are far from regular in the
2469 theoretical sense, but in regular use they work quite well.  Here's a
2470 regular expression: C</Oh s.*t./>.  This will match strings like "C<Oh
2471 say can you see by the dawn's early light>" and "C<Oh sit!>".  See
2472 L<perlre>.
2473
2474 =item regular expression modifier
2475
2476 An option on a pattern or substitution, such as C</i> to render the
2477 pattern case insensitive.  See also L</cloister>.
2478
2479 =item regular file
2480
2481 A L</file> that's not a L</directory>, a L</device>, a named L</pipe>
2482 or L</socket>, or a L</symbolic link>.  Perl uses the C<-f> file test
2483 operator to identify regular files.  Sometimes called a "plain" file.
2484
2485 =item relational operator
2486
2487 An L</operator> that says whether a particular ordering relationship
2488 is L</true> about a pair of L<operands|/operand>.  Perl has both
2489 numeric and string relational operators.  See L</collating sequence>.
2490
2491 =item reserved words
2492
2493 A word with a specific, built-in meaning to a L</compiler>, such as
2494 C<if> or L<delete|perlfunc/delete>.  In many languages (not Perl),
2495 it's illegal to use reserved words to name anything else.  (Which is
2496 why they're reserved, after all.)  In Perl, you just can't use them to
2497 name L<labels|/label> or L<filehandles|/filehandle>.  Also called
2498 "keywords".
2499
2500 =item return value
2501
2502 The L</value> produced by a L</subroutine> or L</expression> when
2503 evaluated.  In Perl, a return value may be either a L</list> or a
2504 L</scalar>.
2505
2506 =item RFC
2507
2508 Request For Comment, which despite the timid connotations is the name
2509 of a series of important standards documents.
2510
2511 =item right shift
2512
2513 A L</bit shift> that divides a number by some power of 2.
2514
2515 =item root
2516
2517 The superuser (UID == 0).  Also, the top-level directory of the
2518 filesystem.
2519
2520 =item RTFM
2521
2522 What you are told when someone thinks you should Read The Fine Manual.
2523
2524 =item run phase
2525
2526 Any time after Perl starts running your main program.  See also
2527 L</compile phase>.  Run phase is mostly spent in L</run time> but may
2528 also be spent in L</compile time> when L<require|perlfunc/require>,
2529 L<do|perlfunc/do> C<FILE>, or L<eval|perlfunc/eval> C<STRING>
2530 operators are executed or when a substitution uses the C</ee>
2531 modifier.
2532
2533 =item run time
2534
2535 The time when Perl is actually doing what your code says to do, as
2536 opposed to the earlier period of time when it was trying to figure out
2537 whether what you said made any sense whatsoever, which is L</compile
2538 time>.
2539
2540 =item run-time pattern
2541
2542 A pattern that contains one or more variables to be interpolated
2543 before parsing the pattern as a L</regular expression>, and that
2544 therefore cannot be analyzed at compile time, but must be re-analyzed
2545 each time the pattern match operator is evaluated.  Run-time patterns
2546 are useful but expensive.
2547
2548 =item RV
2549
2550 A recreational vehicle, not to be confused with vehicular recreation.
2551 RV also means an internal Reference Value of the type a L</scalar> can
2552 hold.  See also L</IV> and L</NV> if you're not confused yet.
2553
2554 =item rvalue
2555
2556 A L</value> that you might find on the right side of an
2557 L</assignment>.  See also L</lvalue>.
2558
2559 =back
2560
2561 =head2 S
2562
2563 =over 4
2564
2565 =item scalar
2566
2567 A simple, singular value; a number, L</string>, or L</reference>.
2568
2569 =item scalar context
2570
2571 The situation in which an L</expression> is expected by its
2572 surroundings (the code calling it) to return a single L</value> rather
2573 than a L</list> of values.  See also L</context> and L</list context>.
2574 A scalar context sometimes imposes additional constraints on the
2575 return value--see L</string context> and L</numeric context>.
2576 Sometimes we talk about a L</Boolean context> inside conditionals, but
2577 this imposes no additional constraints, since any scalar value,
2578 whether numeric or L</string>, is already true or false.
2579
2580 =item scalar literal
2581
2582 A number or quoted L</string>--an actual L</value> in the text of your
2583 program, as opposed to a L</variable>.
2584
2585 =item scalar value
2586
2587 A value that happens to be a L</scalar> as opposed to a L</list>.
2588
2589 =item scalar variable
2590
2591 A L</variable> prefixed with C<$> that holds a single value.
2592
2593 =item scope
2594
2595 How far away you can see a variable from, looking through one.  Perl
2596 has two visibility mechanisms: it does L</dynamic scoping> of
2597 L<local|perlfunc/local> L<variables|/variable>, meaning that the rest
2598 of the L</block>, and any L<subroutines|/subroutine> that are called
2599 by the rest of the block, can see the variables that are local to the
2600 block.  Perl does L</lexical scoping> of L<my|perlfunc/my> variables,
2601 meaning that the rest of the block can see the variable, but other
2602 subroutines called by the block I<cannot> see the variable.
2603
2604 =item scratchpad
2605
2606 The area in which a particular invocation of a particular file or
2607 subroutine keeps some of its temporary values, including any lexically
2608 scoped variables.
2609
2610 =item script
2611
2612 A text L</file> that is a program intended to be L<executed|/execute>
2613 directly rather than L<compiled|/compiler> to another form of file
2614 before execution.  Also, in the context of L</Unicode>, a writing
2615 system for a particular language or group of languages, such as Greek,
2616 Bengali, or Klingon.
2617
2618 =item script kiddie
2619
2620 A L</cracker> who is not a L</hacker>, but knows just enough to run
2621 canned scripts.  A cargo-cult programmer.
2622
2623 =item sed
2624
2625 A venerable Stream EDitor from which Perl derives some of its ideas.
2626
2627 =item semaphore
2628
2629 A fancy kind of interlock that prevents multiple L<threads|/thread> or
2630 L<processes|/process> from using up the same resources simultaneously.
2631
2632 =item separator
2633
2634 A L</character> or L</string> that keeps two surrounding strings from
2635 being confused with each other.  The L<split|perlfunc/split> function
2636 works on separators.  Not to be confused with L<delimiters|/delimiter>
2637 or L<terminators|/terminator>.  The "or" in the previous sentence
2638 separated the two alternatives.
2639
2640 =item serialization
2641
2642 Putting a fancy L</data structure> into linear order so that it can be
2643 stored as a L</string> in a disk file or database or sent through a
2644 L</pipe>.  Also called marshalling.
2645
2646 =item server
2647
2648 In networking, a L</process> that either advertises a L</service> or
2649 just hangs around at a known location and waits for L<clients|/client>
2650 who need service to get in touch with it.
2651
2652 =item service
2653
2654 Something you do for someone else to make them happy, like giving them
2655 the time of day (or of their life).  On some machines, well-known
2656 services are listed by the L<getservent|perlfunc/getservent> function.
2657
2658 =item setgid
2659
2660 Same as L</setuid>, only having to do with giving away L</group>
2661 privileges.
2662
2663 =item setuid
2664
2665 Said of a program that runs with the privileges of its L</owner>
2666 rather than (as is usually the case) the privileges of whoever is
2667 running it.  Also describes the bit in the mode word (L</permission
2668 bits>) that controls the feature.  This bit must be explicitly set by
2669 the owner to enable this feature, and the program must be carefully
2670 written not to give away more privileges than it ought to.
2671
2672 =item shared memory
2673
2674 A piece of L</memory> accessible by two different
2675 L<processes|/process> who otherwise would not see each other's memory.
2676
2677 =item shebang
2678
2679 Irish for the whole McGillicuddy.  In Perl culture, a portmanteau of
2680 "sharp" and "bang", meaning the C<#!> sequence that tells the system
2681 where to find the interpreter.
2682
2683 =item shell
2684
2685 A L</command>-line L</interpreter>.  The program that interactively
2686 gives you a prompt, accepts one or more L<lines|/line> of input, and
2687 executes the programs you mentioned, feeding each of them their proper
2688 L<arguments|/argument> and input data.  Shells can also execute
2689 scripts containing such commands.  Under Unix, typical shells include
2690 the Bourne shell (I</bin/sh>), the C shell (I</bin/csh>), and the Korn
2691 shell (I</bin/ksh>).  Perl is not strictly a shell because it's not
2692 interactive (although Perl programs can be interactive).
2693
2694 =item side effects
2695
2696 Something extra that happens when you evaluate an L</expression>.
2697 Nowadays it can refer to almost anything.  For example, evaluating a
2698 simple assignment statement typically has the "side effect" of
2699 assigning a value to a variable.  (And you thought assigning the value
2700 was your primary intent in the first place!)  Likewise, assigning a
2701 value to the special variable C<$|> (C<$AUTOFLUSH>) has the side
2702 effect of forcing a flush after every L<write|perlfunc/write> or
2703 L<print|perlfunc/print> on the currently selected filehandle.
2704
2705 =item signal
2706
2707 A bolt out of the blue; that is, an event triggered by the
2708 L</operating system>, probably when you're least expecting it.
2709
2710 =item signal handler
2711
2712 A L</subroutine> that, instead of being content to be called in the
2713 normal fashion, sits around waiting for a bolt out of the blue before
2714 it will deign to L</execute>.  Under Perl, bolts out of the blue are
2715 called signals, and you send them with the L<kill|perlfunc/kill>
2716 built-in.  See L<perlvar/%SIG> and L<perlipc/Signals>.
2717
2718 =item single inheritance
2719
2720 The features you got from your mother, if she told you that you don't
2721 have a father.  (See also L</inheritance> and L</multiple
2722 inheritance>.)  In computer languages, the notion that
2723 L<classes|/class> reproduce asexually so that a given class can only
2724 have one direct ancestor or L</base class>.  Perl supplies no such
2725 restriction, though you may certainly program Perl that way if you
2726 like.
2727
2728 =item slice
2729
2730 A selection of any number of L<elements|/element> from a L</list>,
2731 L</array>, or L</hash>.
2732
2733 =item slurp
2734
2735 To read an entire L</file> into a L</string> in one operation.
2736
2737 =item socket
2738
2739 An endpoint for network communication among multiple
2740 L<processes|/process> that works much like a telephone or a post
2741 office box.  The most important thing about a socket is its L</network
2742 address> (like a phone number).  Different kinds of sockets have
2743 different kinds of addresses--some look like filenames, and some
2744 don't.
2745
2746 =item soft reference
2747
2748 See L</symbolic reference>.
2749
2750 =item source filter
2751
2752 A special kind of L</module> that does L</preprocessing> on your
2753 script just before it gets to the L</tokener>.
2754
2755 =item stack
2756
2757 A device you can put things on the top of, and later take them back
2758 off in the opposite order in which you put them on.  See L</LIFO>.
2759
2760 =item standard
2761
2762 Included in the official Perl distribution, as in a standard module, a
2763 standard tool, or a standard Perl L</manpage>.
2764
2765 =item standard error
2766
2767 The default output L</stream> for nasty remarks that don't belong in
2768 L</standard output>.  Represented within a Perl program by the
2769 L</filehandle> L</STDERR>.  You can use this stream explicitly, but the
2770 L<die|perlfunc/die> and L<warn|perlfunc/warn> built-ins write to your
2771 standard error stream automatically.
2772
2773 =item standard I/O
2774
2775 A standard C library for doing L<buffered|/buffer> input and output to
2776 the L</operating system>.  (The "standard" of standard I/O is only
2777 marginally related to the "standard" of standard input and output.)
2778 In general, Perl relies on whatever implementation of standard I/O a
2779 given operating system supplies, so the buffering characteristics of a
2780 Perl program on one machine may not exactly match those on another
2781 machine.  Normally this only influences efficiency, not semantics.  If
2782 your standard I/O package is doing block buffering and you want it to
2783 L</flush> the buffer more often, just set the C<$|> variable to a true
2784 value.
2785
2786 =item standard input
2787
2788 The default input L</stream> for your program, which if possible
2789 shouldn't care where its data is coming from.  Represented within a
2790 Perl program by the L</filehandle> L</STDIN>.
2791
2792 =item standard output
2793
2794 The default output L</stream> for your program, which if possible
2795 shouldn't care where its data is going.  Represented within a Perl
2796 program by the L</filehandle> L</STDOUT>.
2797
2798 =item stat structure
2799
2800 A special internal spot in which Perl keeps the information about the
2801 last L</file> on which you requested information.
2802
2803 =item statement
2804
2805 A L</command> to the computer about what to do next, like a step in a
2806 recipe: "Add marmalade to batter and mix until mixed."  A statement is
2807 distinguished from a L</declaration>, which doesn't tell the computer
2808 to do anything, but just to learn something.
2809
2810 =item statement modifier
2811
2812 A L</conditional> or L</loop> that you put after the L</statement>
2813 instead of before, if you know what we mean.
2814
2815 =item static
2816
2817 Varying slowly compared to something else.  (Unfortunately, everything
2818 is relatively stable compared to something else, except for certain
2819 elementary particles, and we're not so sure about them.)  In
2820 computers, where things are supposed to vary rapidly, "static" has a
2821 derogatory connotation, indicating a slightly dysfunctional
2822 L</variable>, L</subroutine>, or L</method>.  In Perl culture, the
2823 word is politely avoided.
2824
2825 =item static method
2826
2827 No such thing.  See L</class method>.
2828
2829 =item static scoping
2830
2831 No such thing.  See L</lexical scoping>.
2832
2833 =item static variable
2834
2835 No such thing.  Just use a L</lexical variable> in a scope larger than
2836 your L</subroutine>.
2837
2838 =item status
2839
2840 The L</value> returned to the parent L</process> when one of its child
2841 processes dies.  This value is placed in the special variable C<$?>.
2842 Its upper eight L<bits|/bit> are the exit status of the defunct
2843 process, and its lower eight bits identify the signal (if any) that
2844 the process died from.  On Unix systems, this status value is the same
2845 as the status word returned by I<wait>(2).  See L<perlfunc/system>.
2846
2847 =item STDERR
2848
2849 See L</standard error>.
2850
2851 =item STDIN
2852
2853 See L</standard input>.
2854
2855 =item STDIO
2856
2857 See L</standard IE<sol>O>.
2858
2859 =item STDOUT
2860
2861 See L</standard output>.
2862
2863 =item stream
2864
2865 A flow of data into or out of a process as a steady sequence of bytes
2866 or characters, without the appearance of being broken up into packets.
2867 This is a kind of L</interface>--the underlying L</implementation> may
2868 well break your data up into separate packets for delivery, but this
2869 is hidden from you.
2870
2871 =item string
2872
2873 A sequence of characters such as "He said !@#*&%@#*?!".  A string does
2874 not have to be entirely printable.
2875
2876 =item string context
2877
2878 The situation in which an expression is expected by its surroundings
2879 (the code calling it) to return a L</string>.  See also L</context>
2880 and L</numeric context>.
2881
2882 =item stringification
2883
2884 The process of producing a L</string> representation of an abstract
2885 object.
2886
2887 =item struct
2888
2889 C keyword introducing a structure definition or name.
2890
2891 =item structure
2892
2893 See L</data structure>.
2894
2895 =item subclass
2896
2897 See L</derived class>.
2898
2899 =item subpattern
2900
2901 A component of a L</regular expression> pattern.
2902
2903 =item subroutine
2904
2905 A named or otherwise accessible piece of program that can be invoked
2906 from elsewhere in the program in order to accomplish some sub-goal of
2907 the program.  A subroutine is often parameterized to accomplish
2908 different but related things depending on its input
2909 L<arguments|/argument>.  If the subroutine returns a meaningful
2910 L</value>, it is also called a L</function>.
2911
2912 =item subscript
2913
2914 A L</value> that indicates the position of a particular L</array>
2915 L</element> in an array.
2916
2917 =item substitution
2918
2919 Changing parts of a string via the C<s///> operator.  (We avoid use of
2920 this term to mean L</variable interpolation>.)
2921
2922 =item substring
2923
2924 A portion of a L</string>, starting at a certain L</character>
2925 position (L</offset>) and proceeding for a certain number of
2926 characters.
2927
2928 =item superclass
2929
2930 See L</base class>.
2931
2932 =item superuser
2933
2934 The person whom the L</operating system> will let do almost anything.
2935 Typically your system administrator or someone pretending to be your
2936 system administrator.  On Unix systems, the L</root> user.  On Windows
2937 systems, usually the Administrator user.
2938
2939 =item SV
2940
2941 Short for "scalar value".  But within the Perl interpreter every
2942 L</referent> is treated as a member of a class derived from SV, in an
2943 object-oriented sort of way.  Every L</value> inside Perl is passed
2944 around as a C language C<SV*> pointer.  The SV L</struct> knows its
2945 own "referent type", and the code is smart enough (we hope) not to try
2946 to call a L</hash> function on a L</subroutine>.
2947
2948 =item switch
2949
2950 An option you give on a command line to influence the way your program
2951 works, usually introduced with a minus sign.  The word is also used as
2952 a nickname for a L</switch statement>.
2953
2954 =item switch cluster
2955
2956 The combination of multiple command-line switches (e.g., B<-a -b -c>)
2957 into one switch (e.g., B<-abc>).  Any switch with an additional
2958 L</argument> must be the last switch in a cluster.
2959
2960 =item switch statement
2961
2962 A program technique that lets you evaluate an L</expression> and then,
2963 based on the value of the expression, do a multiway branch to the
2964 appropriate piece of code for that value.  Also called a "case
2965 structure", named after the similar Pascal construct.  Most switch
2966 statements in Perl are spelled C<for>.  See L<perlsyn/Basic BLOCKs and
2967 Switch Statements>.
2968
2969 =item symbol
2970
2971 Generally, any L</token> or L</metasymbol>.  Often used more
2972 specifically to mean the sort of name you might find in a L</symbol
2973 table>.
2974
2975 =item symbol table
2976
2977 Where a L</compiler> remembers symbols.  A program like Perl must
2978 somehow remember all the names of all the L<variables|/variable>,
2979 L<filehandles|/filehandle>, and L<subroutines|/subroutine> you've
2980 used.  It does this by placing the names in a symbol table, which is
2981 implemented in Perl using a L</hash table>.  There is a separate
2982 symbol table for each L</package> to give each package its own
2983 L</namespace>.
2984
2985 =item symbolic debugger
2986
2987 A program that lets you step through the L<execution|/execute> of your
2988 program, stopping or printing things out here and there to see whether
2989 anything has gone wrong, and if so, what.  The "symbolic" part just
2990 means that you can talk to the debugger using the same symbols with
2991 which your program is written.
2992
2993 =item symbolic link
2994
2995 An alternate filename that points to the real L</filename>, which in
2996 turn points to the real L</file>.  Whenever the L</operating system>
2997 is trying to parse a L</pathname> containing a symbolic link, it
2998 merely substitutes the new name and continues parsing.
2999
3000 =item symbolic reference
3001
3002 A variable whose value is the name of another variable or subroutine.
3003 By L<dereferencing|/dereference> the first variable, you can get at
3004 the second one.  Symbolic references are illegal under L<use strict
3005 'refs'|strict/strict refs>.
3006
3007 =item synchronous
3008
3009 Programming in which the orderly sequence of events can be determined;
3010 that is, when things happen one after the other, not at the same time.
3011
3012 =item syntactic sugar
3013
3014 An alternative way of writing something more easily; a shortcut.
3015
3016 =item syntax
3017
3018 From Greek, "with-arrangement".  How things (particularly symbols) are
3019 put together with each other.
3020
3021 =item syntax tree
3022
3023 An internal representation of your program wherein lower-level
3024 L<constructs|/construct> dangle off the higher-level constructs
3025 enclosing them.
3026
3027 =item syscall
3028
3029 A L</function> call directly to the L</operating system>.  Many of the
3030 important subroutines and functions you use aren't direct system
3031 calls, but are built up in one or more layers above the system call
3032 level.  In general, Perl programmers don't need to worry about the
3033 distinction.  However, if you do happen to know which Perl functions
3034 are really syscalls, you can predict which of these will set the C<$!>
3035 (C<$ERRNO>) variable on failure.  Unfortunately, beginning programmers
3036 often confusingly employ the term "system call" to mean what happens
3037 when you call the Perl L<system|perlfunc/system> function, which
3038 actually involves many syscalls.  To avoid any confusion, we nearly
3039 always use say "syscall" for something you could call indirectly via
3040 Perl's L<syscall|perlfunc/syscall> function, and never for something
3041 you would call with Perl's L<system|perlfunc/system> function.
3042
3043 =back
3044
3045 =head2 T
3046
3047 =over 4
3048
3049 =item tainted
3050
3051 Said of data derived from the grubby hands of a user and thus unsafe
3052 for a secure program to rely on.  Perl does taint checks if you run a
3053 L</setuid> (or L</setgid>) program, or if you use the B<-T> switch.
3054
3055 =item TCP
3056
3057 Short for Transmission Control Protocol.  A protocol wrapped around
3058 the Internet Protocol to make an unreliable packet transmission
3059 mechanism appear to the application program to be a reliable
3060 L</stream> of bytes.  (Usually.)
3061
3062 =item term
3063
3064 Short for a "terminal", that is, a leaf node of a L</syntax tree>.  A
3065 thing that functions grammatically as an L</operand> for the operators
3066 in an expression.
3067
3068 =item terminator
3069
3070 A L</character> or L</string> that marks the end of another string.
3071 The C<$/> variable contains the string that terminates a
3072 L<readline|perlfunc/readline> operation, which L<chomp|perlfunc/chomp>
3073 deletes from the end.  Not to be confused with
3074 L<delimiters|/delimiter> or L<separators|/separator>.  The period at
3075 the end of this sentence is a terminator.
3076
3077 =item ternary
3078
3079 An L</operator> taking three L<operands|/operand>.  Sometimes
3080 pronounced L</trinary>.
3081
3082 =item text
3083
3084 A L</string> or L</file> containing primarily printable characters.
3085
3086 =item thread
3087
3088 Like a forked process, but without L</fork>'s inherent memory
3089 protection.  A thread is lighter weight than a full process, in that a
3090 process could have multiple threads running around in it, all fighting
3091 over the same process's memory space unless steps are taken to protect
3092 threads from each other.  See L<threads>.
3093
3094 =item tie
3095
3096 The bond between a magical variable and its implementation class.  See
3097 L<perlfunc/tie> and L<perltie>.
3098
3099 =item TMTOWTDI
3100
3101 There's More Than One Way To Do It, the Perl Motto.  The notion that
3102 there can be more than one valid path to solving a programming problem
3103 in context.  (This doesn't mean that more ways are always better or
3104 that all possible paths are equally desirable--just that there need
3105 not be One True Way.)  Pronounced TimToady.
3106
3107 =item token
3108
3109 A morpheme in a programming language, the smallest unit of text with
3110 semantic significance.
3111
3112 =item tokener
3113
3114 A module that breaks a program text into a sequence of
3115 L<tokens|/token> for later analysis by a parser.
3116
3117 =item tokenizing
3118
3119 Splitting up a program text into L<tokens|/token>.  Also known as
3120 "lexing", in which case you get "lexemes" instead of tokens.
3121
3122 =item toolbox approach
3123
3124 The notion that, with a complete set of simple tools that work well
3125 together, you can build almost anything you want.  Which is fine if
3126 you're assembling a tricycle, but if you're building a defranishizing
3127 comboflux regurgalator, you really want your own machine shop in which
3128 to build special tools.  Perl is sort of a machine shop.
3129
3130 =item transliterate
3131
3132 To turn one string representation into another by mapping each
3133 character of the source string to its corresponding character in the
3134 result string.  See
3135 L<perlop/trE<sol>SEARCHLISTE<sol>REPLACEMENTLISTE<sol>cds>.
3136
3137 =item trigger
3138
3139 An event that causes a L</handler> to be run.
3140
3141 =item trinary
3142
3143 Not a stellar system with three stars, but an L</operator> taking
3144 three L<operands|/operand>.  Sometimes pronounced L</ternary>.
3145
3146 =item troff
3147
3148 A venerable typesetting language from which Perl derives the name of
3149 its C<$%> variable and which is secretly used in the production of
3150 Camel books.
3151
3152 =item true
3153
3154 Any scalar value that doesn't evaluate to 0 or C<"">.
3155
3156 =item truncating
3157
3158 Emptying a file of existing contents, either automatically when
3159 opening a file for writing or explicitly via the
3160 L<truncate|perlfunc/truncate> function.
3161
3162 =item type
3163
3164 See L</data type> and L</class>.
3165
3166 =item type casting
3167
3168 Converting data from one type to another.  C permits this.  Perl does
3169 not need it.  Nor want it.
3170
3171 =item typed lexical
3172
3173 A L</lexical variable> that is declared with a L</class> type: C<my
3174 Pony $bill>.
3175
3176 =item typedef
3177
3178 A type definition in the C language.
3179
3180 =item typeglob
3181
3182 Use of a single identifier, prefixed with C<*>.  For example, C<*name>
3183 stands for any or all of C<$name>, C<@name>, C<%name>, C<&name>, or
3184 just C<name>.  How you use it determines whether it is interpreted as
3185 all or only one of them.  See L<perldata/Typeglobs and Filehandles>.
3186
3187 =item typemap
3188
3189 A description of how C types may be transformed to and from Perl types
3190 within an L</extension> module written in L</XS>.
3191
3192 =back
3193
3194 =head2 U
3195
3196 =over 4
3197
3198 =item UDP
3199
3200 User Datagram Protocol, the typical way to send L<datagrams|/datagram>
3201 over the Internet.
3202
3203 =item UID
3204
3205 A user ID.  Often used in the context of L</file> or L</process>
3206 ownership.
3207
3208 =item umask
3209
3210 A mask of those L</permission bits> that should be forced off when
3211 creating files or directories, in order to establish a policy of whom
3212 you'll ordinarily deny access to.  See the L<umask|perlfunc/umask>
3213 function.
3214
3215 =item unary operator
3216
3217 An operator with only one L</operand>, like C<!> or
3218 L<chdir|perlfunc/chdir>.  Unary operators are usually prefix
3219 operators; that is, they precede their operand.  The C<++> and C<-->
3220 operators can be either prefix or postfix.  (Their position I<does>
3221 change their meanings.)
3222
3223 =item Unicode
3224
3225 A character set comprising all the major character sets of the world,
3226 more or less.  See L<perlunicode> and L<http://www.unicode.org>.
3227
3228 =item Unix
3229
3230 A very large and constantly evolving language with several alternative
3231 and largely incompatible syntaxes, in which anyone can define anything
3232 any way they choose, and usually do.  Speakers of this language think
3233 it's easy to learn because it's so easily twisted to one's own ends,
3234 but dialectical differences make tribal intercommunication nearly
3235 impossible, and travelers are often reduced to a pidgin-like subset of
3236 the language.  To be universally understood, a Unix shell programmer
3237 must spend years of study in the art.  Many have abandoned this
3238 discipline and now communicate via an Esperanto-like language called
3239 Perl.
3240
3241 In ancient times, Unix was also used to refer to some code that a
3242 couple of people at Bell Labs wrote to make use of a PDP-7 computer
3243 that wasn't doing much of anything else at the time.
3244
3245 =back
3246
3247 =head2 V
3248
3249 =over 4
3250
3251 =item value
3252
3253 An actual piece of data, in contrast to all the variables, references,
3254 keys, indexes, operators, and whatnot that you need to access the
3255 value.
3256
3257 =item variable
3258
3259 A named storage location that can hold any of various kinds of
3260 L</value>, as your program sees fit.
3261
3262 =item variable interpolation
3263
3264 The L</interpolation> of a scalar or array variable into a string.
3265
3266 =item variadic
3267
3268 Said of a L</function> that happily receives an indeterminate number
3269 of L</actual arguments>.
3270
3271 =item vector
3272
3273 Mathematical jargon for a list of L<scalar values|/scalar value>.
3274
3275 =item virtual
3276
3277 Providing the appearance of something without the reality, as in:
3278 virtual memory is not real memory.  (See also L</memory>.)  The
3279 opposite of "virtual" is "transparent", which means providing the
3280 reality of something without the appearance, as in: Perl handles the
3281 variable-length UTF-8 character encoding transparently.
3282
3283 =item void context
3284
3285 A form of L</scalar context> in which an L</expression> is not
3286 expected to return any L</value> at all and is evaluated for its
3287 L</side effects> alone.
3288
3289 =item v-string
3290
3291 A "version" or "vector" L</string> specified with a C<v> followed by a
3292 series of decimal integers in dot notation, for instance,
3293 C<v1.20.300.4000>.  Each number turns into a L</character> with the
3294 specified ordinal value.  (The C<v> is optional when there are at
3295 least three integers.)
3296
3297 =back
3298
3299 =head2 W
3300
3301 =over 4
3302
3303 =item warning
3304
3305 A message printed to the L</STDERR> stream to the effect that something
3306 might be wrong but isn't worth blowing up over.  See L<perlfunc/warn>
3307 and the L<warnings> pragma.
3308
3309 =item watch expression
3310
3311 An expression which, when its value changes, causes a breakpoint in
3312 the Perl debugger.
3313
3314 =item whitespace
3315
3316 A L</character> that moves your cursor but doesn't otherwise put
3317 anything on your screen.  Typically refers to any of: space, tab, line
3318 feed, carriage return, or form feed.
3319
3320 =item word
3321
3322 In normal "computerese", the piece of data of the size most
3323 efficiently handled by your computer, typically 32 bits or so, give or
3324 take a few powers of 2.  In Perl culture, it more often refers to an
3325 alphanumeric L</identifier> (including underscores), or to a string of
3326 nonwhitespace L<characters|/character> bounded by whitespace or string
3327 boundaries.
3328
3329 =item working directory
3330
3331 Your current L</directory>, from which relative pathnames are
3332 interpreted by the L</operating system>.  The operating system knows
3333 your current directory because you told it with a
3334 L<chdir|perlfunc/chdir> or because you started out in the place where
3335 your parent L</process> was when you were born.
3336
3337 =item wrapper
3338
3339 A program or subroutine that runs some other program or subroutine for
3340 you, modifying some of its input or output to better suit your
3341 purposes.
3342
3343 =item WYSIWYG
3344
3345 What You See Is What You Get.  Usually used when something that
3346 appears on the screen matches how it will eventually look, like Perl's
3347 L<format|perlfunc/format> declarations.  Also used to mean the
3348 opposite of magic because everything works exactly as it appears, as
3349 in the three-argument form of L<open|perlfunc/open>.
3350
3351 =back
3352
3353 =head2 X
3354
3355 =over 4
3356
3357 =item XS
3358
3359 An extraordinarily exported, expeditiously excellent, expressly
3360 eXternal Subroutine, executed in existing C or C++ or in an exciting
3361 new extension language called (exasperatingly) XS.  Examine L<perlxs>
3362 for the exact explanation or L<perlxstut> for an exemplary unexacting
3363 one.
3364
3365 =item XSUB
3366
3367 An external L</subroutine> defined in L</XS>.
3368
3369 =back
3370
3371 =head2 Y
3372
3373 =over 4
3374
3375 =item yacc
3376
3377 Yet Another Compiler Compiler.  A parser generator without which Perl
3378 probably would not have existed.  See the file I<perly.y> in the Perl
3379 source distribution.
3380
3381 =back
3382
3383 =head2 Z
3384
3385 =over 4
3386
3387 =item zero width
3388
3389 A subpattern L</assertion> matching the L</null string> between
3390 L<characters|/character>.
3391
3392 =item zombie
3393
3394 A process that has died (exited) but whose parent has not yet received
3395 proper notification of its demise by virtue of having called
3396 L<wait|perlfunc/wait> or L<waitpid|perlfunc/waitpid>.  If you
3397 L<fork|perlfunc/fork>, you must clean up after your child processes
3398 when they exit, or else the process table will fill up and your system
3399 administrator will Not Be Happy with you.
3400
3401 =back
3402
3403 =head1 AUTHOR AND COPYRIGHT
3404
3405 Based on the Glossary of Programming Perl, Third Edition,
3406 by Larry Wall, Tom Christiansen & Jon Orwant.
3407 Copyright (c) 2000, 1996, 1991 O'Reilly Media, Inc.
3408 This document may be distributed under the same terms as Perl itself.