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