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