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