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