3 perlglossary - Perl Glossary
7 A glossary of terms (technical and otherwise) used in the Perl documentation.
8 Other useful sources include the Free On-Line Dictionary of Computing
9 L<http://foldoc.doc.ic.ac.uk/foldoc/index.html>, the Jargon File
10 L<http://catb.org/~esr/jargon/>, and Wikipedia L<http://www.wikipedia.org/>.
16 =item accessor methods
18 A C<method> used to indirectly inspect or update an C<object>'s
19 state (its C<instance variable>s).
21 =item actual arguments
23 The C<scalar value>s that you supply to a C<function>
24 or C<subroutine> when you call it. For instance, when you call
25 C<power("puff")>, the string C<"puff"> is the actual argument. See
26 also C<argument> and C<formal arguments>.
28 =item address operator
30 Some languages work directly with the memory addresses of values, but
31 this can be like playing with fire. Perl provides a set of asbestos
32 gloves for handling all memory management. The closest to an address
33 operator in Perl is the backslash operator, but it gives you a C<hard
34 reference>, which is much safer than a memory address.
38 A well-defined sequence of steps, clearly enough explained that even a
39 computer could do them.
43 A nickname for something, which behaves in all ways as though you'd
44 used the original name instead of the nickname. Temporary aliases are
45 implicitly created in the loop variable for C<foreach> loops, in the
46 C<$_> variable for L<map|perlfunc/map> or L<grep|perlfunc/grep>
47 operators, in C<$a> and C<$b> during L<sort|perlfunc/sort>'s
48 comparison function, and in each element of C<@_> for the C<actual
49 arguments> of a subroutine call. Permanent aliases are explicitly
50 created in C<package>s by C<import>ing symbols or by
51 assignment to C<typeglob>s. Lexically scoped aliases for
52 package variables are explicitly created by the L<our|perlfunc/our>
57 A list of possible choices from which you may select only one, as in
58 "Would you like door A, B, or C?" Alternatives in regular expressions
59 are separated with a single vertical bar: C<|>. Alternatives in
60 normal Perl expressions are separated with a double vertical bar:
61 C<||>. Logical alternatives in C<Boolean> expressions are separated
62 with either C<||> or C<or>.
66 Used to describe a C<referent> that is not directly accessible
67 through a named C<variable>. Such a referent must be indirectly
68 accessible through at least one C<hard reference>. When the last
69 hard reference goes away, the anonymous referent is destroyed without
74 The kind of compluter you're working on, where one "kind" of computer
75 means all those computers sharing a compatible machine language.
76 Since Perl programs are (typically) simple text files, not executable
77 images, a Perl program is much less sensitive to the architecture it's
78 running on than programs in other languages, such as C, that are
79 compiled into machine code. See also C<platform> and C<operating
84 A piece of data supplied to a L<program|/executable file>,
85 C<subroutine>, C<function>, or C<method> to tell it what it's
86 supposed to do. Also called a "parameter".
90 The name of the array containing the C<argument> C<vector> from the
91 command line. If you use the empty C<E<lt>E<gt>> operator, C<ARGV> is
92 the name of both the C<filehandle> used to traverse the arguments and
93 the C<scalar> containing the name of the current input file.
95 =item arithmetical operator
97 A C<symbol> such as C<+> or C</> that tells Perl to do the arithmetic
98 you were supposed to learn in grade school.
102 An ordered sequence of C<value>s, stored such that you can
103 easily access any of the values using an integer C<subscript>
104 that specifies the value's C<offset> in the sequence.
108 An archaic expression for what is more correctly referred to as
113 The American Standard Code for Information Interchange (a 7-bit
114 character set adequate only for poorly representing English text).
115 Often used loosely to describe the lowest 128 values of the various
116 ISO-8859-X character sets, a bunch of mutually incompatible 8-bit
117 codes best described as half ASCII. See also C<Unicode>.
121 A component of a C<regular expression> that must be true for the
122 pattern to match but does not necessarily match any characters itself.
123 Often used specifically to mean a C<zero width> assertion.
127 An C<operator> whose assigned mission in life is to change the value
130 =item assignment operator
132 Either a regular C<assignment>, or a compound C<operator> composed
133 of an ordinary assignment and some other operator, that changes the
134 value of a variable in place, that is, relative to its old value. For
135 example, C<$a += 2> adds C<2> to C<$a>.
137 =item associative array
143 Determines whether you do the left C<operator> first or the right
144 C<operator> first when you have "A C<operator> B C<operator> C" and
145 the two operators are of the same precedence. Operators like C<+> are
146 left associative, while operators like C<**> are right associative.
147 See L<perlop> for a list of operators and their associativity.
151 Said of events or activities whose relative temporal ordering is
152 indeterminate because too many things are going on at once. Hence, an
153 asynchronous event is one you didn't know when to expect.
157 A C<regular expression> component potentially matching a
158 C<substring> containing one or more characters and treated as an
159 indivisible syntactic unit by any following C<quantifier>. (Contrast
160 with an C<assertion> that matches something of C<zero width> and may
163 =item atomic operation
165 When Democritus gave the word "atom" to the indivisible bits of
166 matter, he meant literally something that could not be cut: I<a->
167 (not) + I<tomos> (cuttable). An atomic operation is an action that
168 can't be interrupted, not one forbidden in a nuclear-free zone.
172 A new feature that allows the declaration of C<variable>s
173 and C<subroutine>s with modifiers as in C<sub foo : locked
174 method>. Also, another name for an C<instance variable> of an
179 A feature of C<operator overloading> of C<object>s, whereby
180 the behavior of certain C<operator>s can be reasonably
181 deduced using more fundamental operators. This assumes that the
182 overloaded operators will often have the same relationships as the
183 regular operators. See L<perlop>.
187 To add one to something automatically, hence the name of the the C<++>
188 operator. To instead subtract one from something automatically is
189 known as an "autodecrement".
193 To load on demand. (Also called "lazy" loading.) Specifically, to
194 call an C<AUTOLOAD> subroutine on behalf of an undefined subroutine.
198 To split a string automatically, as the B<-a> C<switch> does when
199 running under B<-p> or B<-n> in order to emulate C<awk>. (See also
200 the C<AutoSplit> module, which has nothing to do with the B<-a>
201 switch, but a lot to do with autoloading.)
203 =item autovivification
205 A Greco-Roman word meaning "to bring oneself to life". In Perl,
206 storage locations (C<lvalue>s) spontaneously generate
207 themselves as needed, including the creation of any C<hard reference>
208 values to point to the next level of storage. The assignment
209 C<$a[5][5][5][5][5] = "quintet"> potentially creates five scalar
210 storage locations, plus four references (in the first four scalar
211 locations) pointing to four new anonymous arrays (to hold the last
212 four scalar locations). But the point of autovivification is that you
213 don't have to worry about it.
217 Short for "array value", which refers to one of Perl's internal data
218 types that holds an C<array>. The C<AV> type is a subclass of
223 Descriptive editing term--short for "awkward". Also coincidentally
224 refers to a venerable text-processing language from which Perl derived
225 some of its high-level ideas.
233 A substring L<captured|/capturing> by a subpattern within
234 unadorned parentheses in a C<regex>. Backslashed decimal numbers
235 (C<\1>, C<\2>, etc.) later in the same pattern refer back to the
236 corresponding subpattern in the current match. Outside the pattern,
237 the numbered variables (C<$1>, C<$2>, etc.) continue to refer to these
238 same values, as long as the pattern was the last successful match of
239 the current dynamic scope.
243 The practice of saying, "If I had to do it all over, I'd do it
244 differently," and then actually going back and doing it all over
245 differently. Mathematically speaking, it's returning from an
246 unsuccessful recursion on a tree of possibilities. Perl backtracks
247 when it attempts to match patterns with a C<regular expression>, and
248 its earlier attempts don't pan out. See L<perlre/Backtracking>.
250 =item backward compatibility
252 Means you can still run your old program because we didn't break any
253 of the features or bugs it was relying on.
257 A word sufficiently ambiguous to be deemed illegal under C<use strict
258 'subs'>. In the absence of that stricture, a bareword is treated as
259 if quotes were around it.
263 A generic C<object> type; that is, a C<class> from which other, more
264 specific classes are derived genetically by C<inheritance>. Also
265 called a "superclass" by people who respect their ancestors.
269 From Swift: someone who eats eggs big end first. Also used of
270 computers that store the most significant C<byte> of a word at a
271 lower byte address than the least significant byte. Often considered
272 superior to little-endian machines. See also C<little-endian>.
276 Having to do with numbers represented in base 2. That means there's
277 basically two numbers, 0 and 1. Also used to describe a "non-text
278 file", presumably because such a file makes full use of all the binary
279 bits in its bytes. With the advent of C<Unicode>, this distinction,
280 already suspect, loses even more of its meaning.
282 =item binary operator
284 An C<operator> that takes two C<operand>s.
288 To assign a specific C<network address> to a C<socket>.
292 An integer in the range from 0 to 1, inclusive. The smallest possible
293 unit of information storage. An eighth of a C<byte> or of a dollar.
294 (The term "Pieces of Eight" comes from being able to split the old
295 Spanish dollar into 8 bits, each of which still counted for money.
296 That's why a 25-cent piece today is still "two bits".)
300 The movement of bits left or right in a computer word, which has the
301 effect of multiplying or dividing by a power of 2.
305 A sequence of C<bit>s that is actually being thought of as a
306 sequence of bits, for once.
310 In corporate life, to grant official approval to a thing, as in, "The
311 VP of Engineering has blessed our WebCruncher project." Similarly in
312 Perl, to grant official approval to a C<referent> so that it can
313 function as an C<object>, such as a WebCruncher object. See
318 What a C<process> does when it has to wait for something: "My process
319 blocked waiting for the disk." As an unrelated noun, it refers to a
320 large chunk of data, of a size that the C<operating system> likes to
321 deal with (normally a power of two such as 512 or 8192). Typically
322 refers to a chunk of data that's coming from or going to a disk file.
326 A syntactic construct consisting of a sequence of Perl
327 C<statement>s that is delimited by braces. The C<if> and
328 C<while> statements are defined in terms of C<BLOCK>s, for instance.
329 Sometimes we also say "block" to mean a lexical scope; that is, a
330 sequence of statements that act like a C<BLOCK>, such as within an
331 L<eval|perlfunc/eval> or a file, even though the statements aren't
334 =item block buffering
336 A method of making input and output efficient by passing one C<block>
337 at a time. By default, Perl does block buffering to disk files. See
338 C<buffer> and C<command buffering>.
342 A value that is either C<true> or C<false>.
344 =item Boolean context
346 A special kind of C<scalar context> used in conditionals to decide
347 whether the C<scalar value> returned by an expression is C<true> or
348 C<false>. Does not evaluate as either a string or a number. See
353 A spot in your program where you've told the debugger to stop
354 L<execution|/execute> so you can poke around and see whether anything
359 To send a C<datagram> to multiple destinations simultaneously.
363 A psychoactive drug, popular in the 80s, probably developed at
364 U. C. Berkeley or thereabouts. Similar in many ways to the
365 prescription-only medication called "System V", but infinitely more
366 useful. (Or, at least, more fun.) The full chemical name is
367 "Berkeley Standard Distribution".
371 A location in a C<hash table> containing (potentially) multiple
372 entries whose keys "hash" to the same hash value according to its hash
373 function. (As internal policy, you don't have to worry about it,
374 unless you're into internals, or policy.)
378 A temporary holding location for data. With C<block buffering>, the
379 data is passed on to its destination whenever the buffer is full.
380 With C<line buffering>, it's passed on whenever a complete line is
381 received. With C<command buffering>, it's passed every time you do a
382 L<print|perlfunc/print> command (or equivalent). If your output is
383 unbuffered, the system processes it one byte at a time without the use
384 of a holding area. This can be rather inefficient.
388 A C<function> that is predefined in the language. Even when hidden
389 by C<overriding>, you can always get at a built-in function by
390 L<qualifying|/qualified> its name with the C<CORE::> pseudo-package.
394 A group of related modules on C<CPAN>. (Also, sometimes refers to a
395 group of command-line switches grouped into one C<switch cluster>.)
399 A piece of data worth eight C<bit>s in most places.
403 A pidgin-like language spoken among 'droids when they don't wish to
404 reveal their orientation (see C<endian>). Named after some similar
405 languages spoken (for similar reasons) between compilers and
406 interpreters in the late 20th century. These languages are
407 characterized by representing everything as a
408 non-architecture-dependent sequence of bytes.
416 A language beloved by many for its inside-out C<type> definitions,
417 inscrutable C<precedence> rules, and heavy C<overloading> of the
418 function-call mechanism. (Well, actually, people first switched to C
419 because they found lowercase identifiers easier to read than upper.)
420 Perl is written in C, so it's not surprising that Perl borrowed a few
425 The typical C compiler's first pass, which processes lines beginning
426 with C<#> for conditional compilation and macro definition and does
427 various manipulations of the program text based on the current
428 definitions. Also known as I<cpp>(1).
430 =item call by reference
432 An C<argument>-passing mechanism in which the C<formal arguments>
433 refer directly to the C<actual arguments>, and the C<subroutine> can
434 change the actual arguments by changing the formal arguments. That
435 is, the formal argument is an C<alias> for the actual argument. See
436 also C<call by value>.
440 An C<argument>-passing mechanism in which the C<formal arguments>
441 refer to a copy of the C<actual arguments>, and the C<subroutine>
442 cannot change the actual arguments by changing the formal arguments.
443 See also C<call by reference>.
447 A C<handler> that you register with some other part of your program
448 in the hope that the other part of your program will C<trigger> your
449 handler when some event of interest transpires.
453 Reduced to a standard form to facilitate comparison.
457 The use of parentheses around a C<subpattern> in a C<regular
458 expression> to store the matched C<substring> as a C<backreference>.
459 (Captured strings are also returned as a list in C<list context>.)
463 A small integer representative of a unit of orthography.
464 Historically, characters were usually stored as fixed-width integers
465 (typically in a byte, or maybe two, depending on the character set),
466 but with the advent of UTF-8, characters are often stored in a
467 variable number of bytes depending on the size of the integer that
468 represents the character. Perl manages this transparently for you,
471 =item character class
473 A square-bracketed list of characters used in a C<regular expression>
474 to indicate that any character of the set may occur at a given point.
475 Loosely, any predefined set of characters so used.
477 =item character property
479 A predefined C<character class> matchable by the C<\p>
480 C<metasymbol>. Many standard properties are defined for C<Unicode>.
482 =item circumfix operator
484 An C<operator> that surrounds its C<operand>, like the angle
485 operator, or parentheses, or a hug.
489 A user-defined C<type>, implemented in Perl via a C<package> that
490 provides (either directly or by inheritance) C<method>s (that
491 is, C<subroutine>s) to handle C<instance>s of
492 the class (its C<object>s). See also C<inheritance>.
496 A C<method> whose C<invocant> is a C<package> name, not an
497 C<object> reference. A method associated with the class as a whole.
501 In networking, a C<process> that initiates contact with a C<server>
502 process in order to exchange data and perhaps receive a service.
506 A C<cluster> used to restrict the scope of a C<regular expression
511 An C<anonymous> subroutine that, when a reference to it is generated
512 at run time, keeps track of the identities of externally visible
513 C<lexical variable>s even after those lexical
514 variables have supposedly gone out of C<scope>. They're called
515 "closures" because this sort of behavior gives mathematicians a sense
520 A parenthesized C<subpattern> used to group parts of a C<regular
521 expression> into a single C<atom>.
525 The word returned by the L<ref|perlfunc/ref> function when you apply
526 it to a reference to a subroutine. See also C<CV>.
530 A system that writes code for you in a low-level language, such as
531 code to implement the backend of a compiler. See C<program
534 =item code subpattern
536 A C<regular expression> subpattern whose real purpose is to execute
537 some Perl code, for example, the C<(?{...})> and C<(??{...})>
540 =item collating sequence
542 The order into which C<character>s sort. This is used by
543 C<string> comparison routines to decide, for example, where in this
544 glossary to put "collating sequence".
548 In C<shell> programming, the syntactic combination of a program name
549 and its arguments. More loosely, anything you type to a shell (a
550 command interpreter) that starts it doing something. Even more
551 loosely, a Perl C<statement>, which might start with a C<label> and
552 typically ends with a semicolon.
554 =item command buffering
556 A mechanism in Perl that lets you store up the output of each Perl
557 C<command> and then flush it out as a single request to the
558 C<operating system>. It's enabled by setting the C<$|>
559 (C<$AUTOFLUSH>) variable to a true value. It's used when you don't
560 want data sitting around not going where it's supposed to, which may
561 happen because the default on a C<file> or C<pipe> is to use
566 The name of the program currently executing, as typed on the command
567 line. In C, the C<command> name is passed to the program as the
568 first command-line argument. In Perl, it comes in separately as
571 =item command-line arguments
573 The C<value>s you supply along with a program name when you
574 tell a C<shell> to execute a C<command>. These values are passed to
575 a Perl program through C<@ARGV>.
579 A remark that doesn't affect the meaning of the program. In Perl, a
580 comment is introduced by a C<#> character and continues to the end of
583 =item compilation unit
585 The C<file> (or C<string>, in the case of L<eval|perlfunc/eval>)
586 that is currently being compiled.
590 Any time before Perl starts running your main program. See also
591 C<run phase>. Compile phase is mostly spent in C<compile time>, but
592 may also be spent in C<run time> when C<BEGIN> blocks,
593 L<use|perlfunc/use> declarations, or constant subexpressions are being
594 evaluated. The startup and import code of any L<use|perlfunc/use>
595 declaration is also run during compile phase.
599 The time when Perl is trying to make sense of your code, as opposed to
600 when it thinks it knows what your code means and is merely trying to
601 do what it thinks your code says to do, which is C<run time>.
605 Strictly speaking, a program that munches up another program and spits
606 out yet another file containing the program in a "more executable"
607 form, typically containing native machine instructions. The I<perl>
608 program is not a compiler by this definition, but it does contain a
609 kind of compiler that takes a program and turns it into a more
610 executable form (C<syntax tree>s) within the I<perl>
611 process itself, which the C<interpreter> then interprets. There are,
612 however, extension C<module>s to get Perl to act more like a
613 "real" compiler. See L<O>.
617 A "constructor" for a C<referent> that isn't really an C<object>,
618 like an anonymous array or a hash (or a sonata, for that matter). For
619 example, a pair of braces acts as a composer for a hash, and a pair of
620 brackets acts as a composer for an array. See L<perlref/Making
625 The process of gluing one cat's nose to another cat's tail. Also, a
626 similar operation on two C<string>s.
630 Something "iffy". See C<Boolean context>.
634 In telephony, the temporary electrical circuit between the caller's
635 and the callee's phone. In networking, the same kind of temporary
636 circuit between a C<client> and a C<server>.
640 As a noun, a piece of syntax made up of smaller pieces. As a
641 transitive verb, to create an C<object> using a C<constructor>.
645 Any C<class method>, instance C<method>, or C<subroutine>
646 that composes, initializes, blesses, and returns an C<object>.
647 Sometimes we use the term loosely to mean a C<composer>.
651 The surroundings, or environment. The context given by the
652 surrounding code determines what kind of data a particular
653 C<expression> is expected to return. The three primary contexts are
654 C<list context>, C<scalar context>, and C<void context>. Scalar
655 context is sometimes subdivided into C<Boolean context>, C<numeric
656 context>, C<string context>, and C<void context>. There's also a
657 "don't care" scalar context (which is dealt with in Programming Perl,
658 Third Edition, Chapter 2, "Bits and Pieces" if you care).
662 The treatment of more than one physical C<line> as a single logical
663 line. C<Makefile> lines are continued by putting a backslash before
664 the C<newline>. Mail headers as defined by RFC 822 are continued by
665 putting a space or tab I<after> the newline. In general, lines in
666 Perl do not need any form of continuation mark, because C<whitespace>
667 (including newlines) is gleefully ignored. Usually.
671 The corpse of a C<process>, in the form of a file left in the
672 C<working directory> of the process, usually as a result of certain
673 kinds of fatal error.
677 The Comprehensive Perl Archive Network. (See L<perlfaq2/What modules and extensions are available for Perl? What is CPAN? What does CPANE<sol>srcE<sol>... mean?>).
681 Someone who breaks security on computer systems. A cracker may be a
682 true C<hacker> or only a C<script kiddie>.
684 =item current package
686 The C<package> in which the current statement is compiled. Scan
687 backwards in the text of your program through the current L<lexical
688 scope|/lexical scoping> or any enclosing lexical scopes till you find
689 a package declaration. That's your current package name.
691 =item current working directory
693 See C<working directory>.
695 =item currently selected output channel
697 The last C<filehandle> that was designated with
698 C<select(FILEHANDLE)>; C<STDOUT>, if no filehandle has been selected.
702 An internal "code value" typedef, holding a C<subroutine>. The C<CV>
703 type is a subclass of C<SV>.
709 =item dangling statement
711 A bare, single C<statement>, without any braces, hanging off an C<if>
712 or C<while> conditional. C allows them. Perl doesn't.
716 How your various pieces of data relate to each other and what shape
717 they make when you put them all together, as in a rectangular table or
718 a triangular-shaped tree.
722 A set of possible values, together with all the operations that know
723 how to deal with those values. For example, a numeric data type has a
724 certain set of numbers that you can work with and various mathematical
725 operations that you can do on the numbers but would make little sense
726 on, say, a string such as C<"Kilroy">. Strings have their own
727 operations, such as C<concatenation>. Compound types made of a
728 number of smaller pieces generally have operations to compose and
729 decompose them, and perhaps to rearrange them. An C<object>
730 that models things in the real world often has operations that
731 correspond to real activities. For instance, if you model an
732 elevator, your elevator object might have an C<open_door()>
737 A packet of data, such as a C<UDP> message, that (from the viewpoint
738 of the programs involved) can be sent independently over the network.
739 (In fact, all packets are sent independently at the C<IP> level, but
740 C<stream> protocols such as C<TCP> hide this from your program.)
744 Stands for "Data Base Management" routines, a set of routines that
745 emulate an C<associative array> using disk files. The routines use a
746 dynamic hashing scheme to locate any entry with only two disk
747 accesses. DBM files allow a Perl program to keep a persistent
748 C<hash> across multiple invocations. You can L<tie|perlfunc/tie>
749 your hash variables to various DBM implementations--see L<AnyDBM_File>
754 An C<assertion> that states something exists and perhaps describes
755 what it's like, without giving any commitment as to how or where
756 you'll use it. A declaration is like the part of your recipe that
757 says, "two cups flour, one large egg, four or five tadpoles..." See
758 C<statement> for its opposite. Note that some declarations also
759 function as statements. Subroutine declarations also act as
760 definitions if a body is supplied.
764 To subtract a value from a variable, as in "decrement C<$x>" (meaning
765 to remove 1 from its value) or "decrement C<$x> by 3".
769 A C<value> chosen for you if you don't supply a value of your own.
773 Having a meaning. Perl thinks that some of the things people try to
774 do are devoid of meaning, in particular, making use of variables that
775 have never been given a C<value> and performing certain operations on
776 data that isn't there. For example, if you try to read data past the
777 end of a file, Perl will hand you back an undefined value. See also
778 C<false> and L<perlfunc/defined>.
782 A C<character> or C<string> that sets bounds to an arbitrarily-sized
783 textual object, not to be confused with a C<separator> or
784 C<terminator>. "To delimit" really just means "to surround" or "to
785 enclose" (like these parentheses are doing).
789 A fancy computer science term meaning "to follow a C<reference> to
790 what it points to". The "de" part of it refers to the fact that
791 you're taking away one level of C<indirection>.
795 A C<class> that defines some of its C<method>s in terms of a
796 more generic class, called a C<base class>. Note that classes aren't
797 classified exclusively into base classes or derived classes: a class
798 can function as both a derived class and a base class simultaneously,
799 which is kind of classy.
803 See C<file descriptor>.
807 To deallocate the memory of a C<referent> (first triggering its
808 C<DESTROY> method, if it has one).
812 A special C<method> that is called when an C<object> is thinking
813 about C<destroy>ing itself. A Perl program's C<DESTROY>
814 method doesn't do the actual destruction; Perl just
815 C<trigger>s the method in case the C<class> wants to do any
820 A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a
821 joystick or a mouse) attached to your computer, that the C<operating
822 system> tries to make look like a C<file> (or a bunch of files).
823 Under Unix, these fake files tend to live in the I</dev> directory.
827 A C<pod> directive. See L<perlpod>.
831 A special file that contains other files. Some L<operating
832 systems|/operating system> call these "folders", "drawers", or
835 =item directory handle
837 A name that represents a particular instance of opening a directory to
838 read it, until you close it. See the L<opendir|perlfunc/opendir>
843 To send something to its correct destination. Often used
844 metaphorically to indicate a transfer of programmatic control to a
845 destination selected algorithmically, often by lookup in a table of
846 function C<reference>s or, in the case of object
847 C<method>s, by traversing the inheritance tree looking for the
848 most specific definition for the method.
852 A standard, bundled release of a system of software. The default
853 usage implies source code is included. If that is not the case, it
854 will be called a "binary-only" distribution.
858 An enchantment, illusion, phantasm, or jugglery. Said when Perl's
859 magical C<dwimmer> effects don't do what you expect, but rather seem
860 to be the product of arcane dweomercraft, sorcery, or wonder working.
865 DWIM is an acronym for "Do What I Mean", the principle that something
866 should just do what you want it to do without an undue amount of fuss.
867 A bit of code that does "dwimming" is a "dwimmer". Dwimming can
868 require a great deal of behind-the-scenes magic, which (if it doesn't
869 stay properly behind the scenes) is called a C<dweomer> instead.
871 =item dynamic scoping
873 Dynamic scoping works over a dynamic scope, making variables visible
874 throughout the rest of the C<block> in which they are first used and
875 in any C<subroutine>s that are called by the rest of the
876 block. Dynamically scoped variables can have their values temporarily
877 changed (and implicitly restored later) by a L<local|perlfunc/local>
878 operator. (Compare C<lexical scoping>.) Used more loosely to mean
879 how a subroutine that is in the middle of calling another subroutine
880 "contains" that subroutine at C<run time>.
888 Derived from many sources. Some would say I<too> many.
892 A basic building block. When you're talking about an C<array>, it's
893 one of the items that make up the array.
897 When something is contained in something else, particularly when that
898 might be considered surprising: "I've embedded a complete Perl
899 interpreter in my editor!"
901 =item empty subclass test
903 The notion that an empty C<derived class> should behave exactly like
908 When you change a C<value> as it is being copied. [From French, "in
909 passing", as in the exotic pawn-capturing maneuver in chess.]
913 The veil of abstraction separating the C<interface> from the
914 C<implementation> (whether enforced or not), which mandates that all
915 access to an C<object>'s state be through C<method>s alone.
919 See C<little-endian> and C<big-endian>.
923 The collective set of C<environment variable>s
924 your C<process> inherits from its parent. Accessed via C<%ENV>.
926 =item environment variable
928 A mechanism by which some high-level agent such as a user can pass its
929 preferences down to its future offspring (child C<process>es,
930 grandchild processes, great-grandchild processes, and so on). Each
931 environment variable is a C<key>/C<value> pair, like one entry in a
936 End of File. Sometimes used metaphorically as the terminating string
937 of a C<here document>.
941 The error number returned by a C<syscall> when it fails. Perl refers
942 to the error by the name C<$!> (or C<$OS_ERROR> if you use the English
947 See C<exception> or C<fatal error>.
949 =item escape sequence
955 A fancy term for an error. See C<fatal error>.
957 =item exception handling
959 The way a program responds to an error. The exception handling
960 mechanism in Perl is the L<eval|perlfunc/eval> operator.
964 To throw away the current C<process>'s program and replace it with
965 another without exiting the process or relinquishing any resources
966 held (apart from the old memory image).
968 =item executable file
970 A C<file> that is specially marked to tell the C<operating system>
971 that it's okay to run this file as a program. Usually shortened to
976 To run a L<program|/executable file> or C<subroutine>. (Has nothing
977 to do with the L<kill|perlfunc/kill> built-in, unless you're trying to
978 run a C<signal handler>.)
982 The special mark that tells the operating system it can run this
983 program. There are actually three execute bits under Unix, and which
984 bit gets used depends on whether you own the file singularly,
985 collectively, or not at all.
993 To make symbols from a C<module> available for C<import> by other modules.
997 Anything you can legally say in a spot where a C<value> is required.
998 Typically composed of C<literal>s, C<variable>s,
999 C<operator>s, C<function>s, and C<subroutine>
1000 calls, not necessarily in that order.
1004 A Perl module that also pulls in compiled C or C++ code. More
1005 generally, any experimental option that can be compiled into Perl,
1006 such as multithreading.
1014 In Perl, any value that would look like C<""> or C<"0"> if evaluated
1015 in a string context. Since undefined values evaluate to C<"">, all
1016 undefined values are false, but not all false values are undefined.
1020 Frequently Asked Question (although not necessarily frequently
1021 answered, especially if the answer appears in the Perl FAQ shipped
1022 standard with Perl).
1026 An uncaught C<exception>, which causes termination of the C<process>
1027 after printing a message on your C<standard error> stream. Errors
1028 that happen inside an L<eval|perlfunc/eval> are not fatal. Instead,
1029 the L<eval|perlfunc/eval> terminates after placing the exception
1030 message in the C<$@> (C<$EVAL_ERROR>) variable. You can try to
1031 provoke a fatal error with the L<die|perlfunc/die> operator (known as
1032 throwing or raising an exception), but this may be caught by a
1033 dynamically enclosing L<eval|perlfunc/eval>. If not caught, the
1034 L<die|perlfunc/die> becomes a fatal error.
1038 A single piece of numeric or string data that is part of a longer
1039 C<string>, C<record>, or C<line>. Variable-width fields are
1040 usually split up by C<separator>s (so use
1041 L<split|perlfunc/split> to extract the fields), while fixed-width
1042 fields are usually at fixed positions (so use
1043 L<unpack|perlfunc/unpack>). "fields" are also called C<instance variable>s.
1047 First In, First Out. See also C<LIFO>. Also, a nickname for a
1052 A named collection of data, usually stored on disk in a C<directory>
1053 in a C<filesystem>. Roughly like a document, if you're into office
1054 metaphors. In modern filesystems, you can actually give a file more
1055 than one name. Some files have special properties, like directories
1058 =item file descriptor
1060 The little number the C<operating system> uses to keep track of which
1061 opened C<file> you're talking about. Perl hides the file descriptor
1062 inside a C<standard IE<sol>O> stream and then attaches the stream to
1065 =item file test operator
1067 A built-in unary operator that you use to determine whether something
1068 is C<true> about a file, such as C<-o $filename> to test whether
1069 you're the owner of the file.
1073 A "wildcard" match on C<filename>s. See the
1074 L<glob|perlfunc/glob> function.
1078 An identifier (not necessarily related to the real name of a file)
1079 that represents a particular instance of opening a file until you
1080 close it. If you're going to open and close several different files
1081 in succession, it's fine to open each of them with the same
1082 filehandle, so you don't have to write out separate code to process
1087 One name for a file. This name is listed in a C<directory>, and you
1088 can use it in an L<open|perlfunc/open> to tell the C<operating
1089 system> exactly which file you want to open, and associate the file
1090 with a C<filehandle> which will carry the subsequent identity of that
1091 file in your program, until you close it.
1095 A set of L<directories|/directory> and C<file>s residing on a
1096 partition of the disk. Sometimes known as a "partition". You can
1097 change the file's name or even move a file around from directory to
1098 directory within a filesystem without actually moving the file itself,
1099 at least under Unix.
1103 A program designed to take a C<stream> of input and transform it into
1108 We tend to avoid this term because it means so many things. It may
1109 mean a command-line C<switch> that takes no argument
1110 itself (such as Perl's B<-n> and B<-p>
1111 flags) or, less frequently, a single-bit indicator (such as the
1112 C<O_CREAT> and C<O_EXCL> flags used in
1113 L<sysopen|perlfunc/sysopen>).
1115 =item floating point
1117 A method of storing numbers in "scientific notation", such that the
1118 precision of the number is independent of its magnitude (the decimal
1119 point "floats"). Perl does its numeric work with floating-point
1120 numbers (sometimes called "floats"), when it can't get away with
1121 using C<integer>s. Floating-point numbers are mere
1122 approximations of real numbers.
1126 The act of emptying a C<buffer>, often before it's full.
1130 Far More Than Everything You Ever Wanted To Know. An exhaustive
1131 treatise on one narrow topic, something of a super-C<FAQ>. See Tom
1136 To create a child C<process> identical to the parent process at its
1137 moment of conception, at least until it gets ideas of its own. A
1138 thread with protected memory.
1140 =item formal arguments
1142 The generic names by which a C<subroutine> knows its
1143 C<argument>s. In many languages, formal arguments are
1144 always given individual names, but in Perl, the formal arguments are
1145 just the elements of an array. The formal arguments to a Perl program
1146 are C<$ARGV[0]>, C<$ARGV[1]>, and so on. Similarly, the formal
1147 arguments to a Perl subroutine are C<$_[0]>, C<$_[1]>, and so on. You
1148 may give the arguments individual names by assigning the values to a
1149 L<my|perlfunc/my> list. See also C<actual arguments>.
1153 A specification of how many spaces and digits and things to put
1154 somewhere so that whatever you're printing comes out nice and pretty.
1156 =item freely available
1158 Means you don't have to pay money to get it, but the copyright on it
1159 may still belong to someone else (like Larry).
1161 =item freely redistributable
1163 Means you're not in legal trouble if you give a bootleg copy of it to
1164 your friends and we find out about it. In fact, we'd rather you gave
1165 a copy to all your friends.
1169 Historically, any software that you give away, particularly if you
1170 make the source code available as well. Now often called C<open
1171 source software>. Recently there has been a trend to use the term in
1172 contradistinction to C<open source software>, to refer only to free
1173 software released under the Free Software Foundation's GPL (General
1174 Public License), but this is difficult to justify etymologically.
1178 Mathematically, a mapping of each of a set of input values to a
1179 particular output value. In computers, refers to a C<subroutine> or
1180 C<operator> that returns a C<value>. It may or may not have input
1181 values (called C<argument>s).
1183 =item funny character
1185 Someone like Larry, or one of his peculiar friends. Also refers to
1186 the strange prefixes that Perl requires as noun markers on its
1189 =item garbage collection
1191 A misnamed feature--it should be called, "expecting your mother to
1192 pick up after you". Strictly speaking, Perl doesn't do this, but it
1193 relies on a reference-counting mechanism to keep things tidy.
1194 However, we rarely speak strictly and will often refer to the
1195 reference-counting scheme as a form of garbage collection. (If it's
1196 any comfort, when your interpreter exits, a "real" garbage collector
1197 runs to make sure everything is cleaned up if you've been messy with
1198 circular references and such.)
1206 Group ID--in Unix, the numeric group ID that the C<operating system>
1207 uses to identify you and members of your C<group>.
1211 Strictly, the shell's C<*> character, which will match a "glob" of
1212 characters when you're trying to generate a list of filenames.
1213 Loosely, the act of using globs and similar symbols to do pattern
1214 matching. See also C<fileglob> and C<typeglob>.
1218 Something you can see from anywhere, usually used of
1219 C<variable>s and C<subroutine>s that are visible
1220 everywhere in your program. In Perl, only certain special variables
1221 are truly global--most variables (and all subroutines) exist only in
1222 the current C<package>. Global variables can be declared with
1223 L<our|perlfunc/our>. See L<perlfunc/our>.
1225 =item global destruction
1227 The C<garbage collection> of globals (and the running of any
1228 associated object destructors) that takes place when a Perl
1229 C<interpreter> is being shut down. Global destruction should not be
1230 confused with the Apocalypse, except perhaps when it should.
1234 A language such as Perl that is good at hooking things together that
1235 weren't intended to be hooked together.
1239 The size of the pieces you're dealing with, mentally speaking.
1243 A C<subpattern> whose C<quantifier> wants to match as many things as
1248 Originally from the old Unix editor command for "Globally search for a
1249 Regular Expression and Print it", now used in the general sense of any
1250 kind of search, especially text searches. Perl has a built-in
1251 L<grep|perlfunc/grep> function that searches a list for elements
1252 matching any given criterion, whereas the C<grep>(1) program searches
1253 for lines matching a C<regular expression> in one or more files.
1257 A set of users of which you are a member. In some operating systems
1258 (like Unix), you can give certain file access permissions to other
1259 members of your group.
1263 An internal "glob value" typedef, holding a C<typeglob>. The C<GV>
1264 type is a subclass of C<SV>.
1272 Someone who is brilliantly persistent in solving technical problems,
1273 whether these involve golfing, fighting orcs, or programming. Hacker
1274 is a neutral term, morally speaking. Good hackers are not to be
1275 confused with evil C<cracker>s or clueless L<script
1276 kiddies|/script kiddie>. If you confuse them, we will presume that
1277 you are either evil or clueless.
1281 A C<subroutine> or C<method> that is called by Perl when your
1282 program needs to respond to some internal event, such as a C<signal>,
1283 or an encounter with an operator subject to C<operator overloading>.
1284 See also C<callback>.
1286 =item hard reference
1288 A C<scalar> C<value> containing the actual address of a
1289 C<referent>, such that the referent's C<reference> count accounts
1290 for it. (Some hard references are held internally, such as the
1291 implicit reference from one of a C<typeglob>'s variable slots to its
1292 corresponding referent.) A hard reference is different from a
1293 C<symbolic reference>.
1297 An unordered association of C<key>/C<value> pairs, stored such that
1298 you can easily use a string C<key> to look up its associated data
1299 C<value>. This glossary is like a hash, where the word to be defined
1300 is the key, and the definition is the value. A hash is also sometimes
1301 septisyllabically called an "associative array", which is a pretty
1302 good reason for simply calling it a "hash" instead.
1306 A data structure used internally by Perl for implementing associative
1307 arrays (hashes) efficiently. See also C<bucket>.
1311 A file containing certain required definitions that you must include
1312 "ahead" of the rest of your program to do certain obscure operations.
1313 A C header file has a I<.h> extension. Perl doesn't really have
1314 header files, though historically Perl has sometimes used translated
1315 I<.h> files with a I<.ph> extension. See L<perlfunc/require>.
1316 (Header files have been superseded by the C<module> mechanism.)
1320 So called because of a similar construct in C<shell>s that
1321 pretends that the C<line>s following the C<command> are a
1322 separate C<file> to be fed to the command, up to some terminating
1323 string. In Perl, however, it's just a fancy form of quoting.
1327 A number in base 16, "hex" for short. The digits for 10 through 16
1328 are customarily represented by the letters C<a> through C<f>.
1329 Hexadecimal constants in Perl start with C<0x>. See also
1332 =item home directory
1334 The directory you are put into when you log in. On a Unix system, the
1335 name is often placed into C<$ENV{HOME}> or C<$ENV{LOGDIR}> by
1336 I<login>, but you can also find it with C<(getpwuid($E<lt>))[7]>.
1337 (Some platforms do not have a concept of a home directory.)
1341 The computer on which a program or other data resides.
1345 Excessive pride, the sort of thing Zeus zaps you for. Also the
1346 quality that makes you write (and maintain) programs that other people
1347 won't want to say bad things about. Hence, the third great virtue of
1348 a programmer. See also C<laziness> and C<impatience>.
1352 Short for a "hash value" typedef, which holds Perl's internal
1353 representation of a hash. The C<HV> type is a subclass of C<SV>.
1361 A legally formed name for most anything in which a computer program
1362 might be interested. Many languages (including Perl) allow
1363 identifiers that start with a letter and contain letters and digits.
1364 Perl also counts the underscore character as a valid letter. (Perl
1365 also has more complicated names, such as C<qualified> names.)
1369 The anger you feel when the computer is being lazy. This makes you
1370 write programs that don't just react to your needs, but actually
1371 anticipate them. Or at least that pretend to. Hence, the second
1372 great virtue of a programmer. See also C<laziness> and C<hubris>.
1374 =item implementation
1376 How a piece of code actually goes about doing its job. Users of the
1377 code should not count on implementation details staying the same
1378 unless they are part of the published C<interface>.
1382 To gain access to symbols that are exported from another module. See
1387 To increase the value of something by 1 (or by some other number, if
1392 In olden days, the act of looking up a C<key> in an actual index
1393 (such as a phone book), but now merely the act of using any kind of
1394 key or position to find the corresponding C<value>, even if no index
1395 is involved. Things have degenerated to the point that Perl's
1396 L<index|perlfunc/index> function merely locates the position (index)
1397 of one string in another.
1399 =item indirect filehandle
1401 An C<expression> that evaluates to something that can be used as a
1402 C<filehandle>: a C<string> (filehandle name), a C<typeglob>, a
1403 typeglob C<reference>, or a low-level C<IO> object.
1405 =item indirect object
1407 In English grammar, a short noun phrase between a verb and its direct
1408 object indicating the beneficiary or recipient of the action. In
1409 Perl, C<print STDOUT "$foo\n";> can be understood as "verb
1410 indirect-object object" where C<STDOUT> is the recipient of the
1411 L<print|perlfunc/print> action, and C<"$foo"> is the object being
1412 printed. Similarly, when invoking a C<method>, you might place the
1413 invocant between the method and its arguments:
1415 $gollum = new Pathetic::Creature "Smeagol";
1416 give $gollum "Fisssssh!";
1417 give $gollum "Precious!";
1419 =item indirect object slot
1421 The syntactic position falling between a method call and its arguments
1422 when using the indirect object invocation syntax. (The slot is
1423 distinguished by the absence of a comma between it and the next
1424 argument.) C<STDERR> is in the indirect object slot here:
1426 print STDERR "Awake! Awake! Fear, Fire,
1431 If something in a program isn't the value you're looking for but
1432 indicates where the value is, that's indirection. This can be done
1433 with either C<symbolic reference>s or L<hard
1434 references|/hard reference>.
1438 An C<operator> that comes in between its C<operand>s, such
1439 as multiplication in C<24 * 7>.
1443 What you get from your ancestors, genetically or otherwise. If you
1444 happen to be a C<class>, your ancestors are called L<base
1445 classes|/base class> and your descendants are called L<derived
1446 classes|/derived class>. See C<single inheritance> and C<multiple
1451 Short for "an instance of a class", meaning an C<object> of that C<class>.
1453 =item instance variable
1455 An C<attribute> of an C<object>; data stored with the particular
1456 object rather than with the class as a whole.
1460 A number with no fractional (decimal) part. A counting number, like
1461 1, 2, 3, and so on, but including 0 and the negatives.
1465 The services a piece of code promises to provide forever, in contrast to
1466 its C<implementation>, which it should feel free to change whenever it
1471 The insertion of a scalar or list value somewhere in the middle of
1472 another value, such that it appears to have been there all along. In
1473 Perl, variable interpolation happens in double-quoted strings and
1474 patterns, and list interpolation occurs when constructing the list of
1475 values to pass to a list operator or other such construct that takes a
1480 Strictly speaking, a program that reads a second program and does what
1481 the second program says directly without turning the program into a
1482 different form first, which is what C<compiler>s do. Perl
1483 is not an interpreter by this definition, because it contains a kind
1484 of compiler that takes a program and turns it into a more executable
1485 form (C<syntax tree>s) within the I<perl> process itself,
1486 which the Perl C<run time> system then interprets.
1490 The agent on whose behalf a C<method> is invoked. In a C<class>
1491 method, the invocant is a package name. In an C<instance> method,
1492 the invocant is an object reference.
1496 The act of calling up a deity, daemon, program, method, subroutine, or
1497 function to get it do what you think it's supposed to do. We usually
1498 "call" subroutines but "invoke" methods, since it sounds cooler.
1502 Input from, or output to, a C<file> or C<device>.
1506 An internal I/O object. Can also mean C<indirect object>.
1510 Internet Protocol, or Intellectual Property.
1514 Interprocess Communication.
1518 A relationship between two C<object>s in which one object is
1519 considered to be a more specific version of the other, generic object:
1520 "A camel is a mammal." Since the generic object really only exists in
1521 a Platonic sense, we usually add a little abstraction to the notion of
1522 objects and think of the relationship as being between a generic
1523 C<base class> and a specific C<derived class>. Oddly enough,
1524 Platonic classes don't always have Platonic relationships--see
1529 Doing something repeatedly.
1533 A special programming gizmo that keeps track of where you are in
1534 something that you're trying to iterate over. The C<foreach> loop in
1535 Perl contains an iterator; so does a hash, allowing you to
1536 L<each|perlfunc/each> through it.
1540 The integer four, not to be confused with six, Tom's favorite editor.
1541 IV also means an internal Integer Value of the type a C<scalar> can
1542 hold, not to be confused with an C<NV>.
1550 "Just Another Perl Hacker," a clever but cryptic bit of Perl code that
1551 when executed, evaluates to that string. Often used to illustrate a
1552 particular Perl feature, and something of an ungoing Obfuscated Perl
1553 Contest seen in Usenix signatures.
1561 The string index to a C<hash>, used to look up the C<value>
1562 associated with that key.
1566 See C<reserved words>.
1574 A name you give to a C<statement> so that you can talk about that
1575 statement elsewhere in the program.
1579 The quality that makes you go to great effort to reduce overall energy
1580 expenditure. It makes you write labor-saving programs that other
1581 people will find useful, and document what you wrote so you don't have
1582 to answer so many questions about it. Hence, the first great virtue
1583 of a programmer. Also hence, this book. See also C<impatience> and
1588 A C<bit shift> that multiplies the number by some power of 2.
1590 =item leftmost longest
1592 The preference of the C<regular expression> engine to match the
1593 leftmost occurrence of a C<pattern>, then given a position at which a
1594 match will occur, the preference for the longest match (presuming the
1595 use of a C<greedy> quantifier). See L<perlre> for I<much> more on
1600 Fancy term for a C<token>.
1604 Fancy term for a C<tokener>.
1606 =item lexical analysis
1608 Fancy term for C<tokenizing>.
1610 =item lexical scoping
1612 Looking at your I<Oxford English Dictionary> through a microscope.
1613 (Also known as C<static scoping>, because dictionaries don't change
1614 very fast.) Similarly, looking at variables stored in a private
1615 dictionary (namespace) for each scope, which are visible only from
1616 their point of declaration down to the end of the lexical scope in
1617 which they are declared. --Syn. C<static scoping>.
1618 --Ant. C<dynamic scoping>.
1620 =item lexical variable
1622 A C<variable> subject to C<lexical scoping>, declared by
1623 L<my|perlfunc/my>. Often just called a "lexical". (The
1624 L<our|perlfunc/our> declaration declares a lexically scoped name for a
1625 global variable, which is not itself a lexical variable.)
1629 Generally, a collection of procedures. In ancient days, referred to a
1630 collection of subroutines in a I<.pl> file. In modern times, refers
1631 more often to the entire collection of Perl C<module>s on your
1636 Last In, First Out. See also C<FIFO>. A LIFO is usually called a
1641 In Unix, a sequence of zero or more non-newline characters terminated
1642 with a C<newline> character. On non-Unix machines, this is emulated
1643 by the C library even if the underlying C<operating system> has
1646 =item line buffering
1648 Used by a C<standard IE<sol>O> output stream that flushes its
1649 C<buffer> after every C<newline>. Many standard I/O libraries
1650 automatically set up line buffering on output that is going to the
1655 The number of lines read previous to this one, plus 1. Perl keeps a
1656 separate line number for each source or input file it opens. The
1657 current source file's line number is represented by C<__LINE__>. The
1658 current input line number (for the file that was most recently read
1659 via C<E<lt>FHE<gt>>) is represented by the C<$.>
1660 (C<$INPUT_LINE_NUMBER>) variable. Many error messages report both
1661 values, if available.
1665 Used as a noun, a name in a C<directory>, representing a C<file>. A
1666 given file can have multiple links to it. It's like having the same
1667 phone number listed in the phone directory under different names. As
1668 a verb, to resolve a partially compiled file's unresolved symbols into
1669 a (nearly) executable image. Linking can generally be static or
1670 dynamic, which has nothing to do with static or dynamic scoping.
1674 A syntactic construct representing a comma-separated list of
1675 expressions, evaluated to produce a C<list value>. Each
1676 C<expression> in a C<LIST> is evaluated in C<list context> and
1677 interpolated into the list value.
1681 An ordered set of scalar values.
1685 The situation in which an C<expression> is expected by its
1686 surroundings (the code calling it) to return a list of values rather
1687 than a single value. Functions that want a C<LIST> of arguments tell
1688 those arguments that they should produce a list value. See also
1693 An C<operator> that does something with a list of values, such as
1694 L<join|perlfunc/join> or L<grep|perlfunc/grep>. Usually used for
1695 named built-in operators (such as L<print|perlfunc/print>,
1696 L<unlink|perlfunc/unlink>, and L<system|perlfunc/system>) that do not
1697 require parentheses around their C<argument> list.
1701 An unnamed list of temporary scalar values that may be passed around
1702 within a program from any list-generating function to any function or
1703 construct that provides a C<list context>.
1707 A token in a programming language such as a number or C<string> that
1708 gives you an actual C<value> instead of merely representing possible
1709 values as a C<variable> does.
1713 From Swift: someone who eats eggs little end first. Also used of
1714 computers that store the least significant C<byte> of a word at a
1715 lower byte address than the most significant byte. Often considered
1716 superior to big-endian machines. See also C<big-endian>.
1720 Not meaning the same thing everywhere. A global variable in Perl can
1721 be localized inside a L<dynamic scope|/dynamic scoping> via the
1722 L<local|perlfunc/local> operator.
1724 =item logical operator
1726 Symbols representing the concepts "and", "or", "xor", and "not".
1730 An C<assertion> that peeks at the string to the right of the current
1735 An C<assertion> that peeks at the string to the left of the current
1740 A construct that performs something repeatedly, like a roller coaster.
1742 =item loop control statement
1744 Any statement within the body of a loop that can make a loop
1745 prematurely stop looping or skip an C<iteration>. Generally you
1746 shouldn't try this on roller coasters.
1750 A kind of key or name attached to a loop (or roller coaster) so that
1751 loop control statements can talk about which loop they want to
1756 Able to serve as an C<lvalue>.
1760 Term used by language lawyers for a storage location you can assign a
1761 new C<value> to, such as a C<variable> or an element of an
1762 C<array>. The "l" is short for "left", as in the left side of an
1763 assignment, a typical place for lvalues. An C<lvaluable> function or
1764 expression is one to which a value may be assigned, as in C<pos($x) =
1767 =item lvalue modifier
1769 An adjectival pseudofunction that warps the meaning of an C<lvalue>
1770 in some declarative fashion. Currently there are three lvalue
1771 modifiers: L<my|perlfunc/my>, L<our|perlfunc/our>, and
1772 L<local|perlfunc/local>.
1780 Technically speaking, any extra semantics attached to a variable such
1781 as C<$!>, C<$0>, C<%ENV>, or C<%SIG>, or to any tied variable.
1782 Magical things happen when you diddle those variables.
1784 =item magical increment
1786 An C<increment> operator that knows how to bump up alphabetics as
1789 =item magical variables
1791 Special variables that have side effects when you access them or
1792 assign to them. For example, in Perl, changing elements of the
1793 C<%ENV> array also changes the corresponding environment variables
1794 that subprocesses will use. Reading the C<$!> variable gives you the
1795 current system error number or message.
1799 A file that controls the compilation of a program. Perl programs
1800 don't usually need a C<Makefile> because the Perl compiler has plenty
1805 The Unix program that displays online documentation (manual pages) for
1810 A "page" from the manuals, typically accessed via the C<man>(1)
1811 command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
1812 BUGS, and so on, and is typically longer than a page. There are
1813 manpages documenting C<command>s, C<syscall>s,
1814 C<library> C<function>s, C<device>s,
1815 C<protocol>s, C<file>s, and such. In this book, we
1816 call any piece of standard Perl documentation (like I<perlop> or
1817 I<perldelta>) a manpage, no matter what format it's installed in on
1822 See C<pattern matching>.
1826 See C<instance variable>.
1830 This always means your main memory, not your disk. Clouding the issue
1831 is the fact that your machine may implement C<virtual> memory; that
1832 is, it will pretend that it has more memory than it really does, and
1833 it'll use disk space to hold inactive bits. This can make it seem
1834 like you have a little more memory than you really do, but it's not a
1835 substitute for real memory. The best thing that can be said about
1836 virtual memory is that it lets your performance degrade gradually
1837 rather than suddenly when you run out of real memory. But your
1838 program can die when you run out of virtual memory too, if you haven't
1839 thrashed your disk to death first.
1843 A C<character> that is I<not> supposed to be treated normally. Which
1844 characters are to be treated specially as metacharacters varies
1845 greatly from context to context. Your C<shell> will have certain
1846 metacharacters, double-quoted Perl C<string>s have other
1847 metacharacters, and C<regular expression> patterns have all the
1848 double-quote metacharacters plus some extra ones of their own.
1852 Something we'd call a C<metacharacter> except that it's a sequence of
1853 more than one character. Generally, the first character in the
1854 sequence must be a true metacharacter to get the other characters in
1855 the metasymbol to misbehave along with it.
1859 A kind of action that an C<object> can take if you tell it to. See
1864 The belief that "small is beautiful." Paradoxically, if you say
1865 something in a small language, it turns out big, and if you say it in
1866 a big language, it turns out small. Go figure.
1870 In the context of the I<stat>(2) syscall, refers to the field holding
1871 the C<permission bits> and the type of the C<file>.
1875 See C<statement modifier>, C<regular expression modifier>, and
1876 C<lvalue modifier>, not necessarily in that order.
1880 A C<file> that defines a C<package> of (almost) the same name, which
1881 can either C<export> symbols or function as an C<object> class. (A
1882 module's main I<.pm> file may also load in other files in support of
1883 the module.) See the L<use|perlfunc/use> built-in.
1887 An integer divisor when you're interested in the remainder instead of
1892 Short for Perl Monger, a purveyor of Perl.
1896 A temporary value scheduled to die when the current statement
1899 =item multidimensional array
1901 An array with multiple subscripts for finding a single element. Perl
1902 implements these using C<reference>s--see L<perllol> and
1905 =item multiple inheritance
1907 The features you got from your mother and father, mixed together
1908 unpredictably. (See also C<inheritance>, and C<single
1909 inheritance>.) In computer languages (including Perl), the notion
1910 that a given class may have multiple direct ancestors or L<base
1911 classes|/base class>.
1919 A C<pipe> with a name embedded in the C<filesystem> so that it can
1920 be accessed by two unrelated C<process>es.
1924 A domain of names. You needn't worry about whether the names in one
1925 such domain have been used in another. See C<package>.
1927 =item network address
1929 The most important attribute of a socket, like your telephone's
1930 telephone number. Typically an IP address. See also C<port>.
1934 A single character that represents the end of a line, with the ASCII
1935 value of 012 octal under Unix (but 015 on a Mac), and represented by
1936 C<\n> in Perl strings. For Windows machines writing text files, and
1937 for certain physical devices like terminals, the single newline gets
1938 automatically translated by your C library into a line feed and a
1939 carriage return, but normally, no translation is done.
1943 Network File System, which allows you to mount a remote filesystem as
1946 =item null character
1948 A character with the ASCII value of zero. It's used by C to terminate
1949 strings, but Perl allows strings to contain a null.
1953 A C<list value> with zero elements, represented in Perl by C<()>.
1957 A C<string> containing no characters, not to be confused with a
1958 string containing a C<null character>, which has a positive length
1961 =item numeric context
1963 The situation in which an expression is expected by its surroundings
1964 (the code calling it) to return a number. See also C<context> and
1969 Short for Nevada, no part of which will ever be confused with
1970 civilization. NV also means an internal floating-point Numeric Value
1971 of the type a C<scalar> can hold, not to be confused with an C<IV>.
1975 Half a C<byte>, equivalent to one C<hexadecimal> digit, and worth
1984 An C<instance> of a C<class>. Something that "knows" what
1985 user-defined type (class) it is, and what it can do because of what
1986 class it is. Your program can request an object to do things, but the
1987 object gets to decide whether it wants to do them or not. Some
1988 objects are more accommodating than others.
1992 A number in base 8. Only the digits 0 through 7 are allowed. Octal
1993 constants in Perl start with 0, as in 013. See also the
1994 L<oct|perlfunc/oct> function.
1998 How many things you have to skip over when moving from the beginning
1999 of a string or array to a specific position within it. Thus, the
2000 minimum offset is zero, not one, because you don't skip anything to
2001 get to the first item.
2005 An entire computer program crammed into one line of text.
2007 =item open source software
2009 Programs for which the source code is freely available and freely
2010 redistributable, with no commercial strings attached. For a more
2011 detailed definition, see L<http://www.opensource.org/osd.html>.
2015 An C<expression> that yields a C<value> that an C<operator>
2016 operates on. See also C<precedence>.
2018 =item operating system
2020 A special program that runs on the bare machine and hides the gory
2021 details of managing C<process>es and C<device>s.
2022 Usually used in a looser sense to indicate a particular culture of
2023 programming. The loose sense can be used at varying levels of
2024 specificity. At one extreme, you might say that all versions of Unix
2025 and Unix-lookalikes are the same operating system (upsetting many
2026 people, especially lawyers and other advocates). At the other
2027 extreme, you could say this particular version of this particular
2028 vendor's operating system is different from any other version of this
2029 or any other vendor's operating system. Perl is much more portable
2030 across operating systems than many other languages. See also
2031 C<architecture> and C<platform>.
2035 A gizmo that transforms some number of input values to some number of
2036 output values, often built into a language with a special syntax or
2037 symbol. A given operator may have specific expectations about what
2038 C<type>s of data you give as its arguments
2039 (C<operand>s) and what type of data you want back from it.
2041 =item operator overloading
2043 A kind of C<overloading> that you can do on built-in
2044 C<operator>s to make them work on C<object>s as if
2045 the objects were ordinary scalar values, but with the actual semantics
2046 supplied by the object class. This is set up with the L<overload>
2051 See either C<switch> or C<regular expression modifier>.
2055 Giving additional meanings to a symbol or construct. Actually, all
2056 languages do overloading to one extent or another, since people are
2057 good at figuring out things from C<context>.
2061 Hiding or invalidating some other definition of the same name. (Not
2062 to be confused with C<overloading>, which adds definitions that must
2063 be disambiguated some other way.) To confuse the issue further, we use
2064 the word with two overloaded definitions: to describe how you can
2065 define your own C<subroutine> to hide a built-in C<function> of the
2066 same name (see L<perlsub/Overriding Built-in Functions>) and to
2067 describe how you can define a replacement C<method> in a C<derived
2068 class> to hide a C<base class>'s method of the same name (see
2073 The one user (apart from the superuser) who has absolute control over
2074 a C<file>. A file may also have a C<group> of users who may
2075 exercise joint ownership if the real owner permits it. See
2084 A C<namespace> for global C<variable>s,
2085 C<subroutine>s, and the like, such that they can be kept
2086 separate from like-named C<symbol>s in other namespaces. In a
2087 sense, only the package is global, since the symbols in the package's
2088 symbol table are only accessible from code compiled outside the
2089 package by naming the package. But in another sense, all package
2090 symbols are also globals--they're just well-organized globals.
2094 Short for C<scratchpad>.
2110 The subtle but sometimes brutal art of attempting to turn your
2111 possibly malformed program into a valid C<syntax tree>.
2115 To fix by applying one, as it were. In the realm of hackerdom, a
2116 listing of the differences between two versions of a program as might
2117 be applied by the C<patch>(1) program when you want to fix a bug or
2118 upgrade your old version.
2122 The list of L<directories|/directory> the system searches to find a
2123 program you want to C<execute>. The list is stored as one of your
2124 C<environment variable>s, accessible in Perl as
2129 A fully qualified filename such as I</usr/bin/perl>. Sometimes
2130 confused with C<PATH>.
2134 A template used in C<pattern matching>.
2136 =item pattern matching
2138 Taking a pattern, usually a C<regular expression>, and trying the
2139 pattern various ways on a string to see whether there's any way to
2140 make it fit. Often used to pick interesting tidbits out of a file.
2142 =item permission bits
2144 Bits that the C<owner> of a file sets or unsets to allow or disallow
2145 access to other people. These flag bits are part of the C<mode> word
2146 returned by the L<stat|perlfunc/stat> built-in when you ask about a
2147 file. On Unix systems, you can check the I<ls>(1) manpage for more
2152 What you get when you do C<Perl++> twice. Doing it only once will
2153 curl your hair. You have to increment it eight times to shampoo your
2154 hair. Lather, rinse, iterate.
2158 A direct C<connection> that carries the output of one C<process> to
2159 the input of another without an intermediate temporary file. Once the
2160 pipe is set up, the two processes in question can read and write as if
2161 they were talking to a normal file, with some caveats.
2165 A series of C<process>es all in a row, linked by
2166 C<pipe>s, where each passes its output stream to the next.
2170 The entire hardware and software context in which a program runs. A
2171 program written in a platform-dependent language might break if you
2172 change any of: machine, operating system, libraries, compiler, or
2173 system configuration. The I<perl> interpreter has to be compiled
2174 differently for each platform because it is implemented in C, but
2175 programs written in the Perl language are largely
2176 platform-independent.
2180 The markup used to embed documentation into your Perl code. See
2185 A C<variable> in a language like C that contains the exact memory
2186 location of some other item. Perl handles pointers internally so you
2187 don't have to worry about them. Instead, you just use symbolic
2188 pointers in the form of C<key>s and C<variable> names, or L<hard
2189 references|/hard reference>, which aren't pointers (but act like
2190 pointers and do in fact contain pointers).
2194 The notion that you can tell an C<object> to do something generic,
2195 and the object will interpret the command in different ways depending
2196 on its type. [E<lt>Gk many shapes]
2200 The part of the address of a TCP or UDP socket that directs packets to
2201 the correct process after finding the right machine, something like
2202 the phone extension you give when you reach the company operator.
2203 Also, the result of converting code to run on a different platform
2204 than originally intended, or the verb denoting this conversion.
2208 Once upon a time, C code compilable under both BSD and SysV. In
2209 general, code that can be easily converted to run on another
2210 C<platform>, where "easily" can be defined however you like, and
2211 usually is. Anything may be considered portable if you try hard
2212 enough. See I<mobile home> or I<London Bridge>.
2216 Someone who "carries" software from one C<platform> to another.
2217 Porting programs written in platform-dependent languages such as C can
2218 be difficult work, but porting programs like Perl is very much worth
2223 The Portable Operating System Interface specification.
2227 An C<operator> that follows its C<operand>, as in C<$x++>.
2231 An internal shorthand for a "push-pop" code, that is, C code
2232 implementing Perl's stack machine.
2236 A standard module whose practical hints and suggestions are received
2237 (and possibly ignored) at compile time. Pragmas are named in all
2242 The rules of conduct that, in the absence of other guidance, determine
2243 what should happen first. For example, in the absence of parentheses,
2244 you always do multiplication before addition.
2248 An C<operator> that precedes its C<operand>, as in C<++$x>.
2252 What some helper C<process> did to transform the incoming data into a
2253 form more suitable for the current process. Often done with an
2254 incoming C<pipe>. See also C<C preprocessor>.
2262 An instance of a running program. Under multitasking systems like
2263 Unix, two or more separate processes could be running the same program
2264 independently at the same time--in fact, the L<fork|perlfunc/fork>
2265 function is designed to bring about this happy state of affairs.
2266 Under other operating systems, processes are sometimes called
2267 "threads", "tasks", or "jobs", often with slight nuances in meaning.
2269 =item program generator
2271 A system that algorithmically writes code for you in a high-level
2272 language. See also C<code generator>.
2274 =item progressive matching
2276 Merely C<pattern matching> that picks up where it left off before.
2280 See either C<instance variable> or C<character property>.
2284 In networking, an agreed-upon way of sending messages back and forth
2285 so that neither correspondent will get too confused.
2289 An optional part of a C<subroutine> declaration telling the Perl
2290 compiler how many and what flavor of arguments may be passed as
2291 C<actual arguments>, so that you can write subroutine calls that
2292 parse much like built-in functions. (Or don't parse, as the case may
2295 =item pseudofunction
2297 A construct that sometimes looks like a function but really isn't.
2298 Usually reserved for C<lvalue> modifiers like L<my|perlfunc/my>, for
2299 C<context> modifiers like L<scalar|perlfunc/scalar>, and for the
2300 pick-your-own-quotes constructs, C<q//>, C<qq//>, C<qx//>, C<qw//>,
2301 C<qr//>, C<m//>, C<s///>, C<y///>, and C<tr///>.
2305 A reference to an array whose initial element happens to hold a
2306 reference to a hash. You can treat a pseudohash reference as either
2307 an array reference or a hash reference.
2311 An C<operator> that looks something like a C<literal>, such as the
2312 output-grabbing operator, C<`>C<command>C<`>.
2316 Something not owned by anybody. Perl is copyrighted and is thus
2317 I<not> in the public domain--it's just C<freely available> and
2318 C<freely redistributable>.
2322 A notional "baton" handed around the Perl community indicating who is
2323 the lead integrator in some arena of development.
2327 A C<pumpkin> holder, the person in charge of pumping the pump, or at
2328 least priming it. Must be willing to play the part of the Great
2329 Pumpkin now and then.
2333 A "pointer value", which is Perl Internals Talk for a C<char*>.
2341 Possessing a complete name. The symbol C<$Ent::moot> is qualified;
2342 C<$moot> is unqualified. A fully qualified filename is specified from
2343 the top-level directory.
2347 A component of a C<regular expression> specifying how many times the
2348 foregoing C<atom> may occur.
2356 With respect to files, one that has the proper permission bit set to
2357 let you access the file. With respect to computer programs, one
2358 that's written well enough that someone has a chance of figuring out
2359 what it's trying to do.
2363 The last rites performed by a parent C<process> on behalf of a
2364 deceased child process so that it doesn't remain a C<zombie>. See
2365 the L<wait|perlfunc/wait> and L<waitpid|perlfunc/waitpid> function
2370 A set of related data values in a C<file> or C<stream>, often
2371 associated with a unique C<key> field. In Unix, often commensurate
2372 with a C<line>, or a blank-line-terminated set of lines (a
2373 "paragraph"). Each line of the I</etc/passwd> file is a record, keyed
2374 on login name, containing information about that user.
2378 The art of defining something (at least partly) in terms of itself,
2379 which is a naughty no-no in dictionaries but often works out okay in
2380 computer programs if you're careful not to recurse forever, which is
2381 like an infinite loop with more spectacular failure modes.
2385 Where you look to find a pointer to information somewhere else. (See
2386 C<indirection>.) References come in two flavors, L<symbolic
2387 references|/symbolic reference> and L<hard references|/hard
2392 Whatever a reference refers to, which may or may not have a name.
2393 Common types of referents include scalars, arrays, hashes, and
2398 See C<regular expression>.
2400 =item regular expression
2402 A single entity with various interpretations, like an elephant. To a
2403 computer scientist, it's a grammar for a little language in which some
2404 strings are legal and others aren't. To normal people, it's a pattern
2405 you can use to find what you're looking for when it varies from case
2406 to case. Perl's regular expressions are far from regular in the
2407 theoretical sense, but in regular use they work quite well. Here's a
2408 regular expression: C</Oh s.*t./>. This will match strings like "C<Oh
2409 say can you see by the dawn's early light>" and "C<Oh sit!>". See
2412 =item regular expression modifier
2414 An option on a pattern or substitution, such as C</i> to render the
2415 pattern case insensitive. See also C<cloister>.
2419 A C<file> that's not a C<directory>, a C<device>, a named C<pipe>
2420 or C<socket>, or a C<symbolic link>. Perl uses the C<-f> file test
2421 operator to identify regular files. Sometimes called a "plain" file.
2423 =item relational operator
2425 An C<operator> that says whether a particular ordering relationship
2426 is C<true> about a pair of C<operand>s. Perl has both
2427 numeric and string relational operators. See C<collating sequence>.
2429 =item reserved words
2431 A word with a specific, built-in meaning to a C<compiler>, such as
2432 C<if> or L<delete|perlfunc/delete>. In many languages (not Perl),
2433 it's illegal to use reserved words to name anything else. (Which is
2434 why they're reserved, after all.) In Perl, you just can't use them to
2435 name C<label>s or C<filehandle>s. Also called
2440 The C<value> produced by a C<subroutine> or C<expression> when
2441 evaluated. In Perl, a return value may be either a C<list> or a
2446 Request For Comment, which despite the timid connotations is the name
2447 of a series of important standards documents.
2451 A C<bit shift> that divides a number by some power of 2.
2455 The superuser (UID == 0). Also, the top-level directory of the
2460 What you are told when someone thinks you should Read The Fine Manual.
2464 Any time after Perl starts running your main program. See also
2465 C<compile phase>. Run phase is mostly spent in C<run time> but may
2466 also be spent in C<compile time> when L<require|perlfunc/require>,
2467 L<do|perlfunc/do> C<FILE>, or L<eval|perlfunc/eval> C<STRING>
2468 operators are executed or when a substitution uses the C</ee>
2473 The time when Perl is actually doing what your code says to do, as
2474 opposed to the earlier period of time when it was trying to figure out
2475 whether what you said made any sense whatsoever, which is C<compile
2478 =item run-time pattern
2480 A pattern that contains one or more variables to be interpolated
2481 before parsing the pattern as a C<regular expression>, and that
2482 therefore cannot be analyzed at compile time, but must be re-analyzed
2483 each time the pattern match operator is evaluated. Run-time patterns
2484 are useful but expensive.
2488 A recreational vehicle, not to be confused with vehicular recreation.
2489 RV also means an internal Reference Value of the type a C<scalar> can
2490 hold. See also C<IV> and C<NV> if you're not confused yet.
2494 A C<value> that you might find on the right side of an
2495 C<assignment>. See also C<lvalue>.
2503 A simple, singular value; a number, C<string>, or C<reference>.
2505 =item scalar context
2507 The situation in which an C<expression> is expected by its
2508 surroundings (the code calling it) to return a single C<value> rather
2509 than a C<list> of values. See also C<context> and C<list context>.
2510 A scalar context sometimes imposes additional constraints on the
2511 return value--see C<string context> and C<numeric context>.
2512 Sometimes we talk about a C<Boolean context> inside conditionals, but
2513 this imposes no additional constraints, since any scalar value,
2514 whether numeric or C<string>, is already true or false.
2516 =item scalar literal
2518 A number or quoted C<string>--an actual C<value> in the text of your
2519 program, as opposed to a C<variable>.
2523 A value that happens to be a C<scalar> as opposed to a C<list>.
2525 =item scalar variable
2527 A C<variable> prefixed with C<$> that holds a single value.
2531 How far away you can see a variable from, looking through one. Perl
2532 has two visibility mechanisms: it does C<dynamic scoping> of
2533 L<local|perlfunc/local> C<variable>s, meaning that the rest
2534 of the C<block>, and any C<subroutine>s that are called
2535 by the rest of the block, can see the variables that are local to the
2536 block. Perl does C<lexical scoping> of L<my|perlfunc/my> variables,
2537 meaning that the rest of the block can see the variable, but other
2538 subroutines called by the block I<cannot> see the variable.
2542 The area in which a particular invocation of a particular file or
2543 subroutine keeps some of its temporary values, including any lexically
2548 A text C<file> that is a program intended to be C<execute>d
2549 directly rather than L<compiled|/compiler> to another form of file
2550 before execution. Also, in the context of C<Unicode>, a writing
2551 system for a particular language or group of languages, such as Greek,
2552 Bengali, or Klingon.
2556 A C<cracker> who is not a C<hacker>, but knows just enough to run
2557 canned scripts. A cargo-cult programmer.
2561 A venerable Stream EDitor from which Perl derives some of its ideas.
2565 A fancy kind of interlock that prevents multiple C<thread>s or
2566 C<process>es from using up the same resources simultaneously.
2570 A C<character> or C<string> that keeps two surrounding strings from
2571 being confused with each other. The L<split|perlfunc/split> function
2572 works on separators. Not to be confused with C<delimiter>s
2573 or C<terminator>s. The "or" in the previous sentence
2574 separated the two alternatives.
2578 Putting a fancy C<data structure> into linear order so that it can be
2579 stored as a C<string> in a disk file or database or sent through a
2580 C<pipe>. Also called marshalling.
2584 In networking, a C<process> that either advertises a C<service> or
2585 just hangs around at a known location and waits for C<client>s
2586 who need service to get in touch with it.
2590 Something you do for someone else to make them happy, like giving them
2591 the time of day (or of their life). On some machines, well-known
2592 services are listed by the L<getservent|perlfunc/getservent> function.
2596 Same as C<setuid>, only having to do with giving away C<group>
2601 Said of a program that runs with the privileges of its C<owner>
2602 rather than (as is usually the case) the privileges of whoever is
2603 running it. Also describes the bit in the mode word (C<permission
2604 bits>) that controls the feature. This bit must be explicitly set by
2605 the owner to enable this feature, and the program must be carefully
2606 written not to give away more privileges than it ought to.
2610 A piece of C<memory> accessible by two different
2611 C<process>es who otherwise would not see each other's memory.
2615 Irish for the whole McGillicuddy. In Perl culture, a portmanteau of
2616 "sharp" and "bang", meaning the C<#!> sequence that tells the system
2617 where to find the interpreter.
2621 A C<command>-line C<interpreter>. The program that interactively
2622 gives you a prompt, accepts one or more C<line>s of input, and
2623 executes the programs you mentioned, feeding each of them their proper
2624 C<argument>s and input data. Shells can also execute
2625 scripts containing such commands. Under Unix, typical shells include
2626 the Bourne shell (I</bin/sh>), the C shell (I</bin/csh>), and the Korn
2627 shell (I</bin/ksh>). Perl is not strictly a shell because it's not
2628 interactive (although Perl programs can be interactive).
2632 Something extra that happens when you evaluate an C<expression>.
2633 Nowadays it can refer to almost anything. For example, evaluating a
2634 simple assignment statement typically has the "side effect" of
2635 assigning a value to a variable. (And you thought assigning the value
2636 was your primary intent in the first place!) Likewise, assigning a
2637 value to the special variable L<$E<verbar>
2638 ($AUTOFLUSH)|perlvar/$AUTOFLUSH>) has the side effect of forcing a
2639 flush after every L<write|perlfunc/write> or L<print|perlfunc/print>
2640 on the currently selected filehandle.
2644 A bolt out of the blue; that is, an event triggered by the
2645 C<operating system>, probably when you're least expecting it.
2647 =item signal handler
2649 A C<subroutine> that, instead of being content to be called in the
2650 normal fashion, sits around waiting for a bolt out of the blue before
2651 it will deign to C<execute>. Under Perl, bolts out of the blue are
2652 called signals, and you send them with the L<kill|perlfunc/kill>
2653 built-in. See L<perlvar/%SIG> and L<perlipc/Signals>.
2655 =item single inheritance
2657 The features you got from your mother, if she told you that you don't
2658 have a father. (See also C<inheritance> and C<multiple
2659 inheritance>.) In computer languages, the notion that
2660 C<class>es reproduce asexually so that a given class can only
2661 have one direct ancestor or C<base class>. Perl supplies no such
2662 restriction, though you may certainly program Perl that way if you
2667 A selection of any number of C<element>s from a C<list>,
2668 C<array>, or C<hash>.
2672 To read an entire C<file> into a C<string> in one operation.
2676 An endpoint for network communication among multiple
2677 C<process>es that works much like a telephone or a post
2678 office box. The most important thing about a socket is its C<network
2679 address> (like a phone number). Different kinds of sockets have
2680 different kinds of addresses--some look like filenames, and some
2683 =item soft reference
2685 See C<symbolic reference>.
2689 A special kind of C<module> that does C<preprocessing> on your
2690 script just before it gets to the C<tokener>.
2694 A device you can put things on the top of, and later take them back
2695 off in the opposite order in which you put them on. See C<LIFO>.
2699 Included in the official Perl distribution, as in a standard module, a
2700 standard tool, or a standard Perl C<manpage>.
2702 =item standard error
2704 The default output C<stream> for nasty remarks that don't belong in
2705 C<standard output>. Represented within a Perl program by the
2706 C<filehandle> C<STDERR>. You can use this stream explicitly, but the
2707 L<die|perlfunc/die> and L<warn|perlfunc/warn> built-ins write to your
2708 standard error stream automatically.
2712 A standard C library for doing C<buffer>ed input and output to
2713 the C<operating system>. (The "standard" of standard I/O is only
2714 marginally related to the "standard" of standard input and output.)
2715 In general, Perl relies on whatever implementation of standard I/O a
2716 given operating system supplies, so the buffering characteristics of a
2717 Perl program on one machine may not exactly match those on another
2718 machine. Normally this only influences efficiency, not semantics. If
2719 your standard I/O package is doing block buffering and you want it to
2720 C<flush> the buffer more often, just set the C<$|> variable to a true
2723 =item standard input
2725 The default input C<stream> for your program, which if possible
2726 shouldn't care where its data is coming from. Represented within a
2727 Perl program by the C<filehandle> C<STDIN>.
2729 =item standard output
2731 The default output C<stream> for your program, which if possible
2732 shouldn't care where its data is going. Represented within a Perl
2733 program by the C<filehandle> C<STDOUT>.
2735 =item stat structure
2737 A special internal spot in which Perl keeps the information about the
2738 last C<file> on which you requested information.
2742 A C<command> to the computer about what to do next, like a step in a
2743 recipe: "Add marmalade to batter and mix until mixed." A statement is
2744 distinguished from a C<declaration>, which doesn't tell the computer
2745 to do anything, but just to learn something.
2747 =item statement modifier
2749 A C<conditional> or C<loop> that you put after the C<statement>
2750 instead of before, if you know what we mean.
2754 Varying slowly compared to something else. (Unfortunately, everything
2755 is relatively stable compared to something else, except for certain
2756 elementary particles, and we're not so sure about them.) In
2757 computers, where things are supposed to vary rapidly, "static" has a
2758 derogatory connotation, indicating a slightly dysfunctional
2759 C<variable>, C<subroutine>, or C<method>. In Perl culture, the
2760 word is politely avoided.
2764 No such thing. See C<class method>.
2766 =item static scoping
2768 No such thing. See C<lexical scoping>.
2770 =item static variable
2772 No such thing. Just use a C<lexical variable> in a scope larger than
2777 The C<value> returned to the parent C<process> when one of its child
2778 processes dies. This value is placed in the special variable C<$?>.
2779 Its upper eight C<bit>s are the exit status of the defunct
2780 process, and its lower eight bits identify the signal (if any) that
2781 the process died from. On Unix systems, this status value is the same
2782 as the status word returned by I<wait>(2). See L<perlfunc/system>.
2786 See C<standard error>.
2790 See C<standard input>.
2794 See C<standard IE<sol>O>.
2798 See C<standard output>.
2802 A flow of data into or out of a process as a steady sequence of bytes
2803 or characters, without the appearance of being broken up into packets.
2804 This is a kind of C<interface>--the underlying C<implementation> may
2805 well break your data up into separate packets for delivery, but this
2810 A sequence of characters such as "He said !@#*&%@#*?!". A string does
2811 not have to be entirely printable.
2813 =item string context
2815 The situation in which an expression is expected by its surroundings
2816 (the code calling it) to return a C<string>. See also C<context>
2817 and C<numeric context>.
2819 =item stringification
2821 The process of producing a C<string> representation of an abstract
2826 C keyword introducing a structure definition or name.
2830 See C<data structure>.
2834 See C<derived class>.
2838 A component of a C<regular expression> pattern.
2842 A named or otherwise accessible piece of program that can be invoked
2843 from elsewhere in the program in order to accomplish some sub-goal of
2844 the program. A subroutine is often parameterized to accomplish
2845 different but related things depending on its input
2846 C<argument>s. If the subroutine returns a meaningful
2847 C<value>, it is also called a C<function>.
2851 A C<value> that indicates the position of a particular C<array>
2852 C<element> in an array.
2856 Changing parts of a string via the C<s///> operator. (We avoid use of
2857 this term to mean C<variable interpolation>.)
2861 A portion of a C<string>, starting at a certain C<character>
2862 position (C<offset>) and proceeding for a certain number of
2871 The person whom the C<operating system> will let do almost anything.
2872 Typically your system administrator or someone pretending to be your
2873 system administrator. On Unix systems, the C<root> user. On Windows
2874 systems, usually the Administrator user.
2878 Short for "scalar value". But within the Perl interpreter every
2879 C<referent> is treated as a member of a class derived from SV, in an
2880 object-oriented sort of way. Every C<value> inside Perl is passed
2881 around as a C language C<SV*> pointer. The SV C<struct> knows its
2882 own "referent type", and the code is smart enough (we hope) not to try
2883 to call a C<hash> function on a C<subroutine>.
2887 An option you give on a command line to influence the way your program
2888 works, usually introduced with a minus sign. The word is also used as
2889 a nickname for a C<switch statement>.
2891 =item switch cluster
2893 The combination of multiple command-line switches (e.g., B<-a -b -c>)
2894 into one switch (e.g., B<-abc>). Any switch with an additional
2895 C<argument> must be the last switch in a cluster.
2897 =item switch statement
2899 A program technique that lets you evaluate an C<expression> and then,
2900 based on the value of the expression, do a multiway branch to the
2901 appropriate piece of code for that value. Also called a "case
2902 structure", named after the similar Pascal construct. Most switch
2903 statements in Perl are spelled C<for>. See L<perlsyn/Basic BLOCKs and
2908 Generally, any C<token> or C<metasymbol>. Often used more
2909 specifically to mean the sort of name you might find in a C<symbol
2914 Where a C<compiler> remembers symbols. A program like Perl must
2915 somehow remember all the names of all the C<variable>s,
2916 C<filehandle>s, and C<subroutine>s you've
2917 used. It does this by placing the names in a symbol table, which is
2918 implemented in Perl using a C<hash table>. There is a separate
2919 symbol table for each C<package> to give each package its own
2922 =item symbolic debugger
2924 A program that lets you step through the L<execution|/execute> of your
2925 program, stopping or printing things out here and there to see whether
2926 anything has gone wrong, and if so, what. The "symbolic" part just
2927 means that you can talk to the debugger using the same symbols with
2928 which your program is written.
2932 An alternate filename that points to the real C<filename>, which in
2933 turn points to the real C<file>. Whenever the C<operating system>
2934 is trying to parse a C<pathname> containing a symbolic link, it
2935 merely substitutes the new name and continues parsing.
2937 =item symbolic reference
2939 A variable whose value is the name of another variable or subroutine.
2940 By L<dereferencing|/dereference> the first variable, you can get at
2941 the second one. Symbolic references are illegal under C<use strict
2946 Programming in which the orderly sequence of events can be determined;
2947 that is, when things happen one after the other, not at the same time.
2949 =item syntactic sugar
2951 An alternative way of writing something more easily; a shortcut.
2955 From Greek, "with-arrangement". How things (particularly symbols) are
2956 put together with each other.
2960 An internal representation of your program wherein lower-level
2961 C<construct>s dangle off the higher-level constructs
2966 A C<function> call directly to the C<operating system>. Many of the
2967 important subroutines and functions you use aren't direct system
2968 calls, but are built up in one or more layers above the system call
2969 level. In general, Perl programmers don't need to worry about the
2970 distinction. However, if you do happen to know which Perl functions
2971 are really syscalls, you can predict which of these will set the C<$!>
2972 (C<$ERRNO>) variable on failure. Unfortunately, beginning programmers
2973 often confusingly employ the term "system call" to mean what happens
2974 when you call the Perl L<system|perlfunc/system> function, which
2975 actually involves many syscalls. To avoid any confusion, we nearly
2976 always use say "syscall" for something you could call indirectly via
2977 Perl's L<syscall|perlfunc/syscall> function, and never for something
2978 you would call with Perl's L<system|perlfunc/system> function.
2986 Said of data derived from the grubby hands of a user and thus unsafe
2987 for a secure program to rely on. Perl does taint checks if you run a
2988 C<setuid> (or C<setgid>) program, or if you use the B<-T> switch.
2992 Short for Transmission Control Protocol. A protocol wrapped around
2993 the Internet Protocol to make an unreliable packet transmission
2994 mechanism appear to the application program to be a reliable
2995 C<stream> of bytes. (Usually.)
2999 Short for a "terminal", that is, a leaf node of a C<syntax tree>. A
3000 thing that functions grammatically as an C<operand> for the operators
3005 A C<character> or C<string> that marks the end of another string.
3006 The C<$/> variable contains the string that terminates a
3007 L<readline|perlfunc/readline> operation, which L<chomp|perlfunc/chomp>
3008 deletes from the end. Not to be confused with
3009 C<delimiter>s or C<separator>s. The period at
3010 the end of this sentence is a terminator.
3014 An C<operator> taking three C<operand>s. Sometimes
3015 pronounced C<trinary>.
3019 A C<string> or C<file> containing primarily printable characters.
3023 Like a forked process, but without C<fork>'s inherent memory
3024 protection. A thread is lighter weight than a full process, in that a
3025 process could have multiple threads running around in it, all fighting
3026 over the same process's memory space unless steps are taken to protect
3027 threads from each other. See L<threads>.
3031 The bond between a magical variable and its implementation class. See
3032 L<perlfunc/tie> and L<perltie>.
3036 There's More Than One Way To Do It, the Perl Motto. The notion that
3037 there can be more than one valid path to solving a programming problem
3038 in context. (This doesn't mean that more ways are always better or
3039 that all possible paths are equally desirable--just that there need
3040 not be One True Way.) Pronounced TimToady.
3044 A morpheme in a programming language, the smallest unit of text with
3045 semantic significance.
3049 A module that breaks a program text into a sequence of
3050 C<token>s for later analysis by a parser.
3054 Splitting up a program text into C<token>s. Also known as
3055 "lexing", in which case you get "lexemes" instead of tokens.
3057 =item toolbox approach
3059 The notion that, with a complete set of simple tools that work well
3060 together, you can build almost anything you want. Which is fine if
3061 you're assembling a tricycle, but if you're building a defranishizing
3062 comboflux regurgalator, you really want your own machine shop in which
3063 to build special tools. Perl is sort of a machine shop.
3067 To turn one string representation into another by mapping each
3068 character of the source string to its corresponding character in the
3070 L<perlop/trE<sol>SEARCHLISTE<sol>REPLACEMENTLISTE<sol>cds>.
3074 An event that causes a C<handler> to be run.
3078 Not a stellar system with three stars, but an C<operator> taking
3079 three C<operand>s. Sometimes pronounced C<ternary>.
3083 A venerable typesetting language from which Perl derives the name of
3084 its C<$%> variable and which is secretly used in the production of
3089 Any scalar value that doesn't evaluate to 0 or C<"">.
3093 Emptying a file of existing contents, either automatically when
3094 opening a file for writing or explicitly via the
3095 L<truncate|perlfunc/truncate> function.
3099 See C<data type> and C<class>.
3103 Converting data from one type to another. C permits this. Perl does
3104 not need it. Nor want it.
3108 A C<lexical variable> that is declared with a C<class> type: C<my
3113 A type definition in the C language.
3117 Use of a single identifier, prefixed with C<*>. For example, C<*name>
3118 stands for any or all of C<$name>, C<@name>, C<%name>, C<&name>, or
3119 just C<name>. How you use it determines whether it is interpreted as
3120 all or only one of them. See L<perldata/Typeglobs and Filehandles>.
3124 A description of how C types may be transformed to and from Perl types
3125 within an C<extension> module written in C<XS>.
3133 User Datagram Protocol, the typical way to send C<datagram>s
3138 A user ID. Often used in the context of C<file> or C<process>
3143 A mask of those C<permission bits> that should be forced off when
3144 creating files or directories, in order to establish a policy of whom
3145 you'll ordinarily deny access to. See the L<umask|perlfunc/umask>
3148 =item unary operator
3150 An operator with only one C<operand>, like C<!> or
3151 L<chdir|perlfunc/chdir>. Unary operators are usually prefix
3152 operators; that is, they precede their operand. The C<++> and C<-->
3153 operators can be either prefix or postfix. (Their position I<does>
3154 change their meanings.)
3158 A character set comprising all the major character sets of the world,
3159 more or less. See L<http://www.unicode.org>.
3163 A very large and constantly evolving language with several alternative
3164 and largely incompatible syntaxes, in which anyone can define anything
3165 any way they choose, and usually do. Speakers of this language think
3166 it's easy to learn because it's so easily twisted to one's own ends,
3167 but dialectical differences make tribal intercommunication nearly
3168 impossible, and travelers are often reduced to a pidgin-like subset of
3169 the language. To be universally understood, a Unix shell programmer
3170 must spend years of study in the art. Many have abandoned this
3171 discipline and now communicate via an Esperanto-like language called
3174 In ancient times, Unix was also used to refer to some code that a
3175 couple of people at Bell Labs wrote to make use of a PDP-7 computer
3176 that wasn't doing much of anything else at the time.
3184 An actual piece of data, in contrast to all the variables, references,
3185 keys, indexes, operators, and whatnot that you need to access the
3190 A named storage location that can hold any of various kinds of
3191 C<value>, as your program sees fit.
3193 =item variable interpolation
3195 The C<interpolation> of a scalar or array variable into a string.
3199 Said of a C<function> that happily receives an indeterminate number
3200 of C<actual arguments>.
3204 Mathematical jargon for a list of C<scalar value>s.
3208 Providing the appearance of something without the reality, as in:
3209 virtual memory is not real memory. (See also C<memory>.) The
3210 opposite of "virtual" is "transparent", which means providing the
3211 reality of something without the appearance, as in: Perl handles the
3212 variable-length UTF-8 character encoding transparently.
3216 A form of C<scalar context> in which an C<expression> is not
3217 expected to return any C<value> at all and is evaluated for its
3218 C<side effects> alone.
3222 A "version" or "vector" C<string> specified with a C<v> followed by a
3223 series of decimal integers in dot notation, for instance,
3224 C<v1.20.300.4000>. Each number turns into a C<character> with the
3225 specified ordinal value. (The C<v> is optional when there are at
3226 least three integers.)
3234 A message printed to the C<STDERR> stream to the effect that something
3235 might be wrong but isn't worth blowing up over. See L<perlfunc/warn>
3236 and the L<warnings> pragma.
3238 =item watch expression
3240 An expression which, when its value changes, causes a breakpoint in
3245 A C<character> that moves your cursor but doesn't otherwise put
3246 anything on your screen. Typically refers to any of: space, tab, line
3247 feed, carriage return, or form feed.
3251 In normal "computerese", the piece of data of the size most
3252 efficiently handled by your computer, typically 32 bits or so, give or
3253 take a few powers of 2. In Perl culture, it more often refers to an
3254 alphanumeric C<identifier> (including underscores), or to a string of
3255 nonwhitespace C<character>s bounded by whitespace or string
3258 =item working directory
3260 Your current C<directory>, from which relative pathnames are
3261 interpreted by the C<operating system>. The operating system knows
3262 your current directory because you told it with a
3263 L<chdir|perlfunc/chdir> or because you started out in the place where
3264 your parent C<process> was when you were born.
3268 A program or subroutine that runs some other program or subroutine for
3269 you, modifying some of its input or output to better suit your
3274 What You See Is What You Get. Usually used when something that
3275 appears on the screen matches how it will eventually look, like Perl's
3276 L<format|perlfunc/format> declarations. Also used to mean the
3277 opposite of magic because everything works exactly as it appears, as
3278 in the three-argument form of L<open|perlfunc/open>.
3286 An extraordinarily exported, expeditiously excellent, expressly
3287 eXternal Subroutine, executed in existing C or C++ or in an exciting
3288 new extension language called (exasperatingly) XS. Examine L<perlxs>
3289 for the exact explanation or L<perlxstut> for an exemplary unexacting
3294 An external C<subroutine> defined in C<XS>.
3302 Yet Another Compiler Compiler. A parser generator without which Perl
3303 probably would not have existed. See the file I<perly.y> in the Perl
3304 source distribution.
3312 A subpattern C<assertion> matching the C<null string> between
3317 A process that has died (exited) but whose parent has not yet received
3318 proper notification of its demise by virtue of having called
3319 L<wait|perlfunc/wait> or L<waitpid|perlfunc/waitpid>. If you
3320 L<fork|perlfunc/fork>, you must clean up after your child processes
3321 when they exit, or else the process table will fill up and your system
3322 administrator will Not Be Happy with you.
3326 =head1 AUTHOR AND COPYRIGHT
3328 Based on the Glossary of Programming Perl, Third Edition,
3329 by Larry Wall, Tom Christiansen & Jon Orwant.
3330 Copyright (c) 2000, 1996, 1991 O'Reilly Media, Inc.
3331 Used with permission.