1perlglossary(3) User Contributed Perl Documentation perlglossary(3)
2
6 perlglossary - Perl Glossary
7
9 version 5.20191102
10
12 A glossary of terms (technical and otherwise) used in the Perl
13 documentation, derived from the Glossary of Programming Perl, Fourth
14 Edition. Words or phrases in bold are defined elsewhere in this
15 glossary.
16 Other useful sources include the Unicode Glossary
18 <http://unicode.org/glossary/>, the Free On-Line Dictionary of
19 Computing <http://foldoc.org/>, the Jargon File
20 <http://catb.org/~esr/jargon/>, and Wikipedia
21 <http://www.wikipedia.org/>.
22 A
24 accessor methods
25 A method used to indirectly inspect or update an object’s state
26 (its instance variables).
27 actual arguments
29 The scalar values that you supply to a function or subroutine when
30 you call it. For instance, when you call "power("puff")", the
31 string "puff" is the actual argument. See also argument and formal
32 arguments.
33 address operator
35 Some languages work directly with the memory addresses of values,
36 but this can be like playing with fire. Perl provides a set of
37 asbestos gloves for handling all memory management. The closest to
38 an address operator in Perl is the backslash operator, but it gives
39 you a hard reference, which is much safer than a memory address.
40 algorithm
42 A well-defined sequence of steps, explained clearly enough that
43 even a computer could do them.
44 alias
46 A nickname for something, which behaves in all ways as though you’d
47 used the original name instead of the nickname. Temporary aliases
48 are implicitly created in the loop variable for "foreach" loops, in
49 the $_ variable for "map" or "grep" operators, in $a and $b during
50 "sort"’s comparison function, and in each element of @_ for the
51 actual arguments of a subroutine call. Permanent aliases are
52 explicitly created in packages by importing symbols or by
53 assignment to typeglobs. Lexically scoped aliases for package
54 variables are explicitly created by the "our" declaration.
55 alphabetic
57 The sort of characters we put into words. In Unicode, this is all
58 letters including all ideographs and certain diacritics, letter
59 numbers like Roman numerals, and various combining marks.
60 alternatives
62 A list of possible choices from which you may select only one, as
63 in, “Would you like door A, B, or C?” Alternatives in regular
64 expressions are separated with a single vertical bar: "|".
65 Alternatives in normal Perl expressions are separated with a double
66 vertical bar: "||". Logical alternatives in Boolean expressions are
67 separated with either "||" or "or".
68 anonymous
70 Used to describe a referent that is not directly accessible through
71 a named variable. Such a referent must be indirectly accessible
72 through at least one hard reference. When the last hard reference
73 goes away, the anonymous referent is destroyed without pity.
74 application
76 A bigger, fancier sort of program with a fancier name so people
77 don’t realize they are using a program.
78 architecture
80 The kind of computer you’re working on, where one “kind of
81 computer” means all those computers sharing a compatible machine
82 language. Since Perl programs are (typically) simple text files,
83 not executable images, a Perl program is much less sensitive to the
84 architecture it’s running on than programs in other languages, such
85 as C, that are compiled into machine code. See also platform and
86 operating system.
87 argument
89 A piece of data supplied to a program, subroutine, function, or
90 method to tell it what it’s supposed to do. Also called a
91 “parameter”.
92 ARGV
94 The name of the array containing the argument vector from the
95 command line. If you use the empty "<>" operator, "ARGV" is the
96 name of both the filehandle used to traverse the arguments and the
97 scalar containing the name of the current input file.
98 arithmetical operator
100 A symbol such as "+" or "/" that tells Perl to do the arithmetic
101 you were supposed to learn in grade school.
102 array
104 An ordered sequence of values, stored such that you can easily
105 access any of the values using an integer subscript that specifies
106 the value’s offset in the sequence.
107 array context
109 An archaic expression for what is more correctly referred to as
110 list context.
111 Artistic License
113 The open source license that Larry Wall created for Perl,
114 maximizing Perl’s usefulness, availability, and modifiability. The
115 current version is 2.
116 (<http://www.opensource.org/licenses/artistic-license.php>).
117 ASCII
119 The American Standard Code for Information Interchange (a 7-bit
120 character set adequate only for poorly representing English text).
121 Often used loosely to describe the lowest 128 values of the various
122 ISO-8859-X character sets, a bunch of mutually incompatible 8-bit
123 codes best described as half ASCII. See also Unicode.
124 assertion
126 A component of a regular expression that must be true for the
127 pattern to match but does not necessarily match any characters
128 itself. Often used specifically to mean a zero-width assertion.
129 assignment
131 An operator whose assigned mission in life is to change the value
132 of a variable.
133 assignment operator
135 Either a regular assignment or a compound operator composed of an
136 ordinary assignment and some other operator, that changes the value
137 of a variable in place; that is, relative to its old value. For
138 example, "$a += 2" adds 2 to $a.
139 associative array
141 See hash. Please. The term associative array is the old Perl 4 term
142 for a hash. Some languages call it a dictionary.
143 associativity
145 Determines whether you do the left operator first or the right
146 operator first when you have “A operator B operator C”, and the two
147 operators are of the same precedence. Operators like "+" are left
148 associative, while operators like "**" are right associative. See
149 Camel chapter 3, “Unary and Binary Operators” for a list of
150 operators and their associativity.
151 asynchronous
153 Said of events or activities whose relative temporal ordering is
154 indeterminate because too many things are going on at once. Hence,
155 an asynchronous event is one you didn’t know when to expect.
156 atom
158 A regular expression component potentially matching a substring
159 containing one or more characters and treated as an indivisible
160 syntactic unit by any following quantifier. (Contrast with an
161 assertion that matches something of zero width and may not be
162 quantified.)
163 atomic operation
165 When Democritus gave the word “atom” to the indivisible bits of
166 matter, he meant literally something that could not be cut: ἀ-
167 (not) + -τομος (cuttable). An atomic operation is an action that
168 can’t be interrupted, not one forbidden in a nuclear-free zone.
169 attribute
171 A new feature that allows the declaration of variables and
172 subroutines with modifiers, as in "sub foo : locked method". Also
173 another name for an instance variable of an object.
174 autogeneration
176 A feature of operator overloading of objects, whereby the behavior
177 of certain operators can be reasonably deduced using more
178 fundamental operators. This assumes that the overloaded operators
179 will often have the same relationships as the regular operators.
180 See Camel chapter 13, “Overloading”.
181 autoincrement
183 To add one to something automatically, hence the name of the "++"
184 operator. To instead subtract one from something automatically is
185 known as an “autodecrement”.
186 autoload
188 To load on demand. (Also called “lazy” loading.) Specifically, to
189 call an "AUTOLOAD" subroutine on behalf of an undefined subroutine.
190 autosplit
192 To split a string automatically, as the –a switch does when running
193 under –p or –n in order to emulate awk. (See also the "AutoSplit"
194 module, which has nothing to do with the "–a" switch but a lot to
195 do with autoloading.)
196 autovivification
198 A Graeco-Roman word meaning “to bring oneself to life”. In Perl,
199 storage locations (lvalues) spontaneously generate themselves as
200 needed, including the creation of any hard reference values to
201 point to the next level of storage. The assignment
202 "$a[5][5][5][5][5] = "quintet"" potentially creates five scalar
203 storage locations, plus four references (in the first four scalar
204 locations) pointing to four new anonymous arrays (to hold the last
205 four scalar locations). But the point of autovivification is that
206 you don’t have to worry about it.
207 AV Short for “array value”, which refers to one of Perl’s internal
209 data types that holds an array. The "AV" type is a subclass of SV.
210 awk Descriptive editing term—short for “awkward”. Also coincidentally
212 refers to a venerable text-processing language from which Perl
213 derived some of its high-level ideas.
214 B
216 backreference
217 A substring captured by a subpattern within unadorned parentheses
218 in a regex. Backslashed decimal numbers ("\1", "\2", etc.) later in
219 the same pattern refer back to the corresponding subpattern in the
220 current match. Outside the pattern, the numbered variables ($1, $2,
221 etc.) continue to refer to these same values, as long as the
222 pattern was the last successful match of the current dynamic scope.
223 backtracking
225 The practice of saying, “If I had to do it all over, I’d do it
226 differently,” and then actually going back and doing it all over
227 differently. Mathematically speaking, it’s returning from an
228 unsuccessful recursion on a tree of possibilities. Perl backtracks
229 when it attempts to match patterns with a regular expression, and
230 its earlier attempts don’t pan out. See the section “The Little
231 Engine That /Couldn(n’t)” in Camel chapter 5, “Pattern Matching”.
232 backward compatibility
234 Means you can still run your old program because we didn’t break
235 any of the features or bugs it was relying on.
236 bareword
238 A word sufficiently ambiguous to be deemed illegal under "use
239 strict 'subs'". In the absence of that stricture, a bareword is
240 treated as if quotes were around it.
241 base class
243 A generic object type; that is, a class from which other, more
244 specific classes are derived genetically by inheritance. Also
245 called a “superclass” by people who respect their ancestors.
246 big-endian
248 From Swift: someone who eats eggs big end first. Also used of
249 computers that store the most significant byte of a word at a lower
250 byte address than the least significant byte. Often considered
251 superior to little-endian machines. See also little-endian.
252 binary
254 Having to do with numbers represented in base 2. That means there’s
255 basically two numbers: 0 and 1. Also used to describe a file of
256 “nontext”, presumably because such a file makes full use of all the
257 binary bits in its bytes. With the advent of Unicode, this
258 distinction, already suspect, loses even more of its meaning.
259 binary operator
261 An operator that takes two operands.
262 bind
264 To assign a specific network address to a socket.
265 bit An integer in the range from 0 to 1, inclusive. The smallest
267 possible unit of information storage. An eighth of a byte or of a
268 dollar. (The term “Pieces of Eight” comes from being able to split
269 the old Spanish dollar into 8 bits, each of which still counted for
270 money. That’s why a 25- cent piece today is still “two bits”.)
271 bit shift
273 The movement of bits left or right in a computer word, which has
274 the effect of multiplying or dividing by a power of 2.
275 bit string
277 A sequence of bits that is actually being thought of as a sequence
278 of bits, for once.
279 bless
281 In corporate life, to grant official approval to a thing, as in,
282 “The VP of Engineering has blessed our WebCruncher project.”
283 Similarly, in Perl, to grant official approval to a referent so
284 that it can function as an object, such as a WebCruncher object.
285 See the "bless" function in Camel chapter 27, “Functions”.
286 block
288 What a process does when it has to wait for something: “My process
289 blocked waiting for the disk.” As an unrelated noun, it refers to a
290 large chunk of data, of a size that the operating system likes to
291 deal with (normally a power of 2 such as 512 or 8192). Typically
292 refers to a chunk of data that’s coming from or going to a disk
293 file.
294 BLOCK
296 A syntactic construct consisting of a sequence of Perl statements
297 that is delimited by braces. The "if" and "while" statements are
298 defined in terms of "BLOCK"s, for instance. Sometimes we also say
299 “block” to mean a lexical scope; that is, a sequence of statements
300 that acts like a "BLOCK", such as within an "eval" or a file, even
301 though the statements aren’t delimited by braces.
302 block buffering
304 A method of making input and output efficient by passing one block
305 at a time. By default, Perl does block buffering to disk files. See
306 buffer and command buffering.
307 Boolean
309 A value that is either true or false.
310 Boolean context
312 A special kind of scalar context used in conditionals to decide
313 whether the scalar value returned by an expression is true or
314 false. Does not evaluate as either a string or a number. See
315 context.
316 breakpoint
318 A spot in your program where you’ve told the debugger to stop
319 execution so you can poke around and see whether anything is wrong
320 yet.
321 broadcast
323 To send a datagram to multiple destinations simultaneously.
324 BSD A psychoactive drug, popular in the ’80s, probably developed at UC
326 Berkeley or thereabouts. Similar in many ways to the prescription-
327 only medication called “System V”, but infinitely more useful. (Or,
328 at least, more fun.) The full chemical name is “Berkeley Standard
329 Distribution”.
330 bucket
332 A location in a hash table containing (potentially) multiple
333 entries whose keys “hash” to the same hash value according to its
334 hash function. (As internal policy, you don’t have to worry about
335 it unless you’re into internals, or policy.)
336 buffer
338 A temporary holding location for data. Data that are Block
339 buffering means that the data is passed on to its destination
340 whenever the buffer is full. Line buffering means that it’s passed
341 on whenever a complete line is received. Command buffering means
342 that it’s passed every time you do a "print" command (or
343 equivalent). If your output is unbuffered, the system processes it
344 one byte at a time without the use of a holding area. This can be
345 rather inefficient.
346 built-in
348 A function that is predefined in the language. Even when hidden by
349 overriding, you can always get at a built- in function by
350 qualifying its name with the "CORE::" pseudopackage.
351 bundle
353 A group of related modules on CPAN. (Also sometimes refers to a
354 group of command-line switches grouped into one switch cluster.)
355 byte
357 A piece of data worth eight bits in most places.
358 bytecode
360 A pidgin-like lingo spoken among ’droids when they don’t wish to
361 reveal their orientation (see endian). Named after some similar
362 languages spoken (for similar reasons) between compilers and
363 interpreters in the late 20ᵗʰ century. These languages are
364 characterized by representing everything as a nonarchitecture-
365 dependent sequence of bytes.
366 C
368 C A language beloved by many for its inside-out type definitions,
369 inscrutable precedence rules, and heavy overloading of the
370 function-call mechanism. (Well, actually, people first switched to
371 C because they found lowercase identifiers easier to read than
372 upper.) Perl is written in C, so it’s not surprising that Perl
373 borrowed a few ideas from it.
374 cache
376 A data repository. Instead of computing expensive answers several
377 times, compute it once and save the result.
378 callback
380 A handler that you register with some other part of your program in
381 the hope that the other part of your program will trigger your
382 handler when some event of interest transpires.
383 call by reference
385 An argument-passing mechanism in which the formal arguments refer
386 directly to the actual arguments, and the subroutine can change the
387 actual arguments by changing the formal arguments. That is, the
388 formal argument is an alias for the actual argument. See also call
389 by value.
390 call by value
392 An argument-passing mechanism in which the formal arguments refer
393 to a copy of the actual arguments, and the subroutine cannot change
394 the actual arguments by changing the formal arguments. See also
395 call by reference.
396 canonical
398 Reduced to a standard form to facilitate comparison.
399 capture variables
401 The variables—such as $1 and $2, and "%+" and "%– "—that hold the
402 text remembered in a pattern match. See Camel chapter 5, “Pattern
403 Matching”.
404 capturing
406 The use of parentheses around a subpattern in a regular expression
407 to store the matched substring as a backreference. (Captured
408 strings are also returned as a list in list context.) See Camel
409 chapter 5, “Pattern Matching”.
410 cargo cult
412 Copying and pasting code without understanding it, while
413 superstitiously believing in its value. This term originated from
414 preindustrial cultures dealing with the detritus of explorers and
415 colonizers of technologically advanced cultures. See The Gods Must
416 Be Crazy.
417 case
419 A property of certain characters. Originally, typesetter stored
420 capital letters in the upper of two cases and small letters in the
421 lower one. Unicode recognizes three cases: lowercase (character
422 property "\p{lower}"), titlecase ("\p{title}"), and uppercase
423 ("\p{upper}"). A fourth casemapping called foldcase is not itself a
424 distinct case, but it is used internally to implement casefolding.
425 Not all letters have case, and some nonletters have case.
426 casefolding
428 Comparing or matching a string case-insensitively. In Perl, it is
429 implemented with the "/i" pattern modifier, the "fc" function, and
430 the "\F" double-quote translation escape.
431 casemapping
433 The process of converting a string to one of the four Unicode
434 casemaps; in Perl, it is implemented with the "fc", "lc",
435 "ucfirst", and "uc" functions.
436 character
438 The smallest individual element of a string. Computers store
439 characters as integers, but Perl lets you operate on them as text.
440 The integer used to represent a particular character is called that
441 character’s codepoint.
442 character class
444 A square-bracketed list of characters used in a regular expression
445 to indicate that any character of the set may occur at a given
446 point. Loosely, any predefined set of characters so used.
447 character property
449 A predefined character class matchable by the "\p" or "\P"
450 metasymbol. Unicode defines hundreds of standard properties for
451 every possible codepoint, and Perl defines a few of its own, too.
452 circumfix operator
454 An operator that surrounds its operand, like the angle operator, or
455 parentheses, or a hug.
456 class
458 A user-defined type, implemented in Perl via a package that
459 provides (either directly or by inheritance) methods (that is,
460 subroutines) to handle instances of the class (its objects). See
461 also inheritance.
462 class method
464 A method whose invocant is a package name, not an object reference.
465 A method associated with the class as a whole. Also see instance
466 method.
467 client
469 In networking, a process that initiates contact with a server
470 process in order to exchange data and perhaps receive a service.
471 closure
473 An anonymous subroutine that, when a reference to it is generated
474 at runtime, keeps track of the identities of externally visible
475 lexical variables, even after those lexical variables have
476 supposedly gone out of scope. They’re called “closures” because
477 this sort of behavior gives mathematicians a sense of closure.
478 cluster
480 A parenthesized subpattern used to group parts of a regular
481 expression into a single atom.
482 CODE
484 The word returned by the "ref" function when you apply it to a
485 reference to a subroutine. See also CV.
486 code generator
488 A system that writes code for you in a low-level language, such as
489 code to implement the backend of a compiler. See program generator.
490 codepoint
492 The integer a computer uses to represent a given character. ASCII
493 codepoints are in the range 0 to 127; Unicode codepoints are in the
494 range 0 to 0x1F_FFFF; and Perl codepoints are in the range 0 to
495 2³²−1 or 0 to 2⁶⁴−1, depending on your native integer size. In Perl
496 Culture, sometimes called ordinals.
497 code subpattern
499 A regular expression subpattern whose real purpose is to execute
500 some Perl code—for example, the "(?{...})" and "(??{...})"
501 subpatterns.
502 collating sequence
504 The order into which characters sort. This is used by string
505 comparison routines to decide, for example, where in this glossary
506 to put “collating sequence”.
507 co-maintainer
509 A person with permissions to index a namespace in PAUSE. Anyone can
510 upload any namespace, but only primary and co-maintainers get their
511 contributions indexed.
512 combining character
514 Any character with the General Category of Combining Mark
515 ("\p{GC=M}"), which may be spacing or nonspacing. Some are even
516 invisible. A sequence of combining characters following a grapheme
517 base character together make up a single user-visible character
518 called a grapheme. Most but not all diacritics are combining
519 characters, and vice versa.
520 command
522 In shell programming, the syntactic combination of a program name
523 and its arguments. More loosely, anything you type to a shell (a
524 command interpreter) that starts it doing something. Even more
525 loosely, a Perl statement, which might start with a label and
526 typically ends with a semicolon.
527 command buffering
529 A mechanism in Perl that lets you store up the output of each Perl
530 command and then flush it out as a single request to the operating
531 system. It’s enabled by setting the $| ($AUTOFLUSH) variable to a
532 true value. It’s used when you don’t want data sitting around, not
533 going where it’s supposed to, which may happen because the default
534 on a file or pipe is to use block buffering.
535 command-line arguments
537 The values you supply along with a program name when you tell a
538 shell to execute a command. These values are passed to a Perl
539 program through @ARGV.
540 command name
542 The name of the program currently executing, as typed on the
543 command line. In C, the command name is passed to the program as
544 the first command-line argument. In Perl, it comes in separately as
545 $0.
546 comment
548 A remark that doesn’t affect the meaning of the program. In Perl,
549 a comment is introduced by a "#" character and continues to the end
550 of the line.
551 compilation unit
553 The file (or string, in the case of "eval") that is currently being
554 compiled.
555 compile
557 The process of turning source code into a machine-usable form. See
558 compile phase.
559 compile phase
561 Any time before Perl starts running your main program. See also run
562 phase. Compile phase is mostly spent in compile time, but may also
563 be spent in runtime when "BEGIN" blocks, "use" or "no"
564 declarations, or constant subexpressions are being evaluated. The
565 startup and import code of any "use" declaration is also run during
566 compile phase.
567 compiler
569 Strictly speaking, a program that munches up another program and
570 spits out yet another file containing the program in a “more
571 executable” form, typically containing native machine instructions.
572 The perl program is not a compiler by this definition, but it does
573 contain a kind of compiler that takes a program and turns it into a
574 more executable form (syntax trees) within the perl process itself,
575 which the interpreter then interprets. There are, however,
576 extension modules to get Perl to act more like a “real” compiler.
577 See Camel chapter 16, “Compiling”.
578 compile time
580 The time when Perl is trying to make sense of your code, as opposed
581 to when it thinks it knows what your code means and is merely
582 trying to do what it thinks your code says to do, which is runtime.
583 composer
585 A “constructor” for a referent that isn’t really an object, like an
586 anonymous array or a hash (or a sonata, for that matter). For
587 example, a pair of braces acts as a composer for a hash, and a pair
588 of brackets acts as a composer for an array. See the section
589 “Creating References” in Camel chapter 8, “References”.
590 concatenation
592 The process of gluing one cat’s nose to another cat’s tail. Also a
593 similar operation on two strings.
594 conditional
596 Something “iffy”. See Boolean context.
597 connection
599 In telephony, the temporary electrical circuit between the caller’s
600 and the callee’s phone. In networking, the same kind of temporary
601 circuit between a client and a server.
602 construct
604 As a noun, a piece of syntax made up of smaller pieces. As a
605 transitive verb, to create an object using a constructor.
606 constructor
608 Any class method, instance, or subroutine that composes,
609 initializes, blesses, and returns an object. Sometimes we use the
610 term loosely to mean a composer.
611 context
613 The surroundings or environment. The context given by the
614 surrounding code determines what kind of data a particular
615 expression is expected to return. The three primary contexts are
616 list context, scalar, and void context. Scalar context is sometimes
617 subdivided into Boolean context, numeric context, string context,
618 and void context. There’s also a “don’t care” context (which is
619 dealt with in Camel chapter 2, “Bits and Pieces”, if you care).
620 continuation
622 The treatment of more than one physical line as a single logical
623 line. Makefile lines are continued by putting a backslash before
624 the newline. Mail headers, as defined by RFC 822, are continued by
625 putting a space or tab after the newline. In general, lines in Perl
626 do not need any form of continuation mark, because whitespace
627 (including newlines) is gleefully ignored. Usually.
628 core dump
630 The corpse of a process, in the form of a file left in the working
631 directory of the process, usually as a result of certain kinds of
632 fatal errors.
633 CPAN
635 The Comprehensive Perl Archive Network. (See the Camel Preface and
636 Camel chapter 19, “CPAN” for details.)
637 C preprocessor
639 The typical C compiler’s first pass, which processes lines
640 beginning with "#" for conditional compilation and macro
641 definition, and does various manipulations of the program text
642 based on the current definitions. Also known as cpp(1).
643 cracker
645 Someone who breaks security on computer systems. A cracker may be a
646 true hacker or only a script kiddie.
647 currently selected output channel
649 The last filehandle that was designated with "select(FILEHANDLE)";
650 "STDOUT", if no filehandle has been selected.
651 current package
653 The package in which the current statement is compiled. Scan
654 backward in the text of your program through the current lexical
655 scope or any enclosing lexical scopes until you find a package
656 declaration. That’s your current package name.
657 current working directory
659 See working directory.
660 CV In academia, a curriculum vitæ, a fancy kind of résumé. In Perl, an
662 internal “code value” typedef holding a subroutine. The "CV" type
663 is a subclass of SV.
664 D
666 dangling statement
667 A bare, single statement, without any braces, hanging off an "if"
668 or "while" conditional. C allows them. Perl doesn’t.
669 datagram
671 A packet of data, such as a UDP message, that (from the viewpoint
672 of the programs involved) can be sent independently over the
673 network. (In fact, all packets are sent independently at the IP
674 level, but stream protocols such as TCP hide this from your
675 program.)
676 data structure
678 How your various pieces of data relate to each other and what shape
679 they make when you put them all together, as in a rectangular table
680 or a triangular tree.
681 data type
683 A set of possible values, together with all the operations that
684 know how to deal with those values. For example, a numeric data
685 type has a certain set of numbers that you can work with, as well
686 as various mathematical operations that you can do on the numbers,
687 but would make little sense on, say, a string such as "Kilroy".
688 Strings have their own operations, such as concatenation. Compound
689 types made of a number of smaller pieces generally have operations
690 to compose and decompose them, and perhaps to rearrange them.
691 Objects that model things in the real world often have operations
692 that correspond to real activities. For instance, if you model an
693 elevator, your elevator object might have an "open_door" method.
694 DBM Stands for “Database Management” routines, a set of routines that
696 emulate an associative array using disk files. The routines use a
697 dynamic hashing scheme to locate any entry with only two disk
698 accesses. DBM files allow a Perl program to keep a persistent hash
699 across multiple invocations. You can "tie" your hash variables to
700 various DBM implementations.
701 declaration
703 An assertion that states something exists and perhaps describes
704 what it’s like, without giving any commitment as to how or where
705 you’ll use it. A declaration is like the part of your recipe that
706 says, “two cups flour, one large egg, four or five tadpoles…” See
707 statement for its opposite. Note that some declarations also
708 function as statements. Subroutine declarations also act as
709 definitions if a body is supplied.
710 declarator
712 Something that tells your program what sort of variable you’d like.
713 Perl doesn’t require you to declare variables, but you can use
714 "my", "our", or "state" to denote that you want something other
715 than the default.
716 decrement
718 To subtract a value from a variable, as in “decrement $x” (meaning
719 to remove 1 from its value) or “decrement $x by 3”.
720 default
722 A value chosen for you if you don’t supply a value of your own.
723 defined
725 Having a meaning. Perl thinks that some of the things people try to
726 do are devoid of meaning; in particular, making use of variables
727 that have never been given a value and performing certain
728 operations on data that isn’t there. For example, if you try to
729 read data past the end of a file, Perl will hand you back an
730 undefined value. See also false and the "defined" entry in Camel
731 chapter 27, “Functions”.
732 delimiter
734 A character or string that sets bounds to an arbitrarily sized
735 textual object, not to be confused with a separator or terminator.
736 “To delimit” really just means “to surround” or “to enclose” (like
737 these parentheses are doing).
738 dereference
740 A fancy computer science term meaning “to follow a reference to
741 what it points to”. The “de” part of it refers to the fact that
742 you’re taking away one level of indirection.
743 derived class
745 A class that defines some of its methods in terms of a more generic
746 class, called a base class. Note that classes aren’t classified
747 exclusively into base classes or derived classes: a class can
748 function as both a derived class and a base class simultaneously,
749 which is kind of classy.
750 descriptor
752 See file descriptor.
753 destroy
755 To deallocate the memory of a referent (first triggering its
756 "DESTROY" method, if it has one).
757 destructor
759 A special method that is called when an object is thinking about
760 destroying itself. A Perl program’s "DESTROY" method doesn’t do the
761 actual destruction; Perl just triggers the method in case the class
762 wants to do any associated cleanup.
763 device
765 A whiz-bang hardware gizmo (like a disk or tape drive or a modem or
766 a joystick or a mouse) attached to your computer, which the
767 operating system tries to make look like a file (or a bunch of
768 files). Under Unix, these fake files tend to live in the /dev
769 directory.
770 directive
772 A pod directive. See Camel chapter 23, “Plain Old Documentation”.
773 directory
775 A special file that contains other files. Some operating systems
776 call these “folders”, “drawers”, “catalogues”, or “catalogs”.
777 directory handle
779 A name that represents a particular instance of opening a directory
780 to read it, until you close it. See the "opendir" function.
781 discipline
783 Some people need this and some people avoid it. For Perl, it’s an
784 old way to say I/O layer.
785 dispatch
787 To send something to its correct destination. Often used
788 metaphorically to indicate a transfer of programmatic control to a
789 destination selected algorithmically, often by lookup in a table of
790 function references or, in the case of object methods, by
791 traversing the inheritance tree looking for the most specific
792 definition for the method.
793 distribution
795 A standard, bundled release of a system of software. The default
796 usage implies source code is included. If that is not the case, it
797 will be called a “binary-only” distribution.
798 dual-lived
800 Some modules live both in the Standard Library and on CPAN. These
801 modules might be developed on two tracks as people modify either
802 version. The trend currently is to untangle these situations.
803 dweomer
805 An enchantment, illusion, phantasm, or jugglery. Said when Perl’s
806 magical dwimmer effects don’t do what you expect, but rather seem
807 to be the product of arcane dweomercraft, sorcery, or wonder
808 working. [From Middle English.]
809 dwimmer
811 DWIM is an acronym for “Do What I Mean”, the principle that
812 something should just do what you want it to do without an undue
813 amount of fuss. A bit of code that does “dwimming” is a “dwimmer”.
814 Dwimming can require a great deal of behind-the-scenes magic, which
815 (if it doesn’t stay properly behind the scenes) is called a dweomer
816 instead.
817 dynamic scoping
819 Dynamic scoping works over a dynamic scope, making variables
820 visible throughout the rest of the block in which they are first
821 used and in any subroutines that are called by the rest of the
822 block. Dynamically scoped variables can have their values
823 temporarily changed (and implicitly restored later) by a "local"
824 operator. (Compare lexical scoping.) Used more loosely to mean how
825 a subroutine that is in the middle of calling another subroutine
826 “contains” that subroutine at runtime.
827 E
829 eclectic
830 Derived from many sources. Some would say too many.
831 element
833 A basic building block. When you’re talking about an array, it’s
834 one of the items that make up the array.
835 embedding
837 When something is contained in something else, particularly when
838 that might be considered surprising: “I’ve embedded a complete Perl
839 interpreter in my editor!”
840 empty subclass test
842 The notion that an empty derived class should behave exactly like
843 its base class.
844 encapsulation
846 The veil of abstraction separating the interface from the
847 implementation (whether enforced or not), which mandates that all
848 access to an object’s state be through methods alone.
849 endian
851 See little-endian and big-endian.
852 en passant
854 When you change a value as it is being copied. [From French “in
855 passing”, as in the exotic pawn-capturing maneuver in chess.]
856 environment
858 The collective set of environment variables your process inherits
859 from its parent. Accessed via %ENV.
860 environment variable
862 A mechanism by which some high-level agent such as a user can pass
863 its preferences down to its future offspring (child processes,
864 grandchild processes, great-grandchild processes, and so on). Each
865 environment variable is a key/value pair, like one entry in a hash.
866 EOF End of File. Sometimes used metaphorically as the terminating
868 string of a here document.
869 errno
871 The error number returned by a syscall when it fails. Perl refers
872 to the error by the name $! (or $OS_ERROR if you use the English
873 module).
874 error
876 See exception or fatal error.
877 escape sequence
879 See metasymbol.
880 exception
882 A fancy term for an error. See fatal error.
883 exception handling
885 The way a program responds to an error. The exception-handling
886 mechanism in Perl is the "eval" operator.
887 exec
889 To throw away the current process’s program and replace it with
890 another, without exiting the process or relinquishing any resources
891 held (apart from the old memory image).
892 executable file
894 A file that is specially marked to tell the operating system that
895 it’s okay to run this file as a program. Usually shortened to
896 “executable”.
897 execute
899 To run a program or subroutine. (Has nothing to do with the "kill"
900 built-in, unless you’re trying to run a signal handler.)
901 execute bit
903 The special mark that tells the operating system it can run this
904 program. There are actually three execute bits under Unix, and
905 which bit gets used depends on whether you own the file singularly,
906 collectively, or not at all.
907 exit status
909 See status.
910 exploit
912 Used as a noun in this case, this refers to a known way to
913 compromise a program to get it to do something the author didn’t
914 intend. Your task is to write unexploitable programs.
915 export
917 To make symbols from a module available for import by other
918 modules.
919 expression
921 Anything you can legally say in a spot where a value is required.
922 Typically composed of literals, variables, operators, functions,
923 and subroutine calls, not necessarily in that order.
924 extension
926 A Perl module that also pulls in compiled C or C++ code. More
927 generally, any experimental option that can be compiled into Perl,
928 such as multithreading.
929 F
931 false
932 In Perl, any value that would look like "" or "0" if evaluated in a
933 string context. Since undefined values evaluate to "", all
934 undefined values are false, but not all false values are undefined.
935 FAQ Frequently Asked Question (although not necessarily frequently
937 answered, especially if the answer appears in the Perl FAQ shipped
938 standard with Perl).
939 fatal error
941 An uncaught exception, which causes termination of the process
942 after printing a message on your standard error stream. Errors that
943 happen inside an "eval" are not fatal. Instead, the "eval"
944 terminates after placing the exception message in the $@
945 ($EVAL_ERROR) variable. You can try to provoke a fatal error with
946 the "die" operator (known as throwing or raising an exception), but
947 this may be caught by a dynamically enclosing "eval". If not
948 caught, the "die" becomes a fatal error.
949 feeping creaturism
951 A spoonerism of “creeping featurism”, noting the biological urge to
952 add just one more feature to a program.
953 field
955 A single piece of numeric or string data that is part of a longer
956 string, record, or line. Variable-width fields are usually split up
957 by separators (so use "split" to extract the fields), while fixed-
958 width fields are usually at fixed positions (so use "unpack").
959 Instance variables are also known as “fields”.
960 FIFO
962 First In, First Out. See also LIFO. Also a nickname for a named
963 pipe.
964 file
966 A named collection of data, usually stored on disk in a directory
967 in a filesystem. Roughly like a document, if you’re into office
968 metaphors. In modern filesystems, you can actually give a file more
969 than one name. Some files have special properties, like directories
970 and devices.
971 file descriptor
973 The little number the operating system uses to keep track of which
974 opened file you’re talking about. Perl hides the file descriptor
975 inside a standard I/O stream and then attaches the stream to a
976 filehandle.
977 fileglob
979 A “wildcard” match on filenames. See the "glob" function.
980 filehandle
982 An identifier (not necessarily related to the real name of a file)
983 that represents a particular instance of opening a file, until you
984 close it. If you’re going to open and close several different files
985 in succession, it’s fine to open each of them with the same
986 filehandle, so you don’t have to write out separate code to process
987 each file.
988 filename
990 One name for a file. This name is listed in a directory. You can
991 use it in an "open" to tell the operating system exactly which file
992 you want to open, and associate the file with a filehandle, which
993 will carry the subsequent identity of that file in your program,
994 until you close it.
995 filesystem
997 A set of directories and files residing on a partition of the disk.
998 Sometimes known as a “partition”. You can change the file’s name or
999 even move a file around from directory to directory within a
1000 filesystem without actually moving the file itself, at least under
1001 Unix.
1002 file test operator
1004 A built-in unary operator that you use to determine whether
1005 something is true about a file, such as "–o $filename" to test
1006 whether you’re the owner of the file.
1007 filter
1009 A program designed to take a stream of input and transform it into
1010 a stream of output.
1011 first-come
1013 The first PAUSE author to upload a namespace automatically becomes
1014 the primary maintainer for that namespace. The “first come”
1015 permissions distinguish a primary maintainer who was assigned that
1016 role from one who received it automatically.
1017 flag
1019 We tend to avoid this term because it means so many things. It may
1020 mean a command-line switch that takes no argument itself (such as
1021 Perl’s "–n" and "–p" flags) or, less frequently, a single-bit
1022 indicator (such as the "O_CREAT" and "O_EXCL" flags used in
1023 "sysopen"). Sometimes informally used to refer to certain regex
1024 modifiers.
1025 floating point
1027 A method of storing numbers in “scientific notation”, such that the
1028 precision of the number is independent of its magnitude (the
1029 decimal point “floats”). Perl does its numeric work with floating-
1030 point numbers (sometimes called “floats”) when it can’t get away
1031 with using integers. Floating-point numbers are mere approximations
1032 of real numbers.
1033 flush
1035 The act of emptying a buffer, often before it’s full.
1036 FMTEYEWTK
1038 Far More Than Everything You Ever Wanted To Know. An exhaustive
1039 treatise on one narrow topic, something of a super-FAQ. See Tom for
1040 far more.
1041 foldcase
1043 The casemap used in Unicode when comparing or matching without
1044 regard to case. Comparing lower-, title-, or uppercase are all
1045 unreliable due to Unicode’s complex, one-to-many case mappings.
1046 Foldcase is a lowercase variant (using a partially decomposed
1047 normalization form for certain codepoints) created specifically to
1048 resolve this.
1049 fork
1051 To create a child process identical to the parent process at its
1052 moment of conception, at least until it gets ideas of its own. A
1053 thread with protected memory.
1054 formal arguments
1056 The generic names by which a subroutine knows its arguments. In
1057 many languages, formal arguments are always given individual names;
1058 in Perl, the formal arguments are just the elements of an array.
1059 The formal arguments to a Perl program are $ARGV[0], $ARGV[1], and
1060 so on. Similarly, the formal arguments to a Perl subroutine are
1061 $_[0], $_[1], and so on. You may give the arguments individual
1062 names by assigning the values to a "my" list. See also actual
1063 arguments.
1064 format
1066 A specification of how many spaces and digits and things to put
1067 somewhere so that whatever you’re printing comes out nice and
1068 pretty.
1069 freely available
1071 Means you don’t have to pay money to get it, but the copyright on
1072 it may still belong to someone else (like Larry).
1073 freely redistributable
1075 Means you’re not in legal trouble if you give a bootleg copy of it
1076 to your friends and we find out about it. In fact, we’d rather you
1077 gave a copy to all your friends.
1078 freeware
1080 Historically, any software that you give away, particularly if you
1081 make the source code available as well. Now often called open
1082 source software. Recently there has been a trend to use the term in
1083 contradistinction to open source software, to refer only to free
1084 software released under the Free Software Foundation’s GPL (General
1085 Public License), but this is difficult to justify etymologically.
1086 function
1088 Mathematically, a mapping of each of a set of input values to a
1089 particular output value. In computers, refers to a subroutine or
1090 operator that returns a value. It may or may not have input values
1091 (called arguments).
1092 funny character
1094 Someone like Larry, or one of his peculiar friends. Also refers to
1095 the strange prefixes that Perl requires as noun markers on its
1096 variables.
1097 G
1099 garbage collection
1100 A misnamed feature—it should be called, “expecting your mother to
1101 pick up after you”. Strictly speaking, Perl doesn’t do this, but it
1102 relies on a reference-counting mechanism to keep things tidy.
1103 However, we rarely speak strictly and will often refer to the
1104 reference-counting scheme as a form of garbage collection. (If it’s
1105 any comfort, when your interpreter exits, a “real” garbage
1106 collector runs to make sure everything is cleaned up if you’ve been
1107 messy with circular references and such.)
1108 GID Group ID—in Unix, the numeric group ID that the operating system
1110 uses to identify you and members of your group.
1111 glob
1113 Strictly, the shell’s "*" character, which will match a “glob” of
1114 characters when you’re trying to generate a list of filenames.
1115 Loosely, the act of using globs and similar symbols to do pattern
1116 matching. See also fileglob and typeglob.
1117 global
1119 Something you can see from anywhere, usually used of variables and
1120 subroutines that are visible everywhere in your program. In Perl,
1121 only certain special variables are truly global—most variables (and
1122 all subroutines) exist only in the current package. Global
1123 variables can be declared with "our". See “Global Declarations” in
1124 Camel chapter 4, “Statements and Declarations”.
1125 global destruction
1127 The garbage collection of globals (and the running of any
1128 associated object destructors) that takes place when a Perl
1129 interpreter is being shut down. Global destruction should not be
1130 confused with the Apocalypse, except perhaps when it should.
1131 glue language
1133 A language such as Perl that is good at hooking things together
1134 that weren’t intended to be hooked together.
1135 granularity
1137 The size of the pieces you’re dealing with, mentally speaking.
1138 grapheme
1140 A graphene is an allotrope of carbon arranged in a hexagonal
1141 crystal lattice one atom thick. A grapheme, or more fully, a
1142 grapheme cluster string is a single user-visible character, which
1143 may in turn be several characters (codepoints) long. For example, a
1144 carriage return plus a line feed is a single grapheme but two
1145 characters, while a “ȫ” is a single grapheme but one, two, or even
1146 three characters, depending on normalization.
1147 greedy
1149 A subpattern whose quantifier wants to match as many things as
1150 possible.
1151 grep
1153 Originally from the old Unix editor command for “Globally search
1154 for a Regular Expression and Print it”, now used in the general
1155 sense of any kind of search, especially text searches. Perl has a
1156 built-in "grep" function that searches a list for elements matching
1157 any given criterion, whereas the grep(1) program searches for lines
1158 matching a regular expression in one or more files.
1159 group
1161 A set of users of which you are a member. In some operating systems
1162 (like Unix), you can give certain file access permissions to other
1163 members of your group.
1164 GV An internal “glob value” typedef, holding a typeglob. The "GV" type
1166 is a subclass of SV.
1167 H
1169 hacker
1170 Someone who is brilliantly persistent in solving technical
1171 problems, whether these involve golfing, fighting orcs, or
1172 programming. Hacker is a neutral term, morally speaking. Good
1173 hackers are not to be confused with evil crackers or clueless
1174 script kiddies. If you confuse them, we will presume that you are
1175 either evil or clueless.
1176 handler
1178 A subroutine or method that Perl calls when your program needs to
1179 respond to some internal event, such as a signal, or an encounter
1180 with an operator subject to operator overloading. See also
1181 callback.
1182 hard reference
1184 A scalar value containing the actual address of a referent, such
1185 that the referent’s reference count accounts for it. (Some hard
1186 references are held internally, such as the implicit reference from
1187 one of a typeglob’s variable slots to its corresponding referent.)
1188 A hard reference is different from a symbolic reference.
1189 hash
1191 An unordered association of key/value pairs, stored such that you
1192 can easily use a string key to look up its associated data value.
1193 This glossary is like a hash, where the word to be defined is the
1194 key and the definition is the value. A hash is also sometimes
1195 septisyllabically called an “associative array”, which is a pretty
1196 good reason for simply calling it a “hash” instead.
1197 hash table
1199 A data structure used internally by Perl for implementing
1200 associative arrays (hashes) efficiently. See also bucket.
1201 header file
1203 A file containing certain required definitions that you must
1204 include “ahead” of the rest of your program to do certain obscure
1205 operations. A C header file has a .h extension. Perl doesn’t really
1206 have header files, though historically Perl has sometimes used
1207 translated .h files with a .ph extension. See "require" in Camel
1208 chapter 27, “Functions”. (Header files have been superseded by the
1209 module mechanism.)
1210 here document
1212 So called because of a similar construct in shells that pretends
1213 that the lines following the command are a separate file to be fed
1214 to the command, up to some terminating string. In Perl, however,
1215 it’s just a fancy form of quoting.
1216 hexadecimal
1218 A number in base 16, “hex” for short. The digits for 10 through 15
1219 are customarily represented by the letters "a" through "f".
1220 Hexadecimal constants in Perl start with "0x". See also the "hex"
1221 function in Camel chapter 27, “Functions”.
1222 home directory
1224 The directory you are put into when you log in. On a Unix system,
1225 the name is often placed into $ENV{HOME} or $ENV{LOGDIR} by login,
1226 but you can also find it with "(get""pwuid($<))[7]". (Some
1227 platforms do not have a concept of a home directory.)
1228 host
1230 The computer on which a program or other data resides.
1231 hubris
1233 Excessive pride, the sort of thing for which Zeus zaps you. Also
1234 the quality that makes you write (and maintain) programs that other
1235 people won’t want to say bad things about. Hence, the third great
1236 virtue of a programmer. See also laziness and impatience.
1237 HV Short for a “hash value” typedef, which holds Perl’s internal
1239 representation of a hash. The "HV" type is a subclass of SV.
1240 I
1242 identifier
1243 A legally formed name for most anything in which a computer program
1244 might be interested. Many languages (including Perl) allow
1245 identifiers to start with an alphabetic character, and then contain
1246 alphabetics and digits. Perl also allows connector punctuation like
1247 the underscore character wherever it allows alphabetics. (Perl also
1248 has more complicated names, like qualified names.)
1249 impatience
1251 The anger you feel when the computer is being lazy. This makes you
1252 write programs that don’t just react to your needs, but actually
1253 anticipate them. Or at least that pretend to. Hence, the second
1254 great virtue of a programmer. See also laziness and hubris.
1255 implementation
1257 How a piece of code actually goes about doing its job. Users of the
1258 code should not count on implementation details staying the same
1259 unless they are part of the published interface.
1260 import
1262 To gain access to symbols that are exported from another module.
1263 See "use" in Camel chapter 27, “Functions”.
1264 increment
1266 To increase the value of something by 1 (or by some other number,
1267 if so specified).
1268 indexing
1270 In olden days, the act of looking up a key in an actual index (such
1271 as a phone book). But now it's merely the act of using any kind of
1272 key or position to find the corresponding value, even if no index
1273 is involved. Things have degenerated to the point that Perl’s
1274 "index" function merely locates the position (index) of one string
1275 in another.
1276 indirect filehandle
1278 An expression that evaluates to something that can be used as a
1279 filehandle: a string (filehandle name), a typeglob, a typeglob
1280 reference, or a low-level IO object.
1281 indirection
1283 If something in a program isn’t the value you’re looking for but
1284 indicates where the value is, that’s indirection. This can be done
1285 with either symbolic references or hard.
1286 indirect object
1288 In English grammar, a short noun phrase between a verb and its
1289 direct object indicating the beneficiary or recipient of the
1290 action. In Perl, "print STDOUT "$foo\n";" can be understood as
1291 “verb indirect-object object”, where "STDOUT" is the recipient of
1292 the "print" action, and "$foo" is the object being printed.
1293 Similarly, when invoking a method, you might place the invocant in
1294 the dative slot between the method and its arguments:
1295 $gollum = new Pathetic::Creature "Sméagol";
1297 give $gollum "Fisssssh!";
1298 give $gollum "Precious!";
1299 indirect object slot
1301 The syntactic position falling between a method call and its
1302 arguments when using the indirect object invocation syntax. (The
1303 slot is distinguished by the absence of a comma between it and the
1304 next argument.) "STDERR" is in the indirect object slot here:
1305 print STDERR "Awake! Awake! Fear, Fire, Foes! Awake!\n";
1307 infix
1309 An operator that comes in between its operands, such as
1310 multiplication in "24 * 7".
1311 inheritance
1313 What you get from your ancestors, genetically or otherwise. If you
1314 happen to be a class, your ancestors are called base classes and
1315 your descendants are called derived classes. See single inheritance
1316 and multiple inheritance.
1317 instance
1319 Short for “an instance of a class”, meaning an object of that
1320 class.
1321 instance data
1323 See instance variable.
1324 instance method
1326 A method of an object, as opposed to a class method.
1327 A method whose invocant is an object, not a package name. Every
1329 object of a class shares all the methods of that class, so an
1330 instance method applies to all instances of the class, rather than
1331 applying to a particular instance. Also see class method.
1332 instance variable
1334 An attribute of an object; data stored with the particular object
1335 rather than with the class as a whole.
1336 integer
1338 A number with no fractional (decimal) part. A counting number, like
1339 1, 2, 3, and so on, but including 0 and the negatives.
1340 interface
1342 The services a piece of code promises to provide forever, in
1343 contrast to its implementation, which it should feel free to change
1344 whenever it likes.
1345 interpolation
1347 The insertion of a scalar or list value somewhere in the middle of
1348 another value, such that it appears to have been there all along.
1349 In Perl, variable interpolation happens in double-quoted strings
1350 and patterns, and list interpolation occurs when constructing the
1351 list of values to pass to a list operator or other such construct
1352 that takes a "LIST".
1353 interpreter
1355 Strictly speaking, a program that reads a second program and does
1356 what the second program says directly without turning the program
1357 into a different form first, which is what compilers do. Perl is
1358 not an interpreter by this definition, because it contains a kind
1359 of compiler that takes a program and turns it into a more
1360 executable form (syntax trees) within the perl process itself,
1361 which the Perl runtime system then interprets.
1362 invocant
1364 The agent on whose behalf a method is invoked. In a class method,
1365 the invocant is a package name. In an instance method, the invocant
1366 is an object reference.
1367 invocation
1369 The act of calling up a deity, daemon, program, method, subroutine,
1370 or function to get it to do what you think it’s supposed to do. We
1371 usually “call” subroutines but “invoke” methods, since it sounds
1372 cooler.
1373 I/O Input from, or output to, a file or device.
1375 IO An internal I/O object. Can also mean indirect object.
1377 I/O layer
1379 One of the filters between the data and what you get as input or
1380 what you end up with as output.
1381 IPA India Pale Ale. Also the International Phonetic Alphabet, the
1383 standard alphabet used for phonetic notation worldwide. Draws
1384 heavily on Unicode, including many combining characters.
1385 IP Internet Protocol, or Intellectual Property.
1387 IPC Interprocess Communication.
1389 is-a
1391 A relationship between two objects in which one object is
1392 considered to be a more specific version of the other, generic
1393 object: “A camel is a mammal.” Since the generic object really only
1394 exists in a Platonic sense, we usually add a little abstraction to
1395 the notion of objects and think of the relationship as being
1396 between a generic base class and a specific derived class. Oddly
1397 enough, Platonic classes don’t always have Platonic relationships—
1398 see inheritance.
1399 iteration
1401 Doing something repeatedly.
1402 iterator
1404 A special programming gizmo that keeps track of where you are in
1405 something that you’re trying to iterate over. The "foreach" loop in
1406 Perl contains an iterator; so does a hash, allowing you to "each"
1407 through it.
1408 IV The integer four, not to be confused with six, Tom’s favorite
1410 editor. IV also means an internal Integer Value of the type a
1411 scalar can hold, not to be confused with an NV.
1412 J
1414 JAPH
1415 “Just Another Perl Hacker”, a clever but cryptic bit of Perl code
1416 that, when executed, evaluates to that string. Often used to
1417 illustrate a particular Perl feature, and something of an ongoing
1418 Obfuscated Perl Contest seen in USENET signatures.
1419 K
1421 key The string index to a hash, used to look up the value associated
1422 with that key.
1423 keyword
1425 See reserved words.
1426 L
1428 label
1429 A name you give to a statement so that you can talk about that
1430 statement elsewhere in the program.
1431 laziness
1433 The quality that makes you go to great effort to reduce overall
1434 energy expenditure. It makes you write labor-saving programs that
1435 other people will find useful, and then document what you wrote so
1436 you don’t have to answer so many questions about it. Hence, the
1437 first great virtue of a programmer. Also hence, this book. See also
1438 impatience and hubris.
1439 leftmost longest
1441 The preference of the regular expression engine to match the
1442 leftmost occurrence of a pattern, then given a position at which a
1443 match will occur, the preference for the longest match (presuming
1444 the use of a greedy quantifier). See Camel chapter 5, “Pattern
1445 Matching” for much more on this subject.
1446 left shift
1448 A bit shift that multiplies the number by some power of 2.
1449 lexeme
1451 Fancy term for a token.
1452 lexer
1454 Fancy term for a tokener.
1455 lexical analysis
1457 Fancy term for tokenizing.
1458 lexical scoping
1460 Looking at your Oxford English Dictionary through a microscope.
1461 (Also known as static scoping, because dictionaries don’t change
1462 very fast.) Similarly, looking at variables stored in a private
1463 dictionary (namespace) for each scope, which are visible only from
1464 their point of declaration down to the end of the lexical scope in
1465 which they are declared. —Syn. static scoping. —Ant. dynamic
1466 scoping.
1467 lexical variable
1469 A variable subject to lexical scoping, declared by "my". Often just
1470 called a “lexical”. (The "our" declaration declares a lexically
1471 scoped name for a global variable, which is not itself a lexical
1472 variable.)
1473 library
1475 Generally, a collection of procedures. In ancient days, referred to
1476 a collection of subroutines in a .pl file. In modern times, refers
1477 more often to the entire collection of Perl modules on your system.
1478 LIFO
1480 Last In, First Out. See also FIFO. A LIFO is usually called a
1481 stack.
1482 line
1484 In Unix, a sequence of zero or more nonnewline characters
1485 terminated with a newline character. On non-Unix machines, this is
1486 emulated by the C library even if the underlying operating system
1487 has different ideas.
1488 linebreak
1490 A grapheme consisting of either a carriage return followed by a
1491 line feed or any character with the Unicode Vertical Space
1492 character property.
1493 line buffering
1495 Used by a standard I/O output stream that flushes its buffer after
1496 every newline. Many standard I/O libraries automatically set up
1497 line buffering on output that is going to the terminal.
1498 line number
1500 The number of lines read previous to this one, plus 1. Perl keeps a
1501 separate line number for each source or input file it opens. The
1502 current source file’s line number is represented by "__LINE__". The
1503 current input line number (for the file that was most recently read
1504 via "<FH>") is represented by the $. ($INPUT_LINE_NUMBER) variable.
1505 Many error messages report both values, if available.
1506 link
1508 Used as a noun, a name in a directory that represents a file. A
1509 given file can have multiple links to it. It’s like having the same
1510 phone number listed in the phone directory under different names.
1511 As a verb, to resolve a partially compiled file’s unresolved
1512 symbols into a (nearly) executable image. Linking can generally be
1513 static or dynamic, which has nothing to do with static or dynamic
1514 scoping.
1515 LIST
1517 A syntactic construct representing a comma- separated list of
1518 expressions, evaluated to produce a list value. Each expression in
1519 a "LIST" is evaluated in list context and interpolated into the
1520 list value.
1521 list
1523 An ordered set of scalar values.
1524 list context
1526 The situation in which an expression is expected by its
1527 surroundings (the code calling it) to return a list of values
1528 rather than a single value. Functions that want a "LIST" of
1529 arguments tell those arguments that they should produce a list
1530 value. See also context.
1531 list operator
1533 An operator that does something with a list of values, such as
1534 "join" or "grep". Usually used for named built-in operators (such
1535 as "print", "unlink", and "system") that do not require parentheses
1536 around their argument list.
1537 list value
1539 An unnamed list of temporary scalar values that may be passed
1540 around within a program from any list-generating function to any
1541 function or construct that provides a list context.
1542 literal
1544 A token in a programming language, such as a number or string, that
1545 gives you an actual value instead of merely representing possible
1546 values as a variable does.
1547 little-endian
1549 From Swift: someone who eats eggs little end first. Also used of
1550 computers that store the least significant byte of a word at a
1551 lower byte address than the most significant byte. Often considered
1552 superior to big-endian machines. See also big-endian.
1553 local
1555 Not meaning the same thing everywhere. A global variable in Perl
1556 can be localized inside a dynamic scope via the "local" operator.
1557 logical operator
1559 Symbols representing the concepts “and”, “or”, “xor”, and “not”.
1560 lookahead
1562 An assertion that peeks at the string to the right of the current
1563 match location.
1564 lookbehind
1566 An assertion that peeks at the string to the left of the current
1567 match location.
1568 loop
1570 A construct that performs something repeatedly, like a roller
1571 coaster.
1572 loop control statement
1574 Any statement within the body of a loop that can make a loop
1575 prematurely stop looping or skip an iteration. Generally, you
1576 shouldn’t try this on roller coasters.
1577 loop label
1579 A kind of key or name attached to a loop (or roller coaster) so
1580 that loop control statements can talk about which loop they want to
1581 control.
1582 lowercase
1584 In Unicode, not just characters with the General Category of
1585 Lowercase Letter, but any character with the Lowercase property,
1586 including Modifier Letters, Letter Numbers, some Other Symbols, and
1587 one Combining Mark.
1588 lvaluable
1590 Able to serve as an lvalue.
1591 lvalue
1593 Term used by language lawyers for a storage location you can assign
1594 a new value to, such as a variable or an element of an array. The
1595 “l” is short for “left”, as in the left side of an assignment, a
1596 typical place for lvalues. An lvaluable function or expression is
1597 one to which a value may be assigned, as in "pos($x) = 10".
1598 lvalue modifier
1600 An adjectival pseudofunction that warps the meaning of an lvalue in
1601 some declarative fashion. Currently there are three lvalue
1602 modifiers: "my", "our", and "local".
1603 M
1605 magic
1606 Technically speaking, any extra semantics attached to a variable
1607 such as $!, $0, %ENV, or %SIG, or to any tied variable. Magical
1608 things happen when you diddle those variables.
1609 magical increment
1611 An increment operator that knows how to bump up ASCII alphabetics
1612 as well as numbers.
1613 magical variables
1615 Special variables that have side effects when you access them or
1616 assign to them. For example, in Perl, changing elements of the %ENV
1617 array also changes the corresponding environment variables that
1618 subprocesses will use. Reading the $! variable gives you the
1619 current system error number or message.
1620 Makefile
1622 A file that controls the compilation of a program. Perl programs
1623 don’t usually need a Makefile because the Perl compiler has plenty
1624 of self-control.
1625 man The Unix program that displays online documentation (manual pages)
1627 for you.
1628 manpage
1630 A “page” from the manuals, typically accessed via the man(1)
1631 command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
1632 BUGS, and so on, and is typically longer than a page. There are
1633 manpages documenting commands, syscalls, library functions,
1634 devices, protocols, files, and such. In this book, we call any
1635 piece of standard Perl documentation (like perlop or perldelta) a
1636 manpage, no matter what format it’s installed in on your system.
1637 matching
1639 See pattern matching.
1640 member data
1642 See instance variable.
1643 memory
1645 This always means your main memory, not your disk. Clouding the
1646 issue is the fact that your machine may implement virtual memory;
1647 that is, it will pretend that it has more memory than it really
1648 does, and it’ll use disk space to hold inactive bits. This can make
1649 it seem like you have a little more memory than you really do, but
1650 it’s not a substitute for real memory. The best thing that can be
1651 said about virtual memory is that it lets your performance degrade
1652 gradually rather than suddenly when you run out of real memory. But
1653 your program can die when you run out of virtual memory, too—if you
1654 haven’t thrashed your disk to death first.
1655 metacharacter
1657 A character that is not supposed to be treated normally. Which
1658 characters are to be treated specially as metacharacters varies
1659 greatly from context to context. Your shell will have certain
1660 metacharacters, double-quoted Perl strings have other
1661 metacharacters, and regular expression patterns have all the
1662 double-quote metacharacters plus some extra ones of their own.
1663 metasymbol
1665 Something we’d call a metacharacter except that it’s a sequence of
1666 more than one character. Generally, the first character in the
1667 sequence must be a true metacharacter to get the other characters
1668 in the metasymbol to misbehave along with it.
1669 method
1671 A kind of action that an object can take if you tell it to. See
1672 Camel chapter 12, “Objects”.
1673 method resolution order
1675 The path Perl takes through @INC. By default, this is a double
1676 depth first search, once looking for defined methods and once for
1677 "AUTOLOAD". However, Perl lets you configure this with "mro".
1678 minicpan
1680 A CPAN mirror that includes just the latest versions for each
1681 distribution, probably created with "CPAN::Mini". See Camel chapter
1682 19, “CPAN”.
1683 minimalism
1685 The belief that “small is beautiful”. Paradoxically, if you say
1686 something in a small language, it turns out big, and if you say it
1687 in a big language, it turns out small. Go figure.
1688 mode
1690 In the context of the stat(2) syscall, refers to the field holding
1691 the permission bits and the type of the file.
1692 modifier
1694 See statement modifier, regular expression, and lvalue, not
1695 necessarily in that order.
1696 module
1698 A file that defines a package of (almost) the same name, which can
1699 either export symbols or function as an object class. (A module’s
1700 main .pm file may also load in other files in support of the
1701 module.) See the "use" built-in.
1702 modulus
1704 An integer divisor when you’re interested in the remainder instead
1705 of the quotient.
1706 mojibake
1708 When you speak one language and the computer thinks you’re speaking
1709 another. You’ll see odd translations when you send UTF‑8, for
1710 instance, but the computer thinks you sent Latin-1, showing all
1711 sorts of weird characters instead. The term is written
1712 「文字化け」in Japanese and means “character rot”, an apt
1713 description. Pronounced ["modʑibake"] in standard IPA phonetics, or
1714 approximately “moh-jee-bah-keh”.
1715 monger
1717 Short for one member of Perl mongers, a purveyor of Perl.
1718 mortal
1720 A temporary value scheduled to die when the current statement
1721 finishes.
1722 mro See method resolution order.
1724 multidimensional array
1726 An array with multiple subscripts for finding a single element.
1727 Perl implements these using references—see Camel chapter 9, “Data
1728 Structures”.
1729 multiple inheritance
1731 The features you got from your mother and father, mixed together
1732 unpredictably. (See also inheritance and single inheritance.) In
1733 computer languages (including Perl), it is the notion that a given
1734 class may have multiple direct ancestors or base classes.
1735 N
1737 named pipe
1738 A pipe with a name embedded in the filesystem so that it can be
1739 accessed by two unrelated processes.
1740 namespace
1742 A domain of names. You needn’t worry about whether the names in one
1743 such domain have been used in another. See package.
1744 NaN Not a number. The value Perl uses for certain invalid or
1746 inexpressible floating-point operations.
1747 network address
1749 The most important attribute of a socket, like your telephone’s
1750 telephone number. Typically an IP address. See also port.
1751 newline
1753 A single character that represents the end of a line, with the
1754 ASCII value of 012 octal under Unix (but 015 on a Mac), and
1755 represented by "\n" in Perl strings. For Windows machines writing
1756 text files, and for certain physical devices like terminals, the
1757 single newline gets automatically translated by your C library into
1758 a line feed and a carriage return, but normally, no translation is
1759 done.
1760 NFS Network File System, which allows you to mount a remote filesystem
1762 as if it were local.
1763 normalization
1765 Converting a text string into an alternate but equivalent canonical
1766 (or compatible) representation that can then be compared for
1767 equivalence. Unicode recognizes four different normalization forms:
1768 NFD, NFC, NFKD, and NFKC.
1769 null character
1771 A character with the numeric value of zero. It’s used by C to
1772 terminate strings, but Perl allows strings to contain a null.
1773 null list
1775 A list value with zero elements, represented in Perl by "()".
1776 null string
1778 A string containing no characters, not to be confused with a string
1779 containing a null character, which has a positive length and is
1780 true.
1781 numeric context
1783 The situation in which an expression is expected by its
1784 surroundings (the code calling it) to return a number. See also
1785 context and string context.
1786 numification
1788 (Sometimes spelled nummification and nummify.) Perl lingo for
1789 implicit conversion into a number; the related verb is numify.
1790 Numification is intended to rhyme with mummification, and numify
1791 with mummify. It is unrelated to English numen, numina, numinous.
1792 We originally forgot the extra m a long time ago, and some people
1793 got used to our funny spelling, and so just as with
1794 "HTTP_REFERER"’s own missing letter, our weird spelling has stuck
1795 around.
1796 NV Short for Nevada, no part of which will ever be confused with
1798 civilization. NV also means an internal floating- point Numeric
1799 Value of the type a scalar can hold, not to be confused with an IV.
1800 nybble
1802 Half a byte, equivalent to one hexadecimal digit, and worth four
1803 bits.
1804 O
1806 object
1807 An instance of a class. Something that “knows” what user-defined
1808 type (class) it is, and what it can do because of what class it is.
1809 Your program can request an object to do things, but the object
1810 gets to decide whether it wants to do them or not. Some objects are
1811 more accommodating than others.
1812 octal
1814 A number in base 8. Only the digits 0 through 7 are allowed. Octal
1815 constants in Perl start with 0, as in 013. See also the "oct"
1816 function.
1817 offset
1819 How many things you have to skip over when moving from the
1820 beginning of a string or array to a specific position within it.
1821 Thus, the minimum offset is zero, not one, because you don’t skip
1822 anything to get to the first item.
1823 one-liner
1825 An entire computer program crammed into one line of text.
1826 open source software
1828 Programs for which the source code is freely available and freely
1829 redistributable, with no commercial strings attached. For a more
1830 detailed definition, see <http://www.opensource.org/osd.html>.
1831 operand
1833 An expression that yields a value that an operator operates on. See
1834 also precedence.
1835 operating system
1837 A special program that runs on the bare machine and hides the gory
1838 details of managing processes and devices. Usually used in a
1839 looser sense to indicate a particular culture of programming. The
1840 loose sense can be used at varying levels of specificity. At one
1841 extreme, you might say that all versions of Unix and Unix-
1842 lookalikes are the same operating system (upsetting many people,
1843 especially lawyers and other advocates). At the other extreme, you
1844 could say this particular version of this particular vendor’s
1845 operating system is different from any other version of this or any
1846 other vendor’s operating system. Perl is much more portable across
1847 operating systems than many other languages. See also architecture
1848 and platform.
1849 operator
1851 A gizmo that transforms some number of input values to some number
1852 of output values, often built into a language with a special syntax
1853 or symbol. A given operator may have specific expectations about
1854 what types of data you give as its arguments (operands) and what
1855 type of data you want back from it.
1856 operator overloading
1858 A kind of overloading that you can do on built-in operators to make
1859 them work on objects as if the objects were ordinary scalar values,
1860 but with the actual semantics supplied by the object class. This is
1861 set up with the overload pragma—see Camel chapter 13,
1862 “Overloading”.
1863 options
1865 See either switches or regular expression modifiers.
1866 ordinal
1868 An abstract character’s integer value. Same thing as codepoint.
1869 overloading
1871 Giving additional meanings to a symbol or construct. Actually, all
1872 languages do overloading to one extent or another, since people are
1873 good at figuring out things from context.
1874 overriding
1876 Hiding or invalidating some other definition of the same name. (Not
1877 to be confused with overloading, which adds definitions that must
1878 be disambiguated some other way.) To confuse the issue further, we
1879 use the word with two overloaded definitions: to describe how you
1880 can define your own subroutine to hide a built-in function of the
1881 same name (see the section “Overriding Built-in Functions” in Camel
1882 chapter 11, “Modules”), and to describe how you can define a
1883 replacement method in a derived class to hide a base class’s method
1884 of the same name (see Camel chapter 12, “Objects”).
1885 owner
1887 The one user (apart from the superuser) who has absolute control
1888 over a file. A file may also have a group of users who may exercise
1889 joint ownership if the real owner permits it. See permission bits.
1890 P
1892 package
1893 A namespace for global variables, subroutines, and the like, such
1894 that they can be kept separate from like-named symbols in other
1895 namespaces. In a sense, only the package is global, since the
1896 symbols in the package’s symbol table are only accessible from code
1897 compiled outside the package by naming the package. But in another
1898 sense, all package symbols are also globals—they’re just well-
1899 organized globals.
1900 pad Short for scratchpad.
1902 parameter
1904 See argument.
1905 parent class
1907 See base class.
1908 parse tree
1910 See syntax tree.
1911 parsing
1913 The subtle but sometimes brutal art of attempting to turn your
1914 possibly malformed program into a valid syntax tree.
1915 patch
1917 To fix by applying one, as it were. In the realm of hackerdom, a
1918 listing of the differences between two versions of a program as
1919 might be applied by the patch(1) program when you want to fix a bug
1920 or upgrade your old version.
1921 PATH
1923 The list of directories the system searches to find a program you
1924 want to execute. The list is stored as one of your environment
1925 variables, accessible in Perl as $ENV{PATH}.
1926 pathname
1928 A fully qualified filename such as /usr/bin/perl. Sometimes
1929 confused with "PATH".
1930 pattern
1932 A template used in pattern matching.
1933 pattern matching
1935 Taking a pattern, usually a regular expression, and trying the
1936 pattern various ways on a string to see whether there’s any way to
1937 make it fit. Often used to pick interesting tidbits out of a file.
1938 PAUSE
1940 The Perl Authors Upload SErver (<http://pause.perl.org>), the
1941 gateway for modules on their way to CPAN.
1942 Perl mongers
1944 A Perl user group, taking the form of its name from the New York
1945 Perl mongers, the first Perl user group. Find one near you at
1946 <http://www.pm.org>.
1947 permission bits
1949 Bits that the owner of a file sets or unsets to allow or disallow
1950 access to other people. These flag bits are part of the mode word
1951 returned by the "stat" built-in when you ask about a file. On Unix
1952 systems, you can check the ls(1) manpage for more information.
1953 Pern
1955 What you get when you do "Perl++" twice. Doing it only once will
1956 curl your hair. You have to increment it eight times to shampoo
1957 your hair. Lather, rinse, iterate.
1958 pipe
1960 A direct connection that carries the output of one process to the
1961 input of another without an intermediate temporary file. Once the
1962 pipe is set up, the two processes in question can read and write as
1963 if they were talking to a normal file, with some caveats.
1964 pipeline
1966 A series of processes all in a row, linked by pipes, where each
1967 passes its output stream to the next.
1968 platform
1970 The entire hardware and software context in which a program runs. A
1971 program written in a platform-dependent language might break if you
1972 change any of the following: machine, operating system, libraries,
1973 compiler, or system configuration. The perl interpreter has to be
1974 compiled differently for each platform because it is implemented in
1975 C, but programs written in the Perl language are largely platform
1976 independent.
1977 pod The markup used to embed documentation into your Perl code. Pod
1979 stands for “Plain old documentation”. See Camel chapter 23, “Plain
1980 Old Documentation”.
1981 pod command
1983 A sequence, such as "=head1", that denotes the start of a pod
1984 section.
1985 pointer
1987 A variable in a language like C that contains the exact memory
1988 location of some other item. Perl handles pointers internally so
1989 you don’t have to worry about them. Instead, you just use symbolic
1990 pointers in the form of keys and variable names, or hard
1991 references, which aren’t pointers (but act like pointers and do in
1992 fact contain pointers).
1993 polymorphism
1995 The notion that you can tell an object to do something generic, and
1996 the object will interpret the command in different ways depending
1997 on its type. [< Greek πολυ- + μορϕή, many forms.]
1998 port
2000 The part of the address of a TCP or UDP socket that directs packets
2001 to the correct process after finding the right machine, something
2002 like the phone extension you give when you reach the company
2003 operator. Also the result of converting code to run on a different
2004 platform than originally intended, or the verb denoting this
2005 conversion.
2006 portable
2008 Once upon a time, C code compilable under both BSD and SysV. In
2009 general, code that can be easily converted to run on another
2010 platform, where “easily” can be defined however you like, and
2011 usually is. Anything may be considered portable if you try hard
2012 enough, such as a mobile home or London Bridge.
2013 porter
2015 Someone who “carries” software from one platform to another.
2016 Porting programs written in platform-dependent languages such as C
2017 can be difficult work, but porting programs like Perl is very much
2018 worth the agony.
2019 possessive
2021 Said of quantifiers and groups in patterns that refuse to give up
2022 anything once they’ve gotten their mitts on it. Catchier and easier
2023 to say than the even more formal nonbacktrackable.
2024 POSIX
2026 The Portable Operating System Interface specification.
2027 postfix
2029 An operator that follows its operand, as in "$x++".
2030 pp An internal shorthand for a “push- pop” code; that is, C code
2032 implementing Perl’s stack machine.
2033 pragma
2035 A standard module whose practical hints and suggestions are
2036 received (and possibly ignored) at compile time. Pragmas are named
2037 in all lowercase.
2038 precedence
2040 The rules of conduct that, in the absence of other guidance,
2041 determine what should happen first. For example, in the absence of
2042 parentheses, you always do multiplication before addition.
2043 prefix
2045 An operator that precedes its operand, as in "++$x".
2046 preprocessing
2048 What some helper process did to transform the incoming data into a
2049 form more suitable for the current process. Often done with an
2050 incoming pipe. See also C preprocessor.
2051 primary maintainer
2053 The author that PAUSE allows to assign co-maintainer permissions to
2054 a namespace. A primary maintainer can give up this distinction by
2055 assigning it to another PAUSE author. See Camel chapter 19, “CPAN”.
2056 procedure
2058 A subroutine.
2059 process
2061 An instance of a running program. Under multitasking systems like
2062 Unix, two or more separate processes could be running the same
2063 program independently at the same time—in fact, the "fork" function
2064 is designed to bring about this happy state of affairs. Under other
2065 operating systems, processes are sometimes called “threads”,
2066 “tasks”, or “jobs”, often with slight nuances in meaning.
2067 program
2069 See script.
2070 program generator
2072 A system that algorithmically writes code for you in a high-level
2073 language. See also code generator.
2074 progressive matching
2076 Pattern matching matching>that picks up where it left off before.
2077 property
2079 See either instance variable or character property.
2080 protocol
2082 In networking, an agreed-upon way of sending messages back and
2083 forth so that neither correspondent will get too confused.
2084 prototype
2086 An optional part of a subroutine declaration telling the Perl
2087 compiler how many and what flavor of arguments may be passed as
2088 actual arguments, so you can write subroutine calls that parse much
2089 like built-in functions. (Or don’t parse, as the case may be.)
2090 pseudofunction
2092 A construct that sometimes looks like a function but really isn’t.
2093 Usually reserved for lvalue modifiers like "my", for context
2094 modifiers like "scalar", and for the pick-your-own-quotes
2095 constructs, "q//", "qq//", "qx//", "qw//", "qr//", "m//", "s///",
2096 "y///", and "tr///".
2097 pseudohash
2099 Formerly, a reference to an array whose initial element happens to
2100 hold a reference to a hash. You used to be able to treat a
2101 pseudohash reference as either an array reference or a hash
2102 reference. Pseduohashes are no longer supported.
2103 pseudoliteral
2105 An operator X"that looks something like a literal, such as the
2106 output-grabbing operator, <literal moreinfo="none""`>"command""`".
2107 public domain
2109 Something not owned by anybody. Perl is copyrighted and is thus not
2110 in the public domain—it’s just freely available and freely
2111 redistributable.
2112 pumpkin
2114 A notional “baton” handed around the Perl community indicating who
2115 is the lead integrator in some arena of development.
2116 pumpking
2118 A pumpkin holder, the person in charge of pumping the pump, or at
2119 least priming it. Must be willing to play the part of the Great
2120 Pumpkin now and then.
2121 PV A “pointer value”, which is Perl Internals Talk for a "char*".
2123 Q
2125 qualified
2126 Possessing a complete name. The symbol $Ent::moot is qualified;
2127 $moot is unqualified. A fully qualified filename is specified from
2128 the top-level directory.
2129 quantifier
2131 A component of a regular expression specifying how many times the
2132 foregoing atom may occur.
2133 R
2135 race condition
2136 A race condition exists when the result of several interrelated
2137 events depends on the ordering of those events, but that order
2138 cannot be guaranteed due to nondeterministic timing effects. If two
2139 or more programs, or parts of the same program, try to go through
2140 the same series of events, one might interrupt the work of the
2141 other. This is a good way to find an exploit.
2142 readable
2144 With respect to files, one that has the proper permission bit set
2145 to let you access the file. With respect to computer programs, one
2146 that’s written well enough that someone has a chance of figuring
2147 out what it’s trying to do.
2148 reaping
2150 The last rites performed by a parent process on behalf of a
2151 deceased child process so that it doesn’t remain a zombie. See the
2152 "wait" and "waitpid" function calls.
2153 record
2155 A set of related data values in a file or stream, often associated
2156 with a unique key field. In Unix, often commensurate with a line,
2157 or a blank-line–terminated set of lines (a “paragraph”). Each line
2158 of the /etc/passwd file is a record, keyed on login name,
2159 containing information about that user.
2160 recursion
2162 The art of defining something (at least partly) in terms of itself,
2163 which is a naughty no-no in dictionaries but often works out okay
2164 in computer programs if you’re careful not to recurse forever
2165 (which is like an infinite loop with more spectacular failure
2166 modes).
2167 reference
2169 Where you look to find a pointer to information somewhere else.
2170 (See indirection.) References come in two flavors: symbolic
2171 references and hard references.
2172 referent
2174 Whatever a reference refers to, which may or may not have a name.
2175 Common types of referents include scalars, arrays, hashes, and
2176 subroutines.
2177 regex
2179 See regular expression.
2180 regular expression
2182 A single entity with various interpretations, like an elephant. To
2183 a computer scientist, it’s a grammar for a little language in which
2184 some strings are legal and others aren’t. To normal people, it’s a
2185 pattern you can use to find what you’re looking for when it varies
2186 from case to case. Perl’s regular expressions are far from regular
2187 in the theoretical sense, but in regular use they work quite well.
2188 Here’s a regular expression: "/Oh s.*t./". This will match strings
2189 like “"Oh say can you see by the dawn's early light"” and “"Oh
2190 sit!"”. See Camel chapter 5, “Pattern Matching”.
2191 regular expression modifier
2193 An option on a pattern or substitution, such as "/i" to render the
2194 pattern case- insensitive.
2195 regular file
2197 A file that’s not a directory, a device, a named pipe or socket, or
2198 a symbolic link. Perl uses the "–f" file test operator to identify
2199 regular files. Sometimes called a “plain” file.
2200 relational operator
2202 An operator that says whether a particular ordering relationship is
2203 true about a pair of operands. Perl has both numeric and string
2204 relational operators. See collating sequence.
2205 reserved words
2207 A word with a specific, built-in meaning to a compiler, such as
2208 "if" or "delete". In many languages (not Perl), it’s illegal to use
2209 reserved words to name anything else. (Which is why they’re
2210 reserved, after all.) In Perl, you just can’t use them to name
2211 labels or filehandles. Also called “keywords”.
2212 return value
2214 The value produced by a subroutine or expression when evaluated. In
2215 Perl, a return value may be either a list or a scalar.
2216 RFC Request For Comment, which despite the timid connotations is the
2218 name of a series of important standards documents.
2219 right shift
2221 A bit shift that divides a number by some power of 2.
2222 role
2224 A name for a concrete set of behaviors. A role is a way to add
2225 behavior to a class without inheritance.
2226 root
2228 The superuser ("UID" == 0). Also the top-level directory of the
2229 filesystem.
2230 RTFM
2232 What you are told when someone thinks you should Read The Fine
2233 Manual.
2234 run phase
2236 Any time after Perl starts running your main program. See also
2237 compile phase. Run phase is mostly spent in runtime but may also be
2238 spent in compile time when "require", "do" "FILE", or "eval"
2239 "STRING" operators are executed, or when a substitution uses the
2240 "/ee" modifier.
2241 runtime
2243 The time when Perl is actually doing what your code says to do, as
2244 opposed to the earlier period of time when it was trying to figure
2245 out whether what you said made any sense whatsoever, which is
2246 compile time.
2247 runtime pattern
2249 A pattern that contains one or more variables to be interpolated
2250 before parsing the pattern as a regular expression, and that
2251 therefore cannot be analyzed at compile time, but must be
2252 reanalyzed each time the pattern match operator is evaluated.
2253 Runtime patterns are useful but expensive.
2254 RV A recreational vehicle, not to be confused with vehicular
2256 recreation. RV also means an internal Reference Value of the type a
2257 scalar can hold. See also IV and NV if you’re not confused yet.
2258 rvalue
2260 A value that you might find on the right side of an assignment. See
2261 also lvalue.
2262 S
2264 sandbox
2265 A walled off area that’s not supposed to affect beyond its walls.
2266 You let kids play in the sandbox instead of running in the road.
2267 See Camel chapter 20, “Security”.
2268 scalar
2270 A simple, singular value; a number, string, or reference.
2271 scalar context
2273 The situation in which an expression is expected by its
2274 surroundings (the code calling it) to return a single value rather
2275 than a list of values. See also context and list context. A scalar
2276 context sometimes imposes additional constraints on the return
2277 value—see string context and numeric context. Sometimes we talk
2278 about a Boolean context inside conditionals, but this imposes no
2279 additional constraints, since any scalar value, whether numeric or
2280 string, is already true or false.
2281 scalar literal
2283 A number or quoted string—an actual value in the text of your
2284 program, as opposed to a variable.
2285 scalar value
2287 A value that happens to be a scalar as opposed to a list.
2288 scalar variable
2290 A variable prefixed with "$" that holds a single value.
2291 scope
2293 From how far away you can see a variable, looking through one. Perl
2294 has two visibility mechanisms. It does dynamic scoping of "local"
2295 variables, meaning that the rest of the block, and any subroutines
2296 that are called by the rest of the block, can see the variables
2297 that are local to the block. Perl does lexical scoping of "my"
2298 variables, meaning that the rest of the block can see the variable,
2299 but other subroutines called by the block cannot see the variable.
2300 scratchpad
2302 The area in which a particular invocation of a particular file or
2303 subroutine keeps some of its temporary values, including any
2304 lexically scoped variables.
2305 script
2307 A text file that is a program intended to be executed directly
2308 rather than compiled to another form of file before execution.
2309 Also, in the context of Unicode, a writing system for a particular
2311 language or group of languages, such as Greek, Bengali, or Tengwar.
2312 script kiddie
2314 A cracker who is not a hacker but knows just enough to run canned
2315 scripts. A cargo-cult programmer.
2316 sed A venerable Stream EDitor from which Perl derives some of its
2318 ideas.
2319 semaphore
2321 A fancy kind of interlock that prevents multiple threads or
2322 processes from using up the same resources simultaneously.
2323 separator
2325 A character or string that keeps two surrounding strings from being
2326 confused with each other. The "split" function works on separators.
2327 Not to be confused with delimiters or terminators. The “or” in the
2328 previous sentence separated the two alternatives.
2329 serialization
2331 Putting a fancy data structure into linear order so that it can be
2332 stored as a string in a disk file or database, or sent through a
2333 pipe. Also called marshalling.
2334 server
2336 In networking, a process that either advertises a service or just
2337 hangs around at a known location and waits for clients who need
2338 service to get in touch with it.
2339 service
2341 Something you do for someone else to make them happy, like giving
2342 them the time of day (or of their life). On some machines, well-
2343 known services are listed by the "getservent" function.
2344 setgid
2346 Same as setuid, only having to do with giving away group
2347 privileges.
2348 setuid
2350 Said of a program that runs with the privileges of its owner rather
2351 than (as is usually the case) the privileges of whoever is running
2352 it. Also describes the bit in the mode word (permission bits) that
2353 controls the feature. This bit must be explicitly set by the owner
2354 to enable this feature, and the program must be carefully written
2355 not to give away more privileges than it ought to.
2356 shared memory
2358 A piece of memory accessible by two different processes who
2359 otherwise would not see each other’s memory.
2360 shebang
2362 Irish for the whole McGillicuddy. In Perl culture, a portmanteau of
2363 “sharp” and “bang”, meaning the "#!" sequence that tells the system
2364 where to find the interpreter.
2365 shell
2367 A command-line interpreter. The program that interactively gives
2368 you a prompt, accepts one or more lines of input, and executes the
2369 programs you mentioned, feeding each of them their proper arguments
2370 and input data. Shells can also execute scripts containing such
2371 commands. Under Unix, typical shells include the Bourne shell
2372 (/bin/sh), the C shell (/bin/csh), and the Korn shell (/bin/ksh).
2373 Perl is not strictly a shell because it’s not interactive (although
2374 Perl programs can be interactive).
2375 side effects
2377 Something extra that happens when you evaluate an expression.
2378 Nowadays it can refer to almost anything. For example, evaluating a
2379 simple assignment statement typically has the “side effect” of
2380 assigning a value to a variable. (And you thought assigning the
2381 value was your primary intent in the first place!) Likewise,
2382 assigning a value to the special variable $| ($AUTOFLUSH) has the
2383 side effect of forcing a flush after every "write" or "print" on
2384 the currently selected filehandle.
2385 sigil
2387 A glyph used in magic. Or, for Perl, the symbol in front of a
2388 variable name, such as "$", "@", and "%".
2389 signal
2391 A bolt out of the blue; that is, an event triggered by the
2392 operating system, probably when you’re least expecting it.
2393 signal handler
2395 A subroutine that, instead of being content to be called in the
2396 normal fashion, sits around waiting for a bolt out of the blue
2397 before it will deign to execute. Under Perl, bolts out of the blue
2398 are called signals, and you send them with the "kill" built-in. See
2399 the %SIG hash in Camel chapter 25, “Special Names” and the section
2400 “Signals” in Camel chapter 15, “Interprocess Communication”.
2401 single inheritance
2403 The features you got from your mother, if she told you that you
2404 don’t have a father. (See also inheritance and multiple
2405 inheritance.) In computer languages, the idea that classes
2406 reproduce asexually so that a given class can only have one direct
2407 ancestor or base class. Perl supplies no such restriction, though
2408 you may certainly program Perl that way if you like.
2409 slice
2411 A selection of any number of elements from a list, array, or hash.
2412 slurp
2414 To read an entire file into a string in one operation.
2415 socket
2417 An endpoint for network communication among multiple processes that
2418 works much like a telephone or a post office box. The most
2419 important thing about a socket is its network address (like a phone
2420 number). Different kinds of sockets have different kinds of
2421 addresses—some look like filenames, and some don’t.
2422 soft reference
2424 See symbolic reference.
2425 source filter
2427 A special kind of module that does preprocessing on your script
2428 just before it gets to the tokener.
2429 stack
2431 A device you can put things on the top of, and later take them back
2432 off in the opposite order in which you put them on. See LIFO.
2433 standard
2435 Included in the official Perl distribution, as in a standard
2436 module, a standard tool, or a standard Perl manpage.
2437 standard error
2439 The default output stream for nasty remarks that don’t belong in
2440 standard output. Represented within a Perl program by the output>
2441 filehandle "STDERR". You can use this stream explicitly, but the
2442 "die" and "warn" built-ins write to your standard error stream
2443 automatically (unless trapped or otherwise intercepted).
2444 standard input
2446 The default input stream for your program, which if possible
2447 shouldn’t care where its data is coming from. Represented within a
2448 Perl program by the filehandle "STDIN".
2449 standard I/O
2451 A standard C library for doing buffered input and output to the
2452 operating system. (The “standard” of standard I/O is at most
2453 marginally related to the “standard” of standard input and output.)
2454 In general, Perl relies on whatever implementation of standard I/O
2455 a given operating system supplies, so the buffering characteristics
2456 of a Perl program on one machine may not exactly match those on
2457 another machine. Normally this only influences efficiency, not
2458 semantics. If your standard I/O package is doing block buffering
2459 and you want it to flush the buffer more often, just set the $|
2460 variable to a true value.
2461 Standard Library
2463 Everything that comes with the official perl distribution. Some
2464 vendor versions of perl change their distributions, leaving out
2465 some parts or including extras. See also dual-lived.
2466 standard output
2468 The default output stream for your program, which if possible
2469 shouldn’t care where its data is going. Represented within a Perl
2470 program by the filehandle "STDOUT".
2471 statement
2473 A command to the computer about what to do next, like a step in a
2474 recipe: “Add marmalade to batter and mix until mixed.” A statement
2475 is distinguished from a declaration, which doesn’t tell the
2476 computer to do anything, but just to learn something.
2477 statement modifier
2479 A conditional or loop that you put after the statement instead of
2480 before, if you know what we mean.
2481 static
2483 Varying slowly compared to something else. (Unfortunately,
2484 everything is relatively stable compared to something else, except
2485 for certain elementary particles, and we’re not so sure about
2486 them.) In computers, where things are supposed to vary rapidly,
2487 “static” has a derogatory connotation, indicating a slightly
2488 dysfunctional variable, subroutine, or method. In Perl culture, the
2489 word is politely avoided.
2490 If you’re a C or C++ programmer, you might be looking for Perl’s
2492 "state" keyword.
2493 static method
2495 No such thing. See class method.
2496 static scoping
2498 No such thing. See lexical scoping.
2499 static variable
2501 No such thing. Just use a lexical variable in a scope larger than
2502 your subroutine, or declare it with "state" instead of with "my".
2503 stat structure
2505 A special internal spot in which Perl keeps the information about
2506 the last file on which you requested information.
2507 status
2509 The value returned to the parent process when one of its child
2510 processes dies. This value is placed in the special variable $?.
2511 Its upper eight bits are the exit status of the defunct process,
2512 and its lower eight bits identify the signal (if any) that the
2513 process died from. On Unix systems, this status value is the same
2514 as the status word returned by wait(2). See "system" in Camel
2515 chapter 27, “Functions”.
2516 STDERR
2518 See standard error.
2519 STDIN
2521 See standard input.
2522 STDIO
2524 See standard I/O.
2525 STDOUT
2527 See standard output.
2528 stream
2530 A flow of data into or out of a process as a steady sequence of
2531 bytes or characters, without the appearance of being broken up into
2532 packets. This is a kind of interface—the underlying implementation
2533 may well break your data up into separate packets for delivery, but
2534 this is hidden from you.
2535 string
2537 A sequence of characters such as “He said !@#*&%@#*?!”. A string
2538 does not have to be entirely printable.
2539 string context
2541 The situation in which an expression is expected by its
2542 surroundings (the code calling it) to return a string. See also
2543 context and numeric context.
2544 stringification
2546 The process of producing a string representation of an abstract
2547 object.
2548 struct
2550 C keyword introducing a structure definition or name.
2551 structure
2553 See data structure.
2554 subclass
2556 See derived class.
2557 subpattern
2559 A component of a regular expression pattern.
2560 subroutine
2562 A named or otherwise accessible piece of program that can be
2563 invoked from elsewhere in the program in order to accomplish some
2564 subgoal of the program. A subroutine is often parameterized to
2565 accomplish different but related things depending on its input
2566 arguments. If the subroutine returns a meaningful value, it is also
2567 called a function.
2568 subscript
2570 A value that indicates the position of a particular array element
2571 in an array.
2572 substitution
2574 Changing parts of a string via the "s///" operator. (We avoid use
2575 of this term to mean variable interpolation.)
2576 substring
2578 A portion of a string, starting at a certain character position
2579 (offset) and proceeding for a certain number of characters.
2580 superclass
2582 See base class.
2583 superuser
2585 The person whom the operating system will let do almost anything.
2586 Typically your system administrator or someone pretending to be
2587 your system administrator. On Unix systems, the root user. On
2588 Windows systems, usually the Administrator user.
2589 SV Short for “scalar value”. But within the Perl interpreter, every
2591 referent is treated as a member of a class derived from SV, in an
2592 object-oriented sort of way. Every value inside Perl is passed
2593 around as a C language "SV*" pointer. The SV struct knows its own
2594 “referent type”, and the code is smart enough (we hope) not to try
2595 to call a hash function on a subroutine.
2596 switch
2598 An option you give on a command line to influence the way your
2599 program works, usually introduced with a minus sign. The word is
2600 also used as a nickname for a switch statement.
2601 switch cluster
2603 The combination of multiple command- line switches (e.g., "–a –b
2604 –c") into one switch (e.g., "–abc"). Any switch with an additional
2605 argument must be the last switch in a cluster.
2606 switch statement
2608 A program technique that lets you evaluate an expression and then,
2609 based on the value of the expression, do a multiway branch to the
2610 appropriate piece of code for that value. Also called a “case
2611 structure”, named after the similar Pascal construct. Most switch
2612 statements in Perl are spelled "given". See “The "given" statement”
2613 in Camel chapter 4, “Statements and Declarations”.
2614 symbol
2616 Generally, any token or metasymbol. Often used more specifically to
2617 mean the sort of name you might find in a symbol table.
2618 symbolic debugger
2620 A program that lets you step through the execution of your program,
2621 stopping or printing things out here and there to see whether
2622 anything has gone wrong, and, if so, what. The “symbolic” part just
2623 means that you can talk to the debugger using the same symbols with
2624 which your program is written.
2625 symbolic link
2627 An alternate filename that points to the real filename, which in
2628 turn points to the real file. Whenever the operating system is
2629 trying to parse a pathname containing a symbolic link, it merely
2630 substitutes the new name and continues parsing.
2631 symbolic reference
2633 A variable whose value is the name of another variable or
2634 subroutine. By dereferencing the first variable, you can get at the
2635 second one. Symbolic references are illegal under "use strict
2636 "refs"".
2637 symbol table
2639 Where a compiler remembers symbols. A program like Perl must
2640 somehow remember all the names of all the variables, filehandles,
2641 and subroutines you’ve used. It does this by placing the names in a
2642 symbol table, which is implemented in Perl using a hash table.
2643 There is a separate symbol table for each package to give each
2644 package its own namespace.
2645 synchronous
2647 Programming in which the orderly sequence of events can be
2648 determined; that is, when things happen one after the other, not at
2649 the same time.
2650 syntactic sugar
2652 An alternative way of writing something more easily; a shortcut.
2653 syntax
2655 From Greek σύνταξις, “with-arrangement”. How things (particularly
2656 symbols) are put together with each other.
2657 syntax tree
2659 An internal representation of your program wherein lower-level
2660 constructs dangle off the higher-level constructs enclosing them.
2661 syscall
2663 A function call directly to the operating system. Many of the
2664 important subroutines and functions you use aren’t direct system
2665 calls, but are built up in one or more layers above the system call
2666 level. In general, Perl programmers don’t need to worry about the
2667 distinction. However, if you do happen to know which Perl functions
2668 are really syscalls, you can predict which of these will set the $!
2669 ($ERRNO) variable on failure. Unfortunately, beginning programmers
2670 often confusingly employ the term “system call” to mean what
2671 happens when you call the Perl "system" function, which actually
2672 involves many syscalls. To avoid any confusion, we nearly always
2673 say “syscall” for something you could call indirectly via Perl’s
2674 "syscall" function, and never for something you would call with
2675 Perl’s "system" function.
2676 T
2678 taint checks
2679 The special bookkeeping Perl does to track the flow of external
2680 data through your program and disallow their use in system
2681 commands.
2682 tainted
2684 Said of data derived from the grubby hands of a user, and thus
2685 unsafe for a secure program to rely on. Perl does taint checks if
2686 you run a setuid (or setgid) program, or if you use the "–T"
2687 switch.
2688 taint mode
2690 Running under the "–T" switch, marking all external data as suspect
2691 and refusing to use it with system commands. See Camel chapter 20,
2692 “Security”.
2693 TCP Short for Transmission Control Protocol. A protocol wrapped around
2695 the Internet Protocol to make an unreliable packet transmission
2696 mechanism appear to the application program to be a reliable stream
2697 of bytes. (Usually.)
2698 term
2700 Short for a “terminal”—that is, a leaf node of a syntax tree. A
2701 thing that functions grammatically as an operand for the operators
2702 in an expression.
2703 terminator
2705 A character or string that marks the end of another string. The $/
2706 variable contains the string that terminates a "readline"
2707 operation, which "chomp" deletes from the end. Not to be confused
2708 with delimiters or separators. The period at the end of this
2709 sentence is a terminator.
2710 ternary
2712 An operator taking three operands. Sometimes pronounced trinary.
2713 text
2715 A string or file containing primarily printable characters.
2716 thread
2718 Like a forked process, but without fork’s inherent memory
2719 protection. A thread is lighter weight than a full process, in that
2720 a process could have multiple threads running around in it, all
2721 fighting over the same process’s memory space unless steps are
2722 taken to protect threads from one another.
2723 tie The bond between a magical variable and its implementation class.
2725 See the "tie" function in Camel chapter 27, “Functions” and Camel
2726 chapter 14, “Tied Variables”.
2727 titlecase
2729 The case used for capitals that are followed by lowercase
2730 characters instead of by more capitals. Sometimes called sentence
2731 case or headline case. English doesn’t use Unicode titlecase, but
2732 casing rules for English titles are more complicated than simply
2733 capitalizing each word’s first character.
2734 TMTOWTDI
2736 There’s More Than One Way To Do It, the Perl Motto. The notion that
2737 there can be more than one valid path to solving a programming
2738 problem in context. (This doesn’t mean that more ways are always
2739 better or that all possible paths are equally desirable—just that
2740 there need not be One True Way.)
2741 token
2743 A morpheme in a programming language, the smallest unit of text
2744 with semantic significance.
2745 tokener
2747 A module that breaks a program text into a sequence of tokens for
2748 later analysis by a parser.
2749 tokenizing
2751 Splitting up a program text into tokens. Also known as “lexing”, in
2752 which case you get “lexemes” instead of tokens.
2753 toolbox approach
2755 The notion that, with a complete set of simple tools that work well
2756 together, you can build almost anything you want. Which is fine if
2757 you’re assembling a tricycle, but if you’re building a
2758 defranishizing comboflux regurgalator, you really want your own
2759 machine shop in which to build special tools. Perl is sort of a
2760 machine shop.
2761 topic
2763 The thing you’re working on. Structures like "while(<>)", "for",
2764 "foreach", and "given" set the topic for you by assigning to $_,
2765 the default (topic) variable.
2766 transliterate
2768 To turn one string representation into another by mapping each
2769 character of the source string to its corresponding character in
2770 the result string. Not to be confused with translation: for
2771 example, Greek πολύχρωμος transliterates into polychromos but
2772 translates into many-colored. See the "tr///" operator in Camel
2773 chapter 5, “Pattern Matching”.
2774 trigger
2776 An event that causes a handler to be run.
2777 trinary
2779 Not a stellar system with three stars, but an operator taking three
2780 operands. Sometimes pronounced ternary.
2781 troff
2783 A venerable typesetting language from which Perl derives the name
2784 of its $% variable and which is secretly used in the production of
2785 Camel books.
2786 true
2788 Any scalar value that doesn’t evaluate to 0 or "".
2789 truncating
2791 Emptying a file of existing contents, either automatically when
2792 opening a file for writing or explicitly via the "truncate"
2793 function.
2794 type
2796 See data type and class.
2797 type casting
2799 Converting data from one type to another. C permits this. Perl
2800 does not need it. Nor want it.
2801 typedef
2803 A type definition in the C and C++ languages.
2804 typed lexical
2806 A lexical variable lexical>that is declared with a class type: "my
2807 Pony $bill".
2808 typeglob
2810 Use of a single identifier, prefixed with "*". For example, *name
2811 stands for any or all of $name, @name, %name, &name, or just
2812 "name". How you use it determines whether it is interpreted as all
2813 or only one of them. See “Typeglobs and Filehandles” in Camel
2814 chapter 2, “Bits and Pieces”.
2815 typemap
2817 A description of how C types may be transformed to and from Perl
2818 types within an extension module written in XS.
2819 U
2821 UDP User Datagram Protocol, the typical way to send datagrams over the
2822 Internet.
2823 UID A user ID. Often used in the context of file or process ownership.
2825 umask
2827 A mask of those permission bits that should be forced off when
2828 creating files or directories, in order to establish a policy of
2829 whom you’ll ordinarily deny access to. See the "umask" function.
2830 unary operator
2832 An operator with only one operand, like "!" or "chdir". Unary
2833 operators are usually prefix operators; that is, they precede their
2834 operand. The "++" and "––" operators can be either prefix or
2835 postfix. (Their position does change their meanings.)
2836 Unicode
2838 A character set comprising all the major character sets of the
2839 world, more or less. See <http://www.unicode.org>.
2840 Unix
2842 A very large and constantly evolving language with several
2843 alternative and largely incompatible syntaxes, in which anyone can
2844 define anything any way they choose, and usually do. Speakers of
2845 this language think it’s easy to learn because it’s so easily
2846 twisted to one’s own ends, but dialectical differences make tribal
2847 intercommunication nearly impossible, and travelers are often
2848 reduced to a pidgin-like subset of the language. To be universally
2849 understood, a Unix shell programmer must spend years of study in
2850 the art. Many have abandoned this discipline and now communicate
2851 via an Esperanto-like language called Perl.
2852 In ancient times, Unix was also used to refer to some code that a
2854 couple of people at Bell Labs wrote to make use of a PDP-7 computer
2855 that wasn’t doing much of anything else at the time.
2856 uppercase
2858 In Unicode, not just characters with the General Category of
2859 Uppercase Letter, but any character with the Uppercase property,
2860 including some Letter Numbers and Symbols. Not to be confused with
2861 titlecase.
2862 V
2864 value
2865 An actual piece of data, in contrast to all the variables,
2866 references, keys, indices, operators, and whatnot that you need to
2867 access the value.
2868 variable
2870 A named storage location that can hold any of various kinds of
2871 value, as your program sees fit.
2872 variable interpolation
2874 The interpolation of a scalar or array variable into a string.
2875 variadic
2877 Said of a function that happily receives an indeterminate number of
2878 actual arguments.
2879 vector
2881 Mathematical jargon for a list of scalar values.
2882 virtual
2884 Providing the appearance of something without the reality, as in:
2885 virtual memory is not real memory. (See also memory.) The opposite
2886 of “virtual” is “transparent”, which means providing the reality of
2887 something without the appearance, as in: Perl handles the variable-
2888 length UTF‑8 character encoding transparently.
2889 void context
2891 A form of scalar context in which an expression is not expected to
2892 return any value at all and is evaluated for its side effects
2893 alone.
2894 v-string
2896 A “version” or “vector” string specified with a "v" followed by a
2897 series of decimal integers in dot notation, for instance,
2898 "v1.20.300.4000". Each number turns into a character with the
2899 specified ordinal value. (The "v" is optional when there are at
2900 least three integers.)
2901 W
2903 warning
2904 A message printed to the "STDERR" stream to the effect that
2905 something might be wrong but isn’t worth blowing up over. See
2906 "warn" in Camel chapter 27, “Functions” and the "warnings" pragma
2907 in Camel chapter 28, “Pragmantic Modules”.
2908 watch expression
2910 An expression which, when its value changes, causes a breakpoint in
2911 the Perl debugger.
2912 weak reference
2914 A reference that doesn’t get counted normally. When all the normal
2915 references to data disappear, the data disappears. These are useful
2916 for circular references that would never disappear otherwise.
2917 whitespace
2919 A character that moves your cursor but doesn’t otherwise put
2920 anything on your screen. Typically refers to any of: space, tab,
2921 line feed, carriage return, or form feed. In Unicode, matches many
2922 other characters that Unicode considers whitespace, including the
2923 ɴ-ʙʀ .
2924 word
2926 In normal “computerese”, the piece of data of the size most
2927 efficiently handled by your computer, typically 32 bits or so, give
2928 or take a few powers of 2. In Perl culture, it more often refers to
2929 an alphanumeric identifier (including underscores), or to a string
2930 of nonwhitespace characters bounded by whitespace or string
2931 boundaries.
2932 working directory
2934 Your current directory, from which relative pathnames are
2935 interpreted by the operating system. The operating system knows
2936 your current directory because you told it with a "chdir", or
2937 because you started out in the place where your parent process was
2938 when you were born.
2939 wrapper
2941 A program or subroutine that runs some other program or subroutine
2942 for you, modifying some of its input or output to better suit your
2943 purposes.
2944 WYSIWYG
2946 What You See Is What You Get. Usually used when something that
2947 appears on the screen matches how it will eventually look, like
2948 Perl’s "format" declarations. Also used to mean the opposite of
2949 magic because everything works exactly as it appears, as in the
2950 three- argument form of "open".
2951 X
2953 XS An extraordinarily exported, expeditiously excellent, expressly
2954 eXternal Subroutine, executed in existing C or C++ or in an
2955 exciting extension language called (exasperatingly) XS.
2956 XSUB
2958 An external subroutine defined in XS.
2959 Y
2961 yacc
2962 Yet Another Compiler Compiler. A parser generator without which
2963 Perl probably would not have existed. See the file perly.y in the
2964 Perl source distribution.
2965 Z
2967 zero width
2968 A subpattern assertion matching the null string between characters.
2969 zombie
2971 A process that has died (exited) but whose parent has not yet
2972 received proper notification of its demise by virtue of having
2973 called "wait" or "waitpid". If you "fork", you must clean up after
2974 your child processes when they exit; otherwise, the process table
2975 will fill up and your system administrator will Not Be Happy with
2976 you.
2977
2979 Based on the Glossary of Programming Perl, Fourth Edition, by Tom
2980 Christiansen, brian d foy, Larry Wall, & Jon Orwant. Copyright (c)
2981 2000, 1996, 1991, 2012 O'Reilly Media, Inc. This document may be
2982 distributed under the same terms as Perl itself.
2983perl v5.30.0 2019-11-04 perlglossary(3)