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