Commit | Line | Data |
---|---|---|
c7166200 CBW |
1 | |
2 | =encoding utf8 | |
3 | ||
97a1d740 YST |
4 | =head1 NAME |
5 | ||
6 | perlglossary - Perl Glossary | |
7 | ||
8 | =head1 DESCRIPTION | |
9 | ||
c7166200 CBW |
10 | A glossary of terms (technical and otherwise) used in the Perl |
11 | documentation, derived from the Glossary of I<Programming | |
12 | Perl>, Fourth Edition. Words or phrases in bold are defined elsewhere in | |
13 | this glossary. | |
14 | ||
15 | Other useful sources include the Unicode Glossary L<http://unicode.org/glossary/>, | |
16 | the Free On-Line Dictionary of Computing L<http://foldoc.org/>, | |
17 | the Jargon File L<http://catb.org/~esr/jargon/>, | |
18 | and Wikipedia L<http://www.wikipedia.org/>. | |
97a1d740 | 19 | |
5bbd0522 | 20 | =head2 A |
97a1d740 YST |
21 | |
22 | =over 4 | |
23 | ||
24 | =item accessor methods | |
25 | ||
c7166200 CBW |
26 | A B<X<accessor methods, defined>X<methods, accessor>method> used to |
27 | indirectly inspect or update an B<object>’s state (its B<instance | |
28 | variables>). | |
97a1d740 YST |
29 | |
30 | =item actual arguments | |
31 | ||
c7166200 CBW |
32 | The B<X<actual arguments>X<arguments, actual>scalar values> that you supply |
33 | to a B<function> or B<subroutine> when you call it. For instance, when you | |
34 | call C<power("puff")>, the string C<"puff"> is the actual argument. See also | |
35 | B<argument> and B<formal arguments>. | |
97a1d740 YST |
36 | |
37 | =item address operator | |
38 | ||
c7166200 CBW |
39 | Some X<address operator>languages work directly with the memory addresses of |
40 | values, but this can be like playing with fire. Perl provides a set of | |
41 | asbestos gloves for handling all memory management. The closest to an | |
42 | address operator in Perl is the backslash operator, but it gives you a | |
43 | B<hard reference>, which is much safer than a memory address. | |
97a1d740 YST |
44 | |
45 | =item algorithm | |
46 | ||
c7166200 CBW |
47 | A X<algorithms (term)>well-defined sequence of steps, explained clearly |
48 | enough that even a computer could do them. | |
97a1d740 YST |
49 | |
50 | =item alias | |
51 | ||
c7166200 CBW |
52 | A X<aliases, defined>nickname for something, which behaves in all ways as |
53 | though you’d used the original name instead of the nickname. Temporary | |
54 | aliases are implicitly created in the loop variable for C<foreach> loops, in | |
55 | the C<$_> variable for C<map> or C<grep> operators, in C<$a> and C<$b> | |
56 | during C<sort>’s comparison function, and in each element of C<@_> for the | |
57 | B<actual arguments> of a subroutine call. Permanent aliases are explicitly | |
58 | created in B<packages> by B<importing> symbols or by assignment to | |
59 | B<typeglobs>. Lexically scoped aliases for package variables are explicitly | |
60 | created by the C<our> declaration. | |
61 | ||
62 | =item alphabetic | |
63 | ||
64 | The X<alphabetic sort>sort of characters we put into words. In Unicode, this | |
65 | is all letters including all ideographs and certain diacritics, letter | |
66 | numbers like Roman numerals, and various combining marks. | |
97a1d740 YST |
67 | |
68 | =item alternatives | |
69 | ||
c7166200 CBW |
70 | A X<alternative characters>list of possible choices from which you may |
71 | select only one, as in, “Would you like door A, B, or C?” Alternatives in | |
72 | regular expressions are separated with a single vertical bar: C<|>. | |
73 | Alternatives in normal Perl expressions are separated with a double vertical | |
74 | bar: C<||>. Logical alternatives in B<Boolean> expressions are separated | |
97a1d740 YST |
75 | with either C<||> or C<or>. |
76 | ||
77 | =item anonymous | |
78 | ||
c7166200 CBW |
79 | Used to X<anonymous referents>X<referents, anonymous>describe a B<referent> |
80 | that is not directly accessible through a named B<variable>. Such a referent | |
81 | must be indirectly accessible through at least one B<hard reference>. When | |
82 | the last hard reference goes away, the anonymous referent is destroyed | |
83 | without pity. | |
84 | ||
85 | =item application | |
86 | ||
87 | A X<applications (term)>bigger, fancier sort of B<program> with a fancier | |
88 | name so people don’t realize they are using a program. | |
97a1d740 YST |
89 | |
90 | =item architecture | |
91 | ||
c7166200 CBW |
92 | The kind of X<architecture>computer you’re working on, where one “kind” of |
93 | computer means all those computers sharing a compatible machine language. | |
97a1d740 | 94 | Since Perl programs are (typically) simple text files, not executable |
c7166200 CBW |
95 | images, a Perl program is much less sensitive to the architecture it’s |
96 | running on than programs in other languages, such as C, that are B<compiled> | |
97 | into machine code. See also B<platform> and B<operating system>. | |
97a1d740 YST |
98 | |
99 | =item argument | |
100 | ||
c7166200 CBW |
101 | A X<arguments, defined>piece of data supplied to a B<program>, |
102 | B<subroutine>, B<function>, or B<method> to tell it what it’s supposed to | |
103 | do. Also called a “parameter”. | |
97a1d740 YST |
104 | |
105 | =item ARGV | |
106 | ||
c7166200 CBW |
107 | The name of the X<ARGV filehandle>array containing the B<argument> B<vector> |
108 | from the command line. If you use the empty C<E<lt>E<gt>> operator, C<ARGV> | |
109 | is the name of both the B<filehandle> used to traverse the arguments and the | |
110 | B<scalar> containing the name of the current input file. | |
97a1d740 YST |
111 | |
112 | =item arithmetical operator | |
113 | ||
c7166200 CBW |
114 | A B<X<arithmetic operators, about>symbol> such as C<+> or C</> that tells |
115 | Perl to do the arithmetic you were supposed to learn in grade school. | |
97a1d740 YST |
116 | |
117 | =item array | |
118 | ||
c7166200 CBW |
119 | An X<arrays, defined>ordered sequence of B<values>, stored such that you can |
120 | easily access any of the values using an I<integer subscript> that specifies | |
121 | the value’s B<offset> in the sequence. | |
97a1d740 YST |
122 | |
123 | =item array context | |
124 | ||
c7166200 CBW |
125 | An archaic X<array context>expression for what is more correctly referred to |
126 | as B<list context>. | |
127 | ||
128 | =item Artistic License | |
129 | ||
130 | The open X<Artistic License>source license that X<Wall, Larry>Larry Wall | |
131 | created for Perl, maximizing Perl’s usefulness, availability, and | |
132 | modifiability. The current version is 2. (L<http://www.opensource.org/licenses/artistic-license.php>). | |
97a1d740 YST |
133 | |
134 | =item ASCII | |
135 | ||
c7166200 CBW |
136 | The X<ASCII (American Standard Code for Information Interchange)>X<American |
137 | Standard Code for Information Interchange (ASCII)>American Standard Code for | |
138 | Information Interchange (a 7-bit character set adequate only for poorly | |
139 | representing English text). Often used loosely to describe the lowest 128 | |
140 | values of the various ISO-8859-X character sets, a bunch of mutually | |
141 | incompatible 8-bit codes best described as half ASCII. See also B<Unicode>. | |
97a1d740 YST |
142 | |
143 | =item assertion | |
144 | ||
c7166200 CBW |
145 | A X<assertions (in regexes), defined>X<regular expressions, assertions |
146 | in>component of a B<regular expression> that must be true for the pattern to | |
147 | match but does not necessarily match any characters itself. Often used | |
148 | specifically to mean a B<zero-width> assertion. | |
97a1d740 YST |
149 | |
150 | =item assignment | |
151 | ||
c7166200 CBW |
152 | An X<assignments, defined>B<operator> whose assigned mission in life is to |
153 | change the value of a B<variable>. | |
97a1d740 YST |
154 | |
155 | =item assignment operator | |
156 | ||
c7166200 CBW |
157 | Either a X<assignment operators, about>regular B<assignment> or a compound |
158 | B<operator> composed of an ordinary assignment and some other operator, that | |
159 | changes the value of a variable in place; that is, relative to its old | |
160 | value. For example, C<$a += 2> adds C<2> to C<$a>. | |
97a1d740 YST |
161 | |
162 | =item associative array | |
163 | ||
c7166200 CBW |
164 | See B<hash>. X<associative arrays>Please. The term associative array is the |
165 | old Perl 4 term for a B<hash>. Some languages call it a dictionary. | |
97a1d740 YST |
166 | |
167 | =item associativity | |
168 | ||
c7166200 CBW |
169 | Determines X<associativity>whether you do the left B<operator> first or the |
170 | right B<operator> first when you have “A B<operator> B B<operator> C”, and | |
171 | the two operators are of the same precedence. Operators like C<+> are left | |
172 | associative, while operators like C<**> are right associative. See Camel | |
173 | chapter 3, “Unary and Binary Operators” for a list of operators and their | |
174 | associativity. | |
97a1d740 YST |
175 | |
176 | =item asynchronous | |
177 | ||
c7166200 CBW |
178 | Said of X<asynchronous event processing>events or activities whose relative |
179 | temporal ordering is indeterminate because too many things are going on at | |
180 | once. Hence, an asynchronous event is one you didn’t know when to expect. | |
97a1d740 YST |
181 | |
182 | =item atom | |
183 | ||
c7166200 CBW |
184 | A B<regular X<atoms>expression> component potentially matching a |
185 | B<substring> containing one or more characters and treated as an indivisible | |
186 | syntactic unit by any following B<quantifier>. (Contrast with an | |
187 | B<assertion> that matches something of B<zero width> and may not be quantified.) | |
97a1d740 YST |
188 | |
189 | =item atomic operation | |
190 | ||
c7166200 CBW |
191 | When X<atomic operation>Democritus gave the word “atom” to the indivisible |
192 | bits of matter, he meant literally something that could not be cut: I<ἀ-> | |
193 | (not) + I<-τομος> (cuttable). An atomic operation is an action that can’t be | |
194 | interrupted, not one forbidden in a nuclear-free zone. | |
97a1d740 YST |
195 | |
196 | =item attribute | |
197 | ||
c7166200 CBW |
198 | A new X<attribute feature>feature that allows the declaration of |
199 | B<variables> and B<subroutines> with modifiers, as in C<sub foo : locked | |
200 | method>. Also another name for an B<instance variable> of an B<object>. | |
97a1d740 YST |
201 | |
202 | =item autogeneration | |
203 | ||
c7166200 CBW |
204 | A X<autogeneration, about>feature of B<operator overloading> of B<objects>, |
205 | whereby the behavior of certain B<operators> can be reasonably deduced using | |
206 | more fundamental operators. This assumes that the overloaded operators will | |
207 | often have the same relationships as the regular operators. See Camel | |
208 | chapter 13, “Overloading”. | |
97a1d740 YST |
209 | |
210 | =item autoincrement | |
211 | ||
c7166200 CBW |
212 | To X<autoincrement (term)>add one to something automatically, hence the name |
213 | of the C<++> operator. To instead subtract one from something automatically | |
214 | is known as an “autodecrement”. | |
97a1d740 YST |
215 | |
216 | =item autoload | |
217 | ||
c7166200 CBW |
218 | To X<autoloading, defined>load on demand. (Also called “lazy” loading.) |
219 | Specifically, to call an C<AUTOLOAD> subroutine on behalf of an undefined | |
220 | subroutine. | |
97a1d740 YST |
221 | |
222 | =item autosplit | |
223 | ||
c7166200 CBW |
224 | To X<autosplit (term)>split a string automatically, as the I<–a> B<switch> |
225 | does when running under I<–p> or I<–n> in order to emulate B<awk>. (See also | |
226 | the C<AutoSplit>X<AutoSplit module> module, which has nothing to do with the | |
227 | C<–a> switch but a lot to do with autoloading.) | |
97a1d740 YST |
228 | |
229 | =item autovivification | |
230 | ||
c7166200 CBW |
231 | A X<autovivification>Graeco-Roman word meaning “to bring oneself to life”. |
232 | In Perl, storage locations (B<lvalues>) spontaneously generate themselves as | |
233 | needed, including the creation of any B<hard reference> values to point to | |
234 | the next level of storage. The assignment C<$a[5][5][5][5][5] = "quintet"> | |
235 | potentially creates five scalar storage locations, plus four references (in | |
236 | the first four scalar locations) pointing to four new anonymous arrays (to | |
237 | hold the last four scalar locations). But the point of autovivification is | |
238 | that you don’t have to worry about it. | |
97a1d740 YST |
239 | |
240 | =item AV | |
241 | ||
c7166200 CBW |
242 | Short X<AV (array value)>X<array value (AV)>X<values, array>for “array |
243 | value”, which refers to one of Perl’s internal data types that holds an | |
244 | B<array>. The C<AV> type is a subclass of B<SV>. | |
97a1d740 YST |
245 | |
246 | =item awk | |
247 | ||
c7166200 CBW |
248 | Descriptive X<awk (editing term)>editing term—short for “awkward”. Also |
249 | coincidentally refers to a venerable text-processing language from which | |
250 | Perl derived some of its high-level ideas. | |
97a1d740 YST |
251 | |
252 | =back | |
253 | ||
5bbd0522 YST |
254 | =head2 B |
255 | ||
97a1d740 YST |
256 | =over 4 |
257 | ||
258 | =item backreference | |
259 | ||
c7166200 CBW |
260 | A X<backreferences, about>X<references, backreferences>substring B<captured> |
261 | by a subpattern within unadorned parentheses in a B<regex>. Backslashed | |
262 | decimal numbers (C<\1>, C<\2>, etc.) later in the same pattern refer back to | |
263 | the corresponding subpattern in the current match. Outside the pattern, the | |
264 | numbered variables (C<$1>, C<$2>, etc.) continue to refer to these same | |
265 | values, as long as the pattern was the last successful match of the current | |
266 | B<dynamic scope>. | |
97a1d740 YST |
267 | |
268 | =item backtracking | |
269 | ||
c7166200 CBW |
270 | The X<backtracking>practice of saying, “If I had to do it all over, I’d do |
271 | it differently,” and then actually going back and doing it all over | |
272 | differently. Mathematically speaking, it’s returning from an unsuccessful | |
273 | recursion on a tree of possibilities. Perl backtracks when it attempts to | |
274 | match patterns with a B<regular expression>, and its earlier attempts don’t | |
275 | pan out. See the section “The Little Engine That /Couldn(n’t)” in Camel | |
276 | chapter 5, “Pattern Matching”. | |
97a1d740 YST |
277 | |
278 | =item backward compatibility | |
279 | ||
c7166200 CBW |
280 | Means X<backward compatibility, defined>you can still run your old program |
281 | because we didn’t break any of the features or bugs it was relying on. | |
97a1d740 YST |
282 | |
283 | =item bareword | |
284 | ||
c7166200 CBW |
285 | A word X<barewords, about>sufficiently ambiguous to be deemed illegal under |
286 | C<use strict 'subs'>. In the absence of that stricture, a bareword is | |
287 | treated as if quotes were around it. | |
97a1d740 YST |
288 | |
289 | =item base class | |
290 | ||
c7166200 CBW |
291 | A X<base classes>X<classes, base>generic B<object> type; that is, a B<class> |
292 | from which other, more specific classes are derived genetically by | |
293 | B<inheritance>. Also called aX<superclasses>X<classes, superclasses> | |
294 | “superclass” by people who respect their ancestors. | |
97a1d740 YST |
295 | |
296 | =item big-endian | |
297 | ||
c7166200 CBW |
298 | From X<big–endian, defined>X<endianness, big–endian>Swift: someone who |
299 | eats eggs big end first. Also used of computers that store the most | |
300 | significant B<byte> of a word at a lower byte address than the least | |
301 | significant byte. Often considered superior to little-endian machines. See | |
302 | also B<little-endian>. | |
97a1d740 YST |
303 | |
304 | =item binary | |
305 | ||
c7166200 CBW |
306 | Having X<binary (term)>to do with numbers represented in base 2. That means |
307 | there’s basically two numbers: 0 and 1. Also used to describe a file of | |
308 | “nontext”, presumably because such a file makes full use of all the binary | |
309 | bits in its bytes. With the advent of B<Unicode>, this distinction, already | |
310 | suspect, loses even more of its meaning. | |
97a1d740 YST |
311 | |
312 | =item binary operator | |
313 | ||
c7166200 | 314 | An B<X<binary operators, about>operator> that takes two B<operands>. |
97a1d740 YST |
315 | |
316 | =item bind | |
317 | ||
c7166200 | 318 | To X<bind (term)>assign a specific B<network address> to a B<socket>. |
97a1d740 YST |
319 | |
320 | =item bit | |
321 | ||
c7166200 CBW |
322 | An X<bits, defined>integer in the range from 0 to 1, inclusive. The smallest |
323 | possible unit of information storage. An eighth of a B<byte> or of a dollar. | |
324 | (The term “Pieces of Eight” comes from being able to split the old Spanish | |
325 | dollar into 8 bits, each of which still counted for money. That’s why a 25- | |
326 | cent piece today is still “two bits”.) | |
97a1d740 YST |
327 | |
328 | =item bit shift | |
329 | ||
c7166200 CBW |
330 | The X<bit–shift operators, defined>movement of bits left or right in a |
331 | computer word, which has the effect of multiplying or dividing by a | |
332 | power of 2. | |
97a1d740 YST |
333 | |
334 | =item bit string | |
335 | ||
c7166200 | 336 | A X<bit string>sequence of B<bits> that is actually being thought of as a |
97a1d740 YST |
337 | sequence of bits, for once. |
338 | ||
339 | =item bless | |
340 | ||
c7166200 CBW |
341 | In X<bless function, about>X<bless (term)>corporate life, to grant official |
342 | approval to a thing, as in, “The VP of Engineering has blessed our | |
343 | WebCruncher project.” Similarly, in Perl, to grant official approval to a | |
344 | B<referent> so that it can function as an B<object>, such as a WebCruncher | |
345 | object. See the C<bless> function in Camel chapter 27, “Functions”. | |
97a1d740 YST |
346 | |
347 | =item block | |
348 | ||
c7166200 CBW |
349 | What X<blocks, defined>a B<process> does when it has to wait for something: |
350 | “My process blocked waiting for the disk.” As an unrelated noun, it refers | |
351 | to a large chunk of data, of a size that the B<operating system> likes to | |
352 | deal with (normally a power of 2 such as 512 or 8192). Typically refers to | |
353 | a chunk of data that’s coming from or going to a disk file. | |
97a1d740 YST |
354 | |
355 | =item BLOCK | |
356 | ||
c7166200 CBW |
357 | A X<BLOCK construct, about>X<constructs, BLOCK>syntactic construct |
358 | consisting of a sequence of Perl B<statements> that is delimited by braces. | |
359 | The C<if> and C<while> statements are defined in terms of I<C<BLOCK>>s, for | |
360 | instance. Sometimes we also say “block” to mean a lexical scope; that is, a | |
361 | sequence of statements that acts like a I<C<BLOCK>>, such as within an | |
362 | C<eval> or a file, even though the statements aren’t delimited by braces. | |
97a1d740 YST |
363 | |
364 | =item block buffering | |
365 | ||
c7166200 CBW |
366 | A X<block buffering>X<buffering, block>method of making input and output |
367 | efficient by passing one B<block> at a time. By default, Perl does block | |
368 | buffering to disk files. See B<buffer> and B<command buffering>. | |
97a1d740 YST |
369 | |
370 | =item Boolean | |
371 | ||
c7166200 CBW |
372 | A X<Boolean values>X<values, Boolean>value that is either B<true> or |
373 | B<false>. | |
97a1d740 YST |
374 | |
375 | =item Boolean context | |
376 | ||
c7166200 CBW |
377 | A X<Boolean context, about>X<context, Boolean>special kind of B<scalar |
378 | context> used in conditionals to decide whether the B<scalar value> returned | |
379 | by an expression is B<true> or B<false>. Does not evaluate as either a | |
380 | string or a number. See B<context>. | |
97a1d740 YST |
381 | |
382 | =item breakpoint | |
383 | ||
c7166200 CBW |
384 | A X<breakpoints, defined>spot in your program where you’ve told the debugger |
385 | to stop B<execution> so you can poke around and see whether anything is | |
386 | wrong yet. | |
97a1d740 YST |
387 | |
388 | =item broadcast | |
389 | ||
c7166200 CBW |
390 | To X<broadcast (networking term)>send a B<datagram> to multiple destinations |
391 | simultaneously. | |
97a1d740 YST |
392 | |
393 | =item BSD | |
394 | ||
c7166200 CBW |
395 | A X<BSD (Berkeley Standard Distribution)>X<Berkeley Standard Distribution |
396 | (BSD)>psychoactive drug, popular in the ’80s, probably developed at UC | |
397 | Berkeley or thereabouts. Similar in many ways to the prescription-only | |
398 | medication called “System V”, but infinitely more useful. (Or, at least, | |
399 | more fun.) The full chemical name is “Berkeley Standard Distribution”. | |
97a1d740 YST |
400 | |
401 | =item bucket | |
402 | ||
c7166200 CBW |
403 | A X<buckets (term)>location in a B<hash table> containing (potentially) |
404 | multiple entries whose keys “hash” to the same hash value according to its | |
405 | hash function. (As internal policy, you don’t have to worry about it unless | |
406 | you’re into internals, or policy.) | |
97a1d740 YST |
407 | |
408 | =item buffer | |
409 | ||
c7166200 CBW |
410 | A X<buffers, defined>temporary holding location for data. Data that are |
411 | B<Block buffering> means that the data is passed on to its destination | |
412 | whenever the buffer is full. B<Line buffering> means that it’s passed on | |
413 | whenever a complete line is received. B<Command buffering> means that it’s | |
414 | passed every time you do a C<print> command (or equivalent). If your output | |
415 | is unbuffered, the system processes it one byte at a time without the use of | |
416 | a holding area. This can be rather inefficient. | |
97a1d740 YST |
417 | |
418 | =item built-in | |
419 | ||
c7166200 CBW |
420 | A B<X<built–in functions, about>function> that is predefined in the |
421 | language. Even when hidden by B<overriding>, you can always get at a built- | |
422 | in function by B<qualifying> its name with the C<CORE::> pseudopackage. | |
97a1d740 YST |
423 | |
424 | =item bundle | |
425 | ||
c7166200 CBW |
426 | A X<bundles (term)>group of related modules on B<CPAN>. (Also sometimes |
427 | refers to a group of command-line switches grouped into one B<switch | |
428 | cluster>.) | |
97a1d740 YST |
429 | |
430 | =item byte | |
431 | ||
c7166200 | 432 | A X<bytes (term)>piece of data worth eight B<bits> in most places. |
97a1d740 YST |
433 | |
434 | =item bytecode | |
435 | ||
c7166200 CBW |
436 | A pidgin-like lingo spoken among ’droids when they don’t wish to reveal |
437 | their orientation (see B<endian>). Named after some similar languages spoken | |
438 | (for similar reasons) between compilers and interpreters in the late 20ᵗʰ | |
439 | century. These languages are characterized by representing everything as a | |
440 | nonarchitecture-dependent sequence of bytes. | |
97a1d740 YST |
441 | |
442 | =back | |
443 | ||
5bbd0522 YST |
444 | =head2 C |
445 | ||
97a1d740 YST |
446 | =over 4 |
447 | ||
448 | =item C | |
449 | ||
c7166200 CBW |
450 | A X<C language, about>language beloved by many for its inside-out B<type> |
451 | definitions, inscrutable B<precedence> rules, and heavy B<overloading> of | |
452 | the function-call mechanism. (Well, actually, people first switched to C | |
453 | because they found lowercase identifiers easier to read than upper.) Perl is | |
454 | written in C, so it’s not surprising that Perl borrowed a few ideas from it. | |
97a1d740 | 455 | |
c7166200 | 456 | =item cache |
97a1d740 | 457 | |
c7166200 CBW |
458 | A X<cache (term)>data repository. Instead of computing expensive answers |
459 | several times, compute it once and save the result. | |
97a1d740 | 460 | |
c7166200 | 461 | =item callback |
97a1d740 | 462 | |
c7166200 CBW |
463 | A B<X<callbacks>handler> that you register with some other part of your |
464 | program in the hope that the other part of your program will B<trigger> your | |
465 | handler when some event of interest transpires. | |
97a1d740 | 466 | |
c7166200 | 467 | =item call by reference |
97a1d740 | 468 | |
c7166200 CBW |
469 | An B<argument>-passing X<call by reference>X<references, call by reference |
470 | mechanism>mechanism in which the B<formal arguments> refer directly to the | |
471 | B<actual arguments>, and the B<subroutine> can change the actual arguments | |
472 | by changing the formal arguments. That is, the formal argument is an | |
473 | B<alias> for the actual argument. See also B<call by value>. | |
97a1d740 | 474 | |
c7166200 | 475 | =item call by value |
97a1d740 | 476 | |
c7166200 CBW |
477 | An B<X<call by value>argument>-passing mechanism in which the B<formal |
478 | arguments> refer to a copy of the B<actual arguments>, and the | |
479 | B<subroutine> cannot change the actual arguments by changing the formal | |
480 | arguments. See also B<call by reference>. | |
97a1d740 YST |
481 | |
482 | =item canonical | |
483 | ||
c7166200 | 484 | Reduced X<canonical (term)>to a standard form to facilitate comparison. |
97a1d740 | 485 | |
c7166200 | 486 | =item capture variables |
c27a5cfe | 487 | |
c7166200 CBW |
488 | The X<capture variables>X<variables, capture>variables—such as C<$1> and |
489 | C<$2>, and C<%+> and C<%– >—that hold the text remembered in a pattern | |
490 | match. See Camel chapter 5, “Pattern Matching”. | |
c27a5cfe | 491 | |
97a1d740 YST |
492 | =item capturing |
493 | ||
c7166200 CBW |
494 | The X<capturing in pattern matching>X<subpatterns, capturing>X<pattern |
495 | matching, capturing in>use of parentheses around a B<subpattern> in a | |
496 | B<regular expression> to store the matched B<substring> as a | |
497 | B<backreference>. (Captured strings are also returned as a list in B<list | |
498 | context>.) See Camel chapter 5, “Pattern Matching”. | |
499 | ||
500 | =item cargo cult | |
501 | ||
502 | Copying X<cargo cult>and pasting code without understanding it, while | |
503 | superstitiously believing in its value. This term originated from | |
504 | preindustrial cultures dealing with the detritus of explorers and colonizers | |
505 | of technologically advanced cultures. See I<The Gods Must Be Crazy>. | |
506 | ||
507 | =item case | |
508 | ||
509 | A X<case (character)>X<characters, case considerations>property of certain | |
510 | characters. Originally, typesetter stored capital letters in the upper of | |
511 | two cases and small letters in the lower one. Unicode recognizes three | |
512 | cases: B<lowercase> (B<character property> C<\p{lower}>), B<titlecase> | |
513 | (C<\p{title}>), and B<uppercase> (C<\p{upper}>). A fourth casemapping called | |
514 | B<foldcase> is not itself a distinct case, but it is used internally to | |
515 | implement B<casefolding>. Not all letters have case, and some nonletters | |
516 | have case. | |
517 | ||
518 | =item casefolding | |
519 | ||
520 | Comparing X<casefolding>or matching a string case-insensitively. In Perl, it | |
521 | is implemented with the C</i> pattern modifier, the C<fc> function, and the | |
522 | C<\F> double-quote translation escape. | |
523 | ||
524 | =item casemapping | |
525 | ||
526 | The X<casemapping>process of converting a string to one of the four Unicode | |
527 | B<casemaps>; in Perl, it is implemented with the C<fc>, C<lc>, C<ucfirst>, | |
528 | and C<uc> functions. | |
97a1d740 YST |
529 | |
530 | =item character | |
531 | ||
c7166200 CBW |
532 | The X<characters, defined>smallest individual element of a string. Computers |
533 | store characters as integers, but Perl lets you operate on them as text. The | |
534 | integer used to represent a particular character is called that character’s | |
535 | B<codepoint>. | |
97a1d740 YST |
536 | |
537 | =item character class | |
538 | ||
c7166200 CBW |
539 | A X<character classes, about>X<classes, character>square-bracketed list of |
540 | characters used in a B<regular expression> to indicate that any character | |
541 | of the set may occur at a given point. Loosely, any predefined set of | |
542 | characters so used. | |
97a1d740 YST |
543 | |
544 | =item character property | |
545 | ||
c7166200 CBW |
546 | A X<character property>predefined B<character class> matchable by the C<\p> |
547 | or C<\P> B<metasymbol>. B<Unicode> defines hundreds of standard properties | |
548 | for every possible codepoint, and Perl defines a few of its own, too. | |
97a1d740 YST |
549 | |
550 | =item circumfix operator | |
551 | ||
c7166200 CBW |
552 | An X<circumfix operator>B<operator> that surrounds its B<operand>, like the |
553 | angle operator, or parentheses, or a hug. | |
97a1d740 YST |
554 | |
555 | =item class | |
556 | ||
c7166200 CBW |
557 | A X<classes, defined>user-defined B<type>, implemented in Perl via a |
558 | B<package> that provides (either directly or by inheritance) B<methods> | |
559 | (that is, B<subroutines>) to handle B<instances> of the class (its | |
560 | B<objects>). See also B<inheritance>. | |
97a1d740 YST |
561 | |
562 | =item class method | |
563 | ||
c7166200 CBW |
564 | A B<X<class methods>X<methods, class>method> whose B<invocant> is a |
565 | B<package> name, not an B<object> reference. A method associated with the | |
566 | class as a whole. Also see B<instance method>. | |
97a1d740 YST |
567 | |
568 | =item client | |
569 | ||
c7166200 CBW |
570 | In X<clients, defined>X<processes, client>networking, a B<process> that |
571 | initiates contact with a B<server> process in order to exchange data and | |
572 | perhaps receive a service. | |
97a1d740 YST |
573 | |
574 | =item closure | |
575 | ||
c7166200 CBW |
576 | An B<X<closure subroutines>X<subroutines, closure>anonymous> subroutine |
577 | that, when a reference to it is generated at runtime, keeps track of the | |
578 | identities of externally visible B<lexical variables>, even after those | |
579 | lexical variables have supposedly gone out of B<scope>. They’re called | |
580 | “closures” because this sort of behavior gives mathematicians a sense of | |
581 | closure. | |
97a1d740 YST |
582 | |
583 | =item cluster | |
584 | ||
c7166200 CBW |
585 | A X<clusters, defined>X<subpatterns, cluster>parenthesized B<subpattern> |
586 | used to group parts of a B<regular expression> into a single B<atom>. | |
97a1d740 YST |
587 | |
588 | =item CODE | |
589 | ||
c7166200 CBW |
590 | The X<CODE (ref function)>X<ref function, about>word returned by the C<ref> |
591 | function when you apply it to a reference to a subroutine. See also B<CV>. | |
97a1d740 YST |
592 | |
593 | =item code generator | |
594 | ||
c7166200 CBW |
595 | A X<code generators, defined>system that writes code for you in a low-level |
596 | language, such as code to implement the backend of a compiler. See B<program | |
97a1d740 YST |
597 | generator>. |
598 | ||
c7166200 | 599 | =item codepoint |
1ab74a36 | 600 | |
c7166200 CBW |
601 | The X<codepoints, about>integer a computer uses to represent a given |
602 | character. ASCII codepoints are in the range 0 to 127; Unicode codepoints | |
603 | are in the range 0 to 0x1F_FFFF; and Perl codepoints are in the range 0 to | |
604 | 2³²−1 or 0 to 2⁶⁴−1, depending on your native integer size. In Perl Culture, | |
605 | sometimes called B<ordinals>. | |
1ab74a36 | 606 | |
97a1d740 YST |
607 | =item code subpattern |
608 | ||
c7166200 CBW |
609 | A B<X<code subpatterns>X<subpatterns, code>regular expression> subpattern |
610 | whose real purpose is to execute some Perl code—for example, the C<(?{...})> | |
611 | and C<(??{...})> subpatterns. | |
97a1d740 YST |
612 | |
613 | =item collating sequence | |
614 | ||
c7166200 CBW |
615 | The X<collating sequence>X<collating sequence>order into which B<characters> |
616 | sort. This is used by B<string> comparison routines to decide, for example, | |
617 | where in this glossary to put “collating sequence”. | |
618 | ||
619 | =item co-maintainer | |
620 | ||
621 | A X<co–maintainers>person with permissions to index a B<namespace> in | |
622 | B<PAUSE>. Anyone can upload any namespace, but only primary and | |
623 | co-maintainers get their contributions indexed. | |
624 | ||
625 | =item combining character | |
626 | ||
627 | Any X<combining characters>X<characters, combining>character with the | |
628 | General Category of Combining Mark (C<\p{GC=M}>), which may be spacing or | |
629 | nonspacing. Some are even invisible. A sequence of combining characters | |
630 | following a grapheme base character together make up a single user-visible | |
631 | character called a B<grapheme>. Most but not all diacritics are combining | |
632 | characters, and vice versa. | |
97a1d740 YST |
633 | |
634 | =item command | |
635 | ||
c7166200 CBW |
636 | In B<shell> X<commands, defined>programming, the syntactic combination of a |
637 | program name and its arguments. More loosely, anything you type to a shell | |
638 | (a command interpreter) that starts it doing something. Even more loosely, a | |
639 | Perl B<statement>, which might start with a B<label> and typically ends with | |
640 | a semicolon. | |
97a1d740 YST |
641 | |
642 | =item command buffering | |
643 | ||
c7166200 CBW |
644 | A X<command buffering>X<buffering, command>mechanism in Perl that lets you |
645 | store up the output of each Perl B<command> and then flush it out as a | |
646 | single request to the B<operating system>. It’s enabled by setting the C<$|> | |
647 | (C<$AUTOFLUSH>) variable to a true value. It’s used when you don’t want data | |
648 | sitting around, not going where it’s supposed to, which may happen because | |
649 | the default on a B<file> or B<pipe> is to use B<block buffering>. | |
97a1d740 | 650 | |
c7166200 | 651 | =item command-line arguments |
97a1d740 | 652 | |
c7166200 CBW |
653 | The X<command–line arguments>B<X<arguments, command–line>values> you supply |
654 | along with a program name when you tell a B<shell> to execute a B<command>. | |
655 | These values are passed to a Perl program through C<@ARGV>. | |
97a1d740 | 656 | |
c7166200 | 657 | =item command name |
97a1d740 | 658 | |
c7166200 CBW |
659 | The X<command names>name of the program currently executing, as typed on the |
660 | command line. In C, the B<command> name is passed to the program as the | |
661 | first command-line argument. In Perl, it comes in separately as C<$0>. | |
97a1d740 YST |
662 | |
663 | =item comment | |
664 | ||
c7166200 CBW |
665 | A X<comments, defined>remark that doesn’t affect the meaning of the program. |
666 | In Perl, a comment is introduced by a C<#> character and continues to the | |
667 | end of the line. | |
97a1d740 YST |
668 | |
669 | =item compilation unit | |
670 | ||
c7166200 CBW |
671 | The X<compilation units>B<file> (or B<string>, in the case of C<eval>) that |
672 | is currently being B<compiled>. | |
97a1d740 | 673 | |
c7166200 | 674 | =item compile |
97a1d740 | 675 | |
c7166200 CBW |
676 | The process of turning source code into a machine-usable form. See B<compile |
677 | phase>. | |
97a1d740 | 678 | |
c7166200 | 679 | =item compile phase |
97a1d740 | 680 | |
c7166200 CBW |
681 | Any X<compile phase, defined>time before Perl starts running your main |
682 | program. See also B<run phase>. Compile phase is mostly spent in B<compile | |
683 | time>, but may also be spent in B<runtime> when C<BEGIN> blocks, C<use> or | |
684 | C<no> declarations, or constant subexpressions are being evaluated. The | |
685 | startup and import code of any C<use> declaration is also run during | |
686 | compile phase. | |
97a1d740 YST |
687 | |
688 | =item compiler | |
689 | ||
c7166200 CBW |
690 | Strictly X<compilers and compiling, about>speaking, a program that munches |
691 | up another program and spits out yet another file containing the program in | |
692 | a “more executable” form, typically containing native machine instructions. | |
693 | The I<perl> program is not a compiler by this definition, but it does | |
694 | contain a kind of compiler that takes a program and turns it into a more | |
695 | executable form (B<syntax trees>) within the I<perl> process itself, which | |
696 | the B<interpreter> then interprets. There are, however, extension B<modules> | |
697 | to get Perl to act more like a “real” compiler. See Camel chapter 16, | |
698 | “Compiling”. | |
699 | ||
700 | =item compile time | |
701 | ||
702 | The X<compile time, defined>time when Perl is trying to make sense of your | |
703 | code, as opposed to when it thinks it knows what your code means and is | |
704 | merely trying to do what it thinks your code says to do, which is B<runtime>. | |
97a1d740 YST |
705 | |
706 | =item composer | |
707 | ||
c7166200 CBW |
708 | A “constructor” X<composers, about>for a B<referent> that isn’t really an |
709 | B<object>, like an anonymous array or a hash (or a sonata, for that matter). | |
710 | For example, a pair of braces acts as a composer for a hash, and a pair of | |
711 | brackets acts as a composer for an array. See the section “Creating | |
712 | References” in Camel chapter 8, “References”. | |
97a1d740 YST |
713 | |
714 | =item concatenation | |
715 | ||
c7166200 CBW |
716 | The X<concatenating strings>X<strings, concatenating>process of gluing one |
717 | cat’s nose to another cat’s tail. Also a similar operation on two | |
718 | B<strings>. | |
97a1d740 YST |
719 | |
720 | =item conditional | |
721 | ||
c7166200 | 722 | SomethingX<conditional (term)> “iffy”. See B<Boolean context>. |
97a1d740 YST |
723 | |
724 | =item connection | |
725 | ||
c7166200 CBW |
726 | In X<connections (term)>telephony, the temporary electrical circuit between |
727 | the caller’s and the callee’s phone. In networking, the same kind of | |
728 | temporary circuit between a B<client> and a B<server>. | |
97a1d740 YST |
729 | |
730 | =item construct | |
731 | ||
c7166200 CBW |
732 | As a X<constructs, defined>noun, a piece of syntax made up of smaller |
733 | pieces. As a transitive verb, to create an B<object> using a B<constructor>. | |
97a1d740 YST |
734 | |
735 | =item constructor | |
736 | ||
c7166200 CBW |
737 | AnyX<constructors, defined> B<class method>, B<instance>, or B<subroutine> |
738 | that composes, initializes, blesses, and returns an B<object>. Sometimes we | |
739 | use the term loosely to mean a B<composer>. | |
97a1d740 YST |
740 | |
741 | =item context | |
742 | ||
c7166200 CBW |
743 | The X<context, about>surroundings or environment. The context given by the |
744 | surrounding code determines what kind of data a particular B<expression> is | |
745 | expected to return. The three primary contexts are B<list context>, | |
746 | B<scalar>, and B<void context>. Scalar context is sometimes subdivided into | |
747 | B<Boolean context>, B<numeric context>, B<string context>, and B<void | |
748 | context>. There’s also a “don’t care” context (which is dealt with in Camel | |
749 | chapter 2, “Bits and Pieces”, if you care). | |
97a1d740 YST |
750 | |
751 | =item continuation | |
752 | ||
c7166200 CBW |
753 | The X<continuation lines>treatment of more than one physical B<line> as a |
754 | single logical line. B<Makefile> lines are continued by putting a backslash | |
755 | before the B<newline>. Mail headers, as defined by X<RFC 822>RFC 822, are | |
756 | continued by putting a space or tab I<after> the newline. In general, lines | |
757 | in Perl do not need any form of continuation mark, because B<whitespace> | |
758 | (including newlines) is gleefully ignored. Usually. | |
97a1d740 YST |
759 | |
760 | =item core dump | |
761 | ||
c7166200 CBW |
762 | The X<core dump>corpse of a B<process>, in the form of a file left in the |
763 | B<working directory> of the process, usually as a result of certain kinds | |
764 | of fatal errors. | |
97a1d740 YST |
765 | |
766 | =item CPAN | |
767 | ||
c7166200 CBW |
768 | The X<Comprehensive Perl Archive Network>X<CPAN (Comprehensive Perl Archive |
769 | Network), about>Comprehensive Perl Archive Network. (See the Camel Preface | |
770 | and Camel chapter 19, “CPAN” for details.) | |
771 | ||
772 | =item C preprocessor | |
773 | ||
774 | The X<C preprocessor>typical C compiler’s first pass, which processes lines | |
775 | beginning with C<#> for conditional compilation and macro definition, and | |
776 | does various manipulations of the program text based on the current | |
777 | definitions. Also known as I<cpp>(1). | |
97a1d740 YST |
778 | |
779 | =item cracker | |
780 | ||
c7166200 CBW |
781 | Someone X<crackers>who breaks security on computer systems. A cracker may |
782 | be a true B<hacker> or only a B<script kiddie>. | |
97a1d740 | 783 | |
c7166200 | 784 | =item currently selected output channel |
97a1d740 | 785 | |
c7166200 CBW |
786 | The X<currently selected output channel>last B<filehandle> that was |
787 | designated with C<select(FILEHANDLE)>; C<STDOUT>, if no filehandle has | |
788 | been selected. | |
97a1d740 | 789 | |
c7166200 | 790 | =item current package |
97a1d740 | 791 | |
c7166200 CBW |
792 | The B<package> X<current package>in which the current statement is |
793 | B<compiled>. Scan backward in the text of your program through the current | |
794 | B<lexical scope> or any enclosing lexical scopes until you find a package | |
795 | declaration. That’s your current package name. | |
97a1d740 | 796 | |
c7166200 | 797 | =item current working directory |
97a1d740 | 798 | |
c7166200 | 799 | SeeX<current working directory> B<working directory>. |
97a1d740 YST |
800 | |
801 | =item CV | |
802 | ||
c7166200 CBW |
803 | In academia, a curriculum vitæ, a fancy kind of résumé. In Perl, an X<CV |
804 | (code value)>X<code value (CV)>internal “code value” typedef holding a | |
805 | B<subroutine>. The C<CV> type is a subclass of B<SV>. | |
97a1d740 YST |
806 | |
807 | =back | |
808 | ||
5bbd0522 YST |
809 | =head2 D |
810 | ||
97a1d740 YST |
811 | =over 4 |
812 | ||
813 | =item dangling statement | |
814 | ||
c7166200 CBW |
815 | A bare, single B<X<dangling statements>X<statements, dangling>statement>, |
816 | without any braces, hanging off an C<if> or C<while> conditional. C allows | |
817 | them. Perl doesn’t. | |
97a1d740 | 818 | |
c7166200 | 819 | =item datagram |
97a1d740 | 820 | |
c7166200 CBW |
821 | A packet of X<datagrams, defined>data, such as a B<UDP> message, that (from |
822 | the viewpoint of the programs involved) can be sent independently over the | |
823 | network. (In fact, all packets are sent independently at the B<IP> level, | |
824 | but B<stream> protocols such as B<TCP> hide this from your program.) | |
97a1d740 | 825 | |
c7166200 | 826 | =item data structure |
97a1d740 | 827 | |
c7166200 CBW |
828 | How your X<data structures, defined>various pieces of data relate to each |
829 | other and what shape they make when you put them all together, as in a | |
830 | rectangular table or a triangular tree. | |
97a1d740 | 831 | |
c7166200 | 832 | =item data type |
97a1d740 | 833 | |
c7166200 CBW |
834 | A set of X<data types, defined>possible values, together with all the |
835 | operations that know how to deal with those values. For example, a numeric | |
836 | data type has a certain set of numbers that you can work with, as well as | |
837 | various mathematical operations that you can do on the numbers, but would | |
838 | make little sense on, say, a string such as C<"Kilroy">. Strings have their | |
839 | own operations, such as B<concatenation>. Compound types made of a number of | |
840 | smaller pieces generally have operations to compose and decompose them, and | |
841 | perhaps to rearrange them. B<Objects> that model things in the real world | |
842 | often have operations that correspond to real activities. For instance, if | |
843 | you model an elevator, your elevator object might have an C<open_door> | |
844 | B<method>. | |
97a1d740 YST |
845 | |
846 | =item DBM | |
847 | ||
c7166200 CBW |
848 | Stands for X<DBM (Database Management) routines>X<Database Management (DBM) |
849 | routines>“Database Management” routines, a set of routines that emulate an | |
850 | B<associative array> using disk files. The routines use a dynamic hashing | |
851 | scheme to locate any entry with only two disk accesses. DBM files allow a | |
852 | Perl program to keep a persistent B<hash> across multiple invocations. You | |
853 | can C<tie> your hash variables to various DBM implementations. | |
97a1d740 YST |
854 | |
855 | =item declaration | |
856 | ||
c7166200 CBW |
857 | An B<assertion> X<declarations, defined>that states something exists and |
858 | perhaps describes what it’s like, without giving any commitment as to how | |
859 | or where you’ll use it. A declaration is like the part of your recipe that | |
860 | says, “two cups flour, one large egg, four or five tadpoles…” See | |
861 | B<statement> for its opposite. Note that some declarations also function | |
862 | as statements. Subroutine declarations also act as definitions if a body | |
863 | is supplied. | |
864 | ||
865 | =item declarator | |
866 | ||
867 | Something X<declarators>that tells your program what sort of variable | |
868 | you’d like. Perl doesn’t require you to declare variables, but you can use | |
869 | C<my>, C<our>, or C<state> to denote that you want something other than | |
870 | the default. | |
97a1d740 YST |
871 | |
872 | =item decrement | |
873 | ||
c7166200 CBW |
874 | To X<decrementing values>X<values, decrementing>subtract a value from a |
875 | variable, as in “decrement C<$x>” (meaning to remove 1 from its value) or | |
876 | “decrement C<$x> by 3”. | |
97a1d740 YST |
877 | |
878 | =item default | |
879 | ||
c7166200 CBW |
880 | A B<value> X<default values>X<values, default>chosen for you if you don’t |
881 | supply a value of your own. | |
97a1d740 YST |
882 | |
883 | =item defined | |
884 | ||
c7166200 CBW |
885 | Having a X<defined (term)>meaning. Perl thinks that some of the things |
886 | people try to do are devoid of meaning; in particular, making use of | |
887 | variables that have never been given a B<value> and performing certain | |
888 | operations on data that isn’t there. For example, if you try to read data | |
889 | past the end of a file, Perl will hand you back an undefined value. See also | |
890 | B<false> and the C<defined> entry in Camel chapter 27, “Functions”. | |
97a1d740 YST |
891 | |
892 | =item delimiter | |
893 | ||
c7166200 CBW |
894 | A B<character> X<delimiters (term)>or B<string> that sets bounds to an |
895 | arbitrarily sized textual object, not to be confused with a B<separator> or | |
896 | B<terminator>. “To delimit” really just means “to surround” or “to enclose” | |
897 | (like these parentheses are doing). | |
2dd6f5a3 | 898 | |
97a1d740 YST |
899 | =item dereference |
900 | ||
c7166200 CBW |
901 | A fancy X<dereference (term)>X<references, dereference>computer science term |
902 | meaning “to follow a B<reference> to what it points to”. The “de” part of it | |
903 | refers to the fact that you’re taking away one level of B<indirection>. | |
97a1d740 YST |
904 | |
905 | =item derived class | |
906 | ||
c7166200 CBW |
907 | A B<class> that X<derived classes>X<classes, derived>X<subclasses>X<classes, |
908 | subclasses>defines some of its B<methods> in terms of a more generic class, | |
909 | called a B<base class>. Note that classes aren’t classified exclusively into | |
910 | base classes or derived classes: a class can function as both a derived | |
911 | class and a base class simultaneously, which is kind of classy. | |
97a1d740 YST |
912 | |
913 | =item descriptor | |
914 | ||
c7166200 | 915 | See B<file descriptor>. |
97a1d740 YST |
916 | |
917 | =item destroy | |
918 | ||
c7166200 CBW |
919 | To deallocate the X<destroy (term)>memory of a B<referent> (first triggering |
920 | its C<DESTROY> method, if it has one). | |
97a1d740 YST |
921 | |
922 | =item destructor | |
923 | ||
c7166200 CBW |
924 | A special B<method> X<destructor method>X<methods, destructor>that is called |
925 | when an B<object> is thinking about B<destroying> itself. A Perl program’s | |
926 | C<DESTROY> method doesn’t do the actual destruction; Perl just B<triggers> | |
927 | the method in case the B<class> wants to do any associated cleanup. | |
97a1d740 YST |
928 | |
929 | =item device | |
930 | ||
c7166200 CBW |
931 | A whiz-bang X<devices (term)>hardware gizmo (like a disk or tape drive or a |
932 | modem or a joystick or a mouse) attached to your computer, which the | |
933 | B<operating system> tries to make look like a B<file> (or a bunch of files). | |
97a1d740 YST |
934 | Under Unix, these fake files tend to live in the I</dev> directory. |
935 | ||
936 | =item directive | |
937 | ||
c7166200 CBW |
938 | A B<pod> X<directives, defined>directive. See Camel chapter 23, “Plain Old |
939 | Documentation”. | |
97a1d740 YST |
940 | |
941 | =item directory | |
942 | ||
c7166200 CBW |
943 | A special X<directories, defined>file that contains other files. Some |
944 | B<operating systems> call these “folders”, “drawers”, “catalogues”, or | |
945 | “catalogs”. | |
97a1d740 YST |
946 | |
947 | =item directory handle | |
948 | ||
c7166200 CBW |
949 | A name X<directory handle>that represents a particular instance of opening a |
950 | directory to read it, until you close it. See the C<opendir> function. | |
951 | ||
952 | =item discipline | |
953 | ||
954 | Some X<discipline (I/O layer)>people need this and some people avoid it. | |
955 | For Perl, it’s an old way to say B<I/O layer>. | |
97a1d740 YST |
956 | |
957 | =item dispatch | |
958 | ||
c7166200 | 959 | To send X<dispatching>something to its correct destination. Often used |
97a1d740 | 960 | metaphorically to indicate a transfer of programmatic control to a |
c7166200 CBW |
961 | destination selected algorithmically, often by lookup in a table of function |
962 | B<references> or, in the case of object B<methods>, by traversing the | |
963 | inheritance tree looking for the most specific definition for the method. | |
97a1d740 YST |
964 | |
965 | =item distribution | |
966 | ||
c7166200 CBW |
967 | A standard, X<distributions, defined>bundled release of a system of |
968 | software. The default usage implies source code is included. If that is not | |
969 | the case, it will be called a “binary-only” distribution. | |
97a1d740 | 970 | |
c7166200 | 971 | =item dual-lived |
2dd6f5a3 | 972 | |
c7166200 CBW |
973 | Some X<dual–lived modules>X<modules, dual–lived>modules live both in the |
974 | B<Standard Library> and on B<CPAN>. These modules might be developed on two | |
975 | tracks as people modify either version. The trend currently is to untangle | |
976 | these situations. | |
2dd6f5a3 | 977 | |
97a1d740 YST |
978 | =item dweomer |
979 | ||
c7166200 CBW |
980 | An enchantment, illusion, X<dweomer>phantasm, or jugglery. Said when Perl’s |
981 | magical B<dwimmer> effects don’t do what you expect, but rather seem to be | |
982 | the product of arcane I<dweomercraft>, sorcery, or wonder working. [From | |
983 | Middle English.] | |
97a1d740 YST |
984 | |
985 | =item dwimmer | |
986 | ||
c7166200 CBW |
987 | DWIM X<DWIM (Do What I Mean) principle>X<Do What I Mean (DWIM) principle>is |
988 | an acronym for X<dwimming>“Do What I Mean”, the principle that something | |
989 | should just do what you want it to do without an undue amount of fuss. A bit | |
990 | of code that does “dwimming” is a “dwimmer”. Dwimming can require a great | |
991 | deal of behind-the-scenes magic, which (if it doesn’t stay properly behind | |
992 | the scenes) is called a B<dweomer> instead. | |
97a1d740 YST |
993 | |
994 | =item dynamic scoping | |
995 | ||
c7166200 CBW |
996 | Dynamic X<dynamic scope>X<scopes, dynamic>scoping works over a B<dynamic |
997 | scope>, making variables visible throughout the rest of the B<block> in | |
998 | which they are first used and in any B<subroutines> that are called by the | |
999 | rest of the block. Dynamically scoped variables can have their values | |
1000 | temporarily changed (and implicitly restored later) by a C<local> operator. | |
1001 | (Compare B<lexical scoping>.) Used more loosely to mean how a subroutine | |
1002 | that is in the middle of calling another subroutine “contains” that | |
1003 | subroutine at B<runtime>. | |
97a1d740 YST |
1004 | |
1005 | =back | |
1006 | ||
5bbd0522 YST |
1007 | =head2 E |
1008 | ||
97a1d740 YST |
1009 | =over 4 |
1010 | ||
1011 | =item eclectic | |
1012 | ||
c7166200 | 1013 | Derived X<eclectic (term)>from many sources. Some would say I<too> many. |
97a1d740 YST |
1014 | |
1015 | =item element | |
1016 | ||
c7166200 CBW |
1017 | A basic X<elements, about>building block. When you’re talking about an |
1018 | B<array>, it’s one of the items that make up the array. | |
97a1d740 YST |
1019 | |
1020 | =item embedding | |
1021 | ||
c7166200 CBW |
1022 | When X<embedding (term)>something is contained in something else, |
1023 | particularly when that might be considered surprising: “I’ve embedded a | |
1024 | complete Perl interpreter in my editor!” | |
3097ec40 | 1025 | |
97a1d740 YST |
1026 | =item empty subclass test |
1027 | ||
c7166200 CBW |
1028 | The notion X<empty subclass test>that an empty B<derived class> should |
1029 | behave exactly like its B<base class>. | |
97a1d740 YST |
1030 | |
1031 | =item encapsulation | |
1032 | ||
c7166200 CBW |
1033 | The veil of X<encapsulation (term)>abstraction separating the B<interface> |
1034 | from the B<implementation> (whether enforced or not), which mandates that | |
1035 | all access to an B<object>’s state be through B<methods> alone. | |
97a1d740 YST |
1036 | |
1037 | =item endian | |
1038 | ||
c7166200 CBW |
1039 | See B<little-endian> and B<big-endian>. |
1040 | ||
1041 | =item en passant | |
1042 | ||
1043 | When you X<en passant (term)>change a B<value> as it is being copied. [From | |
1044 | French “in passing”, as in the exotic pawn-capturing maneuver in chess.] | |
97a1d740 YST |
1045 | |
1046 | =item environment | |
1047 | ||
c7166200 CBW |
1048 | The collectiveX<environment (term)> set of B<environment variables> your |
1049 | B<process> inherits from its parent. Accessed via C<%ENV>. | |
97a1d740 YST |
1050 | |
1051 | =item environment variable | |
1052 | ||
c7166200 CBW |
1053 | A mechanism X<environment variables>X<variables, environment>X<environment |
1054 | variables>by which some high-level agent such as a user can pass its | |
1055 | preferences down to its future offspring (child B<processes>, grandchild | |
1056 | processes, great-grandchild processes, and so on). Each environment | |
1057 | variable is a B<key>/B<value> pair, like one entry in a B<hash>. | |
97a1d740 YST |
1058 | |
1059 | =item EOF | |
1060 | ||
c7166200 CBW |
1061 | End of File. X<End of File (EOF)>X<EOF (End of File)>Sometimes used |
1062 | metaphorically as the terminating string of a B<here document>. | |
97a1d740 YST |
1063 | |
1064 | =item errno | |
1065 | ||
c7166200 CBW |
1066 | The X<errno (error number)>X<error number (errno)>error number returned by a |
1067 | B<syscall> when it fails. Perl refers to the error by the name C<$!> (or | |
1068 | C<$OS_ERROR> if you use the English module). | |
97a1d740 YST |
1069 | |
1070 | =item error | |
1071 | ||
c7166200 | 1072 | See B<exception> or B<fatal error>. |
97a1d740 YST |
1073 | |
1074 | =item escape sequence | |
1075 | ||
c7166200 | 1076 | See B<metasymbol>. |
97a1d740 YST |
1077 | |
1078 | =item exception | |
1079 | ||
c7166200 | 1080 | A fancy term for an error. See B<fatal error>. |
97a1d740 YST |
1081 | |
1082 | =item exception handling | |
1083 | ||
c7166200 CBW |
1084 | The X<exception handling, defined>way a program responds to an error. The |
1085 | exception-handling mechanism in Perl is the C<eval> operator. | |
97a1d740 YST |
1086 | |
1087 | =item exec | |
1088 | ||
c7166200 CBW |
1089 | To X<exec function>throw away the current B<process>’s program and replace |
1090 | it with another, without exiting the process or relinquishing any resources | |
97a1d740 YST |
1091 | held (apart from the old memory image). |
1092 | ||
1093 | =item executable file | |
1094 | ||
c7166200 CBW |
1095 | A B<file> X<executable files>X<files, executable>that is specially marked to |
1096 | tell the B<operating system> that it’s okay to run this file as a program. | |
1097 | Usually shortened to “executable”. | |
97a1d740 YST |
1098 | |
1099 | =item execute | |
1100 | ||
c7166200 CBW |
1101 | To run X<execute (term)>a B<program> or B<subroutine>. (Has nothing to do |
1102 | with the C<kill> built-in, unless you’re trying to run a B<signal handler>.) | |
97a1d740 YST |
1103 | |
1104 | =item execute bit | |
1105 | ||
c7166200 CBW |
1106 | The X<execute bit>special mark that tells the operating system it can run |
1107 | this program. There are actually three execute bits under Unix, and which | |
1108 | bit gets used depends on whether you own the file singularly, collectively, | |
1109 | or not at all. | |
97a1d740 YST |
1110 | |
1111 | =item exit status | |
1112 | ||
c7166200 CBW |
1113 | See B<status>. |
1114 | ||
1115 | =item exploit | |
1116 | ||
1117 | Used X<exploits, security>as a noun in this case, this refers to a known way | |
1118 | to compromise a program to get it to do something the author didn’t intend. | |
1119 | Your task is to write unexploitable programs. | |
97a1d740 YST |
1120 | |
1121 | =item export | |
1122 | ||
c7166200 CBW |
1123 | To make X<exporting, defined>symbols from a B<module> available for |
1124 | B<import> by other modules. | |
97a1d740 YST |
1125 | |
1126 | =item expression | |
1127 | ||
c7166200 CBW |
1128 | Anything X<expressions, defined>X<expressions>you can legally say in a spot |
1129 | where a B<value> is required. Typically composed of B<literals>, | |
1130 | B<variables>, B<operators>, B<functions>, and B<subroutine> calls, not | |
1131 | necessarily in that order. | |
97a1d740 YST |
1132 | |
1133 | =item extension | |
1134 | ||
c7166200 CBW |
1135 | A Perl module X<extensions, defined>that also pulls in B<compiled> C or C++ |
1136 | code. More generally, any experimental option that can be B<compiled> into | |
1137 | Perl, such as multithreading. | |
97a1d740 YST |
1138 | |
1139 | =back | |
1140 | ||
5bbd0522 YST |
1141 | =head2 F |
1142 | ||
97a1d740 YST |
1143 | =over 4 |
1144 | ||
1145 | =item false | |
1146 | ||
c7166200 CBW |
1147 | In Perl, any value X<false values>X<values, false>that would look like C<""> |
1148 | or C<"0"> if evaluated in a string context. Since undefined values evaluate | |
1149 | to C<"">, all undefined values are false, but not all false values are | |
1150 | undefined. | |
97a1d740 YST |
1151 | |
1152 | =item FAQ | |
1153 | ||
c7166200 CBW |
1154 | Frequently Asked QuestionX<FAQ (Frequently Asked |
1155 | Question)>X<Frequently Asked Question (FAQ)> (although not necessarily | |
1156 | frequently answered, especially if the answer appears in the Perl FAQ | |
1157 | shipped standard with Perl). | |
97a1d740 YST |
1158 | |
1159 | =item fatal error | |
1160 | ||
c7166200 CBW |
1161 | An uncaught B<exception>, X<fatal errors>which causes termination of the |
1162 | B<process> after printing a message on your B<standard error> stream. Errors | |
1163 | that happen inside an C<eval> are not fatal. Instead, the C<eval> terminates | |
1164 | after placing the exception message in the C<$@> (C<$EVAL_ERROR>) variable. | |
1165 | You can try to provoke a fatal error with the C<die> operator (known as | |
1166 | throwing or raising an exception), but this may be caught by a dynamically | |
1167 | enclosing C<eval>. If not caught, the C<die> becomes a fatal error. | |
1168 | ||
1169 | =item feeping creaturism | |
1170 | ||
1171 | A spoonerism X<feeping creaturism>X<creeping featurism>of “creeping | |
1172 | featurism”, noting the biological urge to add just one more feature to | |
1173 | a program. | |
97a1d740 YST |
1174 | |
1175 | =item field | |
1176 | ||
c7166200 CBW |
1177 | A single X<fields (term)>piece of numeric or string data that is part of a |
1178 | longer B<string>, B<record>, or B<line>. Variable-width fields are usually | |
1179 | split up by B<separators> (so use C<split> to extract the fields), while | |
1180 | fixed-width fields are usually at fixed positions (so use C<unpack>). | |
1181 | B<Instance variables> are also known as “fields”. | |
97a1d740 YST |
1182 | |
1183 | =item FIFO | |
1184 | ||
c7166200 CBW |
1185 | First In, First Out.X<First In, First Out (FIFO)>X<FIFO (First In, First |
1186 | Out)> See also B<LIFO>. Also a nickname for a B<named pipe>. | |
97a1d740 YST |
1187 | |
1188 | =item file | |
1189 | ||
c7166200 CBW |
1190 | A named X<files, defined>collection of data, usually stored on disk in a |
1191 | B<directory> in a B<filesystem>. Roughly like a document, if you’re into | |
1192 | office metaphors. In modern filesystems, you can actually give a file more | |
1193 | than one name. Some files have special properties, like directories and | |
1194 | devices. | |
97a1d740 YST |
1195 | |
1196 | =item file descriptor | |
1197 | ||
c7166200 CBW |
1198 | The little X<file descriptors>X<descriptors, file>number the B<operating |
1199 | system> uses to keep track of which opened B<file> you’re talking about. | |
1200 | Perl hides the file descriptor inside a B<standard I/O> stream and then | |
1201 | attaches the stream to a B<filehandle>. | |
97a1d740 YST |
1202 | |
1203 | =item fileglob | |
1204 | ||
c7166200 | 1205 | A “wildcard” X<fileglobs>match on B<filenames>. See the C<glob> function. |
97a1d740 YST |
1206 | |
1207 | =item filehandle | |
1208 | ||
c7166200 CBW |
1209 | An identifier X<filehandles, about>(not necessarily related to the real |
1210 | name of a file) that represents a particular instance of opening a file, | |
1211 | until you close it. If you’re going to open and close several different | |
1212 | files in succession, it’s fine to open each of them with the same | |
1213 | filehandle, so you don’t have to write out separate code to process each | |
1214 | file. | |
97a1d740 YST |
1215 | |
1216 | =item filename | |
1217 | ||
c7166200 CBW |
1218 | One name for a X<filenames, about>file. This name is listed in a |
1219 | B<directory>. You can use it in an C<open> to tell the B<operating system> | |
1220 | exactly which file you want to open, and associate the file with a | |
1221 | B<filehandle>, which will carry the subsequent identity of that file in | |
1222 | your program, until you close it. | |
97a1d740 YST |
1223 | |
1224 | =item filesystem | |
1225 | ||
c7166200 CBW |
1226 | A set X<filesystems, defined>of B<directories> and B<files> residing on a |
1227 | partition of the disk. Sometimes known as a “partition”. You can change the | |
1228 | file’s name or even move a file around from directory to directory within a | |
1229 | filesystem without actually moving the file itself, at least under Unix. | |
1230 | ||
1231 | =item file test operator | |
1232 | ||
1233 | A built-in X<file test operators, about>unary operator that you use to | |
1234 | determine whether something is B<true> about a file, such as C<–o | |
1235 | $filename> to test whether you’re the owner of the file. | |
97a1d740 YST |
1236 | |
1237 | =item filter | |
1238 | ||
c7166200 CBW |
1239 | A X<filters, defined>program designed to take a B<stream> of input and |
1240 | transform it into a stream of output. | |
1241 | ||
1242 | =item first-come | |
1243 | ||
1244 | The X<first–come permissions>X<permissions, first–come>first B<PAUSE> | |
1245 | author to upload a B<namespace> automatically becomes the B<primary | |
1246 | maintainer> for that namespace. The “first come” permissions distinguish a | |
1247 | B<primary maintainer> who was assigned that role from one who received it | |
1248 | automatically. | |
97a1d740 YST |
1249 | |
1250 | =item flag | |
1251 | ||
c7166200 CBW |
1252 | We X<flags (term)>tend to avoid this term because it means so many things. |
1253 | It may mean a command-line B<switch> that takes no argument itself (such as | |
1254 | Perl’s C<–n> and C<–p> flags) or, less frequently, a single-bit indicator | |
1255 | (such as the C<O_CREAT> and C<O_EXCL> flags used in C<sysopen>). Sometimes | |
1256 | informally used to refer to certain regex modifiers. | |
97a1d740 YST |
1257 | |
1258 | =item floating point | |
1259 | ||
c7166200 CBW |
1260 | A X<floating point methods>X<methods, floating point>method of storing |
1261 | numbers in “scientific notation”, such that the precision of the number is | |
1262 | independent of its magnitude (the decimal point “floats”). Perl does its | |
1263 | numeric work with floating-point numbers (sometimes called “floats”) when | |
1264 | it can’t get away with using B<integers>. Floating-point numbers are mere | |
97a1d740 YST |
1265 | approximations of real numbers. |
1266 | ||
1267 | =item flush | |
1268 | ||
c7166200 CBW |
1269 | The act of X<flushing buffers>X<buffers, flushing>emptying a B<buffer>, |
1270 | often before it’s full. | |
97a1d740 YST |
1271 | |
1272 | =item FMTEYEWTK | |
1273 | ||
c7166200 CBW |
1274 | Far More Than Everything You Ever Wanted To KnowX<FMTEYEWTK acronym>. An |
1275 | exhaustive treatise on one narrow topic, something of a super-B<FAQ>. See | |
1276 | Tom for far more. | |
1277 | ||
1278 | =item foldcase | |
1279 | ||
1280 | The casemap X<foldcase (term)>used in Unicode when comparing or matching | |
1281 | without regard to case. Comparing lower-, title-, or uppercase are all | |
1282 | unreliable due to Unicode’s complex, one-to-many case mappings. Foldcase is | |
1283 | a B<lowercase> variant (using a partially decomposed B<normalization> form | |
1284 | for certain codepoints) created specifically to resolve this. | |
97a1d740 YST |
1285 | |
1286 | =item fork | |
1287 | ||
c7166200 CBW |
1288 | To create a X<forking processes>X<processes, forking>child B<process> |
1289 | identical to the parent process at its moment of conception, at least until | |
1290 | it gets ideas of its own. A thread with protected memory. | |
97a1d740 YST |
1291 | |
1292 | =item formal arguments | |
1293 | ||
c7166200 CBW |
1294 | The X<formal arguments>X<arguments, formal>generic names by which a |
1295 | B<subroutine> knows its B<arguments>. In many languages, formal arguments | |
1296 | are always given individual names; in Perl, the formal arguments are just | |
1297 | the elements of an array. The formal arguments to a Perl program are | |
1298 | C<$ARGV[0]>, C<$ARGV[1]>, and so on. Similarly, the formal arguments to a | |
1299 | Perl subroutine are C<$_[0]>, C<$_[1]>, and so on. You may give the | |
1300 | arguments individual names by assigning the values to a C<my> list. See | |
1301 | also B<actual arguments>. | |
97a1d740 YST |
1302 | |
1303 | =item format | |
1304 | ||
c7166200 CBW |
1305 | A X<formats, defined>specification of how many spaces and digits and things |
1306 | to put somewhere so that whatever you’re printing comes out nice and | |
1307 | pretty. | |
97a1d740 YST |
1308 | |
1309 | =item freely available | |
1310 | ||
c7166200 CBW |
1311 | Means X<freely available (term)>you don’t have to pay money to get it, but |
1312 | the copyright on it may still belong to someone else (like Larry). | |
97a1d740 YST |
1313 | |
1314 | =item freely redistributable | |
1315 | ||
c7166200 CBW |
1316 | Means X<freely redistributable (term)>you’re not in legal trouble if you |
1317 | give a bootleg copy of it to your friends and we find out about it. In | |
1318 | fact, we’d rather you gave a copy to all your friends. | |
97a1d740 YST |
1319 | |
1320 | =item freeware | |
1321 | ||
c7166200 CBW |
1322 | Historically, X<freeware (term)>any software that you give away, |
1323 | particularly if you make the source code available as well. Now often | |
1324 | called B<open source software>. Recently there has been a trend to use the | |
1325 | term in contradistinction to B<open source software>, to refer only to free | |
1326 | software released under the X<Free Software Foundation>Free Software | |
1327 | Foundation’s GPL (General Public License), but this is difficult to justify | |
1328 | etymologically. | |
97a1d740 YST |
1329 | |
1330 | =item function | |
1331 | ||
c7166200 CBW |
1332 | Mathematically, X<functions, about>a mapping of each of a set of input |
1333 | values to a particular output value. In computers, refers to a | |
1334 | B<subroutine> or B<operator> that returns a B<value>. It may or may not | |
1335 | have input values (called B<arguments>). | |
97a1d740 YST |
1336 | |
1337 | =item funny character | |
1338 | ||
c7166200 CBW |
1339 | Someone X<funny characters>X<characters, funny>like Larry, or one of his |
1340 | peculiar friends. Also refers to the strange prefixes that Perl requires as | |
1341 | noun markers on its variables. | |
97a1d740 | 1342 | |
043d1e6f PA |
1343 | =back |
1344 | ||
1345 | =head2 G | |
1346 | ||
1347 | =over 4 | |
1348 | ||
97a1d740 YST |
1349 | =item garbage collection |
1350 | ||
c7166200 CBW |
1351 | A misnamed feature—X<garbage collection, defined>it should be called, |
1352 | “expecting your mother to pick up after you”. Strictly speaking, Perl | |
1353 | doesn’t do this, but it relies on a reference-counting mechanism to keep | |
1354 | things tidy. However, we rarely speak strictly and will often refer to the | |
1355 | reference-counting scheme as a form of garbage collection. (If it’s any | |
1356 | comfort, when your interpreter exits, a “real” garbage collector runs to | |
1357 | make sure everything is cleaned up if you’ve been messy with circular | |
1358 | references and such.) | |
97a1d740 | 1359 | |
97a1d740 YST |
1360 | =item GID |
1361 | ||
c7166200 CBW |
1362 | Group ID—in Unix, X<GID (Group ID)>X<Group ID (GID)>the numeric group ID |
1363 | that the B<operating system> uses to identify you and members of your | |
1364 | B<group>. | |
97a1d740 YST |
1365 | |
1366 | =item glob | |
1367 | ||
c7166200 CBW |
1368 | Strictly, the X<glob (* character)>shell’s C<*> character, which will match |
1369 | a “glob” of characters when you’re trying to generate a list of filenames. | |
1370 | Loosely, the act of using globs and similar symbols to do pattern matching. | |
1371 | See also B<fileglob> and B<typeglob>. | |
97a1d740 YST |
1372 | |
1373 | =item global | |
1374 | ||
c7166200 CBW |
1375 | Something X<global (term)>you can see from anywhere, usually used of |
1376 | B<variables> and B<subroutines> that are visible everywhere in your | |
1377 | program. In Perl, only certain special variables are truly global—most | |
1378 | variables (and all subroutines) exist only in the current B<package>. | |
1379 | Global variables can be declared with C<our>. See “Global Declarations” in | |
1380 | Camel chapter 4, “Statements and Declarations”. | |
97a1d740 YST |
1381 | |
1382 | =item global destruction | |
1383 | ||
c7166200 CBW |
1384 | The B<garbage X<global destruction>collection> of globals (and the running |
1385 | of any associated object destructors) that takes place when a Perl | |
1386 | B<interpreter> is being shut down. Global destruction should not be | |
97a1d740 YST |
1387 | confused with the Apocalypse, except perhaps when it should. |
1388 | ||
1389 | =item glue language | |
1390 | ||
c7166200 CBW |
1391 | A language X<glue language>such as Perl that is good at hooking things |
1392 | together that weren’t intended to be hooked together. | |
97a1d740 YST |
1393 | |
1394 | =item granularity | |
1395 | ||
c7166200 CBW |
1396 | The size of the X<granularity>pieces you’re dealing with, mentally |
1397 | speaking. | |
1398 | ||
1399 | =item grapheme | |
1400 | ||
1401 | A graphene is X<graphemes, defined>an allotrope of carbon arranged in a | |
1402 | hexagonal crystal lattice one atom thick. A B<grapheme>, or more fully, a | |
1403 | I<grapheme cluster string> is a single user-visible B<character>, which may | |
1404 | in turn be several characters (B<codepoints>) long. For example, a carriage | |
1405 | return plus a line feed is a single grapheme but two characters, while a | |
1406 | “ȫ” is a single grapheme but one, two, or even three characters, depending | |
1407 | on B<normalization>. | |
97a1d740 YST |
1408 | |
1409 | =item greedy | |
1410 | ||
c7166200 CBW |
1411 | A B<subpattern> X<greedy subpatterns>X<subpatterns, greedy>whose |
1412 | B<quantifier> wants to match as many things as possible. | |
97a1d740 YST |
1413 | |
1414 | =item grep | |
1415 | ||
c7166200 CBW |
1416 | Originally X<grep function>from the old Unix editor command for “Globally |
1417 | search for a Regular Expression and Print it”, now used in the general | |
1418 | sense of any kind of search, especially text searches. Perl has a built-in | |
1419 | C<grep> function that searches a list for elements matching any given | |
1420 | criterion, whereas the B<grep>(1) program searches for lines matching a | |
1421 | B<regular expression> in one or more files. | |
97a1d740 YST |
1422 | |
1423 | =item group | |
1424 | ||
c7166200 CBW |
1425 | A set of users X<groups, defined>of which you are a member. In some |
1426 | operating systems (like Unix), you can give certain file access permissions | |
1427 | to other members of your group. | |
97a1d740 YST |
1428 | |
1429 | =item GV | |
1430 | ||
c7166200 CBW |
1431 | An internal “glob value” X<GV (glob value)>X<glob value (GV)>typedef, |
1432 | holding a B<typeglob>. The C<GV> type is a subclass of B<SV>. | |
97a1d740 YST |
1433 | |
1434 | =back | |
1435 | ||
5bbd0522 YST |
1436 | =head2 H |
1437 | ||
97a1d740 YST |
1438 | =over 4 |
1439 | ||
1440 | =item hacker | |
1441 | ||
c7166200 CBW |
1442 | Someone X<hackers>who is brilliantly persistent in solving technical |
1443 | problems, whether these involve golfing, fighting orcs, or programming. | |
1444 | Hacker is a neutral term, morally speaking. Good hackers are not to be | |
1445 | confused with evil B<crackers> or clueless B<script kiddies>. If you | |
1446 | confuse them, we will presume that you are either evil or clueless. | |
97a1d740 YST |
1447 | |
1448 | =item handler | |
1449 | ||
c7166200 CBW |
1450 | A B<subroutine> X<handlers, defined>or B<method> that Perl calls when your |
1451 | program needs to respond to some internal event, such as a B<signal>, or an | |
1452 | encounter with an operator subject to B<operator overloading>. See also | |
1453 | B<callback>. | |
97a1d740 YST |
1454 | |
1455 | =item hard reference | |
1456 | ||
c7166200 CBW |
1457 | A B<scalar> B<value> X<hard references, about>X<references, hard>containing |
1458 | the actual address of a B<referent>, such that the referent’s B<reference> | |
1459 | count accounts for it. (Some hard references are held internally, such as | |
1460 | the implicit reference from one of a B<typeglob>’s variable slots to its | |
1461 | corresponding referent.) A hard reference is different from a B<symbolic | |
1462 | reference>. | |
97a1d740 YST |
1463 | |
1464 | =item hash | |
1465 | ||
c7166200 CBW |
1466 | An unordered X<hashes, about>association of B<key>/B<value> X<key/value |
1467 | pairs, about>pairs, stored such that you can easily use a string B<key> to | |
1468 | look up its associated data B<value>. This glossary is like a hash, where | |
1469 | the word to be defined is the key and the definition is the value. A hash | |
1470 | is also sometimes septisyllabically called an “associative array”, which is | |
1471 | a pretty good reason for simply calling it a “hash” instead. | |
97a1d740 YST |
1472 | |
1473 | =item hash table | |
1474 | ||
c7166200 CBW |
1475 | A data X<hash tables>structure used internally by Perl for implementing |
1476 | associative arrays (hashes) efficiently. See also B<bucket>. | |
97a1d740 YST |
1477 | |
1478 | =item header file | |
1479 | ||
c7166200 CBW |
1480 | A file X<header files>X<files, header>containing certain required |
1481 | definitions that you must include “ahead” of the rest of your program to do | |
1482 | certain obscure operations. A C header file has a I<.h> extension. Perl | |
1483 | doesn’t really have header files, though historically Perl has sometimes | |
1484 | used translated I<.h> files with a I<.ph> extension. See C<require> in | |
1485 | Camel chapter 27, “Functions”. (Header files have been superseded by the | |
1486 | B<module> mechanism.) | |
97a1d740 YST |
1487 | |
1488 | =item here document | |
1489 | ||
c7166200 CBW |
1490 | So X<here documents>called because of a similar construct in B<shells> that |
1491 | pretends that the B<lines> following the B<command> are a separate B<file> | |
1492 | to be fed to the command, up to some terminating string. In Perl, however, | |
1493 | it’s just a fancy form of quoting. | |
97a1d740 YST |
1494 | |
1495 | =item hexadecimal | |
1496 | ||
c7166200 CBW |
1497 | A X<hexadecimals>number in base 16, “hex” for short. The digits for 10 |
1498 | through 16 are customarily represented by the letters C<a> through C<f>. | |
1499 | Hexadecimal constants in Perl start with C<0x>. See also the C<hex> | |
1500 | function in Camel chapter 27, “Functions”. | |
97a1d740 YST |
1501 | |
1502 | =item home directory | |
1503 | ||
c7166200 CBW |
1504 | The X<home directory>X<directories, home>directory you are put into when |
1505 | you log in. On a Unix system, the name is often placed into C<$ENV{HOME}> | |
1506 | or C<$ENV{LOGDIR}> by I<login>, but you can also find it with | |
1507 | C<(get>C<pwuid($E<lt>))[7]>. (Some platforms do not have a concept of a | |
1508 | home directory.) | |
97a1d740 YST |
1509 | |
1510 | =item host | |
1511 | ||
c7166200 | 1512 | The computer X<host computers>on which a program or other data resides. |
97a1d740 YST |
1513 | |
1514 | =item hubris | |
1515 | ||
c7166200 CBW |
1516 | Excessive pride, X<hubris quality>the sort of thing for which Zeus zaps |
1517 | you. Also the quality that makes you write (and maintain) programs that | |
1518 | other people won’t want to say bad things about. Hence, the third great | |
1519 | virtue of a programmer. See also B<laziness> and B<impatience>. | |
97a1d740 YST |
1520 | |
1521 | =item HV | |
1522 | ||
c7166200 CBW |
1523 | Short for a “hash value” X<HV (hash value)>X<hash value (HV)>typedef, which |
1524 | holds Perl’s internal representation of a hash. The C<HV> type is a | |
1525 | subclass of B<SV>. | |
97a1d740 YST |
1526 | |
1527 | =back | |
1528 | ||
5bbd0522 YST |
1529 | =head2 I |
1530 | ||
97a1d740 YST |
1531 | =over 4 |
1532 | ||
1533 | =item identifier | |
1534 | ||
c7166200 CBW |
1535 | A legally X<identifiers, defined>formed name for most anything in which a |
1536 | computer program might be interested. Many languages (including Perl) allow | |
1537 | identifiers to start with an alphabetic character, and then contain | |
1538 | alphabetics and digits. Perl also allows connector punctuation like the | |
1539 | underscore character wherever it allows alphabetics. (Perl also has more | |
1540 | complicated names, like B<qualified> names.) | |
97a1d740 YST |
1541 | |
1542 | =item impatience | |
1543 | ||
c7166200 CBW |
1544 | The anger X<impatience quality>you feel when the computer is being lazy. |
1545 | This makes you write programs that don’t just react to your needs, but | |
1546 | actually anticipate them. Or at least that pretend to. Hence, the second | |
1547 | great virtue of a programmer. See also B<laziness> and B<hubris>. | |
97a1d740 YST |
1548 | |
1549 | =item implementation | |
1550 | ||
c7166200 CBW |
1551 | How a X<implementation (term)>piece of code actually goes about doing its |
1552 | job. Users of the code should not count on implementation details staying | |
1553 | the same unless they are part of the published B<interface>. | |
97a1d740 YST |
1554 | |
1555 | =item import | |
1556 | ||
c7166200 CBW |
1557 | To gain X<import (term)>access to symbols that are exported from another |
1558 | module. See C<use> in Camel chapter 27, “Functions”. | |
97a1d740 YST |
1559 | |
1560 | =item increment | |
1561 | ||
c7166200 CBW |
1562 | To increase the X<incrementing values>X<values, incrementing>value of |
1563 | something by 1 (or by some other number, if so specified). | |
97a1d740 YST |
1564 | |
1565 | =item indexing | |
1566 | ||
c7166200 CBW |
1567 | In olden days, X<indexing (term)>the act of looking up a B<key> in an |
1568 | actual index (such as a phone book). But now it's merely the act of using | |
1569 | any kind of key or position to find the corresponding B<value>, even if no | |
1570 | index is involved. Things have degenerated to the point that Perl’s | |
1571 | C<index> function merely locates the position (index) of one string in | |
1572 | another. | |
97a1d740 YST |
1573 | |
1574 | =item indirect filehandle | |
1575 | ||
c7166200 CBW |
1576 | An B<expression> X<indirect filehandles>X<filehandles, indirect>that |
1577 | evaluates to something that can be used as a B<filehandle>: a B<string> | |
1578 | (filehandle name), a B<typeglob>, a typeglob B<reference>, or a low-level | |
1579 | B<IO> object. | |
97a1d740 | 1580 | |
c7166200 CBW |
1581 | =item indirection |
1582 | ||
1583 | If something in a X<indirection (term)>program isn’t the value you’re | |
1584 | looking for but indicates where the value is, that’s indirection. This can | |
1585 | be done with either B<symbolic references> or B<hard>. | |
97a1d740 | 1586 | |
c7166200 | 1587 | =item indirect object |
97a1d740 | 1588 | |
c7166200 CBW |
1589 | In English grammar, X<indirect objects, defined>X<objects, indirect>a short |
1590 | noun phrase between a verb and its direct object indicating the beneficiary | |
1591 | or recipient of the action. In Perl, C<print STDOUT "$foo\n";> can be | |
1592 | understood as “verb indirect-object object”, where C<STDOUT> is the | |
1593 | recipient of the C<print> action, and C<"$foo"> is the object being | |
1594 | printed. Similarly, when invoking a B<method>, you might place the | |
1595 | invocant in the dative slot between the method and its arguments: | |
97a1d740 | 1596 | |
c7166200 CBW |
1597 | $gollum = new Pathetic::Creature "Sméagol"; |
1598 | give $gollum "Fisssssh!"; | |
1599 | give $gollum "Precious!"; | |
797f796a | 1600 | |
97a1d740 YST |
1601 | =item indirect object slot |
1602 | ||
c7166200 CBW |
1603 | The syntactic X<indirect object slot>position falling between a method call |
1604 | and its arguments when using the indirect object invocation syntax. (The | |
1605 | slot is distinguished by the absence of a comma between it and the next | |
1606 | argument.) C<STDERR> is in the indirect object slot here: | |
97a1d740 | 1607 | |
c7166200 | 1608 | print STDERR "Awake! Awake! Fear, Fire, Foes! Awake!\n"; |
97a1d740 YST |
1609 | |
1610 | =item infix | |
1611 | ||
c7166200 CBW |
1612 | An B<operator> that X<infix operators>comes in between its B<operands>, |
1613 | such as multiplication in C<24 * 7>. | |
97a1d740 YST |
1614 | |
1615 | =item inheritance | |
1616 | ||
c7166200 CBW |
1617 | What you get from your X<inheritance, defined>ancestors, genetically or |
1618 | otherwise. If you happen to be a B<class>, your ancestors are called B<base | |
1619 | classes> and your descendants are called B<derived classes>. See B<single | |
1620 | inheritance> and B<multiple inheritance>. | |
97a1d740 YST |
1621 | |
1622 | =item instance | |
1623 | ||
c7166200 CBW |
1624 | Short for “an instance of a class”, X<instances (term)>meaning an B<object> |
1625 | of that B<class>. | |
1626 | ||
1627 | =item instance data | |
1628 | ||
1629 | SeeX<instance data> B<instance variable>. | |
1630 | ||
1631 | =item instance method | |
1632 | ||
1633 | A B<method> of X<instance methods>X<methods, instance>an B<object>, as | |
1634 | opposed to a B<class method>. | |
1635 | ||
1636 | A B<method> whose B<invocant> is an B<object>, not a B<package> name. Every | |
1637 | object of a class shares all the methods of that class, so an instance | |
1638 | method applies to all instances of the class, rather than applying to a | |
1639 | particular instance. Also see B<class method>. | |
97a1d740 YST |
1640 | |
1641 | =item instance variable | |
1642 | ||
c7166200 CBW |
1643 | An B<attribute> of an B<object>; X<instance variables, defined>X<variables, |
1644 | instance>data stored with the particular object rather than with the class | |
1645 | as a whole. | |
97a1d740 YST |
1646 | |
1647 | =item integer | |
1648 | ||
c7166200 CBW |
1649 | A number X<integers (term)>with no fractional (decimal) part. A counting |
1650 | number, like 1, 2, 3, and so on, but including 0 and the negatives. | |
97a1d740 YST |
1651 | |
1652 | =item interface | |
1653 | ||
c7166200 CBW |
1654 | The services X<interfaces (term)>a piece of code promises to provide |
1655 | forever, in contrast to its B<implementation>, which it should feel free to | |
1656 | change whenever it likes. | |
97a1d740 YST |
1657 | |
1658 | =item interpolation | |
1659 | ||
c7166200 CBW |
1660 | The insertion of X<interpolation, defined>a scalar or list value somewhere |
1661 | in the middle of another value, such that it appears to have been there all | |
1662 | along. In Perl, variable interpolation happens in double-quoted strings and | |
97a1d740 YST |
1663 | patterns, and list interpolation occurs when constructing the list of |
1664 | values to pass to a list operator or other such construct that takes a | |
c7166200 | 1665 | I<C<LIST>>. |
97a1d740 YST |
1666 | |
1667 | =item interpreter | |
1668 | ||
c7166200 CBW |
1669 | Strictly speaking, X<interpreters, defined>a program that reads a second |
1670 | program and does what the second program says directly without turning the | |
1671 | program into a different form first, which is what B<compilers> do. Perl is | |
1672 | not an interpreter by this definition, because it contains a kind of | |
1673 | compiler that takes a program and turns it into a more executable form | |
1674 | (B<syntax trees>) within the I<perl> process itself, which the Perl | |
1675 | B<runtime> system then interprets. | |
97a1d740 | 1676 | |
7698aede | 1677 | =item invocant |
97a1d740 | 1678 | |
c7166200 CBW |
1679 | The agent on X<invocants, defined>whose behalf a B<method> is invoked. In a |
1680 | B<class> method, the invocant is a package name. In an B<instance> method, | |
7698aede | 1681 | the invocant is an object reference. |
97a1d740 YST |
1682 | |
1683 | =item invocation | |
1684 | ||
c7166200 CBW |
1685 | The act of X<invocation, method>calling up a deity, daemon, program, |
1686 | method, subroutine, or function to get it to do what you think it’s | |
1687 | supposed to do. We usually “call” subroutines but “invoke” methods, since | |
1688 | it sounds cooler. | |
97a1d740 YST |
1689 | |
1690 | =item I/O | |
1691 | ||
c7166200 CBW |
1692 | Input from, or X<I/O (Input/Output), defined>X<Input/Output (I/O), |
1693 | defined>output to, a B<file> or B<device>. | |
97a1d740 YST |
1694 | |
1695 | =item IO | |
1696 | ||
c7166200 CBW |
1697 | An internal I/O object. Can also mean B<indirect object>. |
1698 | ||
1699 | =item I/O layer | |
1700 | ||
1701 | One of the X<I/O layer>filters between the data and what you get as input | |
1702 | or what you end up with as output. | |
1703 | ||
1704 | =item IPA | |
1705 | ||
1706 | India Pale Ale. Also the X<International Phonetic Alphabet (IPA)>X<IPA | |
1707 | (International Phonetic Alphabet)>International Phonetic Alphabet, the | |
1708 | standard alphabet used for phonetic notation worldwide. Draws heavily on | |
1709 | Unicode, including many combining characters. | |
97a1d740 YST |
1710 | |
1711 | =item IP | |
1712 | ||
c7166200 CBW |
1713 | Internet ProtocolX<Internet Protocol (IP)>X<IP (Internet Protocol)>, or |
1714 | X<IP (Intellectual Property)>X<Intellectual Property (IP)>Intellectual | |
1715 | Property. | |
97a1d740 YST |
1716 | |
1717 | =item IPC | |
1718 | ||
c7166200 CBW |
1719 | Interprocess X<Interprocess Communication>X<IPC (Interprocess |
1720 | Communication), about>X<communication>Communication. | |
97a1d740 YST |
1721 | |
1722 | =item is-a | |
1723 | ||
c7166200 CBW |
1724 | A rX<is–a relationship>elationship between two B<objects> in which one |
1725 | object is considered to be a more specific version of the other, generic | |
1726 | object: “A camel is a mammal.” Since the generic object really only exists | |
1727 | in a Platonic sense, we usually add a little abstraction to the notion of | |
1728 | objects and think of the relationship as being between a generic B<base | |
1729 | class> and a specific B<derived class>. Oddly enough, Platonic classes | |
1730 | don’t always have Platonic relationships—see B<inheritance>. | |
97a1d740 YST |
1731 | |
1732 | =item iteration | |
1733 | ||
c7166200 | 1734 | Doing X<iteration>something repeatedly. |
97a1d740 YST |
1735 | |
1736 | =item iterator | |
1737 | ||
c7166200 CBW |
1738 | A special X<iterators>programming gizmo that keeps track of where you are |
1739 | in something that you’re trying to iterate over. The C<foreach> loop in | |
1740 | Perl contains an iterator; so does a hash, allowing you to C<each> through | |
1741 | it. | |
97a1d740 YST |
1742 | |
1743 | =item IV | |
1744 | ||
c7166200 CBW |
1745 | The integer X<IV (Integer Value)>X<Integer Value (IV)>four, not to be |
1746 | confused with six, Tom’s favorite editor. IV also means an internal Integer | |
1747 | Value of the type a B<scalar> can hold, not to be confused with an B<NV>. | |
97a1d740 YST |
1748 | |
1749 | =back | |
1750 | ||
5bbd0522 YST |
1751 | =head2 J |
1752 | ||
97a1d740 YST |
1753 | =over 4 |
1754 | ||
1755 | =item JAPH | |
1756 | ||
c7166200 CBW |
1757 | “Just Another Perl Hacker”, a X<JAPH acronym>clever but cryptic bit of Perl |
1758 | code that, when executed, evaluates to that string. Often used to | |
1759 | illustrate a particular Perl feature, and something of an ongoing | |
1760 | Obfuscated Perl Contest seen in USENET signatures. | |
97a1d740 YST |
1761 | |
1762 | =back | |
1763 | ||
5bbd0522 YST |
1764 | =head2 K |
1765 | ||
97a1d740 YST |
1766 | =over 4 |
1767 | ||
1768 | =item key | |
1769 | ||
c7166200 | 1770 | The X<keys, defined>string index to a B<hash>, used to look up the B<value> |
97a1d740 YST |
1771 | associated with that key. |
1772 | ||
1773 | =item keyword | |
1774 | ||
c7166200 | 1775 | See B<reserved words>. |
97a1d740 YST |
1776 | |
1777 | =back | |
1778 | ||
5bbd0522 YST |
1779 | =head2 L |
1780 | ||
97a1d740 YST |
1781 | =over 4 |
1782 | ||
1783 | =item label | |
1784 | ||
c7166200 CBW |
1785 | A X<labels, defined>name you give to a B<statement> so that you can talk |
1786 | about that statement elsewhere in the program. | |
97a1d740 YST |
1787 | |
1788 | =item laziness | |
1789 | ||
c7166200 CBW |
1790 | The X<laziness quality>quality that makes you go to great effort to reduce |
1791 | overall energy expenditure. It makes you write labor-saving programs that | |
1792 | other people will find useful, and then document what you wrote so you | |
1793 | don’t have to answer so many questions about it. Hence, the first great | |
1794 | virtue of a programmer. Also hence, this book. See also B<impatience> and | |
1795 | B<hubris>. | |
97a1d740 | 1796 | |
c7166200 | 1797 | =item leftmost longest |
97a1d740 | 1798 | |
c7166200 CBW |
1799 | The X<leftmost longest preference>X<regular expressions, leftmost longest |
1800 | preference>preference of the B<regular expression> engine to match the | |
1801 | leftmost occurrence of a B<pattern>, then given a position at which a match | |
1802 | will occur, the preference for the longest match (presuming the use of a | |
1803 | B<greedy> quantifier). See Camel chapter 5, “Pattern Matching” for I<much> | |
1804 | more on this subject. | |
97a1d740 | 1805 | |
c7166200 | 1806 | =item left shift |
97a1d740 | 1807 | |
c7166200 CBW |
1808 | A B<bit shift> that X<left shift (E<lt>E<lt>) bit operator>X<bit–shift |
1809 | operators, left shift>X<E<lt>E<lt> (left shift) bit operator>multiplies the | |
1810 | number by some power of 2. | |
97a1d740 YST |
1811 | |
1812 | =item lexeme | |
1813 | ||
c7166200 | 1814 | Fancy X<lexeme (token)>term for a B<token>. |
97a1d740 YST |
1815 | |
1816 | =item lexer | |
1817 | ||
c7166200 | 1818 | Fancy X<lexer (tokener)>term for a B<tokener>. |
97a1d740 YST |
1819 | |
1820 | =item lexical analysis | |
1821 | ||
c7166200 | 1822 | Fancy X<lexical analysis>term for B<tokenizing>. |
97a1d740 YST |
1823 | |
1824 | =item lexical scoping | |
1825 | ||
c7166200 CBW |
1826 | Looking X<lexical scopes, defined>X<scopes>at your I<Oxford English |
1827 | Dictionary> through a microscope. (Also known as B<static scoping>, because | |
1828 | dictionaries don’t change very fast.) Similarly, looking at variables | |
1829 | stored in a private dictionary (namespace) for each scope, which are | |
1830 | visible only from their point of declaration down to the end of theX<static | |
1831 | scopes>X<scopes, static> lexical scope in which they are declared. —Syn. | |
1832 | B<static scoping>. —Ant. B<dynamic scoping>. | |
97a1d740 YST |
1833 | |
1834 | =item lexical variable | |
1835 | ||
c7166200 CBW |
1836 | A B<variable> X<lexical variables, about>X<variables, lexical>subject to |
1837 | B<lexical scoping>, declared by C<my>. Often just called a “lexical”. (The | |
1838 | C<our> declaration declares a lexically scoped name for a global variable, | |
1839 | which is not itself a lexical variable.) | |
97a1d740 YST |
1840 | |
1841 | =item library | |
1842 | ||
c7166200 CBW |
1843 | Generally, a X<libraries, defined>collection of procedures. In ancient |
1844 | days, referred to a collection of subroutines in a I<.pl> file. In modern | |
1845 | times, refers more often to the entire collection of Perl B<modules> on | |
1846 | your system. | |
97a1d740 YST |
1847 | |
1848 | =item LIFO | |
1849 | ||
c7166200 CBW |
1850 | Last In, First OutX<Last In, First Out (LIFO)>X<LIFO (Last In, First |
1851 | Out)>X<stacks, defined>. See also B<FIFO>. A LIFO is usually called a | |
1852 | B<stack>. | |
97a1d740 YST |
1853 | |
1854 | =item line | |
1855 | ||
c7166200 CBW |
1856 | In Unix, a X<line (term)>sequence of zero or more nonnewline characters |
1857 | terminated with a B<newline> character. On non-Unix machines, this is | |
1858 | emulated by the C library even if the underlying B<operating system> has | |
97a1d740 YST |
1859 | different ideas. |
1860 | ||
c7166200 CBW |
1861 | =item linebreak |
1862 | ||
1863 | A B<grapheme> X<linebreaks>consisting of either a carriage return followed | |
1864 | by a line feed or any character with the Unicode Vertical Space B<character | |
1865 | property>. | |
1866 | ||
97a1d740 YST |
1867 | =item line buffering |
1868 | ||
c7166200 CBW |
1869 | Used by X<line buffering>X<buffering, line>a B<standard I/O> output stream that |
1870 | flushes its B<buffer> after every B<newline>. Many standard I/O libraries | |
1871 | automatically set up line buffering on output that is going to the terminal. | |
97a1d740 YST |
1872 | |
1873 | =item line number | |
1874 | ||
c7166200 CBW |
1875 | The number X<line number>of lines read previous to this one, plus 1. Perl |
1876 | keeps a separate line number for each source or input file it opens. The | |
1877 | current source file’s line number is represented by C<__LINE__>. The | |
1878 | current input line number (for the file that was most recently read via | |
1879 | C<E<lt>FHE<gt>>) is represented by the C<$.> (C<$INPUT_LINE_NUMBER>) | |
1880 | variable. Many error messages report both values, if available. | |
97a1d740 YST |
1881 | |
1882 | =item link | |
1883 | ||
c7166200 CBW |
1884 | Used as a X<links, defined>noun, a name in a B<directory> that represents a |
1885 | B<file>. A given file can have multiple links to it. It’s like having the | |
1886 | same phone number listed in the phone directory under different names. As a | |
1887 | verb, to resolve a partially B<compiled> file’s unresolved symbols into a | |
1888 | (nearly) executable image. Linking can generally be static or dynamic, | |
1889 | which has nothing to do with static or dynamic scoping. | |
97a1d740 YST |
1890 | |
1891 | =item LIST | |
1892 | ||
c7166200 CBW |
1893 | A syntactic X<LIST construct>X<constructs, LIST>construct representing a |
1894 | comma- separated list of expressions, evaluated to produce a B<list value>. | |
1895 | Each B<expression> in a I<C<LIST>> is evaluated in B<list context> and | |
97a1d740 YST |
1896 | interpolated into the list value. |
1897 | ||
1898 | =item list | |
1899 | ||
c7166200 | 1900 | An ordered X<lists, defined>set of scalar values. |
97a1d740 YST |
1901 | |
1902 | =item list context | |
1903 | ||
c7166200 CBW |
1904 | The situation X<list context>X<context, list>in which an B<expression> is |
1905 | expected by its surroundings (the code calling it) to return a list of | |
1906 | values rather than a single value. Functions that want a I<C<LIST>> of | |
1907 | arguments tell those arguments that they should produce a list value. See | |
1908 | also B<context>. | |
97a1d740 YST |
1909 | |
1910 | =item list operator | |
1911 | ||
c7166200 CBW |
1912 | An B<operator> that X<list operators, about>does something with a list of |
1913 | values, such as C<join> or C<grep>. Usually used for named built-in | |
1914 | operators (such as C<print>, C<unlink>, and C<system>) that do not require | |
1915 | parentheses around their B<argument> list. | |
97a1d740 YST |
1916 | |
1917 | =item list value | |
1918 | ||
c7166200 CBW |
1919 | An unnamed X<list values, about>X<values, list>list of temporary scalar |
1920 | values that may be passed around within a program from any list-generating | |
1921 | function to any function or construct that provides a B<list context>. | |
97a1d740 YST |
1922 | |
1923 | =item literal | |
1924 | ||
c7166200 CBW |
1925 | A token X<literals, defined>in a programming language, such as a number or |
1926 | B<string>, that gives you an actual B<value> instead of merely representing | |
1927 | possible values as a B<variable> does. | |
97a1d740 YST |
1928 | |
1929 | =item little-endian | |
1930 | ||
c7166200 CBW |
1931 | From Swift: X<little–endian, defined>X<endianness, little–endian>someone |
1932 | who eats eggs little end first. Also used of computers that store the least | |
1933 | significant B<byte> of a word at a lower byte address than the most | |
1934 | significant byte. Often considered superior to big-endian machines. See | |
1935 | also B<big-endian>. | |
97a1d740 YST |
1936 | |
1937 | =item local | |
1938 | ||
c7166200 CBW |
1939 | Not meaning X<local operator, about>the same thing everywhere. A global |
1940 | variable in Perl can be localized inside a B<dynamic scope> via the | |
1941 | C<local> operator. | |
97a1d740 YST |
1942 | |
1943 | =item logical operator | |
1944 | ||
c7166200 CBW |
1945 | Symbols X<logical operators, about>representing the concepts “and”, “or”, |
1946 | “xor”, and “not”. | |
97a1d740 YST |
1947 | |
1948 | =item lookahead | |
1949 | ||
c7166200 CBW |
1950 | An B<assertion> that X<lookahead assertions>X<assertions (in regexes), |
1951 | lookahead>peeks at the string to the right of the current match location. | |
97a1d740 YST |
1952 | |
1953 | =item lookbehind | |
1954 | ||
c7166200 CBW |
1955 | An B<assertion> X<lookbehind assertions>X<assertions (in regexes), |
1956 | lookbehind>that peeks at the string to the left of the current match | |
1957 | location. | |
97a1d740 YST |
1958 | |
1959 | =item loop | |
1960 | ||
c7166200 CBW |
1961 | A construct X<loop constructs and statements, about>X<constructs, loop>that |
1962 | performs something repeatedly, like a roller coaster. | |
97a1d740 YST |
1963 | |
1964 | =item loop control statement | |
1965 | ||
c7166200 CBW |
1966 | Any statement X<statements, loop control>within the body of a loop that can |
1967 | make a loop prematurely stop looping or skip an B<iteration>. Generally, | |
1968 | you shouldn’t try this on roller coasters. | |
97a1d740 YST |
1969 | |
1970 | =item loop label | |
1971 | ||
c7166200 CBW |
1972 | A kind X<loop labels>X<labels, loop>of key or name attached to a loop (or |
1973 | roller coaster) so that loop control statements can talk about which loop | |
1974 | they want to control. | |
1975 | ||
1976 | =item lowercase | |
1977 | ||
1978 | In Unicode, X<lowercase characters>X<characters, lowercase>not just | |
1979 | characters with the General Category of Lowercase Letter, but any character | |
1980 | with the Lowercase property, including Modifier Letters, Letter Numbers, | |
1981 | some Other Symbols, and one Combining Mark. | |
97a1d740 YST |
1982 | |
1983 | =item lvaluable | |
1984 | ||
c7166200 | 1985 | Able to X<lvaluable function>X<functions, lvaluable>serve as an B<lvalue>. |
97a1d740 YST |
1986 | |
1987 | =item lvalue | |
1988 | ||
c7166200 CBW |
1989 | Term used by X<lvalue (term)>X<values, lvalue>language lawyers for a |
1990 | storage location you can assign a new B<value> to, such as a B<variable> or | |
1991 | an element of an B<array>. The “l” is short for “left”, as in the left side | |
1992 | of an assignment, a typical place for lvalues. An B<lvaluable> function or | |
1993 | expression is one to which a value may be assigned, as in C<pos($x) = 10>. | |
97a1d740 YST |
1994 | |
1995 | =item lvalue modifier | |
1996 | ||
c7166200 CBW |
1997 | An X<lvalue modifier>X<modifiers, lvalue>adjectival pseudofunction that |
1998 | warps the meaning of an B<lvalue> in some declarative fashion. Currently | |
1999 | there are three lvalue modifiers: C<my>, C<our>, and C<local>. | |
97a1d740 YST |
2000 | |
2001 | =back | |
2002 | ||
5bbd0522 YST |
2003 | =head2 M |
2004 | ||
97a1d740 YST |
2005 | =over 4 |
2006 | ||
2007 | =item magic | |
2008 | ||
c7166200 CBW |
2009 | Technically X<magic (term)>speaking, any extra semantics attached to a |
2010 | variable such as C<$!>, C<$0>, C<%ENV>, or C<%SIG>, or to any tied | |
2011 | variable. Magical things happen when you diddle those variables. | |
97a1d740 YST |
2012 | |
2013 | =item magical increment | |
2014 | ||
c7166200 CBW |
2015 | An B<increment> X<magical increment operator>operator that knows how to |
2016 | bump up ASCII alphabetics as well as numbers. | |
97a1d740 YST |
2017 | |
2018 | =item magical variables | |
2019 | ||
c7166200 CBW |
2020 | Special variables X<magical variables>X<variables, magical>that have side |
2021 | effects when you access them or assign to them. For example, in Perl, | |
2022 | changing elements of the C<%ENV> array also changes the corresponding | |
2023 | environment variables that subprocesses will use. Reading the C<$!> | |
2024 | variable gives you the current system error number or message. | |
97a1d740 YST |
2025 | |
2026 | =item Makefile | |
2027 | ||
c7166200 CBW |
2028 | A file that X<Makefile>controls the compilation of a program. Perl programs |
2029 | don’t usually need a B<Makefile> because the Perl compiler has plenty of | |
2030 | self-control. | |
97a1d740 YST |
2031 | |
2032 | =item man | |
2033 | ||
c7166200 CBW |
2034 | The Unix X<man program (Unix)>program that displays online documentation |
2035 | (manual pages) for you. | |
97a1d740 YST |
2036 | |
2037 | =item manpage | |
2038 | ||
c7166200 CBW |
2039 | A “page” from the X<manpages, defined>manuals, typically accessed via the |
2040 | I<man>(1) command. A manpage contains a SYNOPSIS, a DESCRIPTION, a list of | |
2041 | BUGS, and so on, and is typically longer than a page. There are manpages | |
2042 | documenting B<commands>, B<syscalls>, B<library> B<functions>, B<devices>, | |
2043 | B<protocols>, B<files>, and such. In this book, we call any piece of | |
2044 | standard Perl documentation (like L<perlop> or L<perldelta>) a manpage, no | |
2045 | matter what format it’s installed in on your system. | |
97a1d740 YST |
2046 | |
2047 | =item matching | |
2048 | ||
c7166200 | 2049 | SeeX<matching> B<pattern matching>. |
97a1d740 YST |
2050 | |
2051 | =item member data | |
2052 | ||
c7166200 | 2053 | SeeX<member data> B<instance variable>. |
97a1d740 YST |
2054 | |
2055 | =item memory | |
2056 | ||
c7166200 CBW |
2057 | This X<memory, defined>always means your main memory, not your disk. |
2058 | Clouding the issue is the fact that your machine may implement | |
2059 | B<virtual> memory; that is, it will pretend that it has more memory than | |
2060 | it really does, and it’ll use disk space to hold inactive bits. This can | |
2061 | make it seem like you have a little more memory than you really do, but | |
2062 | it’s not a substitute for real memory. The best thing that can be said | |
2063 | about virtual memory is that it lets your performance degrade gradually | |
2064 | rather than suddenly when you run out of real memory. But your program | |
2065 | can die when you run out of virtual memory, too—if you haven’t thrashed | |
2066 | your disk to death first. | |
97a1d740 YST |
2067 | |
2068 | =item metacharacter | |
2069 | ||
c7166200 CBW |
2070 | A B<character> that X<metacharacters, about>X<characters, regex |
2071 | metacharacters>is I<not> supposed to be treated normally. Which characters | |
2072 | are to be treated specially as metacharacters varies greatly from context to | |
2073 | context. Your B<shell> will have certain metacharacters, double-quoted Perl | |
2074 | B<strings> have other metacharacters,X<regular expressions, metacharacters and> | |
2075 | and B<regular expression> patterns have all the double-quote metacharacters plus | |
2076 | some extra ones of their own. | |
97a1d740 YST |
2077 | |
2078 | =item metasymbol | |
2079 | ||
c7166200 CBW |
2080 | Something we’d call X<metasymbols, about>X<escape sequences>a |
2081 | B<metacharacter> except that it’s a sequence of more than one character. | |
2082 | Generally, the first character in the sequence must be a true metacharacter | |
2083 | to get the other characters in the metasymbol to misbehave along with it. | |
97a1d740 YST |
2084 | |
2085 | =item method | |
2086 | ||
c7166200 CBW |
2087 | A kind of X<methods, defined>action that an B<object> can take if you tell |
2088 | it to. See Camel chapter 12, “Objects”. | |
2089 | ||
2090 | =item method resolution order | |
2091 | ||
2092 | The path X<method resolution order (mro)>X<mro (method resolution | |
2093 | order)>Perl takes through C<@INC>. By default, this is a double depth first | |
2094 | search, once looking for defined methods and once for C<AUTOLOAD>. However, | |
2095 | Perl lets you configure this with C<mro>. | |
2096 | ||
2097 | =item minicpan | |
2098 | ||
2099 | A CPAN X<minicpan, defined>X<CPAN (Comprehensive Perl Archive Network), | |
2100 | minicpan and>mirror that includes just the latest versions for each | |
2101 | distribution, probably created with C<CPAN::Mini>X<CPAN::Mini module>. See | |
2102 | Camel chapter 19, “CPAN”. | |
97a1d740 YST |
2103 | |
2104 | =item minimalism | |
2105 | ||
c7166200 CBW |
2106 | The belief X<minimalism>that “small is beautiful”. Paradoxically, if you |
2107 | say something in a small language, it turns out big, and if you say it in a | |
2108 | big language, it turns out small. Go figure. | |
97a1d740 YST |
2109 | |
2110 | =item mode | |
2111 | ||
c7166200 CBW |
2112 | In the X<mode>context of the I<stat>(2) syscall, refers to the field |
2113 | holding the B<permission bits> and the type of the B<file>. | |
97a1d740 YST |
2114 | |
2115 | =item modifier | |
2116 | ||
c7166200 CBW |
2117 | SeeX<modifiers, defined> B<statement modifier>, B<regular expression>, and |
2118 | B<lvalue>, not necessarily in that order. | |
97a1d740 YST |
2119 | |
2120 | =item module | |
2121 | ||
c7166200 CBW |
2122 | A B<file> that X<modules, defined>defines a B<package> of (almost) the same |
2123 | name, which can either B<export> symbols or function as an B<object> class. | |
2124 | (A module’s main I<.pm> file may also load in other files in support of the | |
2125 | module.) See the C<use> built-in. | |
97a1d740 YST |
2126 | |
2127 | =item modulus | |
2128 | ||
c7166200 CBW |
2129 | An integer X<modulus (%) operator>X<% (modulus) operator>divisor when |
2130 | you’re interested in the remainder instead of the quotient. | |
2131 | ||
2132 | =item mojibake | |
2133 | ||
2134 | When you X<mojibake>speak one language and the computer thinks you’re | |
2135 | speaking another. You’ll see odd translations when you send UTF‑8, for | |
2136 | instance, but the computer thinks you sent Latin-1, showing all sorts of | |
2137 | weird characters instead. The term is written 「文字化け」in Japanese and | |
2138 | means “character rot”, an apt description. Pronounced [C<modʑibake>] in | |
2139 | standard B<IPA> phonetics, or approximately “moh-jee-bah-keh”. | |
97a1d740 YST |
2140 | |
2141 | =item monger | |
2142 | ||
c7166200 CBW |
2143 | Short for X<mongers, Perl>X<Perl mongers>one member of B<Perl mongers>, a |
2144 | purveyor of Perl. | |
97a1d740 YST |
2145 | |
2146 | =item mortal | |
2147 | ||
c7166200 CBW |
2148 | A temporary X<mortal value>X<values, mortal>value scheduled to die when the |
2149 | current statement finishes. | |
2150 | ||
2151 | =item mro | |
2152 | ||
2153 | See B<method resolution order>. | |
97a1d740 YST |
2154 | |
2155 | =item multidimensional array | |
2156 | ||
c7166200 CBW |
2157 | An array X<multidimensional arrays>X<arrays, multidimensional>with multiple |
2158 | subscripts for finding a single element. Perl implements these using | |
2159 | B<references>—see Camel chapter 9, “Data Structures”. | |
97a1d740 YST |
2160 | |
2161 | =item multiple inheritance | |
2162 | ||
c7166200 CBW |
2163 | The features X<multiple inheritance>X<inheritance, multiple>you got from |
2164 | your mother and father, mixed together unpredictably. (See also | |
2165 | B<inheritance> and B<single inheritance>.) In computer languages (including | |
2166 | Perl), it is the notion that a given class may have multiple direct | |
2167 | ancestors or B<base classes>. | |
97a1d740 YST |
2168 | |
2169 | =back | |
2170 | ||
5bbd0522 YST |
2171 | =head2 N |
2172 | ||
97a1d740 YST |
2173 | =over 4 |
2174 | ||
2175 | =item named pipe | |
2176 | ||
c7166200 CBW |
2177 | A B<pipe> X<named pipes>X<pipes, names>with a name embedded in the |
2178 | B<filesystem> so that it can be accessed by two unrelated B<processes>. | |
97a1d740 YST |
2179 | |
2180 | =item namespace | |
2181 | ||
c7166200 CBW |
2182 | A domain of X<namespaces, about>names. You needn’t worry about whether the |
2183 | names in one such domain have been used in another. See B<package>. | |
2184 | ||
2185 | =item NaN | |
2186 | ||
2187 | Not a number. X<NaN (not a number)>X<not a number (NaN)>The value Perl uses | |
2188 | for certain invalid or inexpressible floating-point operations. | |
97a1d740 YST |
2189 | |
2190 | =item network address | |
2191 | ||
c7166200 CBW |
2192 | The most X<network address>important attribute of a socket, like your |
2193 | telephone’s telephone number. Typically an IP address. See also B<port>. | |
97a1d740 YST |
2194 | |
2195 | =item newline | |
2196 | ||
c7166200 CBW |
2197 | A single X<newline character>X<characters, newline>character that |
2198 | represents the end of a line, with the ASCII value of 012 octal under Unix | |
2199 | (but 015 on a Mac), and represented by C<\n> in Perl strings. For Windows | |
2200 | machines writing text files, and for certain physical devices like | |
2201 | terminals, the single newline gets automatically translated by your C | |
2202 | library into a line feed and a carriage return, but normally, no | |
2203 | translation is done. | |
97a1d740 YST |
2204 | |
2205 | =item NFS | |
2206 | ||
c7166200 CBW |
2207 | Network File System, X<NFS (Network File System)>X<Network File System |
2208 | (NFS)>which allows you to mount a remote filesystem as if it were local. | |
2209 | ||
2210 | =item normalization | |
2211 | ||
2212 | Converting a X<normalization>text string into an alternate but equivalent | |
2213 | B<canonical> (or compatible) representation that can then be compared for | |
2214 | equivalence. Unicode recognizes four different normalization forms: NFD, | |
2215 | NFC, NFKD, and NFKC. | |
97a1d740 YST |
2216 | |
2217 | =item null character | |
2218 | ||
c7166200 CBW |
2219 | A character X<null character>X<characters, null>with the numeric value of |
2220 | zero. It’s used by C to terminate strings, but Perl allows strings to | |
2221 | contain a null. | |
97a1d740 YST |
2222 | |
2223 | =item null list | |
2224 | ||
c7166200 CBW |
2225 | A B<list value> with X<null lists>X<lists, null>zero elements, represented |
2226 | in Perl by C<()>. | |
97a1d740 YST |
2227 | |
2228 | =item null string | |
2229 | ||
c7166200 CBW |
2230 | A B<string> X<null strings>X<strings, null>containing no characters, not to |
2231 | be confused with a string containing a B<null character>, which has a | |
2232 | positive length and is B<true>. | |
97a1d740 YST |
2233 | |
2234 | =item numeric context | |
2235 | ||
c7166200 CBW |
2236 | The situation X<numeric context>X<context, numeric>in which an expression |
2237 | is expected by its surroundings (the code calling it) to return a number. | |
2238 | See also B<context> and B<string context>. | |
2239 | ||
2240 | =item numification | |
2241 | ||
2242 | (Sometimes spelled I<nummification> and I<nummify>.) X<numification>Perl lingo | |
2243 | for implicit conversion into a number; the related verb is I<numify>. | |
2244 | I<Numification> is intended to rhyme with I<mummification>, and I<numify> with | |
2245 | I<mummify>. It is unrelated to English I<numen>, I<numina>, I<numinous>. We | |
2246 | originally forgot the extra I<m> a long time ago, and some people got used to | |
2247 | our funny spelling, and so just as with C<HTTP_REFERER>’s own missing letter, | |
2248 | our weird spelling has stuck around. | |
97a1d740 YST |
2249 | |
2250 | =item NV | |
2251 | ||
c7166200 CBW |
2252 | Short for Nevada, X<Numeric Value (NV)>X<NV (Numeric Value)>no part of |
2253 | which will ever be confused with civilization. NV also means an internal | |
2254 | floating- point Numeric Value of the type a B<scalar> can hold, not to be | |
2255 | confused with an B<IV>. | |
97a1d740 YST |
2256 | |
2257 | =item nybble | |
2258 | ||
c7166200 CBW |
2259 | Half a B<byte>, X<nybble>equivalent to one B<hexadecimal> digit, and worth |
2260 | four B<bits>. | |
97a1d740 YST |
2261 | |
2262 | =back | |
2263 | ||
5bbd0522 YST |
2264 | =head2 O |
2265 | ||
97a1d740 YST |
2266 | =over 4 |
2267 | ||
2268 | =item object | |
2269 | ||
c7166200 CBW |
2270 | An B<instance> X<objects, defined>of a B<class>. Something that “knows” |
2271 | what user-defined type (class) it is, and what it can do because of what | |
2272 | class it is. Your program can request an object to do things, but the | |
2273 | object gets to decide whether it wants to do them or not. Some objects are | |
2274 | more accommodating than others. | |
97a1d740 YST |
2275 | |
2276 | =item octal | |
2277 | ||
c7166200 CBW |
2278 | A number X<octals>in base 8. Only the digits 0 through 7 are allowed. Octal |
2279 | constants in Perl start with 0, as in 013. See also the C<oct> function. | |
97a1d740 YST |
2280 | |
2281 | =item offset | |
2282 | ||
c7166200 CBW |
2283 | How many X<offsets in strings>X<strings, offsets in>things you have to skip |
2284 | over when moving from the beginning of a string or array to a specific | |
2285 | position within it. Thus, the minimum offset is zero, not one, because you | |
2286 | don’t skip anything to get to the first item. | |
97a1d740 YST |
2287 | |
2288 | =item one-liner | |
2289 | ||
c7166200 CBW |
2290 | An entire X<one–liner programs>computer program crammed into one line of |
2291 | text. | |
97a1d740 YST |
2292 | |
2293 | =item open source software | |
2294 | ||
c7166200 CBW |
2295 | Programs X<open source software>for which the source code is freely |
2296 | available and freely redistributable, with no commercial strings attached. | |
2297 | For a more detailed definition, see L<http://www.opensource.org/osd.html>. | |
97a1d740 YST |
2298 | |
2299 | =item operand | |
2300 | ||
c7166200 CBW |
2301 | An B<expression> X<operands (term)>that yields a B<value> that an |
2302 | B<operator> operates on. See also B<precedence>. | |
97a1d740 YST |
2303 | |
2304 | =item operating system | |
2305 | ||
c7166200 CBW |
2306 | A special X<operating systems, defined>program that runs on the bare |
2307 | machine and hides the gory details of managing B<processes> and B<devices>. | |
97a1d740 | 2308 | Usually used in a looser sense to indicate a particular culture of |
c7166200 CBW |
2309 | programming. The loose sense can be used at varying levels of specificity. |
2310 | At one extreme, you might say that all versions of Unix and Unix-lookalikes | |
2311 | are the same operating system (upsetting many people, especially lawyers | |
2312 | and other advocates). At the other extreme, you could say this particular | |
2313 | version of this particular vendor’s operating system is different from any | |
2314 | other version of this or any other vendor’s operating system. Perl is much | |
2315 | more portable across operating systems than many other languages. See also | |
2316 | B<architecture> and B<platform>. | |
97a1d740 YST |
2317 | |
2318 | =item operator | |
2319 | ||
c7166200 CBW |
2320 | A gizmo X<operators, about>that transforms some number of input values to |
2321 | some number of output values, often built into a language with a special | |
2322 | syntax or symbol. A given operator may have specific expectations about | |
2323 | what B<types> of data you give as its arguments (B<operands>) and what type | |
2324 | of data you want back from it. | |
97a1d740 YST |
2325 | |
2326 | =item operator overloading | |
2327 | ||
c7166200 CBW |
2328 | A kind X<operator overloading, about>X<overloading, operator>of |
2329 | B<overloading> that you can do on built-in B<operators> to make them work | |
2330 | on B<objects> as if the objects were ordinary scalar values, but with the | |
2331 | actual semantics supplied by the object class. This is set up with the | |
2332 | overload B<pragma>—see Camel chapter 13, “Overloading”. | |
97a1d740 YST |
2333 | |
2334 | =item options | |
2335 | ||
c7166200 | 2336 | See X<options>either B<switches> or B<regular expression modifiers>. |
97a1d740 | 2337 | |
1ab74a36 KW |
2338 | =item ordinal |
2339 | ||
c7166200 CBW |
2340 | An X<ordinals (term)>abstract character’s integer value. Same thing as |
2341 | B<codepoint>. | |
1ab74a36 | 2342 | |
97a1d740 YST |
2343 | =item overloading |
2344 | ||
c7166200 CBW |
2345 | Giving X<overloading, defined>additional meanings to a symbol or construct. |
2346 | Actually, all languages do overloading to one extent or another, since | |
2347 | people are good at figuring out things from B<context>. | |
97a1d740 YST |
2348 | |
2349 | =item overriding | |
2350 | ||
c7166200 CBW |
2351 | Hiding or X<overriding, defined>invalidating some other definition of the |
2352 | same name. (Not to be confused with B<overloading>, which adds definitions | |
2353 | that must be disambiguated some other way.) To confuse the issue further, | |
2354 | we use the word with two overloaded definitions: to describe how you can | |
2355 | define your own B<subroutine> to hide a built-in B<function> of the same | |
2356 | name (see the section “Overriding Built-in Functions” in Camel chapter 11, | |
2357 | “Modules”), and to describe how you can define a replacement B<method> in a | |
2358 | B<derived class> to hide a B<base class>’s method of the same name (see | |
2359 | Camel chapter 12, “Objects”). | |
97a1d740 YST |
2360 | |
2361 | =item owner | |
2362 | ||
c7166200 CBW |
2363 | The one X<ownership, file>X<files, ownership of>user (apart from the |
2364 | superuser) who has absolute control over a B<file>. A file may also have a | |
2365 | B<group> of users who may exercise joint ownership if the real owner | |
2366 | permits it. See B<permission bits>. | |
97a1d740 YST |
2367 | |
2368 | =back | |
2369 | ||
5bbd0522 YST |
2370 | =head2 P |
2371 | ||
97a1d740 YST |
2372 | =over 4 |
2373 | ||
2374 | =item package | |
2375 | ||
c7166200 CBW |
2376 | A B<namespace> for X<packages, defined>global B<variables>, B<subroutines>, |
2377 | and the like, such that they can be kept separate from like-named | |
2378 | B<symbols> in other namespaces. In a sense, only the package is global, | |
2379 | since the symbols in the package’s symbol table are only accessible from | |
2380 | code B<compiled> outside the package by naming the package. But in another | |
2381 | sense, all package symbols are also globals—they’re just well-organized | |
2382 | globals. | |
97a1d740 YST |
2383 | |
2384 | =item pad | |
2385 | ||
c7166200 | 2386 | Short X<pads (scratchpads)>for B<scratchpad>. |
97a1d740 YST |
2387 | |
2388 | =item parameter | |
2389 | ||
c7166200 | 2390 | SeeX<parameters> B<argument>. |
97a1d740 YST |
2391 | |
2392 | =item parent class | |
2393 | ||
c7166200 | 2394 | SeeX<parent classes>X<classes, parent> B<base class>. |
97a1d740 YST |
2395 | |
2396 | =item parse tree | |
2397 | ||
c7166200 | 2398 | SeeX<parse tree> B<syntax tree>. |
97a1d740 YST |
2399 | |
2400 | =item parsing | |
2401 | ||
c7166200 CBW |
2402 | The X<parsing, about>subtle but sometimes brutal art of attempting to turn |
2403 | your possibly malformed program into a valid B<syntax tree>. | |
97a1d740 YST |
2404 | |
2405 | =item patch | |
2406 | ||
c7166200 CBW |
2407 | To X<patches>fix by applying one, as it were. In the realm of hackerdom, a |
2408 | listing of the differences between two versions of a program as might be | |
2409 | applied by the B<patch>(1) program when you want to fix a bug or upgrade | |
2410 | your old version. | |
97a1d740 YST |
2411 | |
2412 | =item PATH | |
2413 | ||
c7166200 CBW |
2414 | The X<PATH environment variable>X<variables, environment>list of |
2415 | B<directories> the system searches to find a program you want to | |
2416 | B<execute>. The list is stored as one of your B<environment variables>, | |
2417 | accessible in Perl as C<$ENV{PATH}>. | |
97a1d740 YST |
2418 | |
2419 | =item pathname | |
2420 | ||
c7166200 CBW |
2421 | A X<pathname>fully qualified filename such as I</usr/bin/perl>. Sometimes |
2422 | confused with C<PATH>. | |
97a1d740 YST |
2423 | |
2424 | =item pattern | |
2425 | ||
c7166200 | 2426 | A X<patterns, defined>template used in B<pattern matching>. |
97a1d740 YST |
2427 | |
2428 | =item pattern matching | |
2429 | ||
c7166200 CBW |
2430 | Taking a X<pattern matching, about>pattern, usually a B<regular |
2431 | expression>, and trying the pattern various ways on a string to see whether | |
2432 | there’s any way to make it fit. Often used to pick interesting tidbits out | |
2433 | of a file. | |
2434 | ||
2435 | =item PAUSE | |
2436 | ||
2437 | The X<Perl Authors Upload SErver (PAUSE)>X<PAUSE (Perl Authors Upload | |
2438 | SErver)>Perl Authors Upload SErver (L<http://pause.perl.org>), the gateway | |
2439 | for B<modules> on their way to B<CPAN>. | |
2440 | ||
2441 | =item Perl mongers | |
2442 | ||
2443 | A X<Perl mongers>X<mongers, Perl>Perl user group, taking the form of its | |
2444 | name from the New York Perl mongers, the first Perl user group. Find one | |
2445 | near you at L<http://www.pm.org>. | |
97a1d740 YST |
2446 | |
2447 | =item permission bits | |
2448 | ||
c7166200 CBW |
2449 | Bits X<permission bits>X<bits, permission>that the B<owner> of a file sets |
2450 | or unsets to allow or disallow access to other people. These flag bits are | |
2451 | part of the B<mode> word returned by the C<stat> built-in when you ask | |
2452 | about a file. On Unix systems, you can check the I<ls>(1) manpage for more | |
97a1d740 YST |
2453 | information. |
2454 | ||
2455 | =item Pern | |
2456 | ||
c7166200 CBW |
2457 | What you get X<Pern (term)>when you do C<Perl++> twice. Doing it only once |
2458 | will curl your hair. You have to increment it eight times to shampoo your | |
2459 | hair. Lather, rinse, iterate. | |
97a1d740 YST |
2460 | |
2461 | =item pipe | |
2462 | ||
c7166200 CBW |
2463 | A X<pipes, defined>direct B<connection> that carries the output of one |
2464 | B<process> to the input of another without an intermediate temporary file. | |
2465 | Once the pipe is set up, the two processes in question can read and write | |
2466 | as if they were talking to a normal file, with some caveats. | |
97a1d740 YST |
2467 | |
2468 | =item pipeline | |
2469 | ||
c7166200 CBW |
2470 | A X<pipeline>series of B<processes> all in a row, linked by B<pipes>, where |
2471 | each passes its output stream to the next. | |
97a1d740 YST |
2472 | |
2473 | =item platform | |
2474 | ||
c7166200 CBW |
2475 | The X<platforms, defined>entire hardware and software context in which a |
2476 | program runs. A program written in a platform-dependent language might | |
2477 | break if you change any of the following: machine, operating system, | |
2478 | libraries, compiler, or system configuration. The I<perl> interpreter has | |
2479 | to be B<compiled> differently for each platform because it is implemented | |
2480 | in C, but programs written in the Perl language are largely platform | |
2481 | independent. | |
97a1d740 YST |
2482 | |
2483 | =item pod | |
2484 | ||
c7166200 CBW |
2485 | The X<pod (plain old documentation), about>X<plain old documentation>markup |
2486 | used to embed documentation into your Perl code. Pod stands for “Plain old | |
2487 | documentation”. See Camel chapter 23, “Plain Old Documentation”. | |
2488 | ||
2489 | =item pod command | |
2490 | ||
2491 | A X<pod commands>X<commands, pod>sequence, such as C<=head1>, that denotes | |
2492 | the start of a B<pod> section. | |
97a1d740 YST |
2493 | |
2494 | =item pointer | |
2495 | ||
c7166200 CBW |
2496 | A B<variable> X<pointers>in a language like C that contains the exact |
2497 | memory location of some other item. Perl handles pointers internally so you | |
2498 | don’t have to worry about them. Instead, you just use symbolic pointers in | |
2499 | the form of B<keys> and B<variable> names, or B<hard references>, which | |
2500 | aren’t pointers (but act like pointers and do in fact contain pointers). | |
97a1d740 YST |
2501 | |
2502 | =item polymorphism | |
2503 | ||
c7166200 CBW |
2504 | The notion X<polymorphism>that you can tell an B<object> to do something |
2505 | generic, and the object will interpret the command in different ways | |
2506 | depending on its type. [E<lt> Greek πολυ- + μορϕή, many forms.] | |
97a1d740 YST |
2507 | |
2508 | =item port | |
2509 | ||
c7166200 CBW |
2510 | The X<ports (term)>part of the address of a TCP or UDP socket that directs |
2511 | packets to the correct process after finding the right machine, something | |
2512 | like the phone extension you give when you reach the company operator. Also | |
2513 | the result of converting code to run on a different platform than | |
2514 | originally intended, or the verb denoting this conversion. | |
97a1d740 YST |
2515 | |
2516 | =item portable | |
2517 | ||
c7166200 CBW |
2518 | Once X<portability, about>upon a time, C code compilable under both BSD and |
2519 | SysV. In general, code that can be easily converted to run on another | |
2520 | B<platform>, where “easily” can be defined however you like, and usually | |
2521 | is. Anything may be considered portable if you try hard enough, such as a | |
2522 | mobile home or London Bridge. | |
97a1d740 YST |
2523 | |
2524 | =item porter | |
2525 | ||
c7166200 CBW |
2526 | Someone X<porters>who “carries” software from one B<platform> to another. |
2527 | Porting programs written in platform-dependent languages such as C can be | |
2528 | difficult work, but porting programs like Perl is very much worth the | |
2529 | agony. | |
2530 | ||
2531 | =item possessive | |
2532 | ||
2533 | Said of X<possessive (term)>quantifiers and groups in patterns that refuse | |
2534 | to give up anything once they’ve gotten their mitts on it. Catchier and | |
2535 | easier to say than the even more formal I<nonbacktrackable>. | |
97a1d740 YST |
2536 | |
2537 | =item POSIX | |
2538 | ||
c7166200 CBW |
2539 | The X<Portable Operating System Interface (POSIX), about>X<POSIX (Portable |
2540 | Operating System Interface), about>Portable Operating System Interface | |
2541 | specification. | |
97a1d740 YST |
2542 | |
2543 | =item postfix | |
2544 | ||
c7166200 CBW |
2545 | An B<operator> X<postfix operator>that follows its B<operand>, as in |
2546 | C<$x++>. | |
97a1d740 YST |
2547 | |
2548 | =item pp | |
2549 | ||
c7166200 CBW |
2550 | An X<pp (push–pop) code>X<push–pop (pp) code>internal shorthand for a |
2551 | “push- pop” code; that is, C code implementing Perl’s stack machine. | |
97a1d740 YST |
2552 | |
2553 | =item pragma | |
2554 | ||
c7166200 CBW |
2555 | A X<pragmas, about>X<modules>standard module whose practical hints and |
2556 | suggestions are received (and possibly ignored) at compile time. Pragmas | |
2557 | are named in all lowercase. | |
97a1d740 YST |
2558 | |
2559 | =item precedence | |
2560 | ||
c7166200 CBW |
2561 | The X<precedence rules, about>X<operators, precedence rules>rules of |
2562 | conduct that, in the absence of other guidance, determine what should | |
2563 | happen first. For example, in the absence of parentheses, you always do | |
2564 | multiplication before addition. | |
97a1d740 YST |
2565 | |
2566 | =item prefix | |
2567 | ||
c7166200 CBW |
2568 | An B<operator> X<prefix operators>that precedes its B<operand>, as in |
2569 | C<++$x>. | |
97a1d740 YST |
2570 | |
2571 | =item preprocessing | |
2572 | ||
c7166200 CBW |
2573 | What X<preprocessing>some helper B<process> did to transform the incoming |
2574 | data into a form more suitable for the current process. Often done with an | |
2575 | incoming B<pipe>. See also B<C preprocessor>. | |
2576 | ||
2577 | =item primary maintainer | |
2578 | ||
2579 | The X<primary maintainer>author that PAUSE allows to assign B<co-maintainer> | |
2580 | permissions to a B<namespace>. A primary maintainer can give up this | |
2581 | distinction by assigning it to another PAUSE author. See Camel chapter 19, | |
2582 | “CPAN”. | |
97a1d740 YST |
2583 | |
2584 | =item procedure | |
2585 | ||
c7166200 | 2586 | AX<procedures, defined> B<subroutine>. |
97a1d740 YST |
2587 | |
2588 | =item process | |
2589 | ||
c7166200 CBW |
2590 | An X<processes, defined>instance of a running program. Under multitasking |
2591 | systems like Unix, two or more separate processes could be running the same | |
2592 | program independently at the same time—in fact, the C<fork> function is | |
2593 | designed to bring about this happy state of affairs. Under other operating | |
2594 | systems, processes are sometimes called “threads”, “tasks”, or “jobs”, | |
2595 | often with slight nuances in meaning. | |
2596 | ||
2597 | =item program | |
2598 | ||
2599 | See B<script>. | |
97a1d740 YST |
2600 | |
2601 | =item program generator | |
2602 | ||
c7166200 CBW |
2603 | A system X<program generators>that algorithmically writes code for you in a |
2604 | high-level language. See also B<code generator>. | |
97a1d740 YST |
2605 | |
2606 | =item progressive matching | |
2607 | ||
c7166200 CBW |
2608 | B<Pattern matching> X<progressive matching>X<pattern matching, progressive |
2609 | matching> matching>that picks up where it left off before. | |
97a1d740 YST |
2610 | |
2611 | =item property | |
2612 | ||
c7166200 | 2613 | See X<property>either B<instance variable> or B<character property>. |
97a1d740 YST |
2614 | |
2615 | =item protocol | |
2616 | ||
c7166200 CBW |
2617 | In X<protocols (term)>networking, an agreed-upon way of sending messages |
2618 | back and forth so that neither correspondent will get too confused. | |
97a1d740 YST |
2619 | |
2620 | =item prototype | |
2621 | ||
c7166200 CBW |
2622 | An X<prototypes, about>optional part of a B<subroutine> declaration telling |
2623 | the Perl compiler how many and what flavor of arguments may be passed as | |
2624 | B<actual arguments>, so you can write subroutine calls that parse much like | |
2625 | built-in functions. (Or don’t parse, as the case may be.) | |
97a1d740 YST |
2626 | |
2627 | =item pseudofunction | |
2628 | ||
c7166200 CBW |
2629 | A X<pseudofunctions>X<constructs, pseudofunctions>X<functions, |
2630 | pseudofunctions>construct that sometimes looks like a function but really | |
2631 | isn’t. Usually reserved for B<lvalue> modifiers like C<my>, for B<context> | |
2632 | modifiers like C<scalar>, and for the pick-your-own-quotes constructs, | |
2633 | C<q//>, C<qq//>, C<qx//>, C<qw//>, C<qr//>, C<m//>, C<s///>, C<y///>, and | |
2634 | C<tr///>. | |
97a1d740 YST |
2635 | |
2636 | =item pseudohash | |
2637 | ||
c7166200 CBW |
2638 | Formerly, a reference X<pseudohashes>X<hashes, pseudohashes>to an array |
2639 | whose initial element happens to hold a reference to a hash. You used to be | |
2640 | able to treat a pseudohash reference as either an array reference or a hash | |
2641 | reference. Pseduohashes are no longer supported. | |
97a1d740 YST |
2642 | |
2643 | =item pseudoliteral | |
2644 | ||
c7166200 CBW |
2645 | An B<operator> X<pseudoliterals>XC<that looks something like a B<literal>, |
2646 | such as the output-grabbing operator, <literal | |
2647 | moreinfo="none">`>I<C<command>>C<`>. | |
97a1d740 YST |
2648 | |
2649 | =item public domain | |
2650 | ||
c7166200 CBW |
2651 | Something X<public domain>not owned by anybody. Perl is copyrighted and is |
2652 | thus I<not> in the public domain—it’s just B<freely available> and B<freely | |
2653 | redistributable>. | |
97a1d740 YST |
2654 | |
2655 | =item pumpkin | |
2656 | ||
c7166200 CBW |
2657 | A X<pumpkin (term)>notional “baton” handed around the Perl community |
2658 | indicating who is the lead integrator in some arena of development. | |
97a1d740 YST |
2659 | |
2660 | =item pumpking | |
2661 | ||
c7166200 CBW |
2662 | A B<X<pumpking>pumpkin> holder, the person in charge of pumping the pump, |
2663 | or at least priming it. Must be willing to play the part of the Great | |
97a1d740 YST |
2664 | Pumpkin now and then. |
2665 | ||
2666 | =item PV | |
2667 | ||
c7166200 CBW |
2668 | A “X<PV (pointer value)>X<pointer value (PV)>pointer value”, which is Perl |
2669 | Internals Talk for a C<char*>. | |
97a1d740 YST |
2670 | |
2671 | =back | |
2672 | ||
5bbd0522 YST |
2673 | =head2 Q |
2674 | ||
97a1d740 YST |
2675 | =over 4 |
2676 | ||
2677 | =item qualified | |
2678 | ||
c7166200 CBW |
2679 | Possessing a X<qualified (term)>complete name. The symbol C<$Ent::moot> is |
2680 | qualified; C<$moot> is unqualified. A fully qualified filename is specified | |
2681 | from the top-level directory. | |
97a1d740 YST |
2682 | |
2683 | =item quantifier | |
2684 | ||
c7166200 CBW |
2685 | A X<quantifiers, about>component of a B<regular expression> specifying how |
2686 | many times the foregoing B<atom> may occur. | |
97a1d740 YST |
2687 | |
2688 | =back | |
2689 | ||
5bbd0522 YST |
2690 | =head2 R |
2691 | ||
97a1d740 YST |
2692 | =over 4 |
2693 | ||
c7166200 CBW |
2694 | =item race condition |
2695 | ||
2696 | A X<race conditions, defined>race condition exists when the result of | |
2697 | several interrelated events depends on the ordering of those events, but | |
2698 | that order cannot be guaranteed due to nondeterministic timing effects. If | |
2699 | two or more programs, or parts of the same program, try to go through the | |
2700 | same series of events, one might interrupt the work of the other. This is a | |
2701 | good way to find an B<exploit>. | |
2702 | ||
97a1d740 YST |
2703 | =item readable |
2704 | ||
c7166200 CBW |
2705 | With X<readable (term)>respect to files, one that has the proper permission |
2706 | bit set to let you access the file. With respect to computer programs, one | |
2707 | that’s written well enough that someone has a chance of figuring out what | |
2708 | it’s trying to do. | |
97a1d740 YST |
2709 | |
2710 | =item reaping | |
2711 | ||
c7166200 CBW |
2712 | The last X<reaping zombie processes>rites performed by a parent B<process> |
2713 | on behalf of a deceased child process so that it doesn’t remain a | |
2714 | B<zombie>. See the C<wait> and C<waitpid> function calls. | |
97a1d740 YST |
2715 | |
2716 | =item record | |
2717 | ||
c7166200 CBW |
2718 | A set of X<records, defined>related data values in a B<file> or B<stream>, |
2719 | often associated with a unique B<key> field. In Unix, often commensurate | |
2720 | with a B<line>, or a blank-line–terminated set of lines (a “paragraph”). | |
2721 | Each line of the I</etc/passwd> file is a record, keyed on login name, | |
2722 | containing information about that user. | |
97a1d740 YST |
2723 | |
2724 | =item recursion | |
2725 | ||
c7166200 CBW |
2726 | The art of X<recursion, defined>defining something (at least partly) in |
2727 | terms of itself, which is a naughty no-no in dictionaries but often works | |
2728 | out okay in computer programs if you’re careful not to recurse forever | |
2729 | (which is like an infinite loop with more spectacular failure modes). | |
97a1d740 YST |
2730 | |
2731 | =item reference | |
2732 | ||
c7166200 CBW |
2733 | Where you X<references, about>look to find a pointer to information |
2734 | somewhere else. (See B<indirection>.) References come in two flavors: | |
2735 | B<symbolic references> and B<hard references>. | |
97a1d740 YST |
2736 | |
2737 | =item referent | |
2738 | ||
c7166200 CBW |
2739 | Whatever a X<referents, defined>reference refers to, which may or may not |
2740 | have a name. Common types of referents include scalars, arrays, hashes, and | |
97a1d740 YST |
2741 | subroutines. |
2742 | ||
2743 | =item regex | |
2744 | ||
c7166200 | 2745 | See B<regular expression>. |
97a1d740 YST |
2746 | |
2747 | =item regular expression | |
2748 | ||
c7166200 CBW |
2749 | A single X<regular expressions, defined>entity with various |
2750 | interpretations, like an elephant. To a computer scientist, it’s a grammar | |
2751 | for a little language in which some strings are legal and others aren’t. To | |
2752 | normal people, it’s a pattern you can use to find what you’re looking for | |
2753 | when it varies from case to case. Perl’s regular expressions are far from | |
2754 | regular in the theoretical sense, but in regular use they work quite well. | |
2755 | Here’s a regular expression: C</Oh s.*t./>. This will match strings like | |
2756 | “C<Oh say can you see by the dawn's early light>” and “C<Oh sit!>”. See | |
2757 | Camel chapter 5, “Pattern Matching”. | |
97a1d740 YST |
2758 | |
2759 | =item regular expression modifier | |
2760 | ||
c7166200 CBW |
2761 | An option on a X<regular expression modifiers>X<modifiers, regular |
2762 | expression>pattern or substitution, such as C</i> to render the pattern | |
2763 | case- insensitive. | |
97a1d740 YST |
2764 | |
2765 | =item regular file | |
2766 | ||
c7166200 CBW |
2767 | A B<file> that’s X<regular files>X<files, regular>not a B<directory>, a |
2768 | B<device>, a named B<pipe> or B<socket>, or a B<symbolic link>. Perl uses | |
2769 | the C<–f> file test operator to identify regular files. Sometimes called a | |
2770 | “plain” file. | |
97a1d740 YST |
2771 | |
2772 | =item relational operator | |
2773 | ||
c7166200 CBW |
2774 | An B<operator> that X<relational operators>says whether a particular |
2775 | ordering relationship is B<true> about a pair of B<operands>. Perl has both | |
2776 | numeric and string relational operators. See B<collating sequence>. | |
97a1d740 YST |
2777 | |
2778 | =item reserved words | |
2779 | ||
c7166200 CBW |
2780 | A word with a X<reserved words>X<keywords (term)>specific, built-in meaning |
2781 | to a B<compiler>, such as C<if> or C<delete>. In many languages (not Perl), | |
2782 | it’s illegal to use reserved words to name anything else. (Which is why | |
2783 | they’re reserved, after all.) In Perl, you just can’t use them to name | |
2784 | B<labels> or B<filehandles>. Also called “keywords”. | |
9d055b1a | 2785 | |
97a1d740 YST |
2786 | =item return value |
2787 | ||
c7166200 CBW |
2788 | The B<value> produced X<return values>X<values, return>by a B<subroutine> |
2789 | or B<expression> when evaluated. In Perl, a return value may be either a | |
2790 | B<list> or a B<scalar>. | |
97a1d740 YST |
2791 | |
2792 | =item RFC | |
2793 | ||
c7166200 CBW |
2794 | Request For Comment, X<Request For Comment (RFC)>X<RFC (Request For |
2795 | Comment)>which despite the timid connotations is the name of a series of | |
2796 | important standards documents. | |
97a1d740 YST |
2797 | |
2798 | =item right shift | |
2799 | ||
c7166200 CBW |
2800 | A B<bit shift> X<right shift (E<gt>E<gt>) bit operator>X<bit–shift |
2801 | operators, right shift>X<E<gt>E<gt> (right shift) bit operator>that divides | |
2802 | a number by some power of 2. | |
2803 | ||
2804 | =item role | |
2805 | ||
2806 | A name X<roles (term)>for a concrete set of behaviors. A role is a way to | |
2807 | add behavior to a class without inheritance. | |
97a1d740 YST |
2808 | |
2809 | =item root | |
2810 | ||
c7166200 CBW |
2811 | The X<root (term)>superuser (C<UID> == 0). Also the top-level directory of |
2812 | the filesystem. | |
97a1d740 YST |
2813 | |
2814 | =item RTFM | |
2815 | ||
c7166200 CBW |
2816 | What X<RTFM acronym>you are told when someone thinks you should Read The |
2817 | Fine Manual. | |
97a1d740 YST |
2818 | |
2819 | =item run phase | |
2820 | ||
c7166200 CBW |
2821 | Any X<run phase, defined>time after Perl starts running your main program. |
2822 | See also B<compile phase>. Run phase is mostly spent in B<runtime> but may | |
2823 | also be spent in B<compile time> when C<require>, C<do> I<C<FILE>>, or | |
2824 | C<eval> I<C<STRING>> operators are executed, or when a substitution uses | |
2825 | the C</ee> modifier. | |
97a1d740 | 2826 | |
c7166200 | 2827 | =item runtime |
97a1d740 | 2828 | |
c7166200 CBW |
2829 | The time X<runtime (term), defined>when Perl is actually doing what your |
2830 | code says to do, as opposed to the earlier period of time when it was | |
2831 | trying to figure out whether what you said made any sense whatsoever, which | |
2832 | is B<compile time>. | |
97a1d740 | 2833 | |
c7166200 | 2834 | =item runtime pattern |
97a1d740 | 2835 | |
c7166200 CBW |
2836 | A X<runtime patterns>X<patterns, runtime>pattern that contains one or more |
2837 | variables to be interpolated before parsing the pattern as a B<regular | |
2838 | expression>, and that therefore cannot be analyzed at compile time, but | |
2839 | must be reanalyzed each time the pattern match operator is evaluated. | |
2840 | Runtime patterns are useful but expensive. | |
97a1d740 YST |
2841 | |
2842 | =item RV | |
2843 | ||
c7166200 CBW |
2844 | A X<Reference Value (RV)>X<RV (Reference Value)>recreational vehicle, not |
2845 | to be confused with vehicular recreation. RV also means an internal | |
2846 | Reference Value of the type a B<scalar> can hold. See also B<IV> and B<NV> | |
2847 | if you’re not confused yet. | |
97a1d740 YST |
2848 | |
2849 | =item rvalue | |
2850 | ||
c7166200 CBW |
2851 | A B<value> that X<rvalue (term)>X<values, rvalue>you might find on the |
2852 | right side of an B<assignment>. See also B<lvalue>. | |
97a1d740 YST |
2853 | |
2854 | =back | |
2855 | ||
5bbd0522 YST |
2856 | =head2 S |
2857 | ||
97a1d740 YST |
2858 | =over 4 |
2859 | ||
c7166200 CBW |
2860 | =item sandbox |
2861 | ||
2862 | A X<sandbox, defined>walled off area that’s not supposed to affect beyond | |
2863 | its walls. You let kids play in the sandbox instead of running in the road. | |
2864 | See Camel chapter 20, “Security”. | |
2865 | ||
97a1d740 YST |
2866 | =item scalar |
2867 | ||
c7166200 CBW |
2868 | A X<scalars, defined>simple, singular value; a number, B<string>, or |
2869 | B<reference>. | |
97a1d740 YST |
2870 | |
2871 | =item scalar context | |
2872 | ||
c7166200 CBW |
2873 | The X<scalar context, about>X<context, scalar>situation in which an |
2874 | B<expression> is expected by its surroundings (the code calling it) to | |
2875 | return a single B<value> rather than a B<list> of values. See also | |
2876 | B<context> and B<list context>. A scalar context sometimes imposes | |
2877 | additional constraints on the return value—see B<string context> and | |
2878 | B<numeric context>. Sometimes we talk about a B<Boolean context> inside | |
2879 | conditionals, but this imposes no additional constraints, since any scalar | |
2880 | value, whether numeric or B<string>, is already true or false. | |
97a1d740 YST |
2881 | |
2882 | =item scalar literal | |
2883 | ||
c7166200 CBW |
2884 | A X<scalar literals>X<literals, scalar>number or quoted B<string>—an actual |
2885 | B<value> in the text of your program, as opposed to a B<variable>. | |
97a1d740 YST |
2886 | |
2887 | =item scalar value | |
2888 | ||
c7166200 CBW |
2889 | A X<scalar values, about>X<values, scalar>X<SV>value that happens to be a |
2890 | B<scalar> as opposed to a B<list>. | |
97a1d740 YST |
2891 | |
2892 | =item scalar variable | |
2893 | ||
c7166200 CBW |
2894 | A B<variable> X<scalar variables, defined>X<variables, scalar>prefixed with |
2895 | C<$> that holds a single value. | |
97a1d740 YST |
2896 | |
2897 | =item scope | |
2898 | ||
c7166200 CBW |
2899 | From X<scopes, defined>how far away you can see a variable, looking through |
2900 | one. Perl has two visibility mechanisms. It does B<dynamic scoping> of | |
2901 | C<local> B<variables>, meaning that the rest of the B<block>, and any | |
2902 | B<subroutines> that are called by the rest of the block, can see the | |
2903 | variables that are local to the block. Perl does B<lexical scoping> of | |
2904 | C<my> variables, meaning that the rest of the block can see the variable, | |
2905 | but other subroutines called by the block I<cannot> see the variable. | |
97a1d740 YST |
2906 | |
2907 | =item scratchpad | |
2908 | ||
c7166200 CBW |
2909 | The X<scratchpads>area in which a particular invocation of a particular |
2910 | file or subroutine keeps some of its temporary values, including any | |
2911 | lexically scoped variables. | |
97a1d740 YST |
2912 | |
2913 | =item script | |
2914 | ||
c7166200 CBW |
2915 | A X<scripts (term)>X<programs, defined>text B<file> that is a program |
2916 | intended to be B<executed> directly rather than B<compiled> to another form | |
2917 | of file before B<execution>. | |
2918 | ||
2919 | Also, in the context of B<Unicode>, a writing system for a particular | |
2920 | language or group of languages, such as Greek, Bengali, or Tengwar. | |
97a1d740 YST |
2921 | |
2922 | =item script kiddie | |
2923 | ||
c7166200 CBW |
2924 | A B<cracker> X<script kiddie>who is not a B<hacker> but knows just enough |
2925 | to run canned scripts. A B<cargo-cult> programmer. | |
97a1d740 YST |
2926 | |
2927 | =item sed | |
2928 | ||
c7166200 CBW |
2929 | A venerable Stream EDitor X<sed (Stream EDitor)>X<Stream EDitor (sed)>from |
2930 | which Perl derives some of its ideas. | |
97a1d740 YST |
2931 | |
2932 | =item semaphore | |
2933 | ||
c7166200 CBW |
2934 | A fancy X<semaphore>kind of interlock that prevents multiple B<threads> or |
2935 | B<processes> from using up the same resources simultaneously. | |
97a1d740 YST |
2936 | |
2937 | =item separator | |
2938 | ||
c7166200 CBW |
2939 | A B<character> X<separators>X<characters, separators>X<strings, |
2940 | separators>or B<string> that keeps two surrounding strings from being | |
2941 | confused with each other. The C<split> function X<split function, | |
2942 | separators and>works on separators. Not to be confused with B<delimiters> | |
2943 | or B<terminators>. The “or” in the previous sentence separated the two | |
2944 | alternatives. | |
97a1d740 YST |
2945 | |
2946 | =item serialization | |
2947 | ||
c7166200 CBW |
2948 | Putting a X<serialization>X<marshalling (term)>fancy B<data structure> into |
2949 | linear order so that it can be stored as a B<string> in a disk file or | |
2950 | database, or sent through a B<pipe>. Also called marshalling. | |
97a1d740 YST |
2951 | |
2952 | =item server | |
2953 | ||
c7166200 CBW |
2954 | In networking, X<servers, defined>X<processes, server>a B<process> that |
2955 | either advertises a B<service> or just hangs around at a known location and | |
2956 | waits for B<clients> who need service to get in touch with it. | |
97a1d740 YST |
2957 | |
2958 | =item service | |
2959 | ||
c7166200 CBW |
2960 | Something X<services (term)>you do for someone else to make them happy, |
2961 | like giving them the time of day (or of their life). On some machines, | |
2962 | well-known services are listed by theX<getservent function> C<getservent> | |
2963 | function. | |
97a1d740 YST |
2964 | |
2965 | =item setgid | |
2966 | ||
c7166200 CBW |
2967 | Same as B<setuid>, X<setgid program, about>only having to do with giving |
2968 | away B<group> privileges. | |
97a1d740 YST |
2969 | |
2970 | =item setuid | |
2971 | ||
c7166200 CBW |
2972 | Said of a program X<setuid program, about>that runs with the privileges of |
2973 | its B<owner> rather than (as is usually the case) the privileges of whoever | |
2974 | is running it. Also describes the bit in the mode word (B<permission bits>) | |
2975 | that controls the feature. This bit must be explicitly set by the owner to | |
2976 | enable this feature, and the program must be carefully written not to give | |
2977 | away more privileges than it ought to. | |
97a1d740 YST |
2978 | |
2979 | =item shared memory | |
2980 | ||
c7166200 CBW |
2981 | A piece of B<memory> X<shared memory>X<memory, shared>accessible by two |
2982 | different B<processes> who otherwise would not see each other’s memory. | |
97a1d740 YST |
2983 | |
2984 | =item shebang | |
2985 | ||
c7166200 CBW |
2986 | Irish for the X<shebang (term)>whole McGillicuddy. In Perl culture, a |
2987 | portmanteau of “sharp” and “bang”, meaning the C<#!> sequence that tells | |
2988 | the system where to find the interpreter. | |
97a1d740 YST |
2989 | |
2990 | =item shell | |
2991 | ||
c7166200 CBW |
2992 | A B<command>-X<shell program, defined>line B<interpreter>. The program that |
2993 | interactively gives you a prompt, accepts one or more B<lines> of input, | |
2994 | and executes the programs you mentioned, feeding each of them their proper | |
2995 | B<arguments> and input data. Shells can also execute scripts containing | |
2996 | such commands. Under Unix, typical shells include the Bourne shell | |
2997 | (I</bin/sh>), the C shell (I</bin/csh>), and the Korn shell (I</bin/ksh>). | |
2998 | Perl is not strictly a shell because it’s not interactive (although Perl | |
2999 | programs can be interactive). | |
97a1d740 YST |
3000 | |
3001 | =item side effects | |
3002 | ||
c7166200 CBW |
3003 | Something extra X<side effects>that happens when you evaluate an |
3004 | B<expression>. Nowadays it can refer to almost anything. For example, | |
3005 | evaluating a simple assignment statement typically has the “side effect” of | |
3006 | assigning a value to a variable. (And you thought assigning the value was | |
3007 | your primary intent in the first place!) Likewise, assigning a value to the | |
3008 | special variable C<$|> (C<$AUTOFLUSH>) has the side effect of forcing a | |
3009 | flush after every C<write> or C<print> on the currently selected | |
3010 | filehandle. | |
3011 | ||
3012 | =item sigil | |
3013 | ||
3014 | A glyph X<sigils, defined>used in magic. Or, for Perl, the symbol in front | |
3015 | of a variable name, such as C<$>, C<@>, and C<%>. | |
97a1d740 YST |
3016 | |
3017 | =item signal | |
3018 | ||
c7166200 CBW |
3019 | A bolt X<signals and signal handling, about>out of the blue; that is, an |
3020 | event triggered by the B<operating system>, probably when you’re least | |
3021 | expecting it. | |
97a1d740 YST |
3022 | |
3023 | =item signal handler | |
3024 | ||
c7166200 CBW |
3025 | A B<subroutine> that, X<handlers, signal>instead of being content to be |
3026 | called in the normal fashion, sits around waiting for a bolt out of the | |
3027 | blue before it will deign to B<execute>. Under Perl, bolts out of the blue | |
3028 | are called signals, and you send them with the C<kill> built-in. See the | |
3029 | C<%SIG> hash in Camel chapter 25, “Special Names” and the section “Signals” | |
3030 | in Camel chapter 15, “Interprocess Communication”. | |
97a1d740 YST |
3031 | |
3032 | =item single inheritance | |
3033 | ||
c7166200 CBW |
3034 | The features X<single inheritance>X<inheritance, single>you got from your |
3035 | mother, if she told you that you don’t have a father. (See also | |
3036 | B<inheritance> and B<multiple inheritance>.) In computer languages, the | |
3037 | idea that B<classes> reproduce asexually so that a given class can only | |
3038 | have one direct ancestor or B<base class>. Perl supplies no such | |
3039 | restriction, though you may certainly program Perl that way if you like. | |
97a1d740 YST |
3040 | |
3041 | =item slice | |
3042 | ||
c7166200 CBW |
3043 | A selection X<slices of elements>X<elements, slices of>of any number of |
3044 | B<elements> from a B<list>, B<array>, or B<hash>. | |
97a1d740 YST |
3045 | |
3046 | =item slurp | |
3047 | ||
c7166200 | 3048 | To read an X<slurp (term)>entire B<file> into a B<string> in one operation. |
97a1d740 YST |
3049 | |
3050 | =item socket | |
3051 | ||
c7166200 CBW |
3052 | An endpoint for X<sockets, defined>network communication among multiple |
3053 | B<processes> that works much like a telephone or a post office box. The | |
3054 | most important thing about a socket is its B<network address> (like a phone | |
3055 | number). Different kinds of sockets have different kinds of addresses—some | |
3056 | look like filenames, and some don’t. | |
97a1d740 YST |
3057 | |
3058 | =item soft reference | |
3059 | ||
c7166200 | 3060 | SeeX<soft references>X<references, soft> B<symbolic reference>. |
97a1d740 YST |
3061 | |
3062 | =item source filter | |
3063 | ||
c7166200 CBW |
3064 | A special X<source filters>X<filters, source>kind of B<module> that does |
3065 | B<preprocessing> on your script just before it gets to the B<tokener>. | |
97a1d740 YST |
3066 | |
3067 | =item stack | |
3068 | ||
c7166200 CBW |
3069 | A X<stacks, defined>device you can put things on the top of, and later take |
3070 | them back off in the opposite order in which you put them on. See B<LIFO>. | |
97a1d740 YST |
3071 | |
3072 | =item standard | |
3073 | ||
c7166200 CBW |
3074 | Included X<standard (term)>in the official Perl distribution, as in a |
3075 | standard module, a standard tool, or a standard Perl B<manpage>. | |
97a1d740 YST |
3076 | |
3077 | =item standard error | |
3078 | ||
c7166200 CBW |
3079 | The default output B<stream> for nasty remarks that don’t belong in |
3080 | B<standard output>. Represented within a Perl program by theX<STDERR | |
3081 | filehandle, about> output> B<filehandle> C<STDERR>. You can use this | |
3082 | stream explicitly, but the C<die> and C<warn> built-ins write to your | |
3083 | standard error stream automatically (unless trapped or otherwise | |
3084 | intercepted). | |
97a1d740 | 3085 | |
c7166200 | 3086 | =item standard input |
97a1d740 | 3087 | |
c7166200 CBW |
3088 | The X<STDIN filehandle, about>default input B<stream> for your program, |
3089 | which if possible shouldn’t care where its data is coming from. Represented | |
3090 | within a Perl program by the B<filehandle> C<STDIN>. | |
97a1d740 | 3091 | |
c7166200 | 3092 | =item standard I/O |
97a1d740 | 3093 | |
c7166200 CBW |
3094 | A X<standard I/O>X<I/O (Input/Output), standard>X<Input/Output (I/O), |
3095 | standard>X<STDIO filehandle>standard C library for doing B<buffered> input | |
3096 | and output to the B<operating system>. (The “standard” of standard I/O is | |
3097 | at most marginally related to the “standard” of standard input and output.) | |
3098 | In general, Perl relies on whatever implementation of standard I/O a given | |
3099 | operating system supplies, so the buffering characteristics of a Perl | |
3100 | program on one machine may not exactly match those on another machine. | |
3101 | Normally this only influences efficiency, not semantics. If your standard | |
3102 | I/O package is doing block buffering and you want it to B<flush> the buffer | |
3103 | more often, just set the C<$|> variable to a true value. | |
97a1d740 | 3104 | |
c7166200 | 3105 | =item Standard Library |
97a1d740 | 3106 | |
c7166200 CBW |
3107 | Everything X<Standard Perl Library, about>that comes with the official |
3108 | I<perl> distribution. Some vendor versions of I<perl> change their | |
3109 | distributions, leaving out some parts or including extras. See also | |
3110 | B<dual-lived>. | |
97a1d740 | 3111 | |
c7166200 | 3112 | =item standard output |
97a1d740 | 3113 | |
c7166200 CBW |
3114 | The X<STDOUT filehandle, about>default output B<stream> for your program, |
3115 | which if possible shouldn’t care where its data is going. Represented | |
3116 | within a Perl program by the B<filehandle> C<STDOUT>. | |
97a1d740 YST |
3117 | |
3118 | =item statement | |
3119 | ||
c7166200 CBW |
3120 | A B<command> to X<statements, about>the computer about what to do next, |
3121 | like a step in a recipe: “Add marmalade to batter and mix until mixed.” A | |
3122 | statement is distinguished from a B<declaration>, which doesn’t tell the | |
3123 | computer to do anything, but just to learn something. | |
97a1d740 YST |
3124 | |
3125 | =item statement modifier | |
3126 | ||
c7166200 CBW |
3127 | A B<conditional> X<statement modifiers, about>X<modifiers, statement>or |
3128 | B<loop> that you put after the B<statement> instead of before, if you know | |
3129 | what we mean. | |
97a1d740 YST |
3130 | |
3131 | =item static | |
3132 | ||
c7166200 CBW |
3133 | Varying X<static (term)>slowly compared to something else. (Unfortunately, |
3134 | everything is relatively stable compared to something else, except for | |
3135 | certain elementary particles, and we’re not so sure about them.) In | |
3136 | computers, where things are supposed to vary rapidly, “static” has a | |
3137 | derogatory connotation, indicating a slightly dysfunctional B<variable>, | |
3138 | B<subroutine>, or B<method>. In Perl culture, the word is politely avoided. | |
3139 | ||
3140 | If you’re a C or C++ programmer, you might be looking for Perl’s C<state> | |
3141 | keyword. | |
97a1d740 YST |
3142 | |
3143 | =item static method | |
3144 | ||
c7166200 | 3145 | No such X<static methods>X<methods, static>thing. See B<class method>. |
97a1d740 YST |
3146 | |
3147 | =item static scoping | |
3148 | ||
c7166200 | 3149 | No such thing. See B<lexical scoping>. |
97a1d740 YST |
3150 | |
3151 | =item static variable | |
3152 | ||
c7166200 CBW |
3153 | No such X<static variables>X<variables, static>thing. Just use a B<lexical |
3154 | variable> in a scope larger than your B<subroutine>, or declare it with | |
3155 | C<state> instead of with C<my>. | |
3156 | ||
3157 | =item stat structure | |
3158 | ||
3159 | A special X<stat structure>X<data structures, stat structure>internal spot | |
3160 | in which Perl keeps the information about the last B<file> on which you | |
3161 | requested information. | |
97a1d740 YST |
3162 | |
3163 | =item status | |
3164 | ||
c7166200 CBW |
3165 | The B<value> X<status value>X<values, status>X<exit status>returned to the |
3166 | parent B<process> when one of its child processes dies. This value is | |
3167 | placed in the special variable C<$?>. Its upper eight B<bits> are the exit | |
3168 | status of the defunct process, and its lower eight bits identify the signal | |
3169 | (if any) that the process died from. On Unix systems, this status value is | |
3170 | the same as the status word returned by I<wait>(2). See C<system> in Camel | |
3171 | chapter 27, “Functions”. | |
97a1d740 YST |
3172 | |
3173 | =item STDERR | |
3174 | ||
c7166200 | 3175 | See B<standard error>. |
97a1d740 YST |
3176 | |
3177 | =item STDIN | |
3178 | ||
c7166200 | 3179 | See B<standard input>. |
97a1d740 YST |
3180 | |
3181 | =item STDIO | |
3182 | ||
c7166200 | 3183 | See B<standard I/O>. |
97a1d740 YST |
3184 | |
3185 | =item STDOUT | |
3186 | ||
c7166200 | 3187 | See B<standard output>. |
97a1d740 YST |
3188 | |
3189 | =item stream | |
3190 | ||
c7166200 CBW |
3191 | A flow X<streaming data>X<processes, streaming data>of data into or out of |
3192 | a process as a steady sequence of bytes or characters, without the | |
3193 | appearance of being broken up into packets. This is a kind of | |
3194 | B<interface>—the underlying B<implementation> may well break your data up | |
3195 | into separate packets for delivery, but this is hidden from you. | |
97a1d740 YST |
3196 | |
3197 | =item string | |
3198 | ||
c7166200 CBW |
3199 | A sequence X<strings, defined>of characters such as “He said !@#*&%@#*?!”. |
3200 | A string does not have to be entirely printable. | |
97a1d740 YST |
3201 | |
3202 | =item string context | |
3203 | ||
c7166200 CBW |
3204 | The situation X<string context>X<context, string>in which an expression is |
3205 | expected by its surroundings (the code calling it) to return a B<string>. | |
3206 | See also B<context> and B<numeric context>. | |
97a1d740 YST |
3207 | |
3208 | =item stringification | |
3209 | ||
c7166200 CBW |
3210 | The process X<stringification>of producing a B<string> representation of an |
3211 | abstract object. | |
97a1d740 YST |
3212 | |
3213 | =item struct | |
3214 | ||
c7166200 | 3215 | C keyword X<struct keyword>introducing a structure definition or name. |
97a1d740 YST |
3216 | |
3217 | =item structure | |
3218 | ||
c7166200 | 3219 | SeeX<structures> B<data structure>. |
97a1d740 YST |
3220 | |
3221 | =item subclass | |
3222 | ||
c7166200 | 3223 | See B<derived class>. |
97a1d740 YST |
3224 | |
3225 | =item subpattern | |
3226 | ||
c7166200 | 3227 | A X<subpatterns, defined>component of a B<regular expression> pattern. |
97a1d740 YST |
3228 | |
3229 | =item subroutine | |
3230 | ||
c7166200 CBW |
3231 | A X<subroutines, defined>named or otherwise accessible piece of program |
3232 | that can be invoked from elsewhere in the program in order to accomplish | |
3233 | some subgoal of the program. A subroutine is often parameterized to | |
3234 | accomplish different but related things depending on its input | |
3235 | B<arguments>. If the subroutine returns a meaningful B<value>, it is also | |
3236 | called a B<function>. | |
97a1d740 YST |
3237 | |
3238 | =item subscript | |
3239 | ||
c7166200 CBW |
3240 | A B<value> X<subscripts>that indicates the position of a particular |
3241 | B<array> B<element> in an array. | |
97a1d740 YST |
3242 | |
3243 | =item substitution | |
3244 | ||
c7166200 CBW |
3245 | Changing X<substitution (s///) operator, about>X<strings, substitution |
3246 | in>X<s/// (substitution) operator, about>parts of a string via the C<s///> | |
3247 | operator. (We avoid use of this term to mean B<variable interpolation>.) | |
97a1d740 YST |
3248 | |
3249 | =item substring | |
3250 | ||
c7166200 CBW |
3251 | A portion of a B<string>, X<substrings (term)>starting at a certain |
3252 | B<character> position (B<offset>) and proceeding for a certain number of | |
97a1d740 YST |
3253 | characters. |
3254 | ||
3255 | =item superclass | |
3256 | ||
c7166200 | 3257 | See B<base class>. |
97a1d740 YST |
3258 | |
3259 | =item superuser | |
3260 | ||
c7166200 CBW |
3261 | The X<superusers>person whom the B<operating system> will let do almost |
3262 | anything. Typically your system administrator or someone pretending to be | |
3263 | your system administrator. On Unix systems, the B<root> user. On Windows | |
97a1d740 YST |
3264 | systems, usually the Administrator user. |
3265 | ||
3266 | =item SV | |
3267 | ||
c7166200 CBW |
3268 | Short X<scalar values, about>X<values, scalar>for “scalar value”. But |
3269 | within the Perl interpreter, every B<referent> is treated as a member of a | |
3270 | class derived from SV, in an object-oriented sort of way. Every B<value> | |
3271 | inside Perl is passed around as a C language C<SV*> pointer. The SV | |
3272 | B<struct> knows its own “referent type”, and the code is smart enough (we | |
3273 | hope) not to try to call a B<hash> function on a B<subroutine>. | |
97a1d740 YST |
3274 | |
3275 | =item switch | |
3276 | ||
c7166200 CBW |
3277 | An X<switches, about>X<switches>option you give on a command line to |
3278 | influence the way your program works, usually introduced with a minus sign. | |
3279 | The word is also used as a nickname for a B<switch statement>. | |
97a1d740 YST |
3280 | |
3281 | =item switch cluster | |
3282 | ||
c7166200 CBW |
3283 | The X<switch clusters>X<clusters, switch>combination of multiple command- |
3284 | line switches (I<e.g.>, C<–a –b –c>) into one switch (I<e.g.>, C<–abc>). | |
3285 | Any switch with an additional B<argument> must be the last switch in a | |
3286 | cluster. | |
97a1d740 YST |
3287 | |
3288 | =item switch statement | |
3289 | ||
c7166200 CBW |
3290 | A X<switch statement>X<statements, switch>program technique that lets you |
3291 | evaluate an B<expression> and then, based on the value of the expression, | |
3292 | do a multiway branch to the appropriate piece of code for that value. Also | |
3293 | called a “case structure”, named after the similar Pascal construct. Most | |
3294 | switch statements in Perl are spelled C<given>. See “The C<given> | |
3295 | statement” in Camel chapter 4, “Statements and Declarations”. | |
97a1d740 YST |
3296 | |
3297 | =item symbol | |
3298 | ||
c7166200 CBW |
3299 | Generally, X<symbols>X<symbols>any B<token> or B<metasymbol>. Often used |
3300 | more specifically to mean the sort of name you might find in a B<symbol | |
97a1d740 YST |
3301 | table>. |
3302 | ||
97a1d740 YST |
3303 | =item symbolic debugger |
3304 | ||
c7166200 CBW |
3305 | A program X<symbolic debugger>X<debugger, about>that lets you step through |
3306 | the B<execution> of your program, stopping or printing things out here and | |
3307 | there to see whether anything has gone wrong, and, if so, what. The | |
3308 | “symbolic” part just means that you can talk to the debugger using the same | |
3309 | symbols with which your program is written. | |
97a1d740 YST |
3310 | |
3311 | =item symbolic link | |
3312 | ||
c7166200 CBW |
3313 | An alternate X<symbolic links>X<links, symbolic>filename that points to the |
3314 | real B<filename>, which in turn points to the real B<file>. Whenever the | |
3315 | B<operating system> is trying to parse a B<pathname> containing a symbolic | |
3316 | link, it merely substitutes the new name and continues parsing. | |
97a1d740 YST |
3317 | |
3318 | =item symbolic reference | |
3319 | ||
c7166200 CBW |
3320 | A variable X<symbolic references>X<references, symbolic>whose value is the |
3321 | name of another variable or subroutine. By B<dereferencing> the first | |
3322 | variable, you can get at the second one. Symbolic references are illegal | |
3323 | under C<use strict "refs">. | |
3324 | ||
3325 | =item symbol table | |
3326 | ||
3327 | Where X<symbol tables, about>a B<compiler> remembers symbols. A program | |
3328 | like Perl must somehow remember all the names of all the B<variables>, | |
3329 | B<filehandles>, and B<subroutines> you’ve used. It does this by placing the | |
3330 | names in a symbol table, which is implemented in Perl using a B<hash | |
3331 | table>. There is a separate symbol table for each B<package> to give each | |
3332 | package its own B<namespace>. | |
97a1d740 YST |
3333 | |
3334 | =item synchronous | |
3335 | ||
c7166200 CBW |
3336 | Programming X<synchronous (term)>in which the orderly sequence of events |
3337 | can be determined; that is, when things happen one after the other, not at | |
3338 | the same time. | |
97a1d740 YST |
3339 | |
3340 | =item syntactic sugar | |
3341 | ||
c7166200 CBW |
3342 | An X<syntactic sugar>alternative way of writing something more easily; a |
3343 | shortcut. | |
97a1d740 YST |
3344 | |
3345 | =item syntax | |
3346 | ||
c7166200 CBW |
3347 | From X<syntax, about>Greek σύνταξις, “with-arrangement”. How things |
3348 | (particularly symbols) are put together with each other. | |
97a1d740 YST |
3349 | |
3350 | =item syntax tree | |
3351 | ||
c7166200 CBW |
3352 | An internal X<syntax tree>representation of your program wherein |
3353 | lower-level B<constructs> dangle off the higher-level constructs enclosing | |
3354 | them. | |
97a1d740 YST |
3355 | |
3356 | =item syscall | |
3357 | ||
c7166200 CBW |
3358 | A B<function> X<syscall function, about>call directly to the B<operating |
3359 | system>. Many of the important subroutines and functions you use aren’t | |
3360 | direct system calls, but are built up in one or more layers above the | |
3361 | system call level. In general, Perl programmers don’t need to worry about | |
3362 | the distinction. However, if you do happen to know which Perl functions are | |
3363 | really syscalls, you can predict which of these will set the C<$!> | |
3364 | (C<$ERRNO>) variable on failure. Unfortunately, beginning programmers often | |
3365 | confusingly employ the term “system call” to mean what happens when you | |
3366 | call the Perl C<system> function, which actually involves many syscalls. To | |
3367 | avoid any confusion, we nearly always say “syscall” for something you could | |
3368 | call indirectly via Perl’s C<syscall> function, and never for something you | |
3369 | would call with Perl’s C<system> function. | |
97a1d740 YST |
3370 | |
3371 | =back | |
3372 | ||
5bbd0522 YST |
3373 | =head2 T |
3374 | ||
97a1d740 YST |
3375 | =over 4 |
3376 | ||
c7166200 CBW |
3377 | =item taint checks |
3378 | ||
3379 | The X<taint checks, about>special bookkeeping Perl does to track the flow | |
3380 | of external data through your program and disallow their use in system | |
3381 | commands. | |
3382 | ||
97a1d740 YST |
3383 | =item tainted |
3384 | ||
c7166200 CBW |
3385 | Said of X<tainted data, about>data derived from the grubby hands of a user, |
3386 | and thus unsafe for a secure program to rely on. Perl does taint checks if | |
3387 | you run a B<setuid> (or B<setgid>) program, or if you use the C<–T> switch. | |
3388 | ||
3389 | =item taint mode | |
3390 | ||
3391 | Running X<taint mode>under the C<–T> switch, marking all external data as | |
3392 | suspect and refusing to use it with system commands. See Camel chapter 20, | |
3393 | “Security”. | |
97a1d740 YST |
3394 | |
3395 | =item TCP | |
3396 | ||
c7166200 CBW |
3397 | Short for X<TCP (Transmission Control Protocol)>X<Transmission Control |
3398 | Protocol (TCP)>Transmission Control Protocol. A protocol wrapped around the | |
3399 | Internet Protocol to make an unreliable packet transmission mechanism | |
3400 | appear to the application program to be a reliable B<stream> of bytes. | |
3401 | (Usually.) | |
97a1d740 YST |
3402 | |
3403 | =item term | |
3404 | ||
c7166200 CBW |
3405 | Short for X<terms, defined>a “terminal”—that is, a leaf node of a B<syntax |
3406 | tree>. A thing that functions grammatically as an B<operand> for the | |
3407 | operators in an expression. | |
97a1d740 YST |
3408 | |
3409 | =item terminator | |
3410 | ||
c7166200 CBW |
3411 | A B<character> X<terminators (term)>X<characters, terminators>X<strings, |
3412 | terminators in>or B<string> that marks the end of another string. The C<$/> | |
3413 | variable contains the string that terminates a C<readline> operation, which | |
3414 | C<chomp> deletes from the end. Not to be confused with B<delimiters> or | |
3415 | B<separators>. The period at the end of this sentence is a terminator. | |
97a1d740 YST |
3416 | |
3417 | =item ternary | |
3418 | ||
c7166200 CBW |
3419 | An B<operator> X<ternary operators>taking three B<operands>. Sometimes |
3420 | pronounced B<trinary>. | |
97a1d740 YST |
3421 | |
3422 | =item text | |
3423 | ||
c7166200 CBW |
3424 | A B<string> or B<file> X<text, defined>X<strings, text>X<files, |
3425 | text>X<text>containing primarily printable characters. | |
97a1d740 YST |
3426 | |
3427 | =item thread | |
3428 | ||
c7166200 CBW |
3429 | Like a X<threads (term)>forked process, but without B<fork>’s inherent |
3430 | memory protection. A thread is lighter weight than a full process, in that | |
3431 | a process could have multiple threads running around in it, all fighting | |
3432 | over the same process’s memory space unless steps are taken to protect | |
3433 | threads from one another. | |
97a1d740 YST |
3434 | |
3435 | =item tie | |
3436 | ||
c7166200 CBW |
3437 | The bond X<tied variables, about>between a magical variable and its |
3438 | implementation class. See the C<tie> function in Camel chapter 27, | |
3439 | “Functions” and Camel chapter 14, “Tied Variables”. | |
3440 | ||
3441 | =item titlecase | |
3442 | ||
3443 | The case X<titlecase characters>X<characters, titlecase>used for capitals | |
3444 | that are followed by lowercase characters instead of by more capitals. | |
3445 | Sometimes called sentence case or headline case. English doesn’t use | |
3446 | Unicode titlecase, but casing rules for English titles are more complicated | |
3447 | than simply capitalizing each word’s first character. | |
97a1d740 YST |
3448 | |
3449 | =item TMTOWTDI | |
3450 | ||
c7166200 CBW |
3451 | There’s More Than One Way To Do It, the Perl MottoX<TMTOWTDI acronym>. The |
3452 | notion that there can be more than one valid path to solving a programming | |
3453 | problem in context. (This doesn’t mean that more ways are always better or | |
3454 | that all possible paths are equally desirable—just that there need not be | |
3455 | One True Way.) | |
97a1d740 YST |
3456 | |
3457 | =item token | |
3458 | ||
c7166200 CBW |
3459 | A morpheme X<tokens, defined>in a programming language, the smallest unit |
3460 | of text with semantic significance. | |
97a1d740 YST |
3461 | |
3462 | =item tokener | |
3463 | ||
c7166200 CBW |
3464 | A module that X<tokeners, defined>breaks a program text into a sequence of |
3465 | B<tokens> for later analysis by a parser. | |
97a1d740 YST |
3466 | |
3467 | =item tokenizing | |
3468 | ||
c7166200 CBW |
3469 | Splitting up a X<tokenizing>program text into B<tokens>. Also known as |
3470 | “lexing”, in which case you get “lexemes” instead of tokens. | |
97a1d740 YST |
3471 | |
3472 | =item toolbox approach | |
3473 | ||
c7166200 CBW |
3474 | The notion that, X<toolbox approach>with a complete set of simple tools |
3475 | that work well together, you can build almost anything you want. Which is | |
3476 | fine if you’re assembling a tricycle, but if you’re building a | |
3477 | defranishizing comboflux regurgalator, you really want your own machine | |
3478 | shop in which to build special tools. Perl is sort of a machine shop. | |
3479 | ||
3480 | =item topic | |
3481 | ||
3482 | The thing you’re X<topics (term)>working on. Structures like | |
3483 | C<while(E<lt>E<gt>)>, C<for>, C<foreach>, and C<given> set the topic for | |
3484 | you by assigning to C<$_>, the default (I<topic>) variable. | |
97a1d740 YST |
3485 | |
3486 | =item transliterate | |
3487 | ||
c7166200 CBW |
3488 | To turn one X<tr/// (transliteration) operator, about>X<strings, |
3489 | transliteration of>X<transliteration (tr///) operator, about>string | |
3490 | representation into another by mapping each character of the source string | |
3491 | to its corresponding character in the result string. Not to be confused | |
3492 | with translation: for example, Greek I<πολύχρωμος> transliterates into | |
3493 | I<polychromos> but translates into I<many-colored>. See the C<tr///> | |
3494 | operator in Camel chapter 5, “Pattern Matching”. | |
97a1d740 YST |
3495 | |
3496 | =item trigger | |
3497 | ||
c7166200 | 3498 | An event X<triggers (term)>that causes a B<handler> to be run. |
97a1d740 YST |
3499 | |
3500 | =item trinary | |
3501 | ||
c7166200 CBW |
3502 | Not a X<trinary operators>stellar system with three stars, but an |
3503 | B<operator> taking three B<operands>. Sometimes pronounced B<ternary>. | |
97a1d740 YST |
3504 | |
3505 | =item troff | |
3506 | ||
c7166200 CBW |
3507 | A venerable X<troff language>typesetting language from which Perl derives |
3508 | the name of its C<$%> variable and which is secretly used in the production | |
3509 | of Camel books. | |
97a1d740 YST |
3510 | |
3511 | =item true | |
3512 | ||
c7166200 CBW |
3513 | Any X<true values>X<values, true>scalar value that doesn’t evaluate to 0 or |
3514 | C<"">. | |
97a1d740 YST |
3515 | |
3516 | =item truncating | |
3517 | ||
c7166200 CBW |
3518 | Emptying a X<truncate function>X<files, truncating>file of existing |
3519 | contents, either automatically when opening a file for writing or | |
3520 | explicitly via the C<truncate> function. | |
97a1d740 YST |
3521 | |
3522 | =item type | |
3523 | ||
c7166200 | 3524 | SeeX<type> B<data type> and B<class>. |
97a1d740 YST |
3525 | |
3526 | =item type casting | |
3527 | ||
c7166200 CBW |
3528 | Converting X<type casting>data from one type to another. C permits this. |
3529 | Perl does not need it. Nor want it. | |
97a1d740 | 3530 | |
c7166200 | 3531 | =item typedef |
97a1d740 | 3532 | |
c7166200 | 3533 | A type X<typedef>definition in the C and C++ languages. |
97a1d740 | 3534 | |
c7166200 | 3535 | =item typed lexical |
97a1d740 | 3536 | |
c7166200 CBW |
3537 | A B<lexical variable> X<typed lexicals>X<lexical variables, typed |
3538 | lexicals>X<variables, variable> lexical>that is declared with a B<class> | |
3539 | type: C<my Pony $bill>. | |
97a1d740 YST |
3540 | |
3541 | =item typeglob | |
3542 | ||
c7166200 CBW |
3543 | Use of X<typeglobs, defined>a single identifier, prefixed with C<*>. For |
3544 | example, C<*name> stands for any or all of C<$name>, C<@name>, C<%name>, | |
3545 | C<&name>, or just C<name>. How you use it determines whether it is | |
3546 | interpreted as all or only one of them. See “Typeglobs and Filehandles” in | |
3547 | Camel chapter 2, “Bits and Pieces”. | |
97a1d740 YST |
3548 | |
3549 | =item typemap | |
3550 | ||
c7166200 CBW |
3551 | A description of X<typemap>how C types may be transformed to and from Perl |
3552 | types within an B<extension> module written in B<XS>. | |
97a1d740 YST |
3553 | |
3554 | =back | |
3555 | ||
5bbd0522 YST |
3556 | =head2 U |
3557 | ||
97a1d740 YST |
3558 | =over 4 |
3559 | ||
3560 | =item UDP | |
3561 | ||
c7166200 CBW |
3562 | User Datagram Protocol, the X<User Datagram Protocol (UDP)>X<UDP (User |
3563 | Datagram Protocol)>X<datagrams, UDP support>typical way to send | |
3564 | B<datagrams> over the Internet. | |
97a1d740 YST |
3565 | |
3566 | =item UID | |
3567 | ||
c7166200 CBW |
3568 | A user ID. X<UID (user ID)>X<user ID (UID)>Often used in the context of |
3569 | B<file> or B<process> ownership. | |
97a1d740 YST |
3570 | |
3571 | =item umask | |
3572 | ||
c7166200 CBW |
3573 | A X<umask function>mask of those B<permission bits> that should be forced |
3574 | off when creating files or directories, in order to establish a policy of | |
3575 | whom you’ll ordinarily deny access to. See the C<umask> function. | |
97a1d740 YST |
3576 | |
3577 | =item unary operator | |
3578 | ||
c7166200 CBW |
3579 | An X<unary operators, about>operator with only one B<operand>, like C<!> or |
3580 | C<chdir>. Unary operators are usually prefix operators; that is, they | |
3581 | precede their operand. The C<++> and C<––> operators can be either prefix | |
3582 | or postfix. (Their position I<does> change their meanings.) | |
97a1d740 YST |
3583 | |
3584 | =item Unicode | |
3585 | ||
c7166200 CBW |
3586 | A character set X<Unicode, about>comprising all the major character sets of |
3587 | the world, more or less. See L<http://www.unicode.org>. | |
97a1d740 YST |
3588 | |
3589 | =item Unix | |
3590 | ||
c7166200 CBW |
3591 | A very large X<Unix language>and constantly evolving language with several |
3592 | alternative and largely incompatible syntaxes, in which anyone can define | |
3593 | anything any way they choose, and usually do. Speakers of this language | |
3594 | think it’s easy to learn because it’s so easily twisted to one’s own ends, | |
97a1d740 | 3595 | but dialectical differences make tribal intercommunication nearly |
c7166200 CBW |
3596 | impossible, and travelers are often reduced to a pidgin-like subset of the |
3597 | language. To be universally understood, a Unix shell programmer must spend | |
3598 | years of study in the art. Many have abandoned this discipline and now | |
3599 | communicate via an Esperanto-like language called Perl. | |
97a1d740 | 3600 | |
c7166200 CBW |
3601 | In ancient times, Unix was also used to refer to some code that a couple of |
3602 | people at Bell Labs wrote to make use of a PDP-7 computer that wasn’t doing | |
3603 | much of anything else at the time. | |
3604 | ||
3605 | =item uppercase | |
3606 | ||
3607 | In Unicode, X<uppercase characters>X<characters, uppercase>not just | |
3608 | characters with the General Category of Uppercase Letter, but any character | |
3609 | with the Uppercase property, including some Letter Numbers and Symbols. Not | |
3610 | to be confused with B<titlecase>. | |
97a1d740 YST |
3611 | |
3612 | =back | |
3613 | ||
5bbd0522 YST |
3614 | =head2 V |
3615 | ||
97a1d740 YST |
3616 | =over 4 |
3617 | ||
3618 | =item value | |
3619 | ||
c7166200 CBW |
3620 | An actual piece X<values, defined>of data, in contrast to all the |
3621 | variables, references, keys, indices, operators, and whatnot that you need | |
3622 | to access the value. | |
97a1d740 YST |
3623 | |
3624 | =item variable | |
3625 | ||
c7166200 CBW |
3626 | A named storage X<variables, defined>X<variables>location that can hold any |
3627 | of various kinds of B<value>, as your program sees fit. | |
97a1d740 YST |
3628 | |
3629 | =item variable interpolation | |
3630 | ||
c7166200 CBW |
3631 | TheX<variable interpolation>X<interpolation, variable> B<interpolation> of |
3632 | a scalar or array variable into a string. | |
97a1d740 YST |
3633 | |
3634 | =item variadic | |
3635 | ||
c7166200 CBW |
3636 | Said of X<variadic (term)>a B<function> that happily receives an |
3637 | indeterminate number of B<actual arguments>. | |
97a1d740 YST |
3638 | |
3639 | =item vector | |
3640 | ||
c7166200 | 3641 | Mathematical X<vectors>jargon for a list of B<scalar values>. |
97a1d740 YST |
3642 | |
3643 | =item virtual | |
3644 | ||
c7166200 CBW |
3645 | Providing the X<virtual (term)>appearance of something without the reality, |
3646 | as in: virtual memory is not real memory. (See also B<memory>.) The | |
3647 | opposite of “virtual” is “transparent”, which means providing the reality | |
3648 | of something without the appearance, as in: Perl handles the | |
3649 | variable-length UTF‑8 character encoding transparently. | |
97a1d740 YST |
3650 | |
3651 | =item void context | |
3652 | ||
c7166200 CBW |
3653 | A form X<void context>X<context, void>of B<scalar context> in which an |
3654 | B<expression> is not expected to return any B<value> at all and is | |
3655 | evaluated for its B<side effects> alone. | |
97a1d740 YST |
3656 | |
3657 | =item v-string | |
3658 | ||
c7166200 CBW |
3659 | A “version” or “vector”X<v–strings>X<strings, v–strings> B<string> |
3660 | specified with a C<v> followed by a series of decimal integers in dot | |
3661 | notation, for instance, C<v1.20.300.4000>. Each number turns into a | |
3662 | B<character> with the specified ordinal value. (The C<v> is optional when | |
3663 | there are at least three integers.) | |
97a1d740 YST |
3664 | |
3665 | =back | |
3666 | ||
5bbd0522 YST |
3667 | =head2 W |
3668 | ||
97a1d740 YST |
3669 | =over 4 |
3670 | ||
3671 | =item warning | |
3672 | ||
c7166200 CBW |
3673 | A message X<warning messages>X<STDERR filehandle, warning messages |
3674 | and>printed to the C<STDERR> stream to the effect that something might be | |
3675 | wrong but isn’t worth blowing up over. See C<warn> in Camel chapter 27, | |
3676 | “Functions” and the C<warnings> pragma in Camel chapter 28, “Pragmantic | |
3677 | Modules”. | |
97a1d740 YST |
3678 | |
3679 | =item watch expression | |
3680 | ||
c7166200 CBW |
3681 | An expression which, X<watch expression>X<expressions, watch>when its value |
3682 | changes, causes a breakpoint in the Perl debugger. | |
3683 | ||
3684 | =item weak reference | |
3685 | ||
3686 | A X<weak references>X<references, weak>reference that doesn’t get counted | |
3687 | normally. When all the normal references to data disappear, the data | |
3688 | disappears. These are useful for circular references that would never | |
3689 | disappear otherwise. | |
97a1d740 YST |
3690 | |
3691 | =item whitespace | |
3692 | ||
c7166200 CBW |
3693 | A B<character> X<whitespace characters>X<characters, whitespace>that moves |
3694 | your cursor but doesn’t otherwise put anything on your screen. Typically | |
3695 | refers to any of: space, tab, line feed, carriage return, or form feed. In | |
3696 | Unicode, matches many other characters that Unicode considers whitespace, | |
3697 | including the ɴ-ʙʀ . | |
97a1d740 YST |
3698 | |
3699 | =item word | |
3700 | ||
c7166200 CBW |
3701 | In normal “computerese”, the X<words (term)>piece of data of the size most |
3702 | efficiently handled by your computer, typically 32 bits or so, give or take a | |
3703 | few powers of 2. In Perl culture, it more often refers to an alphanumeric | |
3704 | B<identifier> (including underscores), or to a string of nonwhitespace | |
3705 | B<characters> bounded by whitespace or string boundaries. | |
97a1d740 YST |
3706 | |
3707 | =item working directory | |
3708 | ||
c7166200 CBW |
3709 | Your X<working directory>X<directories, working>current B<directory>, from |
3710 | which relative pathnames are interpreted by the B<operating system>. The | |
3711 | operating system knows your current directory because you told it with a | |
3712 | C<chdir>, or because you started out in the place where your parent | |
3713 | B<process> was when you were born. | |
97a1d740 YST |
3714 | |
3715 | =item wrapper | |
3716 | ||
c7166200 CBW |
3717 | A program X<wrappers (term)>or subroutine that runs some other program or |
3718 | subroutine for you, modifying some of its input or output to better suit | |
3719 | your purposes. | |
97a1d740 YST |
3720 | |
3721 | =item WYSIWYG | |
3722 | ||
c7166200 CBW |
3723 | What X<WYSIWYG acronym>You See Is What You Get. Usually used when something |
3724 | that appears on the screen matches how it will eventually look, like Perl’s | |
3725 | C<format> declarations. Also used to mean the opposite of magic because | |
3726 | everything works exactly as it appears, as in the three- argument form of | |
3727 | C<open>. | |
97a1d740 YST |
3728 | |
3729 | =back | |
3730 | ||
5bbd0522 YST |
3731 | =head2 X |
3732 | ||
97a1d740 YST |
3733 | =over 4 |
3734 | ||
3735 | =item XS | |
3736 | ||
c7166200 CBW |
3737 | An X<XS (eXternal Subroutine)>X<eXternal Subroutine (XS)>extraordinarily |
3738 | exported, expeditiously excellent, expressly eXternal Subroutine, executed | |
3739 | in existing C or C++ or in an exciting extension language called | |
3740 | (exasperatingly) XS. | |
97a1d740 YST |
3741 | |
3742 | =item XSUB | |
3743 | ||
c7166200 | 3744 | An X<XSUB (term)>external B<subroutine> defined in B<XS>. |
97a1d740 YST |
3745 | |
3746 | =back | |
3747 | ||
5bbd0522 YST |
3748 | =head2 Y |
3749 | ||
97a1d740 YST |
3750 | =over 4 |
3751 | ||
3752 | =item yacc | |
3753 | ||
c7166200 CBW |
3754 | Yet X<yacc acronym>Another Compiler Compiler. A parser generator without |
3755 | which Perl probably would not have existed. See the file I<perly.y> in the | |
3756 | Perl source distribution. | |
97a1d740 YST |
3757 | |
3758 | =back | |
3759 | ||
5bbd0522 YST |
3760 | =head2 Z |
3761 | ||
97a1d740 YST |
3762 | =over 4 |
3763 | ||
3764 | =item zero width | |
3765 | ||
c7166200 CBW |
3766 | A X<zero–width assertions>X<subpatterns, zero–width assertions>X<assertions |
3767 | (in regexes), zero–width>subpattern B<assertion> matching the B<null | |
3768 | string> between B<characters>. | |
97a1d740 YST |
3769 | |
3770 | =item zombie | |
3771 | ||
c7166200 CBW |
3772 | A process X<zombie processes>X<processes, zombie>that has died (exited) but |
3773 | whose parent has not yet received proper notification of its demise by | |
3774 | virtue of having called C<wait> or C<waitpid>. If you C<fork>, you must | |
3775 | clean up after your child processes when they exit; otherwise, the process | |
3776 | table will fill up and your system administrator will Not Be Happy with | |
3777 | you. | |
97a1d740 YST |
3778 | |
3779 | =back | |
3780 | ||
3781 | =head1 AUTHOR AND COPYRIGHT | |
3782 | ||
c7166200 CBW |
3783 | Based on the Glossary of I<Programming Perl>, Fourth Edition, |
3784 | by Tom Christiansen, brian d foy, Larry Wall, & Jon Orwant. | |
3785 | Copyright (c) 2000, 1996, 1991, 2012 O'Reilly Media, Inc. | |
20fd23ef | 3786 | This document may be distributed under the same terms as Perl itself. |