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 "E<lt>E<gt>" operator, "ARGV"
80 is the name of both the "filehandle" used to traverse the arguments
81 and 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 best 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 "E<lt>FHE<gt>") is represented by the $.
1391 ($INPUT_LINE_NUMBER) variable. Many error messages report both
1392 values, if available.
1393 link
1395 Used as a noun, a name in a "directory", representing a "file". A
1396 given file can have multiple links to it. It's like having the
1397 same phone number listed in the phone directory under different
1398 names. As a verb, to resolve a partially compiled file's
1399 unresolved symbols into a (nearly) executable image. Linking can
1400 generally be static or dynamic, which has nothing to do with static
1401 or dynamic scoping.
1402 LIST
1404 A syntactic construct representing a comma-separated list of
1405 expressions, evaluated to produce a "list value". Each
1406 "expression" in a "LIST" is evaluated in "list context" and
1407 interpolated into the list value.
1408 list
1410 An ordered set of scalar values.
1411 list context
1413 The situation in which an "expression" is expected by its
1414 surroundings (the code calling it) to return a list of values
1415 rather than a single value. Functions that want a "LIST" of
1416 arguments tell those arguments that they should produce a list
1417 value. See also "context".
1418 list operator
1420 An "operator" that does something with a list of values, such as
1421 join or grep. Usually used for named built-in operators (such as
1422 print, unlink, and system) that do not require parentheses around
1423 their "argument" list.
1424 list value
1426 An unnamed list of temporary scalar values that may be passed
1427 around within a program from any list-generating function to any
1428 function or construct that provides a "list context".
1429 literal
1431 A token in a programming language such as a number or "string" that
1432 gives you an actual "value" instead of merely representing possible
1433 values as a "variable" does.
1434 little-endian
1436 From Swift: someone who eats eggs little end first. Also used of
1437 computers that store the least significant "byte" of a word at a
1438 lower byte address than the most significant byte. Often
1439 considered superior to big-endian machines. See also "big-endian".
1440 local
1442 Not meaning the same thing everywhere. A global variable in Perl
1443 can be localized inside a dynamic scope via the local operator.
1444 logical operator
1446 Symbols representing the concepts "and", "or", "xor", and "not".
1447 lookahead
1449 An "assertion" that peeks at the string to the right of the current
1450 match location.
1451 lookbehind
1453 An "assertion" that peeks at the string to the left of the current
1454 match location.
1455 loop
1457 A construct that performs something repeatedly, like a roller
1458 coaster.
1459 loop control statement
1461 Any statement within the body of a loop that can make a loop
1462 prematurely stop looping or skip an "iteration". Generally you
1463 shouldn't try this on roller coasters.
1464 loop label
1466 A kind of key or name attached to a loop (or roller coaster) so
1467 that loop control statements can talk about which loop they want to
1468 control.
1469 lvaluable
1471 Able to serve as an "lvalue".
1472 lvalue
1474 Term used by language lawyers for a storage location you can assign
1475 a new "value" to, such as a "variable" or an element of an "array".
1476 The "l" is short for "left", as in the left side of an assignment,
1477 a typical place for lvalues. An "lvaluable" function or expression
1478 is one to which a value may be assigned, as in "pos($x) = 10".
1479 lvalue modifier
1481 An adjectival pseudofunction that warps the meaning of an "lvalue"
1482 in some declarative fashion. Currently there are three lvalue
1483 modifiers: my, our, and local.
1484 M
1486 magic
1487 Technically speaking, any extra semantics attached to a variable
1488 such as $!, $0, %ENV, or %SIG, or to any tied variable. Magical
1489 things happen when you diddle those variables.
1490 magical increment
1492 An "increment" operator that knows how to bump up alphabetics as
1493 well as numbers.
1494 magical variables
1496 Special variables that have side effects when you access them or
1497 assign to them. For example, in Perl, changing elements of the
1498 %ENV array also changes the corresponding environment variables
1499 that subprocesses will use. Reading the $! variable gives you the
1500 current system error number or message.
1501 Makefile
1503 A file that controls the compilation of a program. Perl programs
1504 don't usually need a "Makefile" because the Perl compiler has
1505 plenty of self-control.
1506 man The Unix program that displays online documentation (manual pages)
1508 for you.
1509 manpage
1511 A "page" from the manuals, typically accessed via the man(1)
1512 command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
1513 BUGS, and so on, and is typically longer than a page. There are
1514 manpages documenting commands, syscalls, "library" functions,
1515 devices, protocols, files, and such. In this book, we call any
1516 piece of standard Perl documentation (like perlop or perldelta) a
1517 manpage, no matter what format it's installed in on your system.
1518 matching
1520 See "pattern matching".
1521 member data
1523 See "instance variable".
1524 memory
1526 This always means your main memory, not your disk. Clouding the
1527 issue is the fact that your machine may implement "virtual" memory;
1528 that is, it will pretend that it has more memory than it really
1529 does, and it'll use disk space to hold inactive bits. This can
1530 make it seem like you have a little more memory than you really do,
1531 but it's not a substitute for real memory. The best thing that can
1532 be said about virtual memory is that it lets your performance
1533 degrade gradually rather than suddenly when you run out of real
1534 memory. But your program can die when you run out of virtual
1535 memory too, if you haven't thrashed your disk to death first.
1536 metacharacter
1538 A "character" that is not supposed to be treated normally. Which
1539 characters are to be treated specially as metacharacters varies
1540 greatly from context to context. Your "shell" will have certain
1541 metacharacters, double-quoted Perl strings have other
1542 metacharacters, and "regular expression" patterns have all the
1543 double-quote metacharacters plus some extra ones of their own.
1544 metasymbol
1546 Something we'd call a "metacharacter" except that it's a sequence
1547 of more than one character. Generally, the first character in the
1548 sequence must be a true metacharacter to get the other characters
1549 in the metasymbol to misbehave along with it.
1550 method
1552 A kind of action that an "object" can take if you tell it to. See
1553 perlobj.
1554 minimalism
1556 The belief that "small is beautiful." Paradoxically, if you say
1557 something in a small language, it turns out big, and if you say it
1558 in a big language, it turns out small. Go figure.
1559 mode
1561 In the context of the stat syscall, refers to the field holding the
1562 "permission bits" and the type of the "file".
1563 modifier
1565 See "statement modifier", "regular expression modifier", and
1566 "lvalue modifier", not necessarily in that order.
1567 module
1569 A "file" that defines a "package" of (almost) the same name, which
1570 can either "export" symbols or function as an "object" class. (A
1571 module's main .pm file may also load in other files in support of
1572 the module.) See the use built-in.
1573 modulus
1575 An integer divisor when you're interested in the remainder instead
1576 of the quotient.
1577 monger
1579 Short for Perl Monger, a purveyor of Perl.
1580 mortal
1582 A temporary value scheduled to die when the current statement
1583 finishes.
1584 multidimensional array
1586 An array with multiple subscripts for finding a single element.
1587 Perl implements these using references--see perllol and perldsc.
1588 multiple inheritance
1590 The features you got from your mother and father, mixed together
1591 unpredictably. (See also "inheritance", and "single inheritance".)
1592 In computer languages (including Perl), the notion that a given
1593 class may have multiple direct ancestors or base classes.
1594 N
1596 named pipe
1597 A "pipe" with a name embedded in the "filesystem" so that it can be
1598 accessed by two unrelated processes.
1599 namespace
1601 A domain of names. You needn't worry about whether the names in
1602 one such domain have been used in another. See "package".
1603 network address
1605 The most important attribute of a socket, like your telephone's
1606 telephone number. Typically an IP address. See also "port".
1607 newline
1609 A single character that represents the end of a line, with the
1610 ASCII value of 012 octal under Unix (but 015 on a Mac), and
1611 represented by "\n" in Perl strings. For Windows machines writing
1612 text files, and for certain physical devices like terminals, the
1613 single newline gets automatically translated by your C library into
1614 a line feed and a carriage return, but normally, no translation is
1615 done.
1616 NFS Network File System, which allows you to mount a remote filesystem
1618 as if it were local.
1619 null character
1621 A character with the ASCII value of zero. It's used by C to
1622 terminate strings, but Perl allows strings to contain a null.
1623 null list
1625 A "list value" with zero elements, represented in Perl by "()".
1626 null string
1628 A "string" containing no characters, not to be confused with a
1629 string containing a "null character", which has a positive length
1630 and is "true".
1631 numeric context
1633 The situation in which an expression is expected by its
1634 surroundings (the code calling it) to return a number. See also
1635 "context" and "string context".
1636 NV Short for Nevada, no part of which will ever be confused with
1638 civilization. NV also means an internal floating-point Numeric
1639 Value of the type a "scalar" can hold, not to be confused with an
1640 "IV".
1641 nybble
1643 Half a "byte", equivalent to one "hexadecimal" digit, and worth
1644 four bits.
1645 O
1647 object
1648 An "instance" of a "class". Something that "knows" what user-
1649 defined type (class) it is, and what it can do because of what
1650 class it is. Your program can request an object to do things, but
1651 the object gets to decide whether it wants to do them or not. Some
1652 objects are more accommodating than others.
1653 octal
1655 A number in base 8. Only the digits 0 through 7 are allowed.
1656 Octal constants in Perl start with 0, as in 013. See also the oct
1657 function.
1658 offset
1660 How many things you have to skip over when moving from the
1661 beginning of a string or array to a specific position within it.
1662 Thus, the minimum offset is zero, not one, because you don't skip
1663 anything to get to the first item.
1664 one-liner
1666 An entire computer program crammed into one line of text.
1667 open source software
1669 Programs for which the source code is freely available and freely
1670 redistributable, with no commercial strings attached. For a more
1671 detailed definition, see <http://www.opensource.org/osd.html>.
1672 operand
1674 An "expression" that yields a "value" that an "operator" operates
1675 on. See also "precedence".
1676 operating system
1678 A special program that runs on the bare machine and hides the gory
1679 details of managing processes and devices. Usually used in a
1680 looser sense to indicate a particular culture of programming. The
1681 loose sense can be used at varying levels of specificity. At one
1682 extreme, you might say that all versions of Unix and Unix-
1683 lookalikes are the same operating system (upsetting many people,
1684 especially lawyers and other advocates). At the other extreme, you
1685 could say this particular version of this particular vendor's
1686 operating system is different from any other version of this or any
1687 other vendor's operating system. Perl is much more portable across
1688 operating systems than many other languages. See also
1689 "architecture" and "platform".
1690 operator
1692 A gizmo that transforms some number of input values to some number
1693 of output values, often built into a language with a special syntax
1694 or symbol. A given operator may have specific expectations about
1695 what types of data you give as its arguments (operands) and what
1696 type of data you want back from it.
1697 operator overloading
1699 A kind of "overloading" that you can do on built-in operators to
1700 make them work on objects as if the objects were ordinary scalar
1701 values, but with the actual semantics supplied by the object class.
1702 This is set up with the overload "pragma".
1703 options
1705 See either switches or "regular expression modifier".
1706 overloading
1708 Giving additional meanings to a symbol or construct. Actually, all
1709 languages do overloading to one extent or another, since people are
1710 good at figuring out things from "context".
1711 overriding
1713 Hiding or invalidating some other definition of the same name.
1714 (Not to be confused with "overloading", which adds definitions that
1715 must be disambiguated some other way.) To confuse the issue
1716 further, we use the word with two overloaded definitions: to
1717 describe how you can define your own "subroutine" to hide a built-
1718 in "function" of the same name (see "Overriding Built-in Functions"
1719 in perlsub) and to describe how you can define a replacement
1720 "method" in a "derived class" to hide a "base class"'s method of
1721 the same name (see perlobj).
1722 owner
1724 The one user (apart from the superuser) who has absolute control
1725 over a "file". A file may also have a "group" of users who may
1726 exercise joint ownership if the real owner permits it. See
1727 "permission bits".
1728 P
1730 package
1731 A "namespace" for global variables, subroutines, and the like, such
1732 that they can be kept separate from like-named symbols in other
1733 namespaces. In a sense, only the package is global, since the
1734 symbols in the package's symbol table are only accessible from code
1735 compiled outside the package by naming the package. But in another
1736 sense, all package symbols are also globals--they're just well-
1737 organized globals.
1738 pad Short for "scratchpad".
1740 parameter
1742 See "argument".
1743 parent class
1745 See "base class".
1746 parse tree
1748 See "syntax tree".
1749 parsing
1751 The subtle but sometimes brutal art of attempting to turn your
1752 possibly malformed program into a valid "syntax tree".
1753 patch
1755 To fix by applying one, as it were. In the realm of hackerdom, a
1756 listing of the differences between two versions of a program as
1757 might be applied by the patch(1) program when you want to fix a bug
1758 or upgrade your old version.
1759 PATH
1761 The list of directories the system searches to find a program you
1762 want to "execute". The list is stored as one of your environment
1763 variables, accessible in Perl as $ENV{PATH}.
1764 pathname
1766 A fully qualified filename such as /usr/bin/perl. Sometimes
1767 confused with "PATH".
1768 pattern
1770 A template used in "pattern matching".
1771 pattern matching
1773 Taking a pattern, usually a "regular expression", and trying the
1774 pattern various ways on a string to see whether there's any way to
1775 make it fit. Often used to pick interesting tidbits out of a file.
1776 permission bits
1778 Bits that the "owner" of a file sets or unsets to allow or disallow
1779 access to other people. These flag bits are part of the "mode"
1780 word returned by the stat built-in when you ask about a file. On
1781 Unix systems, you can check the ls(1) manpage for more information.
1782 Pern
1784 What you get when you do "Perl++" twice. Doing it only once will
1785 curl your hair. You have to increment it eight times to shampoo
1786 your hair. Lather, rinse, iterate.
1787 pipe
1789 A direct "connection" that carries the output of one "process" to
1790 the input of another without an intermediate temporary file. Once
1791 the pipe is set up, the two processes in question can read and
1792 write as if they were talking to a normal file, with some caveats.
1793 pipeline
1795 A series of processes all in a row, linked by pipes, where each
1796 passes its output stream to the next.
1797 platform
1799 The entire hardware and software context in which a program runs.
1800 A
1801 program written in a platform-dependent language might break if
1802 you change any of: machine, operating system, libraries, compiler,
1803 or system configuration. The perl interpreter has to be compiled
1804 differently for each platform because it is implemented in C, but
1805 programs written in the Perl language are largely platform-
1806 independent.
1807 pod The markup used to embed documentation into your Perl code. See
1809 perlpod.
1810 pointer
1812 A "variable" in a language like C that contains the exact memory
1813 location of some other item. Perl handles pointers internally so
1814 you don't have to worry about them. Instead, you just use symbolic
1815 pointers in the form of keys and "variable" names, or hard
1816 references, which aren't pointers (but act like pointers and do in
1817 fact contain pointers).
1818 polymorphism
1820 The notion that you can tell an "object" to do something generic,
1821 and the object will interpret the command in different ways
1822 depending on its type. [<Gk many shapes]
1823 port
1825 The part of the address of a TCP or UDP socket that directs packets
1826 to the correct process after finding the right machine, something
1827 like the phone extension you give when you reach the company
1828 operator. Also, the result of converting code to run on a
1829 different platform than originally intended, or the verb denoting
1830 this conversion.
1831 portable
1833 Once upon a time, C code compilable under both BSD and SysV. In
1834 general, code that can be easily converted to run on another
1835 "platform", where "easily" can be defined however you like, and
1836 usually is. Anything may be considered portable if you try hard
1837 enough. See mobile home or London Bridge.
1838 porter
1840 Someone who "carries" software from one "platform" to another.
1841 Porting programs written in platform-dependent languages such as C
1842 can be difficult work, but porting programs like Perl is very much
1843 worth the agony.
1844 POSIX
1846 The Portable Operating System Interface specification.
1847 postfix
1849 An "operator" that follows its "operand", as in "$x++".
1850 pp An internal shorthand for a "push-pop" code, that is, C code
1852 implementing Perl's stack machine.
1853 pragma
1855 A standard module whose practical hints and suggestions are
1856 received (and possibly ignored) at compile time. Pragmas are named
1857 in all lowercase.
1858 precedence
1860 The rules of conduct that, in the absence of other guidance,
1861 determine what should happen first. For example, in the absence of
1862 parentheses, you always do multiplication before addition.
1863 prefix
1865 An "operator" that precedes its "operand", as in "++$x".
1866 preprocessing
1868 What some helper "process" did to transform the incoming data into
1869 a form more suitable for the current process. Often done with an
1870 incoming "pipe". See also "C preprocessor".
1871 procedure
1873 A "subroutine".
1874 process
1876 An instance of a running program. Under multitasking systems like
1877 Unix, two or more separate processes could be running the same
1878 program independently at the same time--in fact, the fork function
1879 is designed to bring about this happy state of affairs. Under
1880 other operating systems, processes are sometimes called "threads",
1881 "tasks", or "jobs", often with slight nuances in meaning.
1882 program generator
1884 A system that algorithmically writes code for you in a high-level
1885 language. See also "code generator".
1886 progressive matching
1888 Pattern matching that picks up where it left off before.
1889 property
1891 See either "instance variable" or "character property".
1892 protocol
1894 In networking, an agreed-upon way of sending messages back and
1895 forth so that neither correspondent will get too confused.
1896 prototype
1898 An optional part of a "subroutine" declaration telling the Perl
1899 compiler how many and what flavor of arguments may be passed as
1900 "actual arguments", so that you can write subroutine calls that
1901 parse much like built-in functions. (Or don't parse, as the case
1902 may be.)
1903 pseudofunction
1905 A construct that sometimes looks like a function but really isn't.
1906 Usually reserved for "lvalue" modifiers like my, for "context"
1907 modifiers like scalar, and for the pick-your-own-quotes constructs,
1908 "q//", "qq//", "qx//", "qw//", "qr//", "m//", "s///", "y///", and
1909 "tr///".
1910 pseudohash
1912 A reference to an array whose initial element happens to hold a
1913 reference to a hash. You can treat a pseudohash reference as
1914 either an array reference or a hash reference.
1915 pseudoliteral
1917 An "operator" that looks something like a "literal", such as the
1918 output-grabbing operator, "`""command""`".
1919 public domain
1921 Something not owned by anybody. Perl is copyrighted and is thus
1922 not in the public domain--it's just "freely available" and "freely
1923 redistributable".
1924 pumpkin
1926 A notional "baton" handed around the Perl community indicating who
1927 is the lead integrator in some arena of development.
1928 pumpking
1930 A "pumpkin" holder, the person in charge of pumping the pump, or at
1931 least priming it. Must be willing to play the part of the Great
1932 Pumpkin now and then.
1933 PV A "pointer value", which is Perl Internals Talk for a "char*".
1935 Q
1937 qualified
1938 Possessing a complete name. The symbol $Ent::moot is qualified;
1939 $moot is unqualified. A fully qualified filename is specified from
1940 the top-level directory.
1941 quantifier
1943 A component of a "regular expression" specifying how many times the
1944 foregoing "atom" may occur.
1945 R
1947 readable
1948 With respect to files, one that has the proper permission bit set
1949 to let you access the file. With respect to computer programs, one
1950 that's written well enough that someone has a chance of figuring
1951 out what it's trying to do.
1952 reaping
1954 The last rites performed by a parent "process" on behalf of a
1955 deceased child process so that it doesn't remain a "zombie". See
1956 the wait and waitpid function calls.
1957 record
1959 A set of related data values in a "file" or "stream", often
1960 associated with a unique "key" field. In Unix, often commensurate
1961 with a "line", or a blank-line-terminated set of lines (a
1962 "paragraph"). Each line of the /etc/passwd file is a record, keyed
1963 on login name, containing information about that user.
1964 recursion
1966 The art of defining something (at least partly) in terms of itself,
1967 which is a naughty no-no in dictionaries but often works out okay
1968 in computer programs if you're careful not to recurse forever,
1969 which is like an infinite loop with more spectacular failure modes.
1970 reference
1972 Where you look to find a pointer to information somewhere else.
1973 (See "indirection".) References come in two flavors, symbolic
1974 references and hard references.
1975 referent
1977 Whatever a reference refers to, which may or may not have a name.
1978 Common types of referents include scalars, arrays, hashes, and
1979 subroutines.
1980 regex
1982 See "regular expression".
1983 regular expression
1985 A single entity with various interpretations, like an elephant. To
1986 a computer scientist, it's a grammar for a little language in which
1987 some strings are legal and others aren't. To normal people, it's a
1988 pattern you can use to find what you're looking for when it varies
1989 from case to case. Perl's regular expressions are far from regular
1990 in the theoretical sense, but in regular use they work quite well.
1991 Here's a regular expression: "/Oh s.*t./". This will match strings
1992 like ""Oh say can you see by the dawn's early light"" and ""Oh
1993 sit!"". See perlre.
1994 regular expression modifier
1996 An option on a pattern or substitution, such as "/i" to render the
1997 pattern case insensitive. See also "cloister".
1998 regular file
2000 A "file" that's not a "directory", a "device", a named "pipe" or
2001 "socket", or a "symbolic link". Perl uses the "-f" file test
2002 operator to identify regular files. Sometimes called a "plain"
2003 file.
2004 relational operator
2006 An "operator" that says whether a particular ordering relationship
2007 is "true" about a pair of operands. Perl has both numeric and
2008 string relational operators. See "collating sequence".
2009 reserved words
2011 A word with a specific, built-in meaning to a "compiler", such as
2012 "if" or delete. In many languages (not Perl), it's illegal to use
2013 reserved words to name anything else. (Which is why they're
2014 reserved, after all.) In Perl, you just can't use them to name
2015 labels or filehandles. Also called "keywords".
2016 return value
2018 The "value" produced by a "subroutine" or "expression" when
2019 evaluated. In Perl, a return value may be either a "list" or a
2020 "scalar".
2021 RFC Request For Comment, which despite the timid connotations is the
2023 name of a series of important standards documents.
2024 right shift
2026 A "bit shift" that divides a number by some power of 2.
2027 root
2029 The superuser (UID == 0). Also, the top-level directory of the
2030 filesystem.
2031 RTFM
2033 What you are told when someone thinks you should Read The Fine
2034 Manual.
2035 run phase
2037 Any time after Perl starts running your main program. See also
2038 "compile phase". Run phase is mostly spent in "run time" but may
2039 also be spent in "compile time" when require, do "FILE", or eval
2040 "STRING" operators are executed or when a substitution uses the
2041 "/ee" modifier.
2042 run time
2044 The time when Perl is actually doing what your code says to do, as
2045 opposed to the earlier period of time when it was trying to figure
2046 out whether what you said made any sense whatsoever, which is
2047 "compile time".
2048 run-time pattern
2050 A pattern that contains one or more variables to be interpolated
2051 before parsing the pattern as a "regular expression", and that
2052 therefore cannot be analyzed at compile time, but must be re-
2053 analyzed each time the pattern match operator is evaluated. Run-
2054 time patterns are useful but expensive.
2055 RV A recreational vehicle, not to be confused with vehicular
2057 recreation. RV also means an internal Reference Value of the type
2058 a "scalar" can hold. See also "IV" and "NV" if you're not confused
2059 yet.
2060 rvalue
2062 A "value" that you might find on the right side of an "assignment".
2063 See also "lvalue".
2064 S
2066 scalar
2067 A simple, singular value; a number, "string", or "reference".
2068 scalar context
2070 The situation in which an "expression" is expected by its
2071 surroundings (the code calling it) to return a single "value"
2072 rather than a "list" of values. See also "context" and "list
2073 context". A scalar context sometimes imposes additional
2074 constraints on the return value--see "string context" and "numeric
2075 context". Sometimes we talk about a "Boolean context" inside
2076 conditionals, but this imposes no additional constraints, since any
2077 scalar value, whether numeric or "string", is already true or
2078 false.
2079 scalar literal
2081 A number or quoted "string"--an actual "value" in the text of your
2082 program, as opposed to a "variable".
2083 scalar value
2085 A value that happens to be a "scalar" as opposed to a "list".
2086 scalar variable
2088 A "variable" prefixed with "$" that holds a single value.
2089 scope
2091 How far away you can see a variable from, looking through one.
2092 Perl has two visibility mechanisms: it does "dynamic scoping" of
2093 local variables, meaning that the rest of the "block", and any
2094 subroutines that are called by the rest of the block, can see the
2095 variables that are local to the block. Perl does "lexical scoping"
2096 of my variables, meaning that the rest of the block can see the
2097 variable, but other subroutines called by the block cannot see the
2098 variable.
2099 scratchpad
2101 The area in which a particular invocation of a particular file or
2102 subroutine keeps some of its temporary values, including any
2103 lexically scoped variables.
2104 script
2106 A text "file" that is a program intended to be executed directly
2107 rather than compiled to another form of file before execution.
2108 Also, in the context of "Unicode", a writing system for a
2109 particular language or group of languages, such as Greek, Bengali,
2110 or Klingon.
2111 script kiddie
2113 A "cracker" who is not a "hacker", but knows just enough to run
2114 canned scripts. A cargo-cult programmer.
2115 sed A venerable Stream EDitor from which Perl derives some of its
2117 ideas.
2118 semaphore
2120 A fancy kind of interlock that prevents multiple threads or
2121 processes from using up the same resources simultaneously.
2122 separator
2124 A "character" or "string" that keeps two surrounding strings from
2125 being confused with each other. The split function works on
2126 separators. Not to be confused with delimiters or terminators.
2127 The "or" in the previous sentence separated the two alternatives.
2128 serialization
2130 Putting a fancy "data structure" into linear order so that it can
2131 be stored as a "string" in a disk file or database or sent through
2132 a "pipe". Also called marshalling.
2133 server
2135 In networking, a "process" that either advertises a "service" or
2136 just hangs around at a known location and waits for clients who
2137 need service to get in touch with it.
2138 service
2140 Something you do for someone else to make them happy, like giving
2141 them the time of day (or of their life). On some machines, well-
2142 known services are listed by the getservent function.
2143 setgid
2145 Same as "setuid", only having to do with giving away "group"
2146 privileges.
2147 setuid
2149 Said of a program that runs with the privileges of its "owner"
2150 rather than (as is usually the case) the privileges of whoever is
2151 running it. Also describes the bit in the mode word ("permission
2152 bits") that controls the feature. This bit must be explicitly set
2153 by the owner to enable this feature, and the program must be
2154 carefully written not to give away more privileges than it ought
2155 to.
2156 shared memory
2158 A piece of "memory" accessible by two different processes who
2159 otherwise would not see each other's memory.
2160 shebang
2162 Irish for the whole McGillicuddy. In Perl culture, a portmanteau
2163 of "sharp" and "bang", meaning the "#!" sequence that tells the
2164 system where to find the interpreter.
2165 shell
2167 A "command"-line "interpreter". The program that interactively
2168 gives you a prompt, accepts one or more lines of input, and
2169 executes the programs you mentioned, feeding each of them their
2170 proper arguments and input data. Shells can also execute scripts
2171 containing such commands. Under Unix, typical shells include the
2172 Bourne shell (/bin/sh), the C shell (/bin/csh), and the Korn shell
2173 (/bin/ksh). Perl is not strictly a shell because it's not
2174 interactive (although Perl programs can be interactive).
2175 side effects
2177 Something extra that happens when you evaluate an "expression".
2178 Nowadays it can refer to almost anything. For example, evaluating
2179 a simple assignment statement typically has the "side effect" of
2180 assigning a value to a variable. (And you thought assigning the
2181 value was your primary intent in the first place!) Likewise,
2182 assigning a value to the special variable $| ($AUTOFLUSH) has the
2183 side effect of forcing a flush after every write or print on the
2184 currently selected filehandle.
2185 signal
2187 A bolt out of the blue; that is, an event triggered by the
2188 "operating system", probably when you're least expecting it.
2189 signal handler
2191 A "subroutine" that, instead of being content to be called in the
2192 normal fashion, sits around waiting for a bolt out of the blue
2193 before it will deign to "execute". Under Perl, bolts out of the
2194 blue are called signals, and you send them with the kill built-in.
2195 See "%SIG" in perlvar and "Signals" in perlipc.
2196 single inheritance
2198 The features you got from your mother, if she told you that you
2199 don't have a father. (See also "inheritance" and "multiple
2200 inheritance".) In computer languages, the notion that classes
2201 reproduce asexually so that a given class can only have one direct
2202 ancestor or "base class". Perl supplies no such restriction,
2203 though you may certainly program Perl that way if you like.
2204 slice
2206 A selection of any number of elements from a "list", "array", or
2207 "hash".
2208 slurp
2210 To read an entire "file" into a "string" in one operation.
2211 socket
2213 An endpoint for network communication among multiple processes that
2214 works much like a telephone or a post office box. The most
2215 important thing about a socket is its "network address" (like a
2216 phone number). Different kinds of sockets have different kinds of
2217 addresses--some look like filenames, and some don't.
2218 soft reference
2220 See "symbolic reference".
2221 source filter
2223 A special kind of "module" that does "preprocessing" on your script
2224 just before it gets to the "tokener".
2225 stack
2227 A device you can put things on the top of, and later take them back
2228 off in the opposite order in which you put them on. See "LIFO".
2229 standard
2231 Included in the official Perl distribution, as in a standard
2232 module, a standard tool, or a standard Perl "manpage".
2233 standard error
2235 The default output "stream" for nasty remarks that don't belong in
2236 "standard output". Represented within a Perl program by the
2237 "filehandle" "STDERR". You can use this stream explicitly, but the
2238 die and warn built-ins write to your standard error stream
2239 automatically.
2240 standard I/O
2242 A standard C library for doing buffered input and output to the
2243 "operating system". (The "standard" of standard I/O is only
2244 marginally related to the "standard" of standard input and output.)
2245 In general, Perl relies on whatever implementation of standard I/O
2246 a given operating system supplies, so the buffering characteristics
2247 of a Perl program on one machine may not exactly match those on
2248 another machine. Normally this only influences efficiency, not
2249 semantics. If your standard I/O package is doing block buffering
2250 and you want it to "flush" the buffer more often, just set the $|
2251 variable to a true value.
2252 standard input
2254 The default input "stream" for your program, which if possible
2255 shouldn't care where its data is coming from. Represented within a
2256 Perl program by the "filehandle" "STDIN".
2257 standard output
2259 The default output "stream" for your program, which if possible
2260 shouldn't care where its data is going. Represented within a Perl
2261 program by the "filehandle" "STDOUT".
2262 stat structure
2264 A special internal spot in which Perl keeps the information about
2265 the last "file" on which you requested information.
2266 statement
2268 A "command" to the computer about what to do next, like a step in a
2269 recipe: "Add marmalade to batter and mix until mixed." A statement
2270 is distinguished from a "declaration", which doesn't tell the
2271 computer to do anything, but just to learn something.
2272 statement modifier
2274 A "conditional" or "loop" that you put after the "statement"
2275 instead of before, if you know what we mean.
2276 static
2278 Varying slowly compared to something else. (Unfortunately,
2279 everything is relatively stable compared to something else, except
2280 for certain elementary particles, and we're not so sure about
2281 them.) In computers, where things are supposed to vary rapidly,
2282 "static" has a derogatory connotation, indicating a slightly
2283 dysfunctional "variable", "subroutine", or "method". In Perl
2284 culture, the word is politely avoided.
2285 static method
2287 No such thing. See "class method".
2288 static scoping
2290 No such thing. See "lexical scoping".
2291 static variable
2293 No such thing. Just use a "lexical variable" in a scope larger
2294 than your "subroutine".
2295 status
2297 The "value" returned to the parent "process" when one of its child
2298 processes dies. This value is placed in the special variable $?.
2299 Its upper eight bits are the exit status of the defunct process,
2300 and its lower eight bits identify the signal (if any) that the
2301 process died from. On Unix systems, this status value is the same
2302 as the status word returned by wait(2). See "system" in perlfunc.
2303 STDERR
2305 See "standard error".
2306 STDIN
2308 See "standard input".
2309 STDIO
2311 See "standard I/O".
2312 STDOUT
2314 See "standard output".
2315 stream
2317 A flow of data into or out of a process as a steady sequence of
2318 bytes or characters, without the appearance of being broken up into
2319 packets. This is a kind of "interface"--the underlying
2320 "implementation" may well break your data up into separate packets
2321 for delivery, but this is hidden from you.
2322 string
2324 A sequence of characters such as "He said !@#*&%@#*?!". A string
2325 does not have to be entirely printable.
2326 string context
2328 The situation in which an expression is expected by its
2329 surroundings (the code calling it) to return a "string". See also
2330 "context" and "numeric context".
2331 stringification
2333 The process of producing a "string" representation of an abstract
2334 object.
2335 struct
2337 C keyword introducing a structure definition or name.
2338 structure
2340 See "data structure".
2341 subclass
2343 See "derived class".
2344 subpattern
2346 A component of a "regular expression" pattern.
2347 subroutine
2349 A named or otherwise accessible piece of program that can be
2350 invoked from elsewhere in the program in order to accomplish some
2351 sub-goal of the program. A subroutine is often parameterized to
2352 accomplish different but related things depending on its input
2353 arguments. If the subroutine returns a meaningful "value", it is
2354 also called a "function".
2355 subscript
2357 A "value" that indicates the position of a particular "array"
2358 "element" in an array.
2359 substitution
2361 Changing parts of a string via the "s///" operator. (We avoid use
2362 of this term to mean "variable interpolation".)
2363 substring
2365 A portion of a "string", starting at a certain "character" position
2366 ("offset") and proceeding for a certain number of characters.
2367 superclass
2369 See "base class".
2370 superuser
2372 The person whom the "operating system" will let do almost anything.
2373 Typically your system administrator or someone pretending to be
2374 your system administrator. On Unix systems, the "root" user. On
2375 Windows systems, usually the Administrator user.
2376 SV Short for "scalar value". But within the Perl interpreter every
2378 "referent" is treated as a member of a class derived from SV, in an
2379 object-oriented sort of way. Every "value" inside Perl is passed
2380 around as a C language "SV*" pointer. The SV "struct" knows its
2381 own "referent type", and the code is smart enough (we hope) not to
2382 try to call a "hash" function on a "subroutine".
2383 switch
2385 An option you give on a command line to influence the way your
2386 program works, usually introduced with a minus sign. The word is
2387 also used as a nickname for a "switch statement".
2388 switch cluster
2390 The combination of multiple command-line switches (e.g., -a -b -c)
2391 into one switch (e.g., -abc). Any switch with an additional
2392 "argument" must be the last switch in a cluster.
2393 switch statement
2395 A program technique that lets you evaluate an "expression" and
2396 then, based on the value of the expression, do a multiway branch to
2397 the appropriate piece of code for that value. Also called a "case
2398 structure", named after the similar Pascal construct. Most switch
2399 statements in Perl are spelled "for". See "Basic BLOCKs and Switch
2400 Statements" in perlsyn.
2401 symbol
2403 Generally, any "token" or "metasymbol". Often used more
2404 specifically to mean the sort of name you might find in a "symbol
2405 table".
2406 symbol table
2408 Where a "compiler" remembers symbols. A program like Perl must
2409 somehow remember all the names of all the variables, filehandles,
2410 and subroutines you've used. It does this by placing the names in
2411 a symbol table, which is implemented in Perl using a "hash table".
2412 There is a separate symbol table for each "package" to give each
2413 package its own "namespace".
2414 symbolic debugger
2416 A program that lets you step through the execution of your program,
2417 stopping or printing things out here and there to see whether
2418 anything has gone wrong, and if so, what. The "symbolic" part just
2419 means that you can talk to the debugger using the same symbols with
2420 which your program is written.
2421 symbolic link
2423 An alternate filename that points to the real "filename", which in
2424 turn points to the real "file". Whenever the "operating system" is
2425 trying to parse a "pathname" containing a symbolic link, it merely
2426 substitutes the new name and continues parsing.
2427 symbolic reference
2429 A variable whose value is the name of another variable or
2430 subroutine. By dereferencing the first variable, you can get at
2431 the second one. Symbolic references are illegal under use strict
2432 'refs'.
2433 synchronous
2435 Programming in which the orderly sequence of events can be
2436 determined; that is, when things happen one after the other, not at
2437 the same time.
2438 syntactic sugar
2440 An alternative way of writing something more easily; a shortcut.
2441 syntax
2443 From Greek, "with-arrangement". How things (particularly symbols)
2444 are put together with each other.
2445 syntax tree
2447 An internal representation of your program wherein lower-level
2448 constructs dangle off the higher-level constructs enclosing them.
2449 syscall
2451 A "function" call directly to the "operating system". Many of the
2452 important subroutines and functions you use aren't direct system
2453 calls, but are built up in one or more layers above the system call
2454 level. In general, Perl programmers don't need to worry about the
2455 distinction. However, if you do happen to know which Perl
2456 functions are really syscalls, you can predict which of these will
2457 set the $! ($ERRNO) variable on failure. Unfortunately, beginning
2458 programmers often confusingly employ the term "system call" to mean
2459 what happens when you call the Perl system function, which actually
2460 involves many syscalls. To avoid any confusion, we nearly always
2461 use say "syscall" for something you could call indirectly via
2462 Perl's syscall function, and never for something you would call
2463 with Perl's system function.
2464 T
2466 tainted
2467 Said of data derived from the grubby hands of a user and thus
2468 unsafe for a secure program to rely on. Perl does taint checks if
2469 you run a "setuid" (or "setgid") program, or if you use the -T
2470 switch.
2471 TCP Short for Transmission Control Protocol. A protocol wrapped around
2473 the Internet Protocol to make an unreliable packet transmission
2474 mechanism appear to the application program to be a reliable
2475 "stream" of bytes. (Usually.)
2476 term
2478 Short for a "terminal", that is, a leaf node of a "syntax tree". A
2479 thing that functions grammatically as an "operand" for the
2480 operators in an expression.
2481 terminator
2483 A "character" or "string" that marks the end of another string.
2484 The $/ variable contains the string that terminates a readline
2485 operation, which chomp deletes from the end. Not to be confused
2486 with delimiters or separators. The period at the end of this
2487 sentence is a terminator.
2488 ternary
2490 An "operator" taking three operands. Sometimes pronounced
2491 "trinary".
2492 text
2494 A "string" or "file" containing primarily printable characters.
2495 thread
2497 Like a forked process, but without "fork"'s inherent memory
2498 protection. A thread is lighter weight than a full process, in
2499 that a process could have multiple threads running around in it,
2500 all fighting over the same process's memory space unless steps are
2501 taken to protect threads from each other. See threads.
2502 tie The bond between a magical variable and its implementation class.
2504 See "tie" in perlfunc and perltie.
2505 TMTOWTDI
2507 There's More Than One Way To Do It, the Perl Motto. The notion
2508 that there can be more than one valid path to solving a programming
2509 problem in context. (This doesn't mean that more ways are always
2510 better or that all possible paths are equally desirable--just that
2511 there need not be One True Way.) Pronounced TimToady.
2512 token
2514 A morpheme in a programming language, the smallest unit of text
2515 with semantic significance.
2516 tokener
2518 A module that breaks a program text into a sequence of tokens for
2519 later analysis by a parser.
2520 tokenizing
2522 Splitting up a program text into tokens. Also known as "lexing",
2523 in which case you get "lexemes" instead of tokens.
2524 toolbox approach
2526 The notion that, with a complete set of simple tools that work well
2527 together, you can build almost anything you want. Which is fine if
2528 you're assembling a tricycle, but if you're building a
2529 defranishizing comboflux regurgalator, you really want your own
2530 machine shop in which to build special tools. Perl is sort of a
2531 machine shop.
2532 transliterate
2534 To turn one string representation into another by mapping each
2535 character of the source string to its corresponding character in
2536 the result string. See "tr/SEARCHLIST/REPLACEMENTLIST/cds" in
2537 perlop.
2538 trigger
2540 An event that causes a "handler" to be run.
2541 trinary
2543 Not a stellar system with three stars, but an "operator" taking
2544 three operands. Sometimes pronounced "ternary".
2545 troff
2547 A venerable typesetting language from which Perl derives the name
2548 of its $% variable and which is secretly used in the production of
2549 Camel books.
2550 true
2552 Any scalar value that doesn't evaluate to 0 or "".
2553 truncating
2555 Emptying a file of existing contents, either automatically when
2556 opening a file for writing or explicitly via the truncate function.
2557 type
2559 See "data type" and "class".
2560 type casting
2562 Converting data from one type to another. C permits this. Perl
2563 does not need it. Nor want it.
2564 typed lexical
2566 A "lexical variable" that is declared with a "class" type: "my Pony
2567 $bill".
2568 typedef
2570 A type definition in the C language.
2571 typeglob
2573 Use of a single identifier, prefixed with "*". For example, *name
2574 stands for any or all of $name, @name, %name, &name, or just
2575 "name". How you use it determines whether it is interpreted as all
2576 or only one of them. See "Typeglobs and Filehandles" in perldata.
2577 typemap
2579 A description of how C types may be transformed to and from Perl
2580 types within an "extension" module written in "XS".
2581 U
2583 UDP User Datagram Protocol, the typical way to send datagrams over the
2584 Internet.
2585 UID A user ID. Often used in the context of "file" or "process"
2587 ownership.
2588 umask
2590 A mask of those "permission bits" that should be forced off when
2591 creating files or directories, in order to establish a policy of
2592 whom you'll ordinarily deny access to. See the umask function.
2593 unary operator
2595 An operator with only one "operand", like "!" or chdir. Unary
2596 operators are usually prefix operators; that is, they precede their
2597 operand. The "++" and "--" operators can be either prefix or
2598 postfix. (Their position does change their meanings.)
2599 Unicode
2601 A character set comprising all the major character sets of the
2602 world, more or less. See <http://www.unicode.org>.
2603 Unix
2605 A very large and constantly evolving language with several
2606 alternative and largely incompatible syntaxes, in which anyone can
2607 define anything any way they choose, and usually do. Speakers of
2608 this language think it's easy to learn because it's so easily
2609 twisted to one's own ends, but dialectical differences make tribal
2610 intercommunication nearly impossible, and travelers are often
2611 reduced to a pidgin-like subset of the language. To be universally
2612 understood, a Unix shell programmer must spend years of study in
2613 the art. Many have abandoned this discipline and now communicate
2614 via an Esperanto-like language called Perl.
2615 In ancient times, Unix was also used to refer to some code that a
2617 couple of people at Bell Labs wrote to make use of a PDP-7 computer
2618 that wasn't doing much of anything else at the time.
2619 V
2621 value
2622 An actual piece of data, in contrast to all the variables,
2623 references, keys, indexes, operators, and whatnot that you need to
2624 access the value.
2625 variable
2627 A named storage location that can hold any of various kinds of
2628 "value", as your program sees fit.
2629 variable interpolation
2631 The "interpolation" of a scalar or array variable into a string.
2632 variadic
2634 Said of a "function" that happily receives an indeterminate number
2635 of "actual arguments".
2636 vector
2638 Mathematical jargon for a list of scalar values.
2639 virtual
2641 Providing the appearance of something without the reality, as in:
2642 virtual memory is not real memory. (See also "memory".) The
2643 opposite of "virtual" is "transparent", which means providing the
2644 reality of something without the appearance, as in: Perl handles
2645 the variable-length UTF-8 character encoding transparently.
2646 void context
2648 A form of "scalar context" in which an "expression" is not expected
2649 to return any "value" at all and is evaluated for its "side
2650 effects" alone.
2651 v-string
2653 A "version" or "vector" "string" specified with a "v" followed by a
2654 series of decimal integers in dot notation, for instance,
2655 "v1.20.300.4000". Each number turns into a "character" with the
2656 specified ordinal value. (The "v" is optional when there are at
2657 least three integers.)
2658 W
2660 warning
2661 A message printed to the "STDERR" stream to the effect that
2662 something might be wrong but isn't worth blowing up over. See
2663 "warn" in perlfunc and the warnings pragma.
2664 watch expression
2666 An expression which, when its value changes, causes a breakpoint in
2667 the Perl debugger.
2668 whitespace
2670 A "character" that moves your cursor but doesn't otherwise put
2671 anything on your screen. Typically refers to any of: space, tab,
2672 line feed, carriage return, or form feed.
2673 word
2675 In normal "computerese", the piece of data of the size most
2676 efficiently handled by your computer, typically 32 bits or so, give
2677 or take a few powers of 2. In Perl culture, it more often refers
2678 to an alphanumeric "identifier" (including underscores), or to a
2679 string of nonwhitespace characters bounded by whitespace or string
2680 boundaries.
2681 working directory
2683 Your current "directory", from which relative pathnames are
2684 interpreted by the "operating system". The operating system knows
2685 your current directory because you told it with a chdir or because
2686 you started out in the place where your parent "process" was when
2687 you were born.
2688 wrapper
2690 A program or subroutine that runs some other program or subroutine
2691 for you, modifying some of its input or output to better suit your
2692 purposes.
2693 WYSIWYG
2695 What You See Is What You Get. Usually used when something that
2696 appears on the screen matches how it will eventually look, like
2697 Perl's format declarations. Also used to mean the opposite of
2698 magic because everything works exactly as it appears, as in the
2699 three-argument form of open.
2700 X
2702 XS An extraordinarily exported, expeditiously excellent, expressly
2703 eXternal Subroutine, executed in existing C or C++ or in an
2704 exciting new extension language called (exasperatingly) XS.
2705 Examine perlxs for the exact explanation or perlxstut for an
2706 exemplary unexacting one.
2707 XSUB
2709 An external "subroutine" defined in "XS".
2710 Y
2712 yacc
2713 Yet Another Compiler Compiler. A parser generator without which
2714 Perl probably would not have existed. See the file perly.y in the
2715 Perl source distribution.
2716 Z
2718 zero width
2719 A subpattern "assertion" matching the "null string" between
2720 characters.
2721 zombie
2723 A process that has died (exited) but whose parent has not yet
2724 received proper notification of its demise by virtue of having
2725 called wait or waitpid. If you fork, you must clean up after your
2726 child processes when they exit, or else the process table will fill
2727 up and your system administrator will Not Be Happy with you.
2728
2730 Based on the Glossary of Programming Perl, Third Edition, by Larry
2731 Wall, Tom Christiansen & Jon Orwant. Copyright (c) 2000, 1996, 1991
2732 O'Reilly Media, Inc. This document may be distributed under the same
2733 terms as Perl itself.
2734perl v5.10.1 2009-04-12 PERLGLOSSARY(1)