From 83083feaedd84cf12545b4f5b0a7b037c12236ee Mon Sep 17 00:00:00 2001 From: Florian Ragwitz Date: Mon, 26 Sep 2011 18:53:55 +0200 Subject: Dual-life perlglossary.pod as part of perlfaq --- MANIFEST | 2 +- cpan/perlfaq/lib/perlglossary.pod | 3437 +++++++++++++++++++++++++++++++++++++ lib/.gitignore | 1 + pod.lst | 2 +- pod/perlglossary.pod | 3437 ------------------------------------- win32/pod.mak | 4 - 6 files changed, 3440 insertions(+), 3443 deletions(-) create mode 100644 cpan/perlfaq/lib/perlglossary.pod delete mode 100644 pod/perlglossary.pod diff --git a/MANIFEST b/MANIFEST index ad38262ce7..aa7e9fdae9 100644 --- a/MANIFEST +++ b/MANIFEST @@ -1867,6 +1867,7 @@ cpan/perlfaq/lib/perlfaq8.pod System Interaction cpan/perlfaq/lib/perlfaq9.pod Networking cpan/perlfaq/lib/perlfaq.pm Perl frequently asked questions cpan/perlfaq/lib/perlfaq.pod Perl frequently asked questions +cpan/perlfaq/lib/perlglossary.pod Perl Glossary cpan/PerlIO-via-QuotedPrint/lib/PerlIO/via/QuotedPrint.pm PerlIO::via::QuotedPrint cpan/PerlIO-via-QuotedPrint/t/QuotedPrint.t PerlIO::via::QuotedPrint cpan/Perl-OSType/lib/Perl/OSType.pm Perl::OSType @@ -4486,7 +4487,6 @@ pod/perlfork.pod Perl fork() information pod/perlform.pod Perl formats pod/perlfunc.pod Perl built-in functions pod/perlgit.pod Using git with the Perl repository -pod/perlglossary.pod Perl Glossary pod/perlgpl.pod GNU General Public License pod/perlguts.pod Perl internal functions for those doing extensions pod/perlhack.pod Perl hackers guide diff --git a/cpan/perlfaq/lib/perlglossary.pod b/cpan/perlfaq/lib/perlglossary.pod new file mode 100644 index 0000000000..014eb99fd5 --- /dev/null +++ b/cpan/perlfaq/lib/perlglossary.pod @@ -0,0 +1,3437 @@ +=head1 NAME + +perlglossary - Perl Glossary + +=head1 DESCRIPTION + +A glossary of terms (technical and otherwise) used in the Perl documentation. +Other useful sources include the Free On-Line Dictionary of Computing +L, the Jargon File +L, and Wikipedia L. + +=head2 A + +=over 4 + +=item accessor methods + +A L used to indirectly inspect or update an L's +state (its L). + +=item actual arguments + +The L that you supply to a L +or L when you call it. For instance, when you call +C, the string C<"puff"> is the actual argument. See +also L and L. + +=item address operator + +Some languages work directly with the memory addresses of values, but +this can be like playing with fire. Perl provides a set of asbestos +gloves for handling all memory management. The closest to an address +operator in Perl is the backslash operator, but it gives you a L, which is much safer than a memory address. + +=item algorithm + +A well-defined sequence of steps, clearly enough explained that even a +computer could do them. + +=item alias + +A nickname for something, which behaves in all ways as though you'd +used the original name instead of the nickname. Temporary aliases are +implicitly created in the loop variable for C loops, in the +C<$_> variable for L or L +operators, in C<$a> and C<$b> during L's +comparison function, and in each element of C<@_> for the L of a subroutine call. Permanent aliases are explicitly +created in L by L symbols or by +assignment to L. Lexically scoped aliases for +package variables are explicitly created by the L +declaration. + +=item alternatives + +A list of possible choices from which you may select only one, as in +"Would you like door A, B, or C?" Alternatives in regular expressions +are separated with a single vertical bar: C<|>. Alternatives in +normal Perl expressions are separated with a double vertical bar: +C<||>. Logical alternatives in L expressions are separated +with either C<||> or C. + +=item anonymous + +Used to describe a L that is not directly accessible +through a named L. Such a referent must be indirectly +accessible through at least one L. When the last +hard reference goes away, the anonymous referent is destroyed without +pity. + +=item architecture + +The kind of computer you're working on, where one "kind" of computer +means all those computers sharing a compatible machine language. +Since Perl programs are (typically) simple text files, not executable +images, a Perl program is much less sensitive to the architecture it's +running on than programs in other languages, such as C, that are +compiled into machine code. See also L and L. + +=item argument + +A piece of data supplied to a L, +L, L, or L to tell it what it's +supposed to do. Also called a "parameter". + +=item ARGV + +The name of the array containing the L L from the +command line. If you use the empty C<< EE >> operator, L is +the name of both the L used to traverse the arguments and +the L containing the name of the current input file. + +=item arithmetical operator + +A L such as C<+> or C that tells Perl to do the arithmetic +you were supposed to learn in grade school. + +=item array + +An ordered sequence of L, stored such that you can +easily access any of the values using an integer L +that specifies the value's L in the sequence. + +=item array context + +An archaic expression for what is more correctly referred to as +L. + +=item ASCII + +The American Standard Code for Information Interchange (a 7-bit +character set adequate only for poorly representing English text). +Often used loosely to describe the lowest 128 values of the various +ISO-8859-X character sets, a bunch of mutually incompatible 8-bit +codes sometimes described as half ASCII. See also L. + +=item assertion + +A component of a L that must be true for the +pattern to match but does not necessarily match any characters itself. +Often used specifically to mean a L assertion. + +=item assignment + +An L whose assigned mission in life is to change the value +of a L. + +=item assignment operator + +Either a regular L, or a compound L composed +of an ordinary assignment and some other operator, that changes the +value of a variable in place, that is, relative to its old value. For +example, C<$a += 2> adds C<2> to C<$a>. + +=item associative array + +See L. Please. + +=item associativity + +Determines whether you do the left L first or the right +L first when you have "A L B L C" and +the two operators are of the same precedence. Operators like C<+> are +left associative, while operators like C<**> are right associative. +See L for a list of operators and their associativity. + +=item asynchronous + +Said of events or activities whose relative temporal ordering is +indeterminate because too many things are going on at once. Hence, an +asynchronous event is one you didn't know when to expect. + +=item atom + +A L component potentially matching a +L containing one or more characters and treated as an +indivisible syntactic unit by any following L. (Contrast +with an L that matches something of L and may +not be quantified.) + +=item atomic operation + +When Democritus gave the word "atom" to the indivisible bits of +matter, he meant literally something that could not be cut: I +(not) + I (cuttable). An atomic operation is an action that +can't be interrupted, not one forbidden in a nuclear-free zone. + +=item attribute + +A new feature that allows the declaration of L +and L with modifiers as in C. Also, another name for an L of an +L. + +=item autogeneration + +A feature of L of L, whereby +the behavior of certain L can be reasonably +deduced using more fundamental operators. This assumes that the +overloaded operators will often have the same relationships as the +regular operators. See L. + +=item autoincrement + +To add one to something automatically, hence the name of the C<++> +operator. To instead subtract one from something automatically is +known as an "autodecrement". + +=item autoload + +To load on demand. (Also called "lazy" loading.) Specifically, to +call an L subroutine on behalf of an +undefined subroutine. + +=item autosplit + +To split a string automatically, as the B<-a> L does when +running under B<-p> or B<-n> in order to emulate L. (See also +the L module, which has nothing to do with the B<-a> +switch, but a lot to do with autoloading.) + +=item autovivification + +A Greco-Roman word meaning "to bring oneself to life". In Perl, +storage locations (L) spontaneously generate +themselves as needed, including the creation of any L +values to point to the next level of storage. The assignment +C<$a[5][5][5][5][5] = "quintet"> potentially creates five scalar +storage locations, plus four references (in the first four scalar +locations) pointing to four new anonymous arrays (to hold the last +four scalar locations). But the point of autovivification is that you +don't have to worry about it. + +=item AV + +Short for "array value", which refers to one of Perl's internal data +types that holds an L. The L type is a subclass of +L. + +=item awk + +Descriptive editing term--short for "awkward". Also coincidentally +refers to a venerable text-processing language from which Perl derived +some of its high-level ideas. + +=back + +=head2 B + +=over 4 + +=item backreference + +A substring L by a subpattern within +unadorned parentheses in a L, also referred to as a capture group. The +sequences (C<\g1>, C<\g2>, etc.) later in the same pattern refer back to +the corresponding subpattern in the current match. Outside the pattern, +the numbered variables (C<$1>, C<$2>, etc.) continue to refer to these +same values, as long as the pattern was the last successful match of +the current dynamic scope. C<\g{-1}> can be used to refer to a group by +relative rather than absolute position; and groups can be also be named, and +referred to later by name rather than number. See L. + +=item backtracking + +The practice of saying, "If I had to do it all over, I'd do it +differently," and then actually going back and doing it all over +differently. Mathematically speaking, it's returning from an +unsuccessful recursion on a tree of possibilities. Perl backtracks +when it attempts to match patterns with a L, and +its earlier attempts don't pan out. See L. + +=item backward compatibility + +Means you can still run your old program because we didn't break any +of the features or bugs it was relying on. + +=item bareword + +A word sufficiently ambiguous to be deemed illegal under L. In the absence of that stricture, a +bareword is treated as if quotes were around it. + +=item base class + +A generic L type; that is, a L from which other, more +specific classes are derived genetically by L. Also +called a "superclass" by people who respect their ancestors. + +=item big-endian + +From Swift: someone who eats eggs big end first. Also used of +computers that store the most significant L of a word at a +lower byte address than the least significant byte. Often considered +superior to little-endian machines. See also L. + +=item binary + +Having to do with numbers represented in base 2. That means there's +basically two numbers, 0 and 1. Also used to describe a "non-text +file", presumably because such a file makes full use of all the binary +bits in its bytes. With the advent of L, this distinction, +already suspect, loses even more of its meaning. + +=item binary operator + +An L that takes two L. + +=item bind + +To assign a specific L to a L. + +=item bit + +An integer in the range from 0 to 1, inclusive. The smallest possible +unit of information storage. An eighth of a L or of a dollar. +(The term "Pieces of Eight" comes from being able to split the old +Spanish dollar into 8 bits, each of which still counted for money. +That's why a 25-cent piece today is still "two bits".) + +=item bit shift + +The movement of bits left or right in a computer word, which has the +effect of multiplying or dividing by a power of 2. + +=item bit string + +A sequence of L that is actually being thought of as a +sequence of bits, for once. + +=item bless + +In corporate life, to grant official approval to a thing, as in, "The +VP of Engineering has blessed our WebCruncher project." Similarly in +Perl, to grant official approval to a L so that it can +function as an L, such as a WebCruncher object. See +L. + +=item block + +What a L does when it has to wait for something: "My process +blocked waiting for the disk." As an unrelated noun, it refers to a +large chunk of data, of a size that the L likes to +deal with (normally a power of two such as 512 or 8192). Typically +refers to a chunk of data that's coming from or going to a disk file. + +=item BLOCK + +A syntactic construct consisting of a sequence of Perl +L that is delimited by braces. The C and +C statements are defined in terms of L, for instance. +Sometimes we also say "block" to mean a lexical scope; that is, a +sequence of statements that act like a L, such as within an +L or a file, even though the statements aren't +delimited by braces. + +=item block buffering + +A method of making input and output efficient by passing one L +at a time. By default, Perl does block buffering to disk files. See +L and L. + +=item Boolean + +A value that is either L or L. + +=item Boolean context + +A special kind of L used in conditionals to decide +whether the L returned by an expression is L or +L. Does not evaluate as either a string or a number. See +L. + +=item breakpoint + +A spot in your program where you've told the debugger to stop +L so you can poke around and see whether anything +is wrong yet. + +=item broadcast + +To send a L to multiple destinations simultaneously. + +=item BSD + +A psychoactive drug, popular in the 80s, probably developed at +U. C. Berkeley or thereabouts. Similar in many ways to the +prescription-only medication called "System V", but infinitely more +useful. (Or, at least, more fun.) The full chemical name is +"Berkeley Standard Distribution". + +=item bucket + +A location in a L containing (potentially) multiple +entries whose keys "hash" to the same hash value according to its hash +function. (As internal policy, you don't have to worry about it, +unless you're into internals, or policy.) + +=item buffer + +A temporary holding location for data. L means that the data is passed on to its destination +whenever the buffer is full. L means +that it's passed on whenever a complete line is received. L means that it's passed every time you do +a L command (or equivalent). If your output is +unbuffered, the system processes it one byte at a time without the use +of a holding area. This can be rather inefficient. + +=item built-in + +A L that is predefined in the language. Even when hidden +by L, you can always get at a built-in function by +L its name with the C pseudo-package. + +=item bundle + +A group of related modules on L. (Also, sometimes refers to a +group of command-line switches grouped into one L.) + +=item byte + +A piece of data worth eight L in most places. + +=item bytecode + +A pidgin-like language spoken among 'droids when they don't wish to +reveal their orientation (see L). Named after some similar +languages spoken (for similar reasons) between compilers and +interpreters in the late 20th century. These languages are +characterized by representing everything as a +non-architecture-dependent sequence of bytes. + +=back + +=head2 C + +=over 4 + +=item C + +A language beloved by many for its inside-out L definitions, +inscrutable L rules, and heavy L of the +function-call mechanism. (Well, actually, people first switched to C +because they found lowercase identifiers easier to read than upper.) +Perl is written in C, so it's not surprising that Perl borrowed a few +ideas from it. + +=item C preprocessor + +The typical C compiler's first pass, which processes lines beginning +with C<#> for conditional compilation and macro definition and does +various manipulations of the program text based on the current +definitions. Also known as I(1). + +=item call by reference + +An L-passing mechanism in which the L +refer directly to the L, and the L can +change the actual arguments by changing the formal arguments. That +is, the formal argument is an L for the actual argument. See +also L. + +=item call by value + +An L-passing mechanism in which the L +refer to a copy of the L, and the L +cannot change the actual arguments by changing the formal arguments. +See also L. + +=item callback + +A L that you register with some other part of your program +in the hope that the other part of your program will L your +handler when some event of interest transpires. + +=item canonical + +Reduced to a standard form to facilitate comparison. + +=item capture buffer, capture group + +These two terms are synonymous: +a L by a regex subpattern. + +=item capturing + +The use of parentheses around a L in a L to store the matched L as a L +or L. +(Captured strings are also returned as a list in L.) + +=item character + +A small integer representative of a unit of orthography. +Historically, characters were usually stored as fixed-width integers +(typically in a byte, or maybe two, depending on the character set), +but with the advent of UTF-8, characters are often stored in a +variable number of bytes depending on the size of the integer that +represents the character. Perl manages this transparently for you, +for the most part. + +=item character class + +A square-bracketed list of characters used in a L +to indicate that any character of the set may occur at a given point. +Loosely, any predefined set of characters so used. + +=item character property + +A predefined L matchable by the C<\p> +L. Many standard properties are defined for L. + +=item circumfix operator + +An L that surrounds its L, like the angle +operator, or parentheses, or a hug. + +=item class + +A user-defined L, implemented in Perl via a L that +provides (either directly or by inheritance) L (that +is, L) to handle L of +the class (its L). See also L. + +=item class method + +A L whose L is a L name, not an +L reference. A method associated with the class as a whole. + +=item client + +In networking, a L that initiates contact with a L +process in order to exchange data and perhaps receive a service. + +=item cloister + +A L used to restrict the scope of a L. + +=item closure + +An L subroutine that, when a reference to it is generated +at run time, keeps track of the identities of externally visible +L even after those lexical +variables have supposedly gone out of L. They're called +"closures" because this sort of behavior gives mathematicians a sense +of closure. + +=item cluster + +A parenthesized L used to group parts of a L into a single L. + +=item CODE + +The word returned by the L function when you apply +it to a reference to a subroutine. See also L. + +=item code generator + +A system that writes code for you in a low-level language, such as +code to implement the backend of a compiler. See L. + +=item code point + +The position of a character in a character set encoding. The character +C is almost certainly at the zeroth position in all character +sets, so its code point is 0. The code point for the C +character in the ASCII character set is 0x20, or 32 decimal; in EBCDIC +it is 0x40, or 64 decimal. The L function returns +the code point of a character. + +"code position" and "ordinal" mean the same thing as "code point". + +=item code subpattern + +A L subpattern whose real purpose is to execute +some Perl code, for example, the C<(?{...})> and C<(??{...})> +subpatterns. + +=item collating sequence + +The order into which L sort. This is used by +L comparison routines to decide, for example, where in this +glossary to put "collating sequence". + +=item command + +In L programming, the syntactic combination of a program name +and its arguments. More loosely, anything you type to a shell (a +command interpreter) that starts it doing something. Even more +loosely, a Perl L, which might start with a L and +typically ends with a semicolon. + +=item command buffering + +A mechanism in Perl that lets you store up the output of each Perl +L and then flush it out as a single request to the +L. It's enabled by setting the C<$|> +(C<$AUTOFLUSH>) variable to a true value. It's used when you don't +want data sitting around not going where it's supposed to, which may +happen because the default on a L or L is to use +L. + +=item command name + +The name of the program currently executing, as typed on the command +line. In C, the L name is passed to the program as the +first command-line argument. In Perl, it comes in separately as +C<$0>. + +=item command-line arguments + +The L you supply along with a program name when you +tell a L to execute a L. These values are passed to +a Perl program through C<@ARGV>. + +=item comment + +A remark that doesn't affect the meaning of the program. In Perl, a +comment is introduced by a C<#> character and continues to the end of +the line. + +=item compilation unit + +The L (or L, in the case of L) +that is currently being compiled. + +=item compile phase + +Any time before Perl starts running your main program. See also +L. Compile phase is mostly spent in L, but +may also be spent in L when C blocks, +L declarations, or constant subexpressions are being +evaluated. The startup and import code of any L +declaration is also run during compile phase. + +=item compile time + +The time when Perl is trying to make sense of your code, as opposed to +when it thinks it knows what your code means and is merely trying to +do what it thinks your code says to do, which is L. + +=item compiler + +Strictly speaking, a program that munches up another program and spits +out yet another file containing the program in a "more executable" +form, typically containing native machine instructions. The I +program is not a compiler by this definition, but it does contain a +kind of compiler that takes a program and turns it into a more +executable form (L) within the I +process itself, which the L then interprets. There are, +however, extension L to get Perl to act more like a +"real" compiler. See L. + +=item composer + +A "constructor" for a L that isn't really an L, +like an anonymous array or a hash (or a sonata, for that matter). For +example, a pair of braces acts as a composer for a hash, and a pair of +brackets acts as a composer for an array. See L. + +=item concatenation + +The process of gluing one cat's nose to another cat's tail. Also, a +similar operation on two L. + +=item conditional + +Something "iffy". See L. + +=item connection + +In telephony, the temporary electrical circuit between the caller's +and the callee's phone. In networking, the same kind of temporary +circuit between a L and a L. + +=item construct + +As a noun, a piece of syntax made up of smaller pieces. As a +transitive verb, to create an L using a L. + +=item constructor + +Any L, instance L, or L +that composes, initializes, blesses, and returns an L. +Sometimes we use the term loosely to mean a L. + +=item context + +The surroundings, or environment. The context given by the +surrounding code determines what kind of data a particular +L is expected to return. The three primary contexts are +L, L, and L. Scalar +context is sometimes subdivided into L, L, L, and L. There's also a +"don't care" scalar context (which is dealt with in Programming Perl, +Third Edition, Chapter 2, "Bits and Pieces" if you care). + +=item continuation + +The treatment of more than one physical L as a single logical +line. L lines are continued by putting a backslash before +the L. Mail headers as defined by RFC 822 are continued by +putting a space or tab I the newline. In general, lines in +Perl do not need any form of continuation mark, because L +(including newlines) is gleefully ignored. Usually. + +=item core dump + +The corpse of a L, in the form of a file left in the +L of the process, usually as a result of certain +kinds of fatal error. + +=item CPAN + +The Comprehensive Perl Archive Network. (See L). + +=item cracker + +Someone who breaks security on computer systems. A cracker may be a +true L or only a L. + +=item current package + +The L in which the current statement is compiled. Scan +backwards in the text of your program through the current L or any enclosing lexical scopes till you find +a package declaration. That's your current package name. + +=item current working directory + +See L. + +=item currently selected output channel + +The last L that was designated with +L(C); L, if no filehandle +has been selected. + +=item CV + +An internal "code value" typedef, holding a L. The L +type is a subclass of L. + +=back + +=head2 D + +=over 4 + +=item dangling statement + +A bare, single L, without any braces, hanging off an C +or C conditional. C allows them. Perl doesn't. + +=item data structure + +How your various pieces of data relate to each other and what shape +they make when you put them all together, as in a rectangular table or +a triangular-shaped tree. + +=item data type + +A set of possible values, together with all the operations that know +how to deal with those values. For example, a numeric data type has a +certain set of numbers that you can work with and various mathematical +operations that you can do on the numbers but would make little sense +on, say, a string such as C<"Kilroy">. Strings have their own +operations, such as L. Compound types made of a +number of smaller pieces generally have operations to compose and +decompose them, and perhaps to rearrange them. L +that model things in the real world often have operations that +correspond to real activities. For instance, if you model an +elevator, your elevator object might have an C +L. + +=item datagram + +A packet of data, such as a L message, that (from the viewpoint +of the programs involved) can be sent independently over the network. +(In fact, all packets are sent independently at the L level, but +L protocols such as L hide this from your program.) + +=item DBM + +Stands for "Data Base Management" routines, a set of routines that +emulate an L using disk files. The routines use a +dynamic hashing scheme to locate any entry with only two disk +accesses. DBM files allow a Perl program to keep a persistent +L across multiple invocations. You can L +your hash variables to various DBM implementations--see L +and L. + +=item declaration + +An L that states something exists and perhaps describes +what it's like, without giving any commitment as to how or where +you'll use it. A declaration is like the part of your recipe that +says, "two cups flour, one large egg, four or five tadpoles..." See +L for its opposite. Note that some declarations also +function as statements. Subroutine declarations also act as +definitions if a body is supplied. + +=item decrement + +To subtract a value from a variable, as in "decrement C<$x>" (meaning +to remove 1 from its value) or "decrement C<$x> by 3". + +=item default + +A L chosen for you if you don't supply a value of your own. + +=item defined + +Having a meaning. Perl thinks that some of the things people try to +do are devoid of meaning, in particular, making use of variables that +have never been given a L and performing certain operations on +data that isn't there. For example, if you try to read data past the +end of a file, Perl will hand you back an undefined value. See also +L and L. + +=item delimiter + +A L or L that sets bounds to an arbitrarily-sized +textual object, not to be confused with a L or +L. "To delimit" really just means "to surround" or "to +enclose" (like these parentheses are doing). + +=item deprecated modules and features + +Deprecated modules and features are those which were part of a stable +release, but later found to be subtly flawed, and which should be avoided. +They are subject to removal and/or bug-incompatible reimplementation in +the next major release (but they will be preserved through maintenance +releases). Deprecation warnings are issued under B<-w> or C, and notices are found in Ls, as well as various +other PODs. Coding practices that misuse features, such as C, can also be deprecated. + +=item dereference + +A fancy computer science term meaning "to follow a L to +what it points to". The "de" part of it refers to the fact that +you're taking away one level of L. + +=item derived class + +A L that defines some of its L in terms of a +more generic class, called a L. Note that classes aren't +classified exclusively into base classes or derived classes: a class +can function as both a derived class and a base class simultaneously, +which is kind of classy. + +=item descriptor + +See L. + +=item destroy + +To deallocate the memory of a L (first triggering its +C method, if it has one). + +=item destructor + +A special L that is called when an L is thinking +about L itself. A Perl program's C +method doesn't do the actual destruction; Perl just +L the method in case the L wants to do any +associated cleanup. + +=item device + +A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a +joystick or a mouse) attached to your computer, that the L tries to make look like a L (or a bunch of files). +Under Unix, these fake files tend to live in the I directory. + +=item directive + +A L directive. See L. + +=item directory + +A special file that contains other files. Some L call these "folders", "drawers", or +"catalogs". + +=item directory handle + +A name that represents a particular instance of opening a directory to +read it, until you close it. See the L +function. + +=item dispatch + +To send something to its correct destination. Often used +metaphorically to indicate a transfer of programmatic control to a +destination selected algorithmically, often by lookup in a table of +function L or, in the case of object +L, by traversing the inheritance tree looking for the +most specific definition for the method. + +=item distribution + +A standard, bundled release of a system of software. The default +usage implies source code is included. If that is not the case, it +will be called a "binary-only" distribution. + +=item (to be) dropped modules + +When Perl 5 was first released (see L), several modules were +included, which have now fallen out of common use. It has been suggested +that these modules should be removed, since the distribution became rather +large, and the common criterion for new module additions is now limited to +modules that help to build, test, and extend perl itself. Furthermore, +the CPAN (which didn't exist at the time of Perl 5.0) can become the new +home of dropped modules. Dropping modules is currently not an option, but +further developments may clear the last barriers. + +=item dweomer + +An enchantment, illusion, phantasm, or jugglery. Said when Perl's +magical L effects don't do what you expect, but rather seem +to be the product of arcane dweomercraft, sorcery, or wonder working. +[From Old English] + +=item dwimmer + +DWIM is an acronym for "Do What I Mean", the principle that something +should just do what you want it to do without an undue amount of fuss. +A bit of code that does "dwimming" is a "dwimmer". Dwimming can +require a great deal of behind-the-scenes magic, which (if it doesn't +stay properly behind the scenes) is called a L instead. + +=item dynamic scoping + +Dynamic scoping works over a dynamic scope, making variables visible +throughout the rest of the L in which they are first used and +in any L that are called by the rest of the +block. Dynamically scoped variables can have their values temporarily +changed (and implicitly restored later) by a L +operator. (Compare L.) Used more loosely to mean +how a subroutine that is in the middle of calling another subroutine +"contains" that subroutine at L. + +=back + +=head2 E + +=over 4 + +=item eclectic + +Derived from many sources. Some would say I many. + +=item element + +A basic building block. When you're talking about an L, it's +one of the items that make up the array. + +=item embedding + +When something is contained in something else, particularly when that +might be considered surprising: "I've embedded a complete Perl +interpreter in my editor!" + +=item empty list + +See . + +=item empty subclass test + +The notion that an empty L should behave exactly like +its L. + +=item en passant + +When you change a L as it is being copied. [From French, "in +passing", as in the exotic pawn-capturing maneuver in chess.] + +=item encapsulation + +The veil of abstraction separating the L from the +L (whether enforced or not), which mandates that all +access to an L's state be through L alone. + +=item endian + +See L and L. + +=item environment + +The collective set of L +your L inherits from its parent. Accessed via C<%ENV>. + +=item environment variable + +A mechanism by which some high-level agent such as a user can pass its +preferences down to its future offspring (child L, +grandchild processes, great-grandchild processes, and so on). Each +environment variable is a L/L pair, like one entry in a +L. + +=item EOF + +End of File. Sometimes used metaphorically as the terminating string +of a L. + +=item errno + +The error number returned by a L when it fails. Perl refers +to the error by the name C<$!> (or C<$OS_ERROR> if you use the English +module). + +=item error + +See L or L. + +=item escape sequence + +See L. + +=item exception + +A fancy term for an error. See L. + +=item exception handling + +The way a program responds to an error. The exception handling +mechanism in Perl is the L operator. + +=item exec + +To throw away the current L's program and replace it with +another without exiting the process or relinquishing any resources +held (apart from the old memory image). + +=item executable file + +A L that is specially marked to tell the L +that it's okay to run this file as a program. Usually shortened to +"executable". + +=item execute + +To run a L or L. (Has nothing +to do with the L built-in, unless you're trying to +run a L.) + +=item execute bit + +The special mark that tells the operating system it can run this +program. There are actually three execute bits under Unix, and which +bit gets used depends on whether you own the file singularly, +collectively, or not at all. + +=item exit status + +See L. + +=item export + +To make symbols from a L available for L by other modules. + +=item expression + +Anything you can legally say in a spot where a L is required. +Typically composed of L, L, +L, L, and L +calls, not necessarily in that order. + +=item extension + +A Perl module that also pulls in compiled C or C++ code. More +generally, any experimental option that can be compiled into Perl, +such as multithreading. + +=back + +=head2 F + +=over 4 + +=item false + +In Perl, any value that would look like C<""> or C<"0"> if evaluated +in a string context. Since undefined values evaluate to C<"">, all +undefined values are false (including the L), but not all +false values are undefined. + +=item FAQ + +Frequently Asked Question (although not necessarily frequently +answered, especially if the answer appears in the Perl FAQ shipped +standard with Perl). + +=item fatal error + +An uncaught L, which causes termination of the L +after printing a message on your L stream. Errors +that happen inside an L are not fatal. Instead, +the L terminates after placing the exception +message in the C<$@> (C<$EVAL_ERROR>) variable. You can try to +provoke a fatal error with the L operator (known as +throwing or raising an exception), but this may be caught by a +dynamically enclosing L. If not caught, the +L becomes a fatal error. + +=item field + +A single piece of numeric or string data that is part of a longer +L, L, or L. Variable-width fields are usually +split up by L (so use L to +extract the fields), while fixed-width fields are usually at fixed +positions (so use L). L are also known as fields. + +=item FIFO + +First In, First Out. See also L. Also, a nickname for a +L. + +=item file + +A named collection of data, usually stored on disk in a L +in a L. Roughly like a document, if you're into office +metaphors. In modern filesystems, you can actually give a file more +than one name. Some files have special properties, like directories +and devices. + +=item file descriptor + +The little number the L uses to keep track of which +opened L you're talking about. Perl hides the file descriptor +inside a LO> stream and then attaches the stream to +a L. + +=item file test operator + +A built-in unary operator that you use to determine whether something +is L about a file, such as C<-o $filename> to test whether +you're the owner of the file. + +=item fileglob + +A "wildcard" match on L. See the +L function. + +=item filehandle + +An identifier (not necessarily related to the real name of a file) +that represents a particular instance of opening a file until you +close it. If you're going to open and close several different files +in succession, it's fine to open each of them with the same +filehandle, so you don't have to write out separate code to process +each file. + +=item filename + +One name for a file. This name is listed in a L, and you +can use it in an L to tell the L exactly which file you want to open, and associate the file +with a L which will carry the subsequent identity of that +file in your program, until you close it. + +=item filesystem + +A set of L and L residing on a +partition of the disk. Sometimes known as a "partition". You can +change the file's name or even move a file around from directory to +directory within a filesystem without actually moving the file itself, +at least under Unix. + +=item filter + +A program designed to take a L of input and transform it into +a stream of output. + +=item flag + +We tend to avoid this term because it means so many things. It may +mean a command-line L that takes no argument +itself (such as Perl's B<-n> and B<-p> +flags) or, less frequently, a single-bit indicator (such as the +C and C flags used in +L). + +=item floating point + +A method of storing numbers in "scientific notation", such that the +precision of the number is independent of its magnitude (the decimal +point "floats"). Perl does its numeric work with floating-point +numbers (sometimes called "floats"), when it can't get away with +using L. Floating-point numbers are mere +approximations of real numbers. + +=item flush + +The act of emptying a L, often before it's full. + +=item FMTEYEWTK + +Far More Than Everything You Ever Wanted To Know. An exhaustive +treatise on one narrow topic, something of a super-L. See Tom +for far more. + +=item fork + +To create a child L identical to the parent process at its +moment of conception, at least until it gets ideas of its own. A +thread with protected memory. + +=item formal arguments + +The generic names by which a L knows its +L. In many languages, formal arguments are +always given individual names, but in Perl, the formal arguments are +just the elements of an array. The formal arguments to a Perl program +are C<$ARGV[0]>, C<$ARGV[1]>, and so on. Similarly, the formal +arguments to a Perl subroutine are C<$_[0]>, C<$_[1]>, and so on. You +may give the arguments individual names by assigning the values to a +L list. See also L. + +=item format + +A specification of how many spaces and digits and things to put +somewhere so that whatever you're printing comes out nice and pretty. + +=item freely available + +Means you don't have to pay money to get it, but the copyright on it +may still belong to someone else (like Larry). + +=item freely redistributable + +Means you're not in legal trouble if you give a bootleg copy of it to +your friends and we find out about it. In fact, we'd rather you gave +a copy to all your friends. + +=item freeware + +Historically, any software that you give away, particularly if you +make the source code available as well. Now often called C. Recently there has been a trend to use the term in +contradistinction to L, to refer only to free +software released under the Free Software Foundation's GPL (General +Public License), but this is difficult to justify etymologically. + +=item function + +Mathematically, a mapping of each of a set of input values to a +particular output value. In computers, refers to a L or +L that returns a L. It may or may not have input +values (called L). + +=item funny character + +Someone like Larry, or one of his peculiar friends. Also refers to +the strange prefixes that Perl requires as noun markers on its +variables. + +=back + +=head2 G + +=over 4 + +=item garbage collection + +A misnamed feature--it should be called, "expecting your mother to +pick up after you". Strictly speaking, Perl doesn't do this, but it +relies on a reference-counting mechanism to keep things tidy. +However, we rarely speak strictly and will often refer to the +reference-counting scheme as a form of garbage collection. (If it's +any comfort, when your interpreter exits, a "real" garbage collector +runs to make sure everything is cleaned up if you've been messy with +circular references and such.) + +=item GID + +Group ID--in Unix, the numeric group ID that the L +uses to identify you and members of your L. + +=item glob + +Strictly, the shell's C<*> character, which will match a "glob" of +characters when you're trying to generate a list of filenames. +Loosely, the act of using globs and similar symbols to do pattern +matching. See also L and L. + +=item global + +Something you can see from anywhere, usually used of +L and L that are visible +everywhere in your program. In Perl, only certain special variables +are truly global--most variables (and all subroutines) exist only in +the current L. Global variables can be declared with +L. See L. + +=item global destruction + +The L of globals (and the running of any +associated object destructors) that takes place when a Perl +L is being shut down. Global destruction should not be +confused with the Apocalypse, except perhaps when it should. + +=item glue language + +A language such as Perl that is good at hooking things together that +weren't intended to be hooked together. + +=item granularity + +The size of the pieces you're dealing with, mentally speaking. + +=item greedy + +A L whose L wants to match as many things as +possible. + +=item grep + +Originally from the old Unix editor command for "Globally search for a +Regular Expression and Print it", now used in the general sense of any +kind of search, especially text searches. Perl has a built-in +L function that searches a list for elements +matching any given criterion, whereas the I(1) program searches +for lines matching a L in one or more files. + +=item group + +A set of users of which you are a member. In some operating systems +(like Unix), you can give certain file access permissions to other +members of your group. + +=item GV + +An internal "glob value" typedef, holding a L. The L +type is a subclass of L. + +=back + +=head2 H + +=over 4 + +=item hacker + +Someone who is brilliantly persistent in solving technical problems, +whether these involve golfing, fighting orcs, or programming. Hacker +is a neutral term, morally speaking. Good hackers are not to be +confused with evil L or clueless L. - -=item current package - -The L in which the current statement is compiled. Scan -backwards in the text of your program through the current L or any enclosing lexical scopes till you find -a package declaration. That's your current package name. - -=item current working directory - -See L. - -=item currently selected output channel - -The last L that was designated with -L(C); L, if no filehandle -has been selected. - -=item CV - -An internal "code value" typedef, holding a L. The L -type is a subclass of L. - -=back - -=head2 D - -=over 4 - -=item dangling statement - -A bare, single L, without any braces, hanging off an C -or C conditional. C allows them. Perl doesn't. - -=item data structure - -How your various pieces of data relate to each other and what shape -they make when you put them all together, as in a rectangular table or -a triangular-shaped tree. - -=item data type - -A set of possible values, together with all the operations that know -how to deal with those values. For example, a numeric data type has a -certain set of numbers that you can work with and various mathematical -operations that you can do on the numbers but would make little sense -on, say, a string such as C<"Kilroy">. Strings have their own -operations, such as L. Compound types made of a -number of smaller pieces generally have operations to compose and -decompose them, and perhaps to rearrange them. L -that model things in the real world often have operations that -correspond to real activities. For instance, if you model an -elevator, your elevator object might have an C -L. - -=item datagram - -A packet of data, such as a L message, that (from the viewpoint -of the programs involved) can be sent independently over the network. -(In fact, all packets are sent independently at the L level, but -L protocols such as L hide this from your program.) - -=item DBM - -Stands for "Data Base Management" routines, a set of routines that -emulate an L using disk files. The routines use a -dynamic hashing scheme to locate any entry with only two disk -accesses. DBM files allow a Perl program to keep a persistent -L across multiple invocations. You can L -your hash variables to various DBM implementations--see L -and L. - -=item declaration - -An L that states something exists and perhaps describes -what it's like, without giving any commitment as to how or where -you'll use it. A declaration is like the part of your recipe that -says, "two cups flour, one large egg, four or five tadpoles..." See -L for its opposite. Note that some declarations also -function as statements. Subroutine declarations also act as -definitions if a body is supplied. - -=item decrement - -To subtract a value from a variable, as in "decrement C<$x>" (meaning -to remove 1 from its value) or "decrement C<$x> by 3". - -=item default - -A L chosen for you if you don't supply a value of your own. - -=item defined - -Having a meaning. Perl thinks that some of the things people try to -do are devoid of meaning, in particular, making use of variables that -have never been given a L and performing certain operations on -data that isn't there. For example, if you try to read data past the -end of a file, Perl will hand you back an undefined value. See also -L and L. - -=item delimiter - -A L or L that sets bounds to an arbitrarily-sized -textual object, not to be confused with a L or -L. "To delimit" really just means "to surround" or "to -enclose" (like these parentheses are doing). - -=item deprecated modules and features - -Deprecated modules and features are those which were part of a stable -release, but later found to be subtly flawed, and which should be avoided. -They are subject to removal and/or bug-incompatible reimplementation in -the next major release (but they will be preserved through maintenance -releases). Deprecation warnings are issued under B<-w> or C, and notices are found in Ls, as well as various -other PODs. Coding practices that misuse features, such as C, can also be deprecated. - -=item dereference - -A fancy computer science term meaning "to follow a L to -what it points to". The "de" part of it refers to the fact that -you're taking away one level of L. - -=item derived class - -A L that defines some of its L in terms of a -more generic class, called a L. Note that classes aren't -classified exclusively into base classes or derived classes: a class -can function as both a derived class and a base class simultaneously, -which is kind of classy. - -=item descriptor - -See L. - -=item destroy - -To deallocate the memory of a L (first triggering its -C method, if it has one). - -=item destructor - -A special L that is called when an L is thinking -about L itself. A Perl program's C -method doesn't do the actual destruction; Perl just -L the method in case the L wants to do any -associated cleanup. - -=item device - -A whiz-bang hardware gizmo (like a disk or tape drive or a modem or a -joystick or a mouse) attached to your computer, that the L tries to make look like a L (or a bunch of files). -Under Unix, these fake files tend to live in the I directory. - -=item directive - -A L directive. See L. - -=item directory - -A special file that contains other files. Some L call these "folders", "drawers", or -"catalogs". - -=item directory handle - -A name that represents a particular instance of opening a directory to -read it, until you close it. See the L -function. - -=item dispatch - -To send something to its correct destination. Often used -metaphorically to indicate a transfer of programmatic control to a -destination selected algorithmically, often by lookup in a table of -function L or, in the case of object -L, by traversing the inheritance tree looking for the -most specific definition for the method. - -=item distribution - -A standard, bundled release of a system of software. The default -usage implies source code is included. If that is not the case, it -will be called a "binary-only" distribution. - -=item (to be) dropped modules - -When Perl 5 was first released (see L), several modules were -included, which have now fallen out of common use. It has been suggested -that these modules should be removed, since the distribution became rather -large, and the common criterion for new module additions is now limited to -modules that help to build, test, and extend perl itself. Furthermore, -the CPAN (which didn't exist at the time of Perl 5.0) can become the new -home of dropped modules. Dropping modules is currently not an option, but -further developments may clear the last barriers. - -=item dweomer - -An enchantment, illusion, phantasm, or jugglery. Said when Perl's -magical L effects don't do what you expect, but rather seem -to be the product of arcane dweomercraft, sorcery, or wonder working. -[From Old English] - -=item dwimmer - -DWIM is an acronym for "Do What I Mean", the principle that something -should just do what you want it to do without an undue amount of fuss. -A bit of code that does "dwimming" is a "dwimmer". Dwimming can -require a great deal of behind-the-scenes magic, which (if it doesn't -stay properly behind the scenes) is called a L instead. - -=item dynamic scoping - -Dynamic scoping works over a dynamic scope, making variables visible -throughout the rest of the L in which they are first used and -in any L that are called by the rest of the -block. Dynamically scoped variables can have their values temporarily -changed (and implicitly restored later) by a L -operator. (Compare L.) Used more loosely to mean -how a subroutine that is in the middle of calling another subroutine -"contains" that subroutine at L. - -=back - -=head2 E - -=over 4 - -=item eclectic - -Derived from many sources. Some would say I many. - -=item element - -A basic building block. When you're talking about an L, it's -one of the items that make up the array. - -=item embedding - -When something is contained in something else, particularly when that -might be considered surprising: "I've embedded a complete Perl -interpreter in my editor!" - -=item empty list - -See . - -=item empty subclass test - -The notion that an empty L should behave exactly like -its L. - -=item en passant - -When you change a L as it is being copied. [From French, "in -passing", as in the exotic pawn-capturing maneuver in chess.] - -=item encapsulation - -The veil of abstraction separating the L from the -L (whether enforced or not), which mandates that all -access to an L's state be through L alone. - -=item endian - -See L and L. - -=item environment - -The collective set of L -your L inherits from its parent. Accessed via C<%ENV>. - -=item environment variable - -A mechanism by which some high-level agent such as a user can pass its -preferences down to its future offspring (child L, -grandchild processes, great-grandchild processes, and so on). Each -environment variable is a L/L pair, like one entry in a -L. - -=item EOF - -End of File. Sometimes used metaphorically as the terminating string -of a L. - -=item errno - -The error number returned by a L when it fails. Perl refers -to the error by the name C<$!> (or C<$OS_ERROR> if you use the English -module). - -=item error - -See L or L. - -=item escape sequence - -See L. - -=item exception - -A fancy term for an error. See L. - -=item exception handling - -The way a program responds to an error. The exception handling -mechanism in Perl is the L operator. - -=item exec - -To throw away the current L's program and replace it with -another without exiting the process or relinquishing any resources -held (apart from the old memory image). - -=item executable file - -A L that is specially marked to tell the L -that it's okay to run this file as a program. Usually shortened to -"executable". - -=item execute - -To run a L or L. (Has nothing -to do with the L built-in, unless you're trying to -run a L.) - -=item execute bit - -The special mark that tells the operating system it can run this -program. There are actually three execute bits under Unix, and which -bit gets used depends on whether you own the file singularly, -collectively, or not at all. - -=item exit status - -See L. - -=item export - -To make symbols from a L available for L by other modules. - -=item expression - -Anything you can legally say in a spot where a L is required. -Typically composed of L, L, -L, L, and L -calls, not necessarily in that order. - -=item extension - -A Perl module that also pulls in compiled C or C++ code. More -generally, any experimental option that can be compiled into Perl, -such as multithreading. - -=back - -=head2 F - -=over 4 - -=item false - -In Perl, any value that would look like C<""> or C<"0"> if evaluated -in a string context. Since undefined values evaluate to C<"">, all -undefined values are false (including the L), but not all -false values are undefined. - -=item FAQ - -Frequently Asked Question (although not necessarily frequently -answered, especially if the answer appears in the Perl FAQ shipped -standard with Perl). - -=item fatal error - -An uncaught L, which causes termination of the L -after printing a message on your L stream. Errors -that happen inside an L are not fatal. Instead, -the L terminates after placing the exception -message in the C<$@> (C<$EVAL_ERROR>) variable. You can try to -provoke a fatal error with the L operator (known as -throwing or raising an exception), but this may be caught by a -dynamically enclosing L. If not caught, the -L becomes a fatal error. - -=item field - -A single piece of numeric or string data that is part of a longer -L, L, or L. Variable-width fields are usually -split up by L (so use L to -extract the fields), while fixed-width fields are usually at fixed -positions (so use L). L are also known as fields. - -=item FIFO - -First In, First Out. See also L. Also, a nickname for a -L. - -=item file - -A named collection of data, usually stored on disk in a L -in a L. Roughly like a document, if you're into office -metaphors. In modern filesystems, you can actually give a file more -than one name. Some files have special properties, like directories -and devices. - -=item file descriptor - -The little number the L uses to keep track of which -opened L you're talking about. Perl hides the file descriptor -inside a LO> stream and then attaches the stream to -a L. - -=item file test operator - -A built-in unary operator that you use to determine whether something -is L about a file, such as C<-o $filename> to test whether -you're the owner of the file. - -=item fileglob - -A "wildcard" match on L. See the -L function. - -=item filehandle - -An identifier (not necessarily related to the real name of a file) -that represents a particular instance of opening a file until you -close it. If you're going to open and close several different files -in succession, it's fine to open each of them with the same -filehandle, so you don't have to write out separate code to process -each file. - -=item filename - -One name for a file. This name is listed in a L, and you -can use it in an L to tell the L exactly which file you want to open, and associate the file -with a L which will carry the subsequent identity of that -file in your program, until you close it. - -=item filesystem - -A set of L and L residing on a -partition of the disk. Sometimes known as a "partition". You can -change the file's name or even move a file around from directory to -directory within a filesystem without actually moving the file itself, -at least under Unix. - -=item filter - -A program designed to take a L of input and transform it into -a stream of output. - -=item flag - -We tend to avoid this term because it means so many things. It may -mean a command-line L that takes no argument -itself (such as Perl's B<-n> and B<-p> -flags) or, less frequently, a single-bit indicator (such as the -C and C flags used in -L). - -=item floating point - -A method of storing numbers in "scientific notation", such that the -precision of the number is independent of its magnitude (the decimal -point "floats"). Perl does its numeric work with floating-point -numbers (sometimes called "floats"), when it can't get away with -using L. Floating-point numbers are mere -approximations of real numbers. - -=item flush - -The act of emptying a L, often before it's full. - -=item FMTEYEWTK - -Far More Than Everything You Ever Wanted To Know. An exhaustive -treatise on one narrow topic, something of a super-L. See Tom -for far more. - -=item fork - -To create a child L identical to the parent process at its -moment of conception, at least until it gets ideas of its own. A -thread with protected memory. - -=item formal arguments - -The generic names by which a L knows its -L. In many languages, formal arguments are -always given individual names, but in Perl, the formal arguments are -just the elements of an array. The formal arguments to a Perl program -are C<$ARGV[0]>, C<$ARGV[1]>, and so on. Similarly, the formal -arguments to a Perl subroutine are C<$_[0]>, C<$_[1]>, and so on. You -may give the arguments individual names by assigning the values to a -L list. See also L. - -=item format - -A specification of how many spaces and digits and things to put -somewhere so that whatever you're printing comes out nice and pretty. - -=item freely available - -Means you don't have to pay money to get it, but the copyright on it -may still belong to someone else (like Larry). - -=item freely redistributable - -Means you're not in legal trouble if you give a bootleg copy of it to -your friends and we find out about it. In fact, we'd rather you gave -a copy to all your friends. - -=item freeware - -Historically, any software that you give away, particularly if you -make the source code available as well. Now often called C. Recently there has been a trend to use the term in -contradistinction to L, to refer only to free -software released under the Free Software Foundation's GPL (General -Public License), but this is difficult to justify etymologically. - -=item function - -Mathematically, a mapping of each of a set of input values to a -particular output value. In computers, refers to a L or -L that returns a L. It may or may not have input -values (called L). - -=item funny character - -Someone like Larry, or one of his peculiar friends. Also refers to -the strange prefixes that Perl requires as noun markers on its -variables. - -=back - -=head2 G - -=over 4 - -=item garbage collection - -A misnamed feature--it should be called, "expecting your mother to -pick up after you". Strictly speaking, Perl doesn't do this, but it -relies on a reference-counting mechanism to keep things tidy. -However, we rarely speak strictly and will often refer to the -reference-counting scheme as a form of garbage collection. (If it's -any comfort, when your interpreter exits, a "real" garbage collector -runs to make sure everything is cleaned up if you've been messy with -circular references and such.) - -=item GID - -Group ID--in Unix, the numeric group ID that the L -uses to identify you and members of your L. - -=item glob - -Strictly, the shell's C<*> character, which will match a "glob" of -characters when you're trying to generate a list of filenames. -Loosely, the act of using globs and similar symbols to do pattern -matching. See also L and L. - -=item global - -Something you can see from anywhere, usually used of -L and L that are visible -everywhere in your program. In Perl, only certain special variables -are truly global--most variables (and all subroutines) exist only in -the current L. Global variables can be declared with -L. See L. - -=item global destruction - -The L of globals (and the running of any -associated object destructors) that takes place when a Perl -L is being shut down. Global destruction should not be -confused with the Apocalypse, except perhaps when it should. - -=item glue language - -A language such as Perl that is good at hooking things together that -weren't intended to be hooked together. - -=item granularity - -The size of the pieces you're dealing with, mentally speaking. - -=item greedy - -A L whose L wants to match as many things as -possible. - -=item grep - -Originally from the old Unix editor command for "Globally search for a -Regular Expression and Print it", now used in the general sense of any -kind of search, especially text searches. Perl has a built-in -L function that searches a list for elements -matching any given criterion, whereas the I(1) program searches -for lines matching a L in one or more files. - -=item group - -A set of users of which you are a member. In some operating systems -(like Unix), you can give certain file access permissions to other -members of your group. - -=item GV - -An internal "glob value" typedef, holding a L. The L -type is a subclass of L. - -=back - -=head2 H - -=over 4 - -=item hacker - -Someone who is brilliantly persistent in solving technical problems, -whether these involve golfing, fighting orcs, or programming. Hacker -is a neutral term, morally speaking. Good hackers are not to be -confused with evil L or clueless L