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.doc.ic.ac.uk/foldoc/index.html>,
12 the Jargon File <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". Backslashed decimal numbers ("\1", "\2", etc.)
197 later in the same pattern refer back to the corresponding
198 subpattern in the current match. Outside the pattern, the numbered
199 variables ($1, $2, etc.) continue to refer to these same values, as
200 long as the pattern was the last successful match of the current
201 dynamic scope.
202 backtracking
204 The practice of saying, "If I had to do it all over, I'd do it
205 differently," and then actually going back and doing it all over
206 differently. Mathematically speaking, it's returning from an
207 unsuccessful recursion on a tree of possibilities. Perl backtracks
208 when it attempts to match patterns with a "regular expression", and
209 its earlier attempts don't pan out. See "Backtracking" in perlre.
210 backward compatibility
212 Means you can still run your old program because we didn't break
213 any of the features or bugs it was relying on.
214 bareword
216 A word sufficiently ambiguous to be deemed illegal under use strict
217 'subs'. In the absence of that stricture, a bareword is treated as
218 if quotes were around it.
219 base class
221 A generic "object" type; that is, a "class" from which other, more
222 specific classes are derived genetically by "inheritance". Also
223 called a "superclass" by people who respect their ancestors.
224 big-endian
226 From Swift: someone who eats eggs big end first. Also used of
227 computers that store the most significant "byte" of a word at a
228 lower byte address than the least significant byte. Often
229 considered superior to little-endian machines. See also "little-
230 endian".
231 binary
233 Having to do with numbers represented in base 2. That means
234 there's basically two numbers, 0 and 1. Also used to describe a
235 "non-text file", presumably because such a file makes full use of
236 all the binary bits in its bytes. With the advent of "Unicode",
237 this distinction, already suspect, loses even more of its meaning.
238 binary operator
240 An "operator" that takes two operands.
241 bind
243 To assign a specific "network address" to a "socket".
244 bit An integer in the range from 0 to 1, inclusive. The smallest
246 possible unit of information storage. An eighth of a "byte" or of
247 a dollar. (The term "Pieces of Eight" comes from being able to
248 split the old Spanish dollar into 8 bits, each of which still
249 counted for money. That's why a 25-cent piece today is still "two
250 bits".)
251 bit shift
253 The movement of bits left or right in a computer word, which has
254 the effect of multiplying or dividing by a power of 2.
255 bit string
257 A sequence of bits that is actually being thought of as a sequence
258 of bits, for once.
259 bless
261 In corporate life, to grant official approval to a thing, as in,
262 "The VP of Engineering has blessed our WebCruncher project."
263 Similarly in Perl, to grant official approval to a "referent" so
264 that it can function as an "object", such as a WebCruncher object.
265 See "bless" in perlfunc.
266 block
268 What a "process" does when it has to wait for something: "My
269 process blocked waiting for the disk." As an unrelated noun, it
270 refers to a large chunk of data, of a size that the "operating
271 system" likes to deal with (normally a power of two such as 512 or
272 8192). Typically refers to a chunk of data that's coming from or
273 going to a disk file.
274 BLOCK
276 A syntactic construct consisting of a sequence of Perl statements
277 that is delimited by braces. The "if" and "while" statements are
278 defined in terms of BLOCKs, for instance. Sometimes we also say
279 "block" to mean a lexical scope; that is, a sequence of statements
280 that act like a "BLOCK", such as within an eval or a file, even
281 though the statements aren't delimited by braces.
282 block buffering
284 A method of making input and output efficient by passing one
285 "block" at a time. By default, Perl does block buffering to disk
286 files. See "buffer" and "command buffering".
287 Boolean
289 A value that is either "true" or "false".
290 Boolean context
292 A special kind of "scalar context" used in conditionals to decide
293 whether the "scalar value" returned by an expression is "true" or
294 "false". Does not evaluate as either a string or a number. See
295 "context".
296 breakpoint
298 A spot in your program where you've told the debugger to stop
299 execution so you can poke around and see whether anything is wrong
300 yet.
301 broadcast
303 To send a "datagram" to multiple destinations simultaneously.
304 BSD A psychoactive drug, popular in the 80s, probably developed at U.
306 C. Berkeley or thereabouts. Similar in many ways to the
307 prescription-only medication called "System V", but infinitely more
308 useful. (Or, at least, more fun.) The full chemical name is
309 "Berkeley Standard Distribution".
310 bucket
312 A location in a "hash table" containing (potentially) multiple
313 entries whose keys "hash" to the same hash value according to its
314 hash function. (As internal policy, you don't have to worry about
315 it, unless you're into internals, or policy.)
316 buffer
318 A temporary holding location for data. Block buffering means that
319 the data is passed on to its destination whenever the buffer is
320 full. Line buffering means that it's passed on whenever a complete
321 line is received. Command buffering means that it's passed every
322 time you do a print command (or equivalent). If your output is
323 unbuffered, the system processes it one byte at a time without the
324 use of a holding area. This can be rather inefficient.
325 built-in
327 A "function" that is predefined in the language. Even when hidden
328 by "overriding", you can always get at a built-in function by
329 qualifying its name with the "CORE::" pseudo-package.
330 bundle
332 A group of related modules on "CPAN". (Also, sometimes refers to a
333 group of command-line switches grouped into one "switch cluster".)
334 byte
336 A piece of data worth eight bits in most places.
337 bytecode
339 A pidgin-like language spoken among 'droids when they don't wish to
340 reveal their orientation (see "endian"). Named after some similar
341 languages spoken (for similar reasons) between compilers and
342 interpreters in the late 20th century. These languages are
343 characterized by representing everything as a non-architecture-
344 dependent sequence of bytes.
345 C
347 C A language beloved by many for its inside-out "type" definitions,
348 inscrutable "precedence" rules, and heavy "overloading" of the
349 function-call mechanism. (Well, actually, people first switched to
350 C because they found lowercase identifiers easier to read than
351 upper.) Perl is written in C, so it's not surprising that Perl
352 borrowed a few ideas from it.
353 C preprocessor
355 The typical C compiler's first pass, which processes lines
356 beginning with "#" for conditional compilation and macro definition
357 and does various manipulations of the program text based on the
358 current definitions. Also known as cpp(1).
359 call by reference
361 An "argument"-passing mechanism in which the "formal arguments"
362 refer directly to the "actual arguments", and the "subroutine" can
363 change the actual arguments by changing the formal arguments. That
364 is, the formal argument is an "alias" for the actual argument. See
365 also "call by value".
366 call by value
368 An "argument"-passing mechanism in which the "formal arguments"
369 refer to a copy of the "actual arguments", and the "subroutine"
370 cannot change the actual arguments by changing the formal
371 arguments. See also "call by reference".
372 callback
374 A "handler" that you register with some other part of your program
375 in the hope that the other part of your program will "trigger" your
376 handler when some event of interest transpires.
377 canonical
379 Reduced to a standard form to facilitate comparison.
380 capturing
382 The use of parentheses around a "subpattern" in a "regular
383 expression" to store the matched "substring" as a "backreference".
384 (Captured strings are also returned as a list in "list context".)
385 character
387 A small integer representative of a unit of orthography.
388 Historically, characters were usually stored as fixed-width
389 integers (typically in a byte, or maybe two, depending on the
390 character set), but with the advent of UTF-8, characters are often
391 stored in a variable number of bytes depending on the size of the
392 integer that represents the character. Perl manages this
393 transparently for you, for the most part.
394 character class
396 A square-bracketed list of characters used in a "regular
397 expression" to indicate that any character of the set may occur at
398 a given point. Loosely, any predefined set of characters so used.
399 character property
401 A predefined "character class" matchable by the "\p" "metasymbol".
402 Many standard properties are defined for "Unicode".
403 circumfix operator
405 An "operator" that surrounds its "operand", like the angle
406 operator, or parentheses, or a hug.
407 class
409 A user-defined "type", implemented in Perl via a "package" that
410 provides (either directly or by inheritance) methods (that is,
411 subroutines) to handle instances of the class (its objects). See
412 also "inheritance".
413 class method
415 A "method" whose "invocant" is a "package" name, not an "object"
416 reference. A method associated with the class as a whole.
417 client
419 In networking, a "process" that initiates contact with a "server"
420 process in order to exchange data and perhaps receive a service.
421 cloister
423 A "cluster" used to restrict the scope of a "regular expression
424 modifier".
425 closure
427 An "anonymous" subroutine that, when a reference to it is generated
428 at run time, keeps track of the identities of externally visible
429 lexical variables even after those lexical variables have
430 supposedly gone out of "scope". They're called "closures" because
431 this sort of behavior gives mathematicians a sense of closure.
432 cluster
434 A parenthesized "subpattern" used to group parts of a "regular
435 expression" into a single "atom".
436 CODE
438 The word returned by the ref function when you apply it to a
439 reference to a subroutine. See also "CV".
440 code generator
442 A system that writes code for you in a low-level language, such as
443 code to implement the backend of a compiler. See "program
444 generator".
445 code subpattern
447 A "regular expression" subpattern whose real purpose is to execute
448 some Perl code, for example, the "(?{...})" and "(??{...})"
449 subpatterns.
450 collating sequence
452 The order into which characters sort. This is used by "string"
453 comparison routines to decide, for example, where in this glossary
454 to put "collating sequence".
455 command
457 In "shell" programming, the syntactic combination of a program name
458 and its arguments. More loosely, anything you type to a shell (a
459 command interpreter) that starts it doing something. Even more
460 loosely, a Perl "statement", which might start with a "label" and
461 typically ends with a semicolon.
462 command buffering
464 A mechanism in Perl that lets you store up the output of each Perl
465 "command" and then flush it out as a single request to the
466 "operating system". It's enabled by setting the $| ($AUTOFLUSH)
467 variable to a true value. It's used when you don't want data
468 sitting around not going where it's supposed to, which may happen
469 because the default on a "file" or "pipe" is to use "block
470 buffering".
471 command name
473 The name of the program currently executing, as typed on the
474 command line. In C, the "command" name is passed to the program as
475 the first command-line argument. In Perl, it comes in separately
476 as $0.
477 command-line arguments
479 The values you supply along with a program name when you tell a
480 "shell" to execute a "command". These values are passed to a Perl
481 program through @ARGV.
482 comment
484 A remark that doesn't affect the meaning of the program. In Perl,
485 a comment is introduced by a "#" character and continues to the end
486 of the line.
487 compilation unit
489 The "file" (or "string", in the case of eval) that is currently
490 being compiled.
491 compile phase
493 Any time before Perl starts running your main program. See also
494 "run phase". Compile phase is mostly spent in "compile time", but
495 may also be spent in "run time" when "BEGIN" blocks, use
496 declarations, or constant subexpressions are being evaluated. The
497 startup and import code of any use declaration is also run during
498 compile phase.
499 compile time
501 The time when Perl is trying to make sense of your code, as opposed
502 to when it thinks it knows what your code means and is merely
503 trying to do what it thinks your code says to do, which is "run
504 time".
505 compiler
507 Strictly speaking, a program that munches up another program and
508 spits out yet another file containing the program in a "more
509 executable" form, typically containing native machine instructions.
510 The perl program is not a compiler by this definition, but it does
511 contain a kind of compiler that takes a program and turns it into a
512 more executable form (syntax trees) within the perl process itself,
513 which the "interpreter" then interprets. There are, however,
514 extension modules to get Perl to act more like a "real" compiler.
515 See O.
516 composer
518 A "constructor" for a "referent" that isn't really an "object",
519 like an anonymous array or a hash (or a sonata, for that matter).
520 For example, a pair of braces acts as a composer for a hash, and a
521 pair of brackets acts as a composer for an array. See "Making
522 References" in perlref.
523 concatenation
525 The process of gluing one cat's nose to another cat's tail. Also,
526 a similar operation on two strings.
527 conditional
529 Something "iffy". See "Boolean context".
530 connection
532 In telephony, the temporary electrical circuit between the caller's
533 and the callee's phone. In networking, the same kind of temporary
534 circuit between a "client" and a "server".
535 construct
537 As a noun, a piece of syntax made up of smaller pieces. As a
538 transitive verb, to create an "object" using a "constructor".
539 constructor
541 Any "class method", instance "method", or "subroutine" that
542 composes, initializes, blesses, and returns an "object". Sometimes
543 we use the term loosely to mean a "composer".
544 context
546 The surroundings, or environment. The context given by the
547 surrounding code determines what kind of data a particular
548 "expression" is expected to return. The three primary contexts are
549 "list context", "scalar context", and "void context". Scalar
550 context is sometimes subdivided into "Boolean context", "numeric
551 context", "string context", and "void context". There's also a
552 "don't care" scalar context (which is dealt with in Programming
553 Perl, Third Edition, Chapter 2, "Bits and Pieces" if you care).
554 continuation
556 The treatment of more than one physical "line" as a single logical
557 line. "Makefile" lines are continued by putting a backslash before
558 the "newline". Mail headers as defined by RFC 822 are continued by
559 putting a space or tab after the newline. In general, lines in
560 Perl do not need any form of continuation mark, because
561 "whitespace" (including newlines) is gleefully ignored. Usually.
562 core dump
564 The corpse of a "process", in the form of a file left in the
565 "working directory" of the process, usually as a result of certain
566 kinds of fatal error.
567 CPAN
569 The Comprehensive Perl Archive Network. (See "What modules and
570 extensions are available for Perl? What is CPAN? What does
571 CPAN/src/... mean?" in perlfaq2).
572 cracker
574 Someone who breaks security on computer systems. A cracker may be
575 a true "hacker" or only a "script kiddie".
576 current package
578 The "package" in which the current statement is compiled. Scan
579 backwards in the text of your program through the current lexical
580 scope or any enclosing lexical scopes till you find a package
581 declaration. That's your current package name.
582 current working directory
584 See "working directory".
585 currently selected output channel
587 The last "filehandle" that was designated with
588 select("FILEHANDLE"); "STDOUT", if no filehandle has been selected.
589 CV An internal "code value" typedef, holding a "subroutine". The "CV"
591 type is a subclass of "SV".
592 D
594 dangling statement
595 A bare, single "statement", without any braces, hanging off an "if"
596 or "while" conditional. C allows them. Perl doesn't.
597 data structure
599 How your various pieces of data relate to each other and what shape
600 they make when you put them all together, as in a rectangular table
601 or a triangular-shaped tree.
602 data type
604 A set of possible values, together with all the operations that
605 know how to deal with those values. For example, a numeric data
606 type has a certain set of numbers that you can work with and
607 various mathematical operations that you can do on the numbers but
608 would make little sense on, say, a string such as "Kilroy".
609 Strings have their own operations, such as "concatenation".
610 Compound types made of a number of smaller pieces generally have
611 operations to compose and decompose them, and perhaps to rearrange
612 them. Objects that model things in the real world often have
613 operations that correspond to real activities. For instance, if
614 you model an elevator, your elevator object might have an
615 "open_door()" "method".
616 datagram
618 A packet of data, such as a "UDP" message, that (from the viewpoint
619 of the programs involved) can be sent independently over the
620 network. (In fact, all packets are sent independently at the "IP"
621 level, but "stream" protocols such as "TCP" hide this from your
622 program.)
623 DBM Stands for "Data Base Management" routines, a set of routines that
625 emulate an "associative array" using disk files. The routines use
626 a dynamic hashing scheme to locate any entry with only two disk
627 accesses. DBM files allow a Perl program to keep a persistent
628 "hash" across multiple invocations. You can tie your hash
629 variables to various DBM implementations--see AnyDBM_File and
630 DB_File.
631 declaration
633 An "assertion" that states something exists and perhaps describes
634 what it's like, without giving any commitment as to how or where
635 you'll use it. A declaration is like the part of your recipe that
636 says, "two cups flour, one large egg, four or five tadpoles..."
637 See "statement" for its opposite. Note that some declarations also
638 function as statements. Subroutine declarations also act as
639 definitions if a body is supplied.
640 decrement
642 To subtract a value from a variable, as in "decrement $x" (meaning
643 to remove 1 from its value) or "decrement $x by 3".
644 default
646 A "value" chosen for you if you don't supply a value of your own.
647 defined
649 Having a meaning. Perl thinks that some of the things people try
650 to do are devoid of meaning, in particular, making use of variables
651 that have never been given a "value" and performing certain
652 operations on data that isn't there. For example, if you try to
653 read data past the end of a file, Perl will hand you back an
654 undefined value. See also "false" and "defined" in perlfunc.
655 delimiter
657 A "character" or "string" that sets bounds to an arbitrarily-sized
658 textual object, not to be confused with a "separator" or
659 "terminator". "To delimit" really just means "to surround" or "to
660 enclose" (like these parentheses are doing).
661 deprecated modules and features
663 Deprecated modules and features are those which were part of a
664 stable release, but later found to be subtly flawed, and which
665 should be avoided. They are subject to removal and/or bug-
666 incompatible reimplementation in the next major release (but they
667 will be preserved through maintenance releases). Deprecation
668 warnings are issued under -w or "use diagnostics", and notices are
669 found in perldeltas, as well as various other PODs. Coding
670 practices that misuse features, such as "my $foo if 0", can also be
671 deprecated.
672 dereference
674 A fancy computer science term meaning "to follow a "reference" to
675 what it points to". The "de" part of it refers to the fact that
676 you're taking away one level of "indirection".
677 derived class
679 A "class" that defines some of its methods in terms of a more
680 generic class, called a "base class". Note that classes aren't
681 classified exclusively into base classes or derived classes: a
682 class can function as both a derived class and a base class
683 simultaneously, which is kind of classy.
684 descriptor
686 See "file descriptor".
687 destroy
689 To deallocate the memory of a "referent" (first triggering its
690 "DESTROY" method, if it has one).
691 destructor
693 A special "method" that is called when an "object" is thinking
694 about destroying itself. A Perl program's "DESTROY" method doesn't
695 do the actual destruction; Perl just triggers the method in case
696 the "class" wants to do any associated cleanup.
697 device
699 A whiz-bang hardware gizmo (like a disk or tape drive or a modem or
700 a joystick or a mouse) attached to your computer, that the
701 "operating system" tries to make look like a "file" (or a bunch of
702 files). Under Unix, these fake files tend to live in the /dev
703 directory.
704 directive
706 A "pod" directive. See perlpod.
707 directory
709 A special file that contains other files. Some operating systems
710 call these "folders", "drawers", or "catalogs".
711 directory handle
713 A name that represents a particular instance of opening a directory
714 to read it, until you close it. See the opendir function.
715 dispatch
717 To send something to its correct destination. Often used
718 metaphorically to indicate a transfer of programmatic control to a
719 destination selected algorithmically, often by lookup in a table of
720 function references or, in the case of object methods, by
721 traversing the inheritance tree looking for the most specific
722 definition for the method.
723 distribution
725 A standard, bundled release of a system of software. The default
726 usage implies source code is included. If that is not the case, it
727 will be called a "binary-only" distribution.
728 (to be) dropped modules
730 When Perl 5 was first released (see perlhistory), several modules
731 were included, which have now fallen out of common use. It has
732 been suggested that these modules should be removed, since the
733 distribution became rather large, and the common criterion for new
734 module additions is now limited to modules that help to build,
735 test, and extend perl itself. Furthermore, the CPAN (which didn't
736 exist at the time of Perl 5.0) can become the new home of dropped
737 modules. Dropping modules is currently not an option, but further
738 developments may clear the last barriers.
739 dweomer
741 An enchantment, illusion, phantasm, or jugglery. Said when Perl's
742 magical "dwimmer" effects don't do what you expect, but rather seem
743 to be the product of arcane dweomercraft, sorcery, or wonder
744 working. [From Old English]
745 dwimmer
747 DWIM is an acronym for "Do What I Mean", the principle that
748 something should just do what you want it to do without an undue
749 amount of fuss. A bit of code that does "dwimming" is a "dwimmer".
750 Dwimming can require a great deal of behind-the-scenes magic, which
751 (if it doesn't stay properly behind the scenes) is called a
752 "dweomer" instead.
753 dynamic scoping
755 Dynamic scoping works over a dynamic scope, making variables
756 visible throughout the rest of the "block" in which they are first
757 used and in any subroutines that are called by the rest of the
758 block. Dynamically scoped variables can have their values
759 temporarily changed (and implicitly restored later) by a local
760 operator. (Compare "lexical scoping".) Used more loosely to mean
761 how a subroutine that is in the middle of calling another
762 subroutine "contains" that subroutine at "run time".
763 E
765 eclectic
766 Derived from many sources. Some would say too many.
767 element
769 A basic building block. When you're talking about an "array", it's
770 one of the items that make up the array.
771 embedding
773 When something is contained in something else, particularly when
774 that might be considered surprising: "I've embedded a complete Perl
775 interpreter in my editor!"
776 empty subclass test
778 The notion that an empty "derived class" should behave exactly like
779 its "base class".
780 en passant
782 When you change a "value" as it is being copied. [From French, "in
783 passing", as in the exotic pawn-capturing maneuver in chess.]
784 encapsulation
786 The veil of abstraction separating the "interface" from the
787 "implementation" (whether enforced or not), which mandates that all
788 access to an "object"'s state be through methods alone.
789 endian
791 See "little-endian" and "big-endian".
792 environment
794 The collective set of environment variables your "process" inherits
795 from its parent. Accessed via %ENV.
796 environment variable
798 A mechanism by which some high-level agent such as a user can pass
799 its preferences down to its future offspring (child processes,
800 grandchild processes, great-grandchild processes, and so on). Each
801 environment variable is a "key"/"value" pair, like one entry in a
802 "hash".
803 EOF End of File. Sometimes used metaphorically as the terminating
805 string of a "here document".
806 errno
808 The error number returned by a "syscall" when it fails. Perl
809 refers to the error by the name $! (or $OS_ERROR if you use the
810 English module).
811 error
813 See "exception" or "fatal error".
814 escape sequence
816 See "metasymbol".
817 exception
819 A fancy term for an error. See "fatal error".
820 exception handling
822 The way a program responds to an error. The exception handling
823 mechanism in Perl is the eval operator.
824 exec
826 To throw away the current "process"'s program and replace it with
827 another without exiting the process or relinquishing any resources
828 held (apart from the old memory image).
829 executable file
831 A "file" that is specially marked to tell the "operating system"
832 that it's okay to run this file as a program. Usually shortened to
833 "executable".
834 execute
836 To run a program or "subroutine". (Has nothing to do with the kill
837 built-in, unless you're trying to run a "signal handler".)
838 execute bit
840 The special mark that tells the operating system it can run this
841 program. There are actually three execute bits under Unix, and
842 which bit gets used depends on whether you own the file singularly,
843 collectively, or not at all.
844 exit status
846 See "status".
847 export
849 To make symbols from a "module" available for "import" by other
850 modules.
851 expression
853 Anything you can legally say in a spot where a "value" is required.
854 Typically composed of literals, variables, operators, functions,
855 and "subroutine" calls, not necessarily in that order.
856 extension
858 A Perl module that also pulls in compiled C or C++ code. More
859 generally, any experimental option that can be compiled into Perl,
860 such as multithreading.
861 F
863 false
864 In Perl, any value that would look like "" or "0" if evaluated in a
865 string context. Since undefined values evaluate to "", all
866 undefined values are false, but not all false values are undefined.
867 FAQ Frequently Asked Question (although not necessarily frequently
869 answered, especially if the answer appears in the Perl FAQ shipped
870 standard with Perl).
871 fatal error
873 An uncaught "exception", which causes termination of the "process"
874 after printing a message on your "standard error" stream. Errors
875 that happen inside an eval are not fatal. Instead, the eval
876 terminates after placing the exception message in the $@
877 ($EVAL_ERROR) variable. You can try to provoke a fatal error with
878 the die operator (known as throwing or raising an exception), but
879 this may be caught by a dynamically enclosing eval. If not caught,
880 the die becomes a fatal error.
881 field
883 A single piece of numeric or string data that is part of a longer
884 "string", "record", or "line". Variable-width fields are usually
885 split up by separators (so use split to extract the fields), while
886 fixed-width fields are usually at fixed positions (so use unpack).
887 Instance variables are also known as fields.
888 FIFO
890 First In, First Out. See also "LIFO". Also, a nickname for a
891 "named pipe".
892 file
894 A named collection of data, usually stored on disk in a "directory"
895 in a "filesystem". Roughly like a document, if you're into office
896 metaphors. In modern filesystems, you can actually give a file
897 more than one name. Some files have special properties, like
898 directories and devices.
899 file descriptor
901 The little number the "operating system" uses to keep track of
902 which opened "file" you're talking about. Perl hides the file
903 descriptor inside a "standard I/O" stream and then attaches the
904 stream to a "filehandle".
905 file test operator
907 A built-in unary operator that you use to determine whether
908 something is "true" about a file, such as "-o $filename" to test
909 whether you're the owner of the file.
910 fileglob
912 A "wildcard" match on filenames. See the glob function.
913 filehandle
915 An identifier (not necessarily related to the real name of a file)
916 that represents a particular instance of opening a file until you
917 close it. If you're going to open and close several different
918 files in succession, it's fine to open each of them with the same
919 filehandle, so you don't have to write out separate code to process
920 each file.
921 filename
923 One name for a file. This name is listed in a "directory", and you
924 can use it in an open to tell the "operating system" exactly which
925 file you want to open, and associate the file with a "filehandle"
926 which will carry the subsequent identity of that file in your
927 program, until you close it.
928 filesystem
930 A set of directories and files residing on a partition of the disk.
931 Sometimes known as a "partition". You can change the file's name
932 or even move a file around from directory to directory within a
933 filesystem without actually moving the file itself, at least under
934 Unix.
935 filter
937 A program designed to take a "stream" of input and transform it
938 into a stream of output.
939 flag
941 We tend to avoid this term because it means so many things. It may
942 mean a command-line "switch" that takes no argument itself (such as
943 Perl's -n and -p flags) or, less frequently, a single-bit indicator
944 (such as the "O_CREAT" and "O_EXCL" flags used in sysopen).
945 floating point
947 A method of storing numbers in "scientific notation", such that the
948 precision of the number is independent of its magnitude (the
949 decimal point "floats"). Perl does its numeric work with floating-
950 point numbers (sometimes called "floats"), when it can't get away
951 with using integers. Floating-point numbers are mere
952 approximations of real numbers.
953 flush
955 The act of emptying a "buffer", often before it's full.
956 FMTEYEWTK
958 Far More Than Everything You Ever Wanted To Know. An exhaustive
959 treatise on one narrow topic, something of a super-"FAQ". See Tom
960 for far more.
961 fork
963 To create a child "process" identical to the parent process at its
964 moment of conception, at least until it gets ideas of its own. A
965 thread with protected memory.
966 formal arguments
968 The generic names by which a "subroutine" knows its arguments. In
969 many languages, formal arguments are always given individual names,
970 but in Perl, the formal arguments are just the elements of an
971 array. The formal arguments to a Perl program are $ARGV[0],
972 $ARGV[1], and so on. Similarly, the formal arguments to a Perl
973 subroutine are $_[0], $_[1], and so on. You may give the arguments
974 individual names by assigning the values to a my list. See also
975 "actual arguments".
976 format
978 A specification of how many spaces and digits and things to put
979 somewhere so that whatever you're printing comes out nice and
980 pretty.
981 freely available
983 Means you don't have to pay money to get it, but the copyright on
984 it may still belong to someone else (like Larry).
985 freely redistributable
987 Means you're not in legal trouble if you give a bootleg copy of it
988 to your friends and we find out about it. In fact, we'd rather you
989 gave a copy to all your friends.
990 freeware
992 Historically, any software that you give away, particularly if you
993 make the source code available as well. Now often called "open
994 source software". Recently there has been a trend to use the term
995 in contradistinction to "open source software", to refer only to
996 free software released under the Free Software Foundation's GPL
997 (General Public License), but this is difficult to justify
998 etymologically.
999 function
1001 Mathematically, a mapping of each of a set of input values to a
1002 particular output value. In computers, refers to a "subroutine" or
1003 "operator" that returns a "value". It may or may not have input
1004 values (called arguments).
1005 funny character
1007 Someone like Larry, or one of his peculiar friends. Also refers to
1008 the strange prefixes that Perl requires as noun markers on its
1009 variables.
1010 garbage collection
1012 A misnamed feature--it should be called, "expecting your mother to
1013 pick up after you". Strictly speaking, Perl doesn't do this, but
1014 it relies on a reference-counting mechanism to keep things tidy.
1015 However, we rarely speak strictly and will often refer to the
1016 reference-counting scheme as a form of garbage collection. (If
1017 it's any comfort, when your interpreter exits, a "real" garbage
1018 collector runs to make sure everything is cleaned up if you've been
1019 messy with circular references and such.)
1020 G
1022 GID Group ID--in Unix, the numeric group ID that the "operating system"
1023 uses to identify you and members of your "group".
1024 glob
1026 Strictly, the shell's "*" character, which will match a "glob" of
1027 characters when you're trying to generate a list of filenames.
1028 Loosely, the act of using globs and similar symbols to do pattern
1029 matching. See also "fileglob" and "typeglob".
1030 global
1032 Something you can see from anywhere, usually used of variables and
1033 subroutines that are visible everywhere in your program. In Perl,
1034 only certain special variables are truly global--most variables
1035 (and all subroutines) exist only in the current "package". Global
1036 variables can be declared with our. See "our" in perlfunc.
1037 global destruction
1039 The "garbage collection" of globals (and the running of any
1040 associated object destructors) that takes place when a Perl
1041 "interpreter" is being shut down. Global destruction should not be
1042 confused with the Apocalypse, except perhaps when it should.
1043 glue language
1045 A language such as Perl that is good at hooking things together
1046 that weren't intended to be hooked together.
1047 granularity
1049 The size of the pieces you're dealing with, mentally speaking.
1050 greedy
1052 A "subpattern" whose "quantifier" wants to match as many things as
1053 possible.
1054 grep
1056 Originally from the old Unix editor command for "Globally search
1057 for a Regular Expression and Print it", now used in the general
1058 sense of any kind of search, especially text searches. Perl has a
1059 built-in grep function that searches a list for elements matching
1060 any given criterion, whereas the grep(1) program searches for lines
1061 matching a "regular expression" in one or more files.
1062 group
1064 A set of users of which you are a member. In some operating
1065 systems (like Unix), you can give certain file access permissions
1066 to other members of your group.
1067 GV An internal "glob value" typedef, holding a "typeglob". The "GV"
1069 type is a subclass of "SV".
1070 H
1072 hacker
1073 Someone who is brilliantly persistent in solving technical
1074 problems, whether these involve golfing, fighting orcs, or
1075 programming. Hacker is a neutral term, morally speaking. Good
1076 hackers are not to be confused with evil crackers or clueless
1077 script kiddies. If you confuse them, we will presume that you are
1078 either evil or clueless.
1079 handler
1081 A "subroutine" or "method" that is called by Perl when your program
1082 needs to respond to some internal event, such as a "signal", or an
1083 encounter with an operator subject to "operator overloading". See
1084 also "callback".
1085 hard reference
1087 A "scalar" "value" containing the actual address of a "referent",
1088 such that the referent's "reference" count accounts for it. (Some
1089 hard references are held internally, such as the implicit reference
1090 from one of a "typeglob"'s variable slots to its corresponding
1091 referent.) A hard reference is different from a "symbolic
1092 reference".
1093 hash
1095 An unordered association of "key"/"value" pairs, stored such that
1096 you can easily use a string "key" to look up its associated data
1097 "value". This glossary is like a hash, where the word to be
1098 defined is the key, and the definition is the value. A hash is
1099 also sometimes septisyllabically called an "associative array",
1100 which is a pretty good reason for simply calling it a "hash"
1101 instead.
1102 hash table
1104 A data structure used internally by Perl for implementing
1105 associative arrays (hashes) efficiently. See also "bucket".
1106 header file
1108 A file containing certain required definitions that you must
1109 include "ahead" of the rest of your program to do certain obscure
1110 operations. A C header file has a .h extension. Perl doesn't
1111 really have header files, though historically Perl has sometimes
1112 used translated .h files with a .ph extension. See "require" in
1113 perlfunc. (Header files have been superseded by the "module"
1114 mechanism.)
1115 here document
1117 So called because of a similar construct in shells that pretends
1118 that the lines following the "command" are a separate "file" to be
1119 fed to the command, up to some terminating string. In Perl,
1120 however, it's just a fancy form of quoting.
1121 hexadecimal
1123 A number in base 16, "hex" for short. The digits for 10 through 16
1124 are customarily represented by the letters "a" through "f".
1125 Hexadecimal constants in Perl start with "0x". See also "hex" in
1126 perlfunc.
1127 home directory
1129 The directory you are put into when you log in. On a Unix system,
1130 the name is often placed into $ENV{HOME} or $ENV{LOGDIR} by login,
1131 but you can also find it with "(getpwuid($<))[7]". (Some platforms
1132 do not have a concept of a home directory.)
1133 host
1135 The computer on which a program or other data resides.
1136 hubris
1138 Excessive pride, the sort of thing Zeus zaps you for. Also the
1139 quality that makes you write (and maintain) programs that other
1140 people won't want to say bad things about. Hence, the third great
1141 virtue of a programmer. See also "laziness" and "impatience".
1142 HV Short for a "hash value" typedef, which holds Perl's internal
1144 representation of a hash. The "HV" type is a subclass of "SV".
1145 I
1147 identifier
1148 A legally formed name for most anything in which a computer program
1149 might be interested. Many languages (including Perl) allow
1150 identifiers that start with a letter and contain letters and
1151 digits. Perl also counts the underscore character as a valid
1152 letter. (Perl also has more complicated names, such as "qualified"
1153 names.)
1154 impatience
1156 The anger you feel when the computer is being lazy. This makes you
1157 write programs that don't just react to your needs, but actually
1158 anticipate them. Or at least that pretend to. Hence, the second
1159 great virtue of a programmer. See also "laziness" and "hubris".
1160 implementation
1162 How a piece of code actually goes about doing its job. Users of
1163 the code should not count on implementation details staying the
1164 same unless they are part of the published "interface".
1165 import
1167 To gain access to symbols that are exported from another module.
1168 See "use" in perlfunc.
1169 increment
1171 To increase the value of something by 1 (or by some other number,
1172 if so specified).
1173 indexing
1175 In olden days, the act of looking up a "key" in an actual index
1176 (such as a phone book), but now merely the act of using any kind of
1177 key or position to find the corresponding "value", even if no index
1178 is involved. Things have degenerated to the point that Perl's
1179 index function merely locates the position (index) of one string in
1180 another.
1181 indirect filehandle
1183 An "expression" that evaluates to something that can be used as a
1184 "filehandle": a "string" (filehandle name), a "typeglob", a
1185 typeglob "reference", or a low-level "IO" object.
1186 indirect object
1188 In English grammar, a short noun phrase between a verb and its
1189 direct object indicating the beneficiary or recipient of the
1190 action. In Perl, "print STDOUT "$foo\n";" can be understood as
1191 "verb indirect-object object" where "STDOUT" is the recipient of
1192 the print action, and "$foo" is the object being printed.
1193 Similarly, when invoking a "method", you might place the invocant
1194 between the method and its arguments:
1195 $gollum = new Pathetic::Creature "Smeagol";
1197 give $gollum "Fisssssh!";
1198 give $gollum "Precious!";
1199 In modern Perl, calling methods this way is often considered bad
1201 practice and to be avoided.
1202 indirect object slot
1204 The syntactic position falling between a method call and its
1205 arguments when using the indirect object invocation syntax. (The
1206 slot is distinguished by the absence of a comma between it and the
1207 next argument.) "STDERR" is in the indirect object slot here:
1208 print STDERR "Awake! Awake! Fear, Fire,
1210 Foes! Awake!\n";
1211 indirection
1213 If something in a program isn't the value you're looking for but
1214 indicates where the value is, that's indirection. This can be done
1215 with either symbolic references or hard references.
1216 infix
1218 An "operator" that comes in between its operands, such as
1219 multiplication in "24 * 7".
1220 inheritance
1222 What you get from your ancestors, genetically or otherwise. If you
1223 happen to be a "class", your ancestors are called base classes and
1224 your descendants are called derived classes. See "single
1225 inheritance" and "multiple inheritance".
1226 instance
1228 Short for "an instance of a class", meaning an "object" of that
1229 "class".
1230 instance variable
1232 An "attribute" of an "object"; data stored with the particular
1233 object rather than with the class as a whole.
1234 integer
1236 A number with no fractional (decimal) part. A counting number,
1237 like 1, 2, 3, and so on, but including 0 and the negatives.
1238 interface
1240 The services a piece of code promises to provide forever, in
1241 contrast to its "implementation", which it should feel free to
1242 change whenever it likes.
1243 interpolation
1245 The insertion of a scalar or list value somewhere in the middle of
1246 another value, such that it appears to have been there all along.
1247 In Perl, variable interpolation happens in double-quoted strings
1248 and patterns, and list interpolation occurs when constructing the
1249 list of values to pass to a list operator or other such construct
1250 that takes a "LIST".
1251 interpreter
1253 Strictly speaking, a program that reads a second program and does
1254 what the second program says directly without turning the program
1255 into a different form first, which is what compilers do. Perl is
1256 not an interpreter by this definition, because it contains a kind
1257 of compiler that takes a program and turns it into a more
1258 executable form (syntax trees) within the perl process itself,
1259 which the Perl "run time" system then interprets.
1260 invocant
1262 The agent on whose behalf a "method" is invoked. In a "class"
1263 method, the invocant is a package name. In an "instance" method,
1264 the invocant is an object reference.
1265 invocation
1267 The act of calling up a deity, daemon, program, method, subroutine,
1268 or function to get it do what you think it's supposed to do. We
1269 usually "call" subroutines but "invoke" methods, since it sounds
1270 cooler.
1271 I/O Input from, or output to, a "file" or "device".
1273 IO An internal I/O object. Can also mean "indirect object".
1275 IP Internet Protocol, or Intellectual Property.
1277 IPC Interprocess Communication.
1279 is-a
1281 A relationship between two objects in which one object is
1282 considered to be a more specific version of the other, generic
1283 object: "A camel is a mammal." Since the generic object really
1284 only exists in a Platonic sense, we usually add a little
1285 abstraction to the notion of objects and think of the relationship
1286 as being between a generic "base class" and a specific "derived
1287 class". Oddly enough, Platonic classes don't always have Platonic
1288 relationships--see "inheritance".
1289 iteration
1291 Doing something repeatedly.
1292 iterator
1294 A special programming gizmo that keeps track of where you are in
1295 something that you're trying to iterate over. The "foreach" loop
1296 in Perl contains an iterator; so does a hash, allowing you to each
1297 through it.
1298 IV The integer four, not to be confused with six, Tom's favorite
1300 editor. IV also means an internal Integer Value of the type a
1301 "scalar" can hold, not to be confused with an "NV".
1302 J
1304 JAPH
1305 "Just Another Perl Hacker," a clever but cryptic bit of Perl code
1306 that when executed, evaluates to that string. Often used to
1307 illustrate a particular Perl feature, and something of an ongoing
1308 Obfuscated Perl Contest seen in Usenix signatures.
1309 K
1311 key The string index to a "hash", used to look up the "value"
1312 associated with that key.
1313 keyword
1315 See "reserved words".
1316 L
1318 label
1319 A name you give to a "statement" so that you can talk about that
1320 statement elsewhere in the program.
1321 laziness
1323 The quality that makes you go to great effort to reduce overall
1324 energy expenditure. It makes you write labor-saving programs that
1325 other people will find useful, and document what you wrote so you
1326 don't have to answer so many questions about it. Hence, the first
1327 great virtue of a programmer. Also hence, this book. See also
1328 "impatience" and "hubris".
1329 left shift
1331 A "bit shift" that multiplies the number by some power of 2.
1332 leftmost longest
1334 The preference of the "regular expression" engine to match the
1335 leftmost occurrence of a "pattern", then given a position at which
1336 a match will occur, the preference for the longest match (presuming
1337 the use of a "greedy" quantifier). See perlre for much more on
1338 this subject.
1339 lexeme
1341 Fancy term for a "token".
1342 lexer
1344 Fancy term for a "tokener".
1345 lexical analysis
1347 Fancy term for "tokenizing".
1348 lexical scoping
1350 Looking at your Oxford English Dictionary through a microscope.
1351 (Also known as "static scoping", because dictionaries don't change
1352 very fast.) Similarly, looking at variables stored in a private
1353 dictionary (namespace) for each scope, which are visible only from
1354 their point of declaration down to the end of the lexical scope in
1355 which they are declared. --Syn. "static scoping". --Ant. "dynamic
1356 scoping".
1357 lexical variable
1359 A "variable" subject to "lexical scoping", declared by my. Often
1360 just called a "lexical". (The our declaration declares a lexically
1361 scoped name for a global variable, which is not itself a lexical
1362 variable.)
1363 library
1365 Generally, a collection of procedures. In ancient days, referred
1366 to a collection of subroutines in a .pl file. In modern times,
1367 refers more often to the entire collection of Perl modules on your
1368 system.
1369 LIFO
1371 Last In, First Out. See also "FIFO". A LIFO is usually called a
1372 "stack".
1373 line
1375 In Unix, a sequence of zero or more non-newline characters
1376 terminated with a "newline" character. On non-Unix machines, this
1377 is emulated by the C library even if the underlying "operating
1378 system" has different ideas.
1379 line buffering
1381 Used by a "standard I/O" output stream that flushes its "buffer"
1382 after every "newline". Many standard I/O libraries automatically
1383 set up line buffering on output that is going to the terminal.
1384 line number
1386 The number of lines read previous to this one, plus 1. Perl keeps
1387 a separate line number for each source or input file it opens. The
1388 current source file's line number is represented by "__LINE__".
1389 The current input line number (for the file that was most recently
1390 read via "<FH>") is represented by the $. ($INPUT_LINE_NUMBER)
1391 variable. Many error messages report both values, if available.
1392 link
1394 Used as a noun, a name in a "directory", representing a "file". A
1395 given file can have multiple links to it. It's like having the
1396 same phone number listed in the phone directory under different
1397 names. As a verb, to resolve a partially compiled file's
1398 unresolved symbols into a (nearly) executable image. Linking can
1399 generally be static or dynamic, which has nothing to do with static
1400 or dynamic scoping.
1401 LIST
1403 A syntactic construct representing a comma-separated list of
1404 expressions, evaluated to produce a "list value". Each
1405 "expression" in a "LIST" is evaluated in "list context" and
1406 interpolated into the list value.
1407 list
1409 An ordered set of scalar values.
1410 list context
1412 The situation in which an "expression" is expected by its
1413 surroundings (the code calling it) to return a list of values
1414 rather than a single value. Functions that want a "LIST" of
1415 arguments tell those arguments that they should produce a list
1416 value. See also "context".
1417 list operator
1419 An "operator" that does something with a list of values, such as
1420 join or grep. Usually used for named built-in operators (such as
1421 print, unlink, and system) that do not require parentheses around
1422 their "argument" list.
1423 list value
1425 An unnamed list of temporary scalar values that may be passed
1426 around within a program from any list-generating function to any
1427 function or construct that provides a "list context".
1428 literal
1430 A token in a programming language such as a number or "string" that
1431 gives you an actual "value" instead of merely representing possible
1432 values as a "variable" does.
1433 little-endian
1435 From Swift: someone who eats eggs little end first. Also used of
1436 computers that store the least significant "byte" of a word at a
1437 lower byte address than the most significant byte. Often
1438 considered superior to big-endian machines. See also "big-endian".
1439 local
1441 Not meaning the same thing everywhere. A global variable in Perl
1442 can be localized inside a dynamic scope via the local operator.
1443 logical operator
1445 Symbols representing the concepts "and", "or", "xor", and "not".
1446 lookahead
1448 An "assertion" that peeks at the string to the right of the current
1449 match location.
1450 lookbehind
1452 An "assertion" that peeks at the string to the left of the current
1453 match location.
1454 loop
1456 A construct that performs something repeatedly, like a roller
1457 coaster.
1458 loop control statement
1460 Any statement within the body of a loop that can make a loop
1461 prematurely stop looping or skip an "iteration". Generally you
1462 shouldn't try this on roller coasters.
1463 loop label
1465 A kind of key or name attached to a loop (or roller coaster) so
1466 that loop control statements can talk about which loop they want to
1467 control.
1468 lvaluable
1470 Able to serve as an "lvalue".
1471 lvalue
1473 Term used by language lawyers for a storage location you can assign
1474 a new "value" to, such as a "variable" or an element of an "array".
1475 The "l" is short for "left", as in the left side of an assignment,
1476 a typical place for lvalues. An "lvaluable" function or expression
1477 is one to which a value may be assigned, as in "pos($x) = 10".
1478 lvalue modifier
1480 An adjectival pseudofunction that warps the meaning of an "lvalue"
1481 in some declarative fashion. Currently there are three lvalue
1482 modifiers: my, our, and local.
1483 M
1485 magic
1486 Technically speaking, any extra semantics attached to a variable
1487 such as $!, $0, %ENV, or %SIG, or to any tied variable. Magical
1488 things happen when you diddle those variables.
1489 magical increment
1491 An "increment" operator that knows how to bump up alphabetics as
1492 well as numbers.
1493 magical variables
1495 Special variables that have side effects when you access them or
1496 assign to them. For example, in Perl, changing elements of the
1497 %ENV array also changes the corresponding environment variables
1498 that subprocesses will use. Reading the $! variable gives you the
1499 current system error number or message.
1500 Makefile
1502 A file that controls the compilation of a program. Perl programs
1503 don't usually need a "Makefile" because the Perl compiler has
1504 plenty of self-control.
1505 man The Unix program that displays online documentation (manual pages)
1507 for you.
1508 manpage
1510 A "page" from the manuals, typically accessed via the man(1)
1511 command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
1512 BUGS, and so on, and is typically longer than a page. There are
1513 manpages documenting commands, syscalls, "library" functions,
1514 devices, protocols, files, and such. In this book, we call any
1515 piece of standard Perl documentation (like perlop or perldelta) a
1516 manpage, no matter what format it's installed in on your system.
1517 matching
1519 See "pattern matching".
1520 member data
1522 See "instance variable".
1523 memory
1525 This always means your main memory, not your disk. Clouding the
1526 issue is the fact that your machine may implement "virtual" memory;
1527 that is, it will pretend that it has more memory than it really
1528 does, and it'll use disk space to hold inactive bits. This can
1529 make it seem like you have a little more memory than you really do,
1530 but it's not a substitute for real memory. The best thing that can
1531 be said about virtual memory is that it lets your performance
1532 degrade gradually rather than suddenly when you run out of real
1533 memory. But your program can die when you run out of virtual
1534 memory too, if you haven't thrashed your disk to death first.
1535 metacharacter
1537 A "character" that is not supposed to be treated normally. Which
1538 characters are to be treated specially as metacharacters varies
1539 greatly from context to context. Your "shell" will have certain
1540 metacharacters, double-quoted Perl strings have other
1541 metacharacters, and "regular expression" patterns have all the
1542 double-quote metacharacters plus some extra ones of their own.
1543 metasymbol
1545 Something we'd call a "metacharacter" except that it's a sequence
1546 of more than one character. Generally, the first character in the
1547 sequence must be a true metacharacter to get the other characters
1548 in the metasymbol to misbehave along with it.
1549 method
1551 A kind of action that an "object" can take if you tell it to. See
1552 perlobj.
1553 minimalism
1555 The belief that "small is beautiful." Paradoxically, if you say
1556 something in a small language, it turns out big, and if you say it
1557 in a big language, it turns out small. Go figure.
1558 mode
1560 In the context of the stat syscall, refers to the field holding the
1561 "permission bits" and the type of the "file".
1562 modifier
1564 See "statement modifier", "regular expression modifier", and
1565 "lvalue modifier", not necessarily in that order.
1566 module
1568 A "file" that defines a "package" of (almost) the same name, which
1569 can either "export" symbols or function as an "object" class. (A
1570 module's main .pm file may also load in other files in support of
1571 the module.) See the use built-in.
1572 modulus
1574 An integer divisor when you're interested in the remainder instead
1575 of the quotient.
1576 monger
1578 Short for Perl Monger, a purveyor of Perl.
1579 mortal
1581 A temporary value scheduled to die when the current statement
1582 finishes.
1583 multidimensional array
1585 An array with multiple subscripts for finding a single element.
1586 Perl implements these using references--see perllol and perldsc.
1587 multiple inheritance
1589 The features you got from your mother and father, mixed together
1590 unpredictably. (See also "inheritance", and "single inheritance".)
1591 In computer languages (including Perl), the notion that a given
1592 class may have multiple direct ancestors or base classes.
1593 N
1595 named pipe
1596 A "pipe" with a name embedded in the "filesystem" so that it can be
1597 accessed by two unrelated processes.
1598 namespace
1600 A domain of names. You needn't worry about whether the names in
1601 one such domain have been used in another. See "package".
1602 network address
1604 The most important attribute of a socket, like your telephone's
1605 telephone number. Typically an IP address. See also "port".
1606 newline
1608 A single character that represents the end of a line, with the
1609 ASCII value of 012 octal under Unix (but 015 on a Mac), and
1610 represented by "\n" in Perl strings. For Windows machines writing
1611 text files, and for certain physical devices like terminals, the
1612 single newline gets automatically translated by your C library into
1613 a line feed and a carriage return, but normally, no translation is
1614 done.
1615 NFS Network File System, which allows you to mount a remote filesystem
1617 as if it were local.
1618 null character
1620 A character with the ASCII value of zero. It's used by C to
1621 terminate strings, but Perl allows strings to contain a null.
1622 null list
1624 A "list value" with zero elements, represented in Perl by "()".
1625 null string
1627 A "string" containing no characters, not to be confused with a
1628 string containing a "null character", which has a positive length
1629 and is "true".
1630 numeric context
1632 The situation in which an expression is expected by its
1633 surroundings (the code calling it) to return a number. See also
1634 "context" and "string context".
1635 NV Short for Nevada, no part of which will ever be confused with
1637 civilization. NV also means an internal floating-point Numeric
1638 Value of the type a "scalar" can hold, not to be confused with an
1639 "IV".
1640 nybble
1642 Half a "byte", equivalent to one "hexadecimal" digit, and worth
1643 four bits.
1644 O
1646 object
1647 An "instance" of a "class". Something that "knows" what user-
1648 defined type (class) it is, and what it can do because of what
1649 class it is. Your program can request an object to do things, but
1650 the object gets to decide whether it wants to do them or not. Some
1651 objects are more accommodating than others.
1652 octal
1654 A number in base 8. Only the digits 0 through 7 are allowed.
1655 Octal constants in Perl start with 0, as in 013. See also the oct
1656 function.
1657 offset
1659 How many things you have to skip over when moving from the
1660 beginning of a string or array to a specific position within it.
1661 Thus, the minimum offset is zero, not one, because you don't skip
1662 anything to get to the first item.
1663 one-liner
1665 An entire computer program crammed into one line of text.
1666 open source software
1668 Programs for which the source code is freely available and freely
1669 redistributable, with no commercial strings attached. For a more
1670 detailed definition, see <http://www.opensource.org/osd.html>.
1671 operand
1673 An "expression" that yields a "value" that an "operator" operates
1674 on. See also "precedence".
1675 operating system
1677 A special program that runs on the bare machine and hides the gory
1678 details of managing processes and devices. Usually used in a
1679 looser sense to indicate a particular culture of programming. The
1680 loose sense can be used at varying levels of specificity. At one
1681 extreme, you might say that all versions of Unix and Unix-
1682 lookalikes are the same operating system (upsetting many people,
1683 especially lawyers and other advocates). At the other extreme, you
1684 could say this particular version of this particular vendor's
1685 operating system is different from any other version of this or any
1686 other vendor's operating system. Perl is much more portable across
1687 operating systems than many other languages. See also
1688 "architecture" and "platform".
1689 operator
1691 A gizmo that transforms some number of input values to some number
1692 of output values, often built into a language with a special syntax
1693 or symbol. A given operator may have specific expectations about
1694 what types of data you give as its arguments (operands) and what
1695 type of data you want back from it.
1696 operator overloading
1698 A kind of "overloading" that you can do on built-in operators to
1699 make them work on objects as if the objects were ordinary scalar
1700 values, but with the actual semantics supplied by the object class.
1701 This is set up with the overload "pragma".
1702 options
1704 See either switches or "regular expression modifier".
1705 overloading
1707 Giving additional meanings to a symbol or construct. Actually, all
1708 languages do overloading to one extent or another, since people are
1709 good at figuring out things from "context".
1710 overriding
1712 Hiding or invalidating some other definition of the same name.
1713 (Not to be confused with "overloading", which adds definitions that
1714 must be disambiguated some other way.) To confuse the issue
1715 further, we use the word with two overloaded definitions: to
1716 describe how you can define your own "subroutine" to hide a built-
1717 in "function" of the same name (see "Overriding Built-in Functions"
1718 in perlsub) and to describe how you can define a replacement
1719 "method" in a "derived class" to hide a "base class"'s method of
1720 the same name (see perlobj).
1721 owner
1723 The one user (apart from the superuser) who has absolute control
1724 over a "file". A file may also have a "group" of users who may
1725 exercise joint ownership if the real owner permits it. See
1726 "permission bits".
1727 P
1729 package
1730 A "namespace" for global variables, subroutines, and the like, such
1731 that they can be kept separate from like-named symbols in other
1732 namespaces. In a sense, only the package is global, since the
1733 symbols in the package's symbol table are only accessible from code
1734 compiled outside the package by naming the package. But in another
1735 sense, all package symbols are also globals--they're just well-
1736 organized globals.
1737 pad Short for "scratchpad".
1739 parameter
1741 See "argument".
1742 parent class
1744 See "base class".
1745 parse tree
1747 See "syntax tree".
1748 parsing
1750 The subtle but sometimes brutal art of attempting to turn your
1751 possibly malformed program into a valid "syntax tree".
1752 patch
1754 To fix by applying one, as it were. In the realm of hackerdom, a
1755 listing of the differences between two versions of a program as
1756 might be applied by the patch(1) program when you want to fix a bug
1757 or upgrade your old version.
1758 PATH
1760 The list of directories the system searches to find a program you
1761 want to "execute". The list is stored as one of your environment
1762 variables, accessible in Perl as $ENV{PATH}.
1763 pathname
1765 A fully qualified filename such as /usr/bin/perl. Sometimes
1766 confused with "PATH".
1767 pattern
1769 A template used in "pattern matching".
1770 pattern matching
1772 Taking a pattern, usually a "regular expression", and trying the
1773 pattern various ways on a string to see whether there's any way to
1774 make it fit. Often used to pick interesting tidbits out of a file.
1775 permission bits
1777 Bits that the "owner" of a file sets or unsets to allow or disallow
1778 access to other people. These flag bits are part of the "mode"
1779 word returned by the stat built-in when you ask about a file. On
1780 Unix systems, you can check the ls(1) manpage for more information.
1781 Pern
1783 What you get when you do "Perl++" twice. Doing it only once will
1784 curl your hair. You have to increment it eight times to shampoo
1785 your hair. Lather, rinse, iterate.
1786 pipe
1788 A direct "connection" that carries the output of one "process" to
1789 the input of another without an intermediate temporary file. Once
1790 the pipe is set up, the two processes in question can read and
1791 write as if they were talking to a normal file, with some caveats.
1792 pipeline
1794 A series of processes all in a row, linked by pipes, where each
1795 passes its output stream to the next.
1796 platform
1798 The entire hardware and software context in which a program runs.
1799 A
1800 program written in a platform-dependent language might break if
1801 you change any of: machine, operating system, libraries, compiler,
1802 or system configuration. The perl interpreter has to be compiled
1803 differently for each platform because it is implemented in C, but
1804 programs written in the Perl language are largely platform-
1805 independent.
1806 pod The markup used to embed documentation into your Perl code. See
1808 perlpod.
1809 pointer
1811 A "variable" in a language like C that contains the exact memory
1812 location of some other item. Perl handles pointers internally so
1813 you don't have to worry about them. Instead, you just use symbolic
1814 pointers in the form of keys and "variable" names, or hard
1815 references, which aren't pointers (but act like pointers and do in
1816 fact contain pointers).
1817 polymorphism
1819 The notion that you can tell an "object" to do something generic,
1820 and the object will interpret the command in different ways
1821 depending on its type. [<Gk many shapes]
1822 port
1824 The part of the address of a TCP or UDP socket that directs packets
1825 to the correct process after finding the right machine, something
1826 like the phone extension you give when you reach the company
1827 operator. Also, the result of converting code to run on a
1828 different platform than originally intended, or the verb denoting
1829 this conversion.
1830 portable
1832 Once upon a time, C code compilable under both BSD and SysV. In
1833 general, code that can be easily converted to run on another
1834 "platform", where "easily" can be defined however you like, and
1835 usually is. Anything may be considered portable if you try hard
1836 enough. See mobile home or London Bridge.
1837 porter
1839 Someone who "carries" software from one "platform" to another.
1840 Porting programs written in platform-dependent languages such as C
1841 can be difficult work, but porting programs like Perl is very much
1842 worth the agony.
1843 POSIX
1845 The Portable Operating System Interface specification.
1846 postfix
1848 An "operator" that follows its "operand", as in "$x++".
1849 pp An internal shorthand for a "push-pop" code, that is, C code
1851 implementing Perl's stack machine.
1852 pragma
1854 A standard module whose practical hints and suggestions are
1855 received (and possibly ignored) at compile time. Pragmas are named
1856 in all lowercase.
1857 precedence
1859 The rules of conduct that, in the absence of other guidance,
1860 determine what should happen first. For example, in the absence of
1861 parentheses, you always do multiplication before addition.
1862 prefix
1864 An "operator" that precedes its "operand", as in "++$x".
1865 preprocessing
1867 What some helper "process" did to transform the incoming data into
1868 a form more suitable for the current process. Often done with an
1869 incoming "pipe". See also "C preprocessor".
1870 procedure
1872 A "subroutine".
1873 process
1875 An instance of a running program. Under multitasking systems like
1876 Unix, two or more separate processes could be running the same
1877 program independently at the same time--in fact, the fork function
1878 is designed to bring about this happy state of affairs. Under
1879 other operating systems, processes are sometimes called "threads",
1880 "tasks", or "jobs", often with slight nuances in meaning.
1881 program generator
1883 A system that algorithmically writes code for you in a high-level
1884 language. See also "code generator".
1885 progressive matching
1887 Pattern matching that picks up where it left off before.
1888 property
1890 See either "instance variable" or "character property".
1891 protocol
1893 In networking, an agreed-upon way of sending messages back and
1894 forth so that neither correspondent will get too confused.
1895 prototype
1897 An optional part of a "subroutine" declaration telling the Perl
1898 compiler how many and what flavor of arguments may be passed as
1899 "actual arguments", so that you can write subroutine calls that
1900 parse much like built-in functions. (Or don't parse, as the case
1901 may be.)
1902 pseudofunction
1904 A construct that sometimes looks like a function but really isn't.
1905 Usually reserved for "lvalue" modifiers like my, for "context"
1906 modifiers like scalar, and for the pick-your-own-quotes constructs,
1907 "q//", "qq//", "qx//", "qw//", "qr//", "m//", "s///", "y///", and
1908 "tr///".
1909 pseudohash
1911 A reference to an array whose initial element happens to hold a
1912 reference to a hash. You can treat a pseudohash reference as
1913 either an array reference or a hash reference.
1914 pseudoliteral
1916 An "operator" that looks something like a "literal", such as the
1917 output-grabbing operator, "`""command""`".
1918 public domain
1920 Something not owned by anybody. Perl is copyrighted and is thus
1921 not in the public domain--it's just "freely available" and "freely
1922 redistributable".
1923 pumpkin
1925 A notional "baton" handed around the Perl community indicating who
1926 is the lead integrator in some arena of development.
1927 pumpking
1929 A "pumpkin" holder, the person in charge of pumping the pump, or at
1930 least priming it. Must be willing to play the part of the Great
1931 Pumpkin now and then.
1932 PV A "pointer value", which is Perl Internals Talk for a "char*".
1934 Q
1936 qualified
1937 Possessing a complete name. The symbol $Ent::moot is qualified;
1938 $moot is unqualified. A fully qualified filename is specified from
1939 the top-level directory.
1940 quantifier
1942 A component of a "regular expression" specifying how many times the
1943 foregoing "atom" may occur.
1944 R
1946 readable
1947 With respect to files, one that has the proper permission bit set
1948 to let you access the file. With respect to computer programs, one
1949 that's written well enough that someone has a chance of figuring
1950 out what it's trying to do.
1951 reaping
1953 The last rites performed by a parent "process" on behalf of a
1954 deceased child process so that it doesn't remain a "zombie". See
1955 the wait and waitpid function calls.
1956 record
1958 A set of related data values in a "file" or "stream", often
1959 associated with a unique "key" field. In Unix, often commensurate
1960 with a "line", or a blank-line-terminated set of lines (a
1961 "paragraph"). Each line of the /etc/passwd file is a record, keyed
1962 on login name, containing information about that user.
1963 recursion
1965 The art of defining something (at least partly) in terms of itself,
1966 which is a naughty no-no in dictionaries but often works out okay
1967 in computer programs if you're careful not to recurse forever,
1968 which is like an infinite loop with more spectacular failure modes.
1969 reference
1971 Where you look to find a pointer to information somewhere else.
1972 (See "indirection".) References come in two flavors, symbolic
1973 references and hard references.
1974 referent
1976 Whatever a reference refers to, which may or may not have a name.
1977 Common types of referents include scalars, arrays, hashes, and
1978 subroutines.
1979 regex
1981 See "regular expression".
1982 regular expression
1984 A single entity with various interpretations, like an elephant. To
1985 a computer scientist, it's a grammar for a little language in which
1986 some strings are legal and others aren't. To normal people, it's a
1987 pattern you can use to find what you're looking for when it varies
1988 from case to case. Perl's regular expressions are far from regular
1989 in the theoretical sense, but in regular use they work quite well.
1990 Here's a regular expression: "/Oh s.*t./". This will match strings
1991 like ""Oh say can you see by the dawn's early light"" and ""Oh
1992 sit!"". See perlre.
1993 regular expression modifier
1995 An option on a pattern or substitution, such as "/i" to render the
1996 pattern case insensitive. See also "cloister".
1997 regular file
1999 A "file" that's not a "directory", a "device", a named "pipe" or
2000 "socket", or a "symbolic link". Perl uses the "-f" file test
2001 operator to identify regular files. Sometimes called a "plain"
2002 file.
2003 relational operator
2005 An "operator" that says whether a particular ordering relationship
2006 is "true" about a pair of operands. Perl has both numeric and
2007 string relational operators. See "collating sequence".
2008 reserved words
2010 A word with a specific, built-in meaning to a "compiler", such as
2011 "if" or delete. In many languages (not Perl), it's illegal to use
2012 reserved words to name anything else. (Which is why they're
2013 reserved, after all.) In Perl, you just can't use them to name
2014 labels or filehandles. Also called "keywords".
2015 return value
2017 The "value" produced by a "subroutine" or "expression" when
2018 evaluated. In Perl, a return value may be either a "list" or a
2019 "scalar".
2020 RFC Request For Comment, which despite the timid connotations is the
2022 name of a series of important standards documents.
2023 right shift
2025 A "bit shift" that divides a number by some power of 2.
2026 root
2028 The superuser (UID == 0). Also, the top-level directory of the
2029 filesystem.
2030 RTFM
2032 What you are told when someone thinks you should Read The Fine
2033 Manual.
2034 run phase
2036 Any time after Perl starts running your main program. See also
2037 "compile phase". Run phase is mostly spent in "run time" but may
2038 also be spent in "compile time" when require, do "FILE", or eval
2039 "STRING" operators are executed or when a substitution uses the
2040 "/ee" modifier.
2041 run time
2043 The time when Perl is actually doing what your code says to do, as
2044 opposed to the earlier period of time when it was trying to figure
2045 out whether what you said made any sense whatsoever, which is
2046 "compile time".
2047 run-time pattern
2049 A pattern that contains one or more variables to be interpolated
2050 before parsing the pattern as a "regular expression", and that
2051 therefore cannot be analyzed at compile time, but must be re-
2052 analyzed each time the pattern match operator is evaluated. Run-
2053 time patterns are useful but expensive.
2054 RV A recreational vehicle, not to be confused with vehicular
2056 recreation. RV also means an internal Reference Value of the type
2057 a "scalar" can hold. See also "IV" and "NV" if you're not confused
2058 yet.
2059 rvalue
2061 A "value" that you might find on the right side of an "assignment".
2062 See also "lvalue".
2063 S
2065 scalar
2066 A simple, singular value; a number, "string", or "reference".
2067 scalar context
2069 The situation in which an "expression" is expected by its
2070 surroundings (the code calling it) to return a single "value"
2071 rather than a "list" of values. See also "context" and "list
2072 context". A scalar context sometimes imposes additional
2073 constraints on the return value--see "string context" and "numeric
2074 context". Sometimes we talk about a "Boolean context" inside
2075 conditionals, but this imposes no additional constraints, since any
2076 scalar value, whether numeric or "string", is already true or
2077 false.
2078 scalar literal
2080 A number or quoted "string"--an actual "value" in the text of your
2081 program, as opposed to a "variable".
2082 scalar value
2084 A value that happens to be a "scalar" as opposed to a "list".
2085 scalar variable
2087 A "variable" prefixed with "$" that holds a single value.
2088 scope
2090 How far away you can see a variable from, looking through one.
2091 Perl has two visibility mechanisms: it does "dynamic scoping" of
2092 local variables, meaning that the rest of the "block", and any
2093 subroutines that are called by the rest of the block, can see the
2094 variables that are local to the block. Perl does "lexical scoping"
2095 of my variables, meaning that the rest of the block can see the
2096 variable, but other subroutines called by the block cannot see the
2097 variable.
2098 scratchpad
2100 The area in which a particular invocation of a particular file or
2101 subroutine keeps some of its temporary values, including any
2102 lexically scoped variables.
2103 script
2105 A text "file" that is a program intended to be executed directly
2106 rather than compiled to another form of file before execution.
2107 Also, in the context of "Unicode", a writing system for a
2108 particular language or group of languages, such as Greek, Bengali,
2109 or Klingon.
2110 script kiddie
2112 A "cracker" who is not a "hacker", but knows just enough to run
2113 canned scripts. A cargo-cult programmer.
2114 sed A venerable Stream EDitor from which Perl derives some of its
2116 ideas.
2117 semaphore
2119 A fancy kind of interlock that prevents multiple threads or
2120 processes from using up the same resources simultaneously.
2121 separator
2123 A "character" or "string" that keeps two surrounding strings from
2124 being confused with each other. The split function works on
2125 separators. Not to be confused with delimiters or terminators.
2126 The "or" in the previous sentence separated the two alternatives.
2127 serialization
2129 Putting a fancy "data structure" into linear order so that it can
2130 be stored as a "string" in a disk file or database or sent through
2131 a "pipe". Also called marshalling.
2132 server
2134 In networking, a "process" that either advertises a "service" or
2135 just hangs around at a known location and waits for clients who
2136 need service to get in touch with it.
2137 service
2139 Something you do for someone else to make them happy, like giving
2140 them the time of day (or of their life). On some machines, well-
2141 known services are listed by the getservent function.
2142 setgid
2144 Same as "setuid", only having to do with giving away "group"
2145 privileges.
2146 setuid
2148 Said of a program that runs with the privileges of its "owner"
2149 rather than (as is usually the case) the privileges of whoever is
2150 running it. Also describes the bit in the mode word ("permission
2151 bits") that controls the feature. This bit must be explicitly set
2152 by the owner to enable this feature, and the program must be
2153 carefully written not to give away more privileges than it ought
2154 to.
2155 shared memory
2157 A piece of "memory" accessible by two different processes who
2158 otherwise would not see each other's memory.
2159 shebang
2161 Irish for the whole McGillicuddy. In Perl culture, a portmanteau
2162 of "sharp" and "bang", meaning the "#!" sequence that tells the
2163 system where to find the interpreter.
2164 shell
2166 A "command"-line "interpreter". The program that interactively
2167 gives you a prompt, accepts one or more lines of input, and
2168 executes the programs you mentioned, feeding each of them their
2169 proper arguments and input data. Shells can also execute scripts
2170 containing such commands. Under Unix, typical shells include the
2171 Bourne shell (/bin/sh), the C shell (/bin/csh), and the Korn shell
2172 (/bin/ksh). Perl is not strictly a shell because it's not
2173 interactive (although Perl programs can be interactive).
2174 side effects
2176 Something extra that happens when you evaluate an "expression".
2177 Nowadays it can refer to almost anything. For example, evaluating
2178 a simple assignment statement typically has the "side effect" of
2179 assigning a value to a variable. (And you thought assigning the
2180 value was your primary intent in the first place!) Likewise,
2181 assigning a value to the special variable $| ($AUTOFLUSH) has the
2182 side effect of forcing a flush after every write or print on the
2183 currently selected filehandle.
2184 signal
2186 A bolt out of the blue; that is, an event triggered by the
2187 "operating system", probably when you're least expecting it.
2188 signal handler
2190 A "subroutine" that, instead of being content to be called in the
2191 normal fashion, sits around waiting for a bolt out of the blue
2192 before it will deign to "execute". Under Perl, bolts out of the
2193 blue are called signals, and you send them with the kill built-in.
2194 See "%SIG" in perlvar and "Signals" in perlipc.
2195 single inheritance
2197 The features you got from your mother, if she told you that you
2198 don't have a father. (See also "inheritance" and "multiple
2199 inheritance".) In computer languages, the notion that classes
2200 reproduce asexually so that a given class can only have one direct
2201 ancestor or "base class". Perl supplies no such restriction,
2202 though you may certainly program Perl that way if you like.
2203 slice
2205 A selection of any number of elements from a "list", "array", or
2206 "hash".
2207 slurp
2209 To read an entire "file" into a "string" in one operation.
2210 socket
2212 An endpoint for network communication among multiple processes that
2213 works much like a telephone or a post office box. The most
2214 important thing about a socket is its "network address" (like a
2215 phone number). Different kinds of sockets have different kinds of
2216 addresses--some look like filenames, and some don't.
2217 soft reference
2219 See "symbolic reference".
2220 source filter
2222 A special kind of "module" that does "preprocessing" on your script
2223 just before it gets to the "tokener".
2224 stack
2226 A device you can put things on the top of, and later take them back
2227 off in the opposite order in which you put them on. See "LIFO".
2228 standard
2230 Included in the official Perl distribution, as in a standard
2231 module, a standard tool, or a standard Perl "manpage".
2232 standard error
2234 The default output "stream" for nasty remarks that don't belong in
2235 "standard output". Represented within a Perl program by the
2236 "filehandle" "STDERR". You can use this stream explicitly, but the
2237 die and warn built-ins write to your standard error stream
2238 automatically.
2239 standard I/O
2241 A standard C library for doing buffered input and output to the
2242 "operating system". (The "standard" of standard I/O is only
2243 marginally related to the "standard" of standard input and output.)
2244 In general, Perl relies on whatever implementation of standard I/O
2245 a given operating system supplies, so the buffering characteristics
2246 of a Perl program on one machine may not exactly match those on
2247 another machine. Normally this only influences efficiency, not
2248 semantics. If your standard I/O package is doing block buffering
2249 and you want it to "flush" the buffer more often, just set the $|
2250 variable to a true value.
2251 standard input
2253 The default input "stream" for your program, which if possible
2254 shouldn't care where its data is coming from. Represented within a
2255 Perl program by the "filehandle" "STDIN".
2256 standard output
2258 The default output "stream" for your program, which if possible
2259 shouldn't care where its data is going. Represented within a Perl
2260 program by the "filehandle" "STDOUT".
2261 stat structure
2263 A special internal spot in which Perl keeps the information about
2264 the last "file" on which you requested information.
2265 statement
2267 A "command" to the computer about what to do next, like a step in a
2268 recipe: "Add marmalade to batter and mix until mixed." A statement
2269 is distinguished from a "declaration", which doesn't tell the
2270 computer to do anything, but just to learn something.
2271 statement modifier
2273 A "conditional" or "loop" that you put after the "statement"
2274 instead of before, if you know what we mean.
2275 static
2277 Varying slowly compared to something else. (Unfortunately,
2278 everything is relatively stable compared to something else, except
2279 for certain elementary particles, and we're not so sure about
2280 them.) In computers, where things are supposed to vary rapidly,
2281 "static" has a derogatory connotation, indicating a slightly
2282 dysfunctional "variable", "subroutine", or "method". In Perl
2283 culture, the word is politely avoided.
2284 static method
2286 No such thing. See "class method".
2287 static scoping
2289 No such thing. See "lexical scoping".
2290 static variable
2292 No such thing. Just use a "lexical variable" in a scope larger
2293 than your "subroutine".
2294 status
2296 The "value" returned to the parent "process" when one of its child
2297 processes dies. This value is placed in the special variable $?.
2298 Its upper eight bits are the exit status of the defunct process,
2299 and its lower eight bits identify the signal (if any) that the
2300 process died from. On Unix systems, this status value is the same
2301 as the status word returned by wait(2). See "system" in perlfunc.
2302 STDERR
2304 See "standard error".
2305 STDIN
2307 See "standard input".
2308 STDIO
2310 See "standard I/O".
2311 STDOUT
2313 See "standard output".
2314 stream
2316 A flow of data into or out of a process as a steady sequence of
2317 bytes or characters, without the appearance of being broken up into
2318 packets. This is a kind of "interface"--the underlying
2319 "implementation" may well break your data up into separate packets
2320 for delivery, but this is hidden from you.
2321 string
2323 A sequence of characters such as "He said !@#*&%@#*?!". A string
2324 does not have to be entirely printable.
2325 string context
2327 The situation in which an expression is expected by its
2328 surroundings (the code calling it) to return a "string". See also
2329 "context" and "numeric context".
2330 stringification
2332 The process of producing a "string" representation of an abstract
2333 object.
2334 struct
2336 C keyword introducing a structure definition or name.
2337 structure
2339 See "data structure".
2340 subclass
2342 See "derived class".
2343 subpattern
2345 A component of a "regular expression" pattern.
2346 subroutine
2348 A named or otherwise accessible piece of program that can be
2349 invoked from elsewhere in the program in order to accomplish some
2350 sub-goal of the program. A subroutine is often parameterized to
2351 accomplish different but related things depending on its input
2352 arguments. If the subroutine returns a meaningful "value", it is
2353 also called a "function".
2354 subscript
2356 A "value" that indicates the position of a particular "array"
2357 "element" in an array.
2358 substitution
2360 Changing parts of a string via the "s///" operator. (We avoid use
2361 of this term to mean "variable interpolation".)
2362 substring
2364 A portion of a "string", starting at a certain "character" position
2365 ("offset") and proceeding for a certain number of characters.
2366 superclass
2368 See "base class".
2369 superuser
2371 The person whom the "operating system" will let do almost anything.
2372 Typically your system administrator or someone pretending to be
2373 your system administrator. On Unix systems, the "root" user. On
2374 Windows systems, usually the Administrator user.
2375 SV Short for "scalar value". But within the Perl interpreter every
2377 "referent" is treated as a member of a class derived from SV, in an
2378 object-oriented sort of way. Every "value" inside Perl is passed
2379 around as a C language "SV*" pointer. The SV "struct" knows its
2380 own "referent type", and the code is smart enough (we hope) not to
2381 try to call a "hash" function on a "subroutine".
2382 switch
2384 An option you give on a command line to influence the way your
2385 program works, usually introduced with a minus sign. The word is
2386 also used as a nickname for a "switch statement".
2387 switch cluster
2389 The combination of multiple command-line switches (e.g., -a -b -c)
2390 into one switch (e.g., -abc). Any switch with an additional
2391 "argument" must be the last switch in a cluster.
2392 switch statement
2394 A program technique that lets you evaluate an "expression" and
2395 then, based on the value of the expression, do a multiway branch to
2396 the appropriate piece of code for that value. Also called a "case
2397 structure", named after the similar Pascal construct. Most switch
2398 statements in Perl are spelled "for". See "Basic BLOCKs and Switch
2399 Statements" in perlsyn.
2400 symbol
2402 Generally, any "token" or "metasymbol". Often used more
2403 specifically to mean the sort of name you might find in a "symbol
2404 table".
2405 symbol table
2407 Where a "compiler" remembers symbols. A program like Perl must
2408 somehow remember all the names of all the variables, filehandles,
2409 and subroutines you've used. It does this by placing the names in
2410 a symbol table, which is implemented in Perl using a "hash table".
2411 There is a separate symbol table for each "package" to give each
2412 package its own "namespace".
2413 symbolic debugger
2415 A program that lets you step through the execution of your program,
2416 stopping or printing things out here and there to see whether
2417 anything has gone wrong, and if so, what. The "symbolic" part just
2418 means that you can talk to the debugger using the same symbols with
2419 which your program is written.
2420 symbolic link
2422 An alternate filename that points to the real "filename", which in
2423 turn points to the real "file". Whenever the "operating system" is
2424 trying to parse a "pathname" containing a symbolic link, it merely
2425 substitutes the new name and continues parsing.
2426 symbolic reference
2428 A variable whose value is the name of another variable or
2429 subroutine. By dereferencing the first variable, you can get at
2430 the second one. Symbolic references are illegal under use strict
2431 'refs'.
2432 synchronous
2434 Programming in which the orderly sequence of events can be
2435 determined; that is, when things happen one after the other, not at
2436 the same time.
2437 syntactic sugar
2439 An alternative way of writing something more easily; a shortcut.
2440 syntax
2442 From Greek, "with-arrangement". How things (particularly symbols)
2443 are put together with each other.
2444 syntax tree
2446 An internal representation of your program wherein lower-level
2447 constructs dangle off the higher-level constructs enclosing them.
2448 syscall
2450 A "function" call directly to the "operating system". Many of the
2451 important subroutines and functions you use aren't direct system
2452 calls, but are built up in one or more layers above the system call
2453 level. In general, Perl programmers don't need to worry about the
2454 distinction. However, if you do happen to know which Perl
2455 functions are really syscalls, you can predict which of these will
2456 set the $! ($ERRNO) variable on failure. Unfortunately, beginning
2457 programmers often confusingly employ the term "system call" to mean
2458 what happens when you call the Perl system function, which actually
2459 involves many syscalls. To avoid any confusion, we nearly always
2460 use say "syscall" for something you could call indirectly via
2461 Perl's syscall function, and never for something you would call
2462 with Perl's system function.
2463 T
2465 tainted
2466 Said of data derived from the grubby hands of a user and thus
2467 unsafe for a secure program to rely on. Perl does taint checks if
2468 you run a "setuid" (or "setgid") program, or if you use the -T
2469 switch.
2470 TCP Short for Transmission Control Protocol. A protocol wrapped around
2472 the Internet Protocol to make an unreliable packet transmission
2473 mechanism appear to the application program to be a reliable
2474 "stream" of bytes. (Usually.)
2475 term
2477 Short for a "terminal", that is, a leaf node of a "syntax tree". A
2478 thing that functions grammatically as an "operand" for the
2479 operators in an expression.
2480 terminator
2482 A "character" or "string" that marks the end of another string.
2483 The $/ variable contains the string that terminates a readline
2484 operation, which chomp deletes from the end. Not to be confused
2485 with delimiters or separators. The period at the end of this
2486 sentence is a terminator.
2487 ternary
2489 An "operator" taking three operands. Sometimes pronounced
2490 "trinary".
2491 text
2493 A "string" or "file" containing primarily printable characters.
2494 thread
2496 Like a forked process, but without "fork"'s inherent memory
2497 protection. A thread is lighter weight than a full process, in
2498 that a process could have multiple threads running around in it,
2499 all fighting over the same process's memory space unless steps are
2500 taken to protect threads from each other. See threads.
2501 tie The bond between a magical variable and its implementation class.
2503 See "tie" in perlfunc and perltie.
2504 TMTOWTDI
2506 There's More Than One Way To Do It, the Perl Motto. The notion
2507 that there can be more than one valid path to solving a programming
2508 problem in context. (This doesn't mean that more ways are always
2509 better or that all possible paths are equally desirable--just that
2510 there need not be One True Way.) Pronounced TimToady.
2511 token
2513 A morpheme in a programming language, the smallest unit of text
2514 with semantic significance.
2515 tokener
2517 A module that breaks a program text into a sequence of tokens for
2518 later analysis by a parser.
2519 tokenizing
2521 Splitting up a program text into tokens. Also known as "lexing",
2522 in which case you get "lexemes" instead of tokens.
2523 toolbox approach
2525 The notion that, with a complete set of simple tools that work well
2526 together, you can build almost anything you want. Which is fine if
2527 you're assembling a tricycle, but if you're building a
2528 defranishizing comboflux regurgalator, you really want your own
2529 machine shop in which to build special tools. Perl is sort of a
2530 machine shop.
2531 transliterate
2533 To turn one string representation into another by mapping each
2534 character of the source string to its corresponding character in
2535 the result string. See "tr/SEARCHLIST/REPLACEMENTLIST/cds" in
2536 perlop.
2537 trigger
2539 An event that causes a "handler" to be run.
2540 trinary
2542 Not a stellar system with three stars, but an "operator" taking
2543 three operands. Sometimes pronounced "ternary".
2544 troff
2546 A venerable typesetting language from which Perl derives the name
2547 of its $% variable and which is secretly used in the production of
2548 Camel books.
2549 true
2551 Any scalar value that doesn't evaluate to 0 or "".
2552 truncating
2554 Emptying a file of existing contents, either automatically when
2555 opening a file for writing or explicitly via the truncate function.
2556 type
2558 See "data type" and "class".
2559 type casting
2561 Converting data from one type to another. C permits this. Perl
2562 does not need it. Nor want it.
2563 typed lexical
2565 A "lexical variable" that is declared with a "class" type: "my Pony
2566 $bill".
2567 typedef
2569 A type definition in the C language.
2570 typeglob
2572 Use of a single identifier, prefixed with "*". For example, *name
2573 stands for any or all of $name, @name, %name, &name, or just
2574 "name". How you use it determines whether it is interpreted as all
2575 or only one of them. See "Typeglobs and Filehandles" in perldata.
2576 typemap
2578 A description of how C types may be transformed to and from Perl
2579 types within an "extension" module written in "XS".
2580 U
2582 UDP User Datagram Protocol, the typical way to send datagrams over the
2583 Internet.
2584 UID A user ID. Often used in the context of "file" or "process"
2586 ownership.
2587 umask
2589 A mask of those "permission bits" that should be forced off when
2590 creating files or directories, in order to establish a policy of
2591 whom you'll ordinarily deny access to. See the umask function.
2592 unary operator
2594 An operator with only one "operand", like "!" or chdir. Unary
2595 operators are usually prefix operators; that is, they precede their
2596 operand. The "++" and "--" operators can be either prefix or
2597 postfix. (Their position does change their meanings.)
2598 Unicode
2600 A character set comprising all the major character sets of the
2601 world, more or less. See perlunicode and <http://www.unicode.org>.
2602 Unix
2604 A very large and constantly evolving language with several
2605 alternative and largely incompatible syntaxes, in which anyone can
2606 define anything any way they choose, and usually do. Speakers of
2607 this language think it's easy to learn because it's so easily
2608 twisted to one's own ends, but dialectical differences make tribal
2609 intercommunication nearly impossible, and travelers are often
2610 reduced to a pidgin-like subset of the language. To be universally
2611 understood, a Unix shell programmer must spend years of study in
2612 the art. Many have abandoned this discipline and now communicate
2613 via an Esperanto-like language called Perl.
2614 In ancient times, Unix was also used to refer to some code that a
2616 couple of people at Bell Labs wrote to make use of a PDP-7 computer
2617 that wasn't doing much of anything else at the time.
2618 V
2620 value
2621 An actual piece of data, in contrast to all the variables,
2622 references, keys, indexes, operators, and whatnot that you need to
2623 access the value.
2624 variable
2626 A named storage location that can hold any of various kinds of
2627 "value", as your program sees fit.
2628 variable interpolation
2630 The "interpolation" of a scalar or array variable into a string.
2631 variadic
2633 Said of a "function" that happily receives an indeterminate number
2634 of "actual arguments".
2635 vector
2637 Mathematical jargon for a list of scalar values.
2638 virtual
2640 Providing the appearance of something without the reality, as in:
2641 virtual memory is not real memory. (See also "memory".) The
2642 opposite of "virtual" is "transparent", which means providing the
2643 reality of something without the appearance, as in: Perl handles
2644 the variable-length UTF-8 character encoding transparently.
2645 void context
2647 A form of "scalar context" in which an "expression" is not expected
2648 to return any "value" at all and is evaluated for its "side
2649 effects" alone.
2650 v-string
2652 A "version" or "vector" "string" specified with a "v" followed by a
2653 series of decimal integers in dot notation, for instance,
2654 "v1.20.300.4000". Each number turns into a "character" with the
2655 specified ordinal value. (The "v" is optional when there are at
2656 least three integers.)
2657 W
2659 warning
2660 A message printed to the "STDERR" stream to the effect that
2661 something might be wrong but isn't worth blowing up over. See
2662 "warn" in perlfunc and the warnings pragma.
2663 watch expression
2665 An expression which, when its value changes, causes a breakpoint in
2666 the Perl debugger.
2667 whitespace
2669 A "character" that moves your cursor but doesn't otherwise put
2670 anything on your screen. Typically refers to any of: space, tab,
2671 line feed, carriage return, or form feed.
2672 word
2674 In normal "computerese", the piece of data of the size most
2675 efficiently handled by your computer, typically 32 bits or so, give
2676 or take a few powers of 2. In Perl culture, it more often refers
2677 to an alphanumeric "identifier" (including underscores), or to a
2678 string of nonwhitespace characters bounded by whitespace or string
2679 boundaries.
2680 working directory
2682 Your current "directory", from which relative pathnames are
2683 interpreted by the "operating system". The operating system knows
2684 your current directory because you told it with a chdir or because
2685 you started out in the place where your parent "process" was when
2686 you were born.
2687 wrapper
2689 A program or subroutine that runs some other program or subroutine
2690 for you, modifying some of its input or output to better suit your
2691 purposes.
2692 WYSIWYG
2694 What You See Is What You Get. Usually used when something that
2695 appears on the screen matches how it will eventually look, like
2696 Perl's format declarations. Also used to mean the opposite of
2697 magic because everything works exactly as it appears, as in the
2698 three-argument form of open.
2699 X
2701 XS An extraordinarily exported, expeditiously excellent, expressly
2702 eXternal Subroutine, executed in existing C or C++ or in an
2703 exciting new extension language called (exasperatingly) XS.
2704 Examine perlxs for the exact explanation or perlxstut for an
2705 exemplary unexacting one.
2706 XSUB
2708 An external "subroutine" defined in "XS".
2709 Y
2711 yacc
2712 Yet Another Compiler Compiler. A parser generator without which
2713 Perl probably would not have existed. See the file perly.y in the
2714 Perl source distribution.
2715 Z
2717 zero width
2718 A subpattern "assertion" matching the "null string" between
2719 characters.
2720 zombie
2722 A process that has died (exited) but whose parent has not yet
2723 received proper notification of its demise by virtue of having
2724 called wait or waitpid. If you fork, you must clean up after your
2725 child processes when they exit, or else the process table will fill
2726 up and your system administrator will Not Be Happy with you.
2727
2729 Based on the Glossary of Programming Perl, Third Edition, by Larry
2730 Wall, Tom Christiansen & Jon Orwant. Copyright (c) 2000, 1996, 1991
2731 O'Reilly Media, Inc. This document may be distributed under the same
2732 terms as Perl itself.
2733perl v5.12.4 2011-06-07 PERLGLOSSARY(1)