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