Skip to content

HTTPS clone URL

Subversion checkout URL

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