Quick ?s
Cheat Sheets
Man Pages
The Lynx
PERLGLOSSARY(1)        Perl Programmers Reference Guide        PERLGLOSSARY(1)

       perlglossary - Perl Glossary

       A glossary of terms (technical and otherwise) used in the Perl documen
       tation.	Other useful sources include the Free On-Line Dictionary of
       Computing , the Jargon
       File , and Wikipedia


       accessor methods
	   A "method" used to indirectly inspect or update an "object"s state
	   (its instance variables).

       actual arguments
	   The scalar values that you supply to a "function" or "subroutine"
	   when you call it.  For instance, when you call "power("puff")", the
	   string "puff" is the actual argument.  See also "argument" and
	   "formal arguments".

       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 "hard reference", which is much safer than a memory address.

	   A well-defined sequence of steps, clearly enough explained that
	   even a computer could do them.

	   A nickname for something, which behaves in all ways as though youd
	   used the original name instead of the nickname.  Temporary aliases
	   are implicitly created in the loop variable for "foreach" loops, in
	   the $_ variable for map or grep operators, in $a and $b during
	   sorts comparison function, and in each element of @_ for the
	   "actual arguments" of a subroutine call.  Permanent aliases are
	   explicitly created in packages by importing symbols or by assign
	   ment to typeglobs.  Lexically scoped aliases for package variables
	   are explicitly created by the our declaration.

	   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: "|".  Alter
	   natives in normal Perl expressions are separated with a double ver
	   tical bar: "||".  Logical alternatives in "Boolean" expressions are
	   separated with either "||" or "or".

	   Used to describe a "referent" that is not directly accessible
	   through a named "variable".	Such a referent must be indirectly
	   accessible through at least one "hard reference".  When the last
	   hard reference goes away, the anonymous referent is destroyed with
	   out pity.

	   The kind of computer youre working on, where one "kind" of com
	   puter 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 its running on than programs in other languages, such
	   as C, that are compiled into machine code.  See also "platform" and
	   "operating system".

	   A piece of data supplied to a program, "subroutine", "function", or
	   "method" to tell it what its supposed to do.  Also called a

	   The name of the array containing the "argument" "vector" from the
	   command line.  If you use the empty "<>" operator, "ARGV" is the
	   name of both the "filehandle" used to traverse the arguments and
	   the "scalar" containing the name of the current input file.

       arithmetical operator
	   A "symbol" such as "+" or "/" that tells Perl to do the arithmetic
	   you were supposed to learn in grade school.

	   An ordered sequence of values, stored such that you can easily
	   access any of the values using an integer "subscript" that speci
	   fies the values "offset" in the sequence.

       array context
	   An archaic expression for what is more correctly referred to as
	   "list context".

	   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 best described as half ASCII.	See also "Unicode".

	   A component of a "regular expression" that must be true for the
	   pattern to match but does not necessarily match any characters
	   itself.  Often used specifically to mean a "zero width" assertion.

	   An "operator" whose assigned mission in life is to change the value
	   of a "variable".

       assignment operator
	   Either a regular "assignment", or a compound "operator" 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, "$a += 2" adds 2 to $a.

       associative array
	   See "hash".	Please.

	   Determines whether you do the left "operator" first or the right
	   "operator" first when you have "A "operator" B "operator" C" and
	   the two operators are of the same precedence.  Operators like "+"
	   are left associative, while operators like "**" are right associa
	   tive.  See perlop for a list of operators and their associativity.

	   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 didnt know when to expect.

	   A "regular expression" component potentially matching a "substring"
	   containing one or more characters and treated as an indivisible
	   syntactic unit by any following "quantifier".  (Contrast with an
	   "assertion" that matches something of "zero width" and may not be

       atomic operation
	   When Democritus gave the word "atom" to the indivisible bits of
	   matter, he meant literally something that could not be cut: a-
	   (not) + tomos (cuttable).  An atomic operation is an action that
	   cant be interrupted, not one forbidden in a nuclear-free zone.

	   A new feature that allows the declaration of variables and subrou
	   tines with modifiers as in "sub foo : locked method".  Also,
	   another name for an "instance variable" of an "object".

	   A feature of "operator overloading" of objects, whereby the behav
	   ior of certain operators can be reasonably deduced using more fun
	   damental operators.	This assumes that the overloaded operators
	   will often have the same relationships as the regular operators.
	   See perlop.

	   To add one to something automatically, hence the name of the "++"
	   operator.  To instead subtract one from something automatically is
	   known as an "autodecrement".

	   To load on demand.  (Also called "lazy" loading.)  Specifically, to
	   call an AUTOLOAD subroutine on behalf of an undefined subroutine.

	   To split a string automatically, as the -a "switch" does when run
	   ning under -p or -n in order to emulate "awk".  (See also the
	   AutoSplit module, which has nothing to do with the -a switch, but a
	   lot to do with autoloading.)

	   A Greco-Roman word meaning "to bring oneself to life".  In Perl,
	   storage locations (lvalues) spontaneously generate themselves as
	   needed, including the creation of any "hard reference" values to
	   point to the next level of storage.	The assignment
	   "$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 dont have to worry about it.

       AV  Short for "array value", which refers to one of Perls internal
	   data types that holds an "array".  The "AV" type is a subclass of

       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.


	   A substring captured by a subpattern within unadorned parentheses
	   in a "regex".  Backslashed decimal numbers ("\1", "\2", etc.)
	   later in the same pattern refer back to the corresponding subpat
	   tern in the current match.  Outside the pattern, the numbered
	   variables ($1, $2, etc.) continue to refer to these same values, as
	   long as the pattern was the last successful match of the current
	   dynamic scope.

	   The practice of saying, "If I had to do it all over, Id do it dif
	   ferently," and then actually going back and doing it all over dif
	   ferently.  Mathematically speaking, its returning from an unsuc
	   cessful recursion on a tree of possibilities.  Perl backtracks when
	   it attempts to match patterns with a "regular expression", and its
	   earlier attempts dont pan out.  See "Backtracking" in perlre.

       backward compatibility
	   Means you can still run your old program because we didnt break
	   any of the features or bugs it was relying on.

	   A word sufficiently ambiguous to be deemed illegal under use strict
	   subs.  In the absence of that stricture, a bareword is treated as
	   if quotes were around it.

       base class
	   A generic "object" type; that is, a "class" from which other, more
	   specific classes are derived genetically by "inheritance".  Also
	   called a "superclass" by people who respect their ancestors.

	   From Swift: someone who eats eggs big end first.  Also used of com
	   puters that store the most significant "byte" of a word at a lower
	   byte address than the least significant byte.  Often considered
	   superior to little-endian machines.	See also "little-endian".

	   Having to do with numbers represented in base 2.  That means
	   theres 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 "Unicode",
	   this distinction, already suspect, loses even more of its meaning.

       binary operator
	   An "operator" that takes two operands.

	   To assign a specific "network address" to a "socket".

       bit An integer in the range from 0 to 1, inclusive.  The smallest pos
	   sible unit of information storage.  An eighth of a "byte" 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.  Thats why a 25-cent piece today is still "two bits".)

       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.

       bit string
	   A sequence of bits that is actually being thought of as a sequence
	   of bits, for once.

	   In corporate life, to grant official approval to a thing, as in,
	   "The VP of Engineering has blessed our WebCruncher project." Simi
	   larly in Perl, to grant official approval to a "referent" so that
	   it can function as an "object", such as a WebCruncher object.  See
	   "bless" in perlfunc.

	   What a "process" does when it has to wait for something: "My pro
	   cess blocked waiting for the disk."	As an unrelated noun, it
	   refers to a large chunk of data, of a size that the "operating sys
	   tem" likes to deal with (normally a power of two such as 512 or
	   8192).  Typically refers to a chunk of data thats coming from or
	   going to a disk file.

	   A syntactic construct consisting of a sequence of Perl statements
	   that is delimited by braces.  The "if" and "while" statements are
	   defined in terms of BLOCKs, for instance.  Sometimes we also say
	   "block" to mean a lexical scope; that is, a sequence of statements
	   that act like a "BLOCK", such as within an eval or a file, even
	   though the statements arent delimited by braces.

       block buffering
	   A method of making input and output efficient by passing one
	   "block" at a time.  By default, Perl does block buffering to disk
	   files.  See "buffer" and "command buffering".

	   A value that is either "true" or "false".

       Boolean context
	   A special kind of "scalar context" used in conditionals to decide
	   whether the "scalar value" returned by an expression is "true" or
	   "false".  Does not evaluate as either a string or a number.	See

	   A spot in your program where youve told the debugger to stop exe
	   cution so you can poke around and see whether anything is wrong

	   To send a "datagram" to multiple destinations simultaneously.

       BSD A psychoactive drug, popular in the 80s, probably developed at U.
	   C. Berkeley or thereabouts.	Similar in many ways to the prescrip
	   tion-only medication called "System V", but infinitely more useful.
	   (Or, at least, more fun.)  The full chemical name is "Berkeley
	   Standard Distribution".

	   A location in a "hash table" containing (potentially) multiple
	   entries whose keys "hash" to the same hash value according to its
	   hash function.  (As internal policy, you dont have to worry about
	   it, unless youre into internals, or policy.)

	   A temporary holding location for data.  Block buffering means that
	   the data is passed on to its destination whenever the buffer is
	   full.  Line buffering means that its passed on whenever a complete
	   line is received.  Command buffering means that its passed every
	   time you do a print 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.

	   A "function" that is predefined in the language.  Even when hidden
	   by "overriding", you can always get at a built-in function by qual
	   ifying its name with the "CORE::" pseudo-package.

	   A group of related modules on "CPAN".  (Also, sometimes refers to a
	   group of command-line switches grouped into one "switch cluster".)

	   A piece of data worth eight bits in most places.

	   A pidgin-like language spoken among droids when they dont wish to
	   reveal their orientation (see "endian").  Named after some similar
	   languages spoken (for similar reasons) between compilers and inter
	   preters in the late 20th century.  These languages are character
	   ized by representing everything as a non-architecture-dependent
	   sequence of bytes.


       C   A language beloved by many for its inside-out "type" definitions,
	   inscrutable "precedence" rules, and heavy "overloading" 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 its not surprising that Perl
	   borrowed a few ideas from it.

       C preprocessor
	   The typical C compilers first pass, which processes lines begin
	   ning with "#" for conditional compilation and macro definition and
	   does various manipulations of the program text based on the current
	   definitions.  Also known as cpp(1).

       call by reference
	   An "argument"-passing mechanism in which the "formal arguments"
	   refer directly to the "actual arguments", and the "subroutine" can
	   change the actual arguments by changing the formal arguments.  That
	   is, the formal argument is an "alias" for the actual argument.  See
	   also "call by value".

       call by value
	   An "argument"-passing mechanism in which the "formal arguments"
	   refer to a copy of the "actual arguments", and the "subroutine"
	   cannot change the actual arguments by changing the formal argu
	   ments.  See also "call by reference".

	   A "handler" that you register with some other part of your program
	   in the hope that the other part of your program will "trigger" your
	   handler when some event of interest transpires.

	   Reduced to a standard form to facilitate comparison.

	   The use of parentheses around a "subpattern" in a "regular expres
	   sion" to store the matched "substring" as a "backreference".  (Cap
	   tured strings are also returned as a list in "list context".)

	   A small integer representative of a unit of orthography.  Histori
	   cally, characters were usually stored as fixed-width integers (typ
	   ically 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.

       character class
	   A square-bracketed list of characters used in a "regular expres
	   sion" to indicate that any character of the set may occur at a
	   given point.  Loosely, any predefined set of characters so used.

       character property
	   A predefined "character class" matchable by the "\p" "metasymbol".
	   Many standard properties are defined for "Unicode".

       circumfix operator
	   An "operator" that surrounds its "operand", like the angle opera
	   tor, or parentheses, or a hug.

	   A user-defined "type", implemented in Perl via a "package" that
	   provides (either directly or by inheritance) methods (that is,
	   subroutines) to handle instances of the class (its objects).  See
	   also "inheritance".

       class method
	   A "method" whose "invocant" is a "package" name, not an "object"
	   reference.  A method associated with the class as a whole.

	   In networking, a "process" that initiates contact with a "server"
	   process in order to exchange data and perhaps receive a service.

	   A "cluster" used to restrict the scope of a "regular expression

	   An "anonymous" subroutine that, when a reference to it is generated
	   at run time, keeps track of the identities of externally visible
	   lexical variables even after those lexical variables have suppos
	   edly gone out of "scope".  Theyre called "closures" because this
	   sort of behavior gives mathematicians a sense of closure.

	   A parenthesized "subpattern" used to group parts of a "regular
	   expression" into a single "atom".

	   The word returned by the ref function when you apply it to a refer
	   ence to a subroutine.  See also "CV".

       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 "program genera

       code subpattern
	   A "regular expression" subpattern whose real purpose is to execute
	   some Perl code, for example, the "(?{...})" and "(??{...})" subpat

       collating sequence
	   The order into which characters sort.  This is used by "string"
	   comparison routines to decide, for example, where in this glossary
	   to put "collating sequence".

	   In "shell" 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 "statement", which might start with a "label" and
	   typically ends with a semicolon.

       command buffering
	   A mechanism in Perl that lets you store up the output of each Perl
	   "command" and then flush it out as a single request to the "operat
	   ing system".  Its enabled by setting the $| ($AUTOFLUSH) variable
	   to a true value.  Its used when you dont want data sitting around
	   not going where its supposed to, which may happen because the
	   default on a "file" or "pipe" is to use "block buffering".

       command name
	   The name of the program currently executing, as typed on the com
	   mand line.  In C, the "command" name is passed to the program as
	   the first command-line argument.  In Perl, it comes in separately
	   as $0.

       command-line arguments
	   The values you supply along with a program name when you tell a
	   "shell" to execute a "command".  These values are passed to a Perl
	   program through @ARGV.

	   A remark that doesnt affect the meaning of the program.  In Perl,
	   a comment is introduced by a "#" character and continues to the end
	   of the line.

       compilation unit
	   The "file" (or "string", in the case of eval) that is currently
	   being compiled.

       compile phase
	   Any time before Perl starts running your main program.  See also
	   "run phase".  Compile phase is mostly spent in "compile time", but
	   may also be spent in "run time" when "BEGIN" blocks, use declara
	   tions, or constant subexpressions are being evaluated.  The startup
	   and import code of any use declaration is also run during compile

       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 try
	   ing to do what it thinks your code says to do, which is "run time".

	   Strictly speaking, a program that munches up another program and
	   spits out yet another file containing the program in a "more exe
	   cutable" form, typically containing native machine instructions.
	   The perl 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 (syntax trees) within the perl process itself,
	   which the "interpreter" then interprets.  There are, however,
	   extension modules to get Perl to act more like a "real" compiler.
	   See O.

	   A "constructor" for a "referent" that isnt really an "object",
	   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 "Making Ref
	   erences" in perlref.

	   The process of gluing one cats nose to another cats tail.  Also,
	   a similar operation on two strings.

	   Something "iffy".  See "Boolean context".

	   In telephony, the temporary electrical circuit between the callers
	   and the callees phone.  In networking, the same kind of temporary
	   circuit between a "client" and a "server".

	   As a noun, a piece of syntax made up of smaller pieces.  As a tran
	   sitive verb, to create an "object" using a "constructor".

	   Any "class method", instance "method", or "subroutine" that com
	   poses, initializes, blesses, and returns an "object".  Sometimes we
	   use the term loosely to mean a "composer".

	   The surroundings, or environment.  The context given by the sur
	   rounding code determines what kind of data a particular "expres
	   sion" is expected to return.  The three primary contexts are "list
	   context", "scalar context", and "void context".  Scalar context is
	   sometimes subdivided into "Boolean context", "numeric context",
	   "string context", and "void context".  Theres also a "dont care"
	   scalar context (which is dealt with in Programming Perl, Third Edi
	   tion, Chapter 2, "Bits and Pieces" if you care).

	   The treatment of more than one physical "line" as a single logical
	   line.  "Makefile" lines are continued by putting a backslash before
	   the "newline".  Mail headers as defined by RFC 822 are continued by
	   putting a space or tab after the newline.  In general, lines in
	   Perl do not need any form of continuation mark, because
	   "whitespace" (including newlines) is gleefully ignored.  Usually.

       core dump
	   The corpse of a "process", in the form of a file left in the "work
	   ing directory" of the process, usually as a result of certain kinds
	   of fatal error.

	   The Comprehensive Perl Archive Network.  (See "What modules and
	   extensions are available for Perl? What is CPAN? What does
	   CPAN/src/... mean?" in perlfaq2).

	   Someone who breaks security on computer systems.  A cracker may be
	   a true "hacker" or only a "script kiddie".

       current package
	   The "package" in which the current statement is compiled.  Scan
	   backwards in the text of your program through the current lexical
	   scope or any enclosing lexical scopes till you find a package dec
	   laration.  Thats your current package name.

       current working directory
	   See "working directory".

       currently selected output channel
	   The last "filehandle" that was designated with select("FILEHAN
	   DLE"); "STDOUT", if no filehandle has been selected.

       CV  An internal "code value" typedef, holding a "subroutine".  The "CV"
	   type is a subclass of "SV".


       dangling statement
	   A bare, single "statement", without any braces, hanging off an "if"
	   or "while" conditional.  C allows them.  Perl doesnt.

       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.

       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 vari
	   ous mathematical operations that you can do on the numbers but
	   would make little sense on, say, a string such as "Kilroy".
	   Strings have their own operations, such as "concatenation".	Com
	   pound types made of a number of smaller pieces generally have oper
	   ations to compose and decompose them, and perhaps to rearrange
	   them.  Objects that model things in the real world often have oper
	   ations that correspond to real activities.  For instance, if you
	   model an elevator, your elevator object might have an "open_door()"

	   A packet of data, such as a "UDP" message, that (from the viewpoint
	   of the programs involved) can be sent independently over the net
	   work.  (In fact, all packets are sent independently at the "IP"
	   level, but "stream" protocols such as "TCP" hide this from your

       DBM Stands for "Data Base Management" routines, a set of routines that
	   emulate an "associative array" 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
	   "hash" across multiple invocations.	You can tie your hash vari
	   ables to various DBM implementations--see AnyDBM_File and DB_File.

	   An "assertion" that states something exists and perhaps describes
	   what its like, without giving any commitment as to how or where
	   youll use it.  A declaration is like the part of your recipe that
	   says, "two cups flour, one large egg, four or five tadpoles..."
	   See "statement" for its opposite.  Note that some declarations also
	   function as statements.  Subroutine declarations also act as defi
	   nitions if a body is supplied.

	   To subtract a value from a variable, as in "decrement $x" (meaning
	   to remove 1 from its value) or "decrement $x by 3".

	   A "value" chosen for you if you dont supply a value of your own.

	   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 "value" and performing certain opera
	   tions on data that isnt 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 "false" and "defined" in perlfunc.

	   A "character" or "string" that sets bounds to an arbitrarily-sized
	   textual object, not to be confused with a "separator" or "termina
	   tor".  "To delimit" really just means "to surround" or "to enclose"
	   (like these parentheses are doing).

	   A fancy computer science term meaning "to follow a "reference" to
	   what it points to".	The "de" part of it refers to the fact that
	   youre taking away one level of "indirection".

       derived class
	   A "class" that defines some of its methods in terms of a more
	   generic class, called a "base class".  Note that classes arent
	   classified exclusively into base classes or derived classes: a
	   class can function as both a derived class and a base class simul
	   taneously, which is kind of classy.

	   See "file descriptor".

	   To deallocate the memory of a "referent" (first triggering its
	   "DESTROY" method, if it has one).

	   A special "method" that is called when an "object" is thinking
	   about destroying itself.  A Perl programs "DESTROY" method doesnt
	   do the actual destruction; Perl just triggers the method in case
	   the "class" wants to do any associated cleanup.

	   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 "operat
	   ing system" tries to make look like a "file" (or a bunch of files).
	   Under Unix, these fake files tend to live in the /dev directory.

	   A "pod" directive.  See perlpod.

	   A special file that contains other files.  Some operating systems
	   call these "folders", "drawers", or "catalogs".

       directory handle
	   A name that represents a particular instance of opening a directory
	   to read it, until you close it.  See the opendir function.

	   To send something to its correct destination.  Often used metaphor
	   ically to indicate a transfer of programmatic control to a destina
	   tion selected algorithmically, often by lookup in a table of func
	   tion references or, in the case of object methods, by traversing
	   the inheritance tree looking for the most specific definition for
	   the method.

	   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.

	   An enchantment, illusion, phantasm, or jugglery.  Said when Perls
	   magical "dwimmer" effects dont do what you expect, but rather seem
	   to be the product of arcane dweomercraft, sorcery, or wonder work
	   ing.  [From Old English]

	   DWIM is an acronym for "Do What I Mean", the principle that some
	   thing 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".  Dwim
	   ming can require a great deal of behind-the-scenes magic, which (if
	   it doesnt stay properly behind the scenes) is called a "dweomer"

       dynamic scoping
	   Dynamic scoping works over a dynamic scope, making variables visi
	   ble throughout the rest of the "block" in which they are first used
	   and in any subroutines that are called by the rest of the block.
	   Dynamically scoped variables can have their values temporarily
	   changed (and implicitly restored later) by a local operator.  (Com
	   pare "lexical scoping".)  Used more loosely to mean how a subrou
	   tine that is in the middle of calling another subroutine "contains"
	   that subroutine at "run time".


	   Derived from many sources.  Some would say too many.

	   A basic building block.  When youre talking about an "array", its
	   one of the items that make up the array.

	   When something is contained in something else, particularly when
	   that might be considered surprising: "Ive embedded a complete Perl
	   interpreter in my editor!"

       empty subclass test
	   The notion that an empty "derived class" should behave exactly like
	   its "base class".

       en passant
	   When you change a "value" as it is being copied.  [From French, "in
	   passing", as in the exotic pawn-capturing maneuver in chess.]

	   The veil of abstraction separating the "interface" from the "imple
	   mentation" (whether enforced or not), which mandates that all
	   access to an "object"s state be through methods alone.

	   See "little-endian" and "big-endian".

	   The collective set of environment variables your "process" inherits
	   from its parent.  Accessed via %ENV.

       environment variable
	   A mechanism by which some high-level agent such as a user can pass
	   its preferences down to its future offspring (child processes,
	   grandchild processes, great-grandchild processes, and so on).  Each
	   environment variable is a "key"/"value" pair, like one entry in a

       EOF End of File.  Sometimes used metaphorically as the terminating
	   string of a "here document".

	   The error number returned by a "syscall" when it fails.  Perl
	   refers to the error by the name $! (or $OS_ERROR if you use the
	   English module).

	   See "exception" or "fatal error".

       escape sequence
	   See "metasymbol".

	   A fancy term for an error.  See "fatal error".

       exception handling
	   The way a program responds to an error.  The exception handling
	   mechanism in Perl is the eval operator.

	   To throw away the current "process"s program and replace it with
	   another without exiting the process or relinquishing any resources
	   held (apart from the old memory image).

       executable file
	   A "file" that is specially marked to tell the "operating system"
	   that its okay to run this file as a program.  Usually shortened to

	   To run a program or "subroutine".  (Has nothing to do with the kill
	   built-in, unless youre trying to run a "signal handler".)

       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.

       exit status
	   See "status".

	   To make symbols from a "module" available for "import" by other

	   Anything you can legally say in a spot where a "value" is required.
	   Typically composed of literals, variables, operators, functions,
	   and "subroutine" calls, not necessarily in that order.

	   A Perl module that also pulls in compiled C or C++ code.  More gen
	   erally, any experimental option that can be compiled into Perl,
	   such as multithreading.


	   In Perl, any value that would look like "" or "0" if evaluated in a
	   string context.  Since undefined values evaluate to "", all unde
	   fined values are false, but not all false values are undefined.

       FAQ Frequently Asked Question (although not necessarily frequently
	   answered, especially if the answer appears in the Perl FAQ shipped
	   standard with Perl).

       fatal error
	   An uncaught "exception", which causes termination of the "process"
	   after printing a message on your "standard error" stream.  Errors
	   that happen inside an eval are not fatal.  Instead, the eval termi
	   nates after placing the exception message in the $@ ($EVAL_ERROR)
	   variable.  You can try to provoke a fatal error with the die opera
	   tor (known as throwing or raising an exception), but this may be
	   caught by a dynamically enclosing eval.  If not caught, the die
	   becomes a fatal error.

	   A single piece of numeric or string data that is part of a longer
	   "string", "record", or "line".  Variable-width fields are usually
	   split up by separators (so use split to extract the fields), while
	   fixed-width fields are usually at fixed positions (so use unpack).
	   Instance variables are also known as fields.

	   First In, First Out.  See also "LIFO".  Also, a nickname for a
	   "named pipe".

	   A named collection of data, usually stored on disk in a "directory"
	   in a "filesystem".  Roughly like a document, if youre 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.

       file descriptor
	   The little number the "operating system" uses to keep track of
	   which opened "file" youre talking about.  Perl hides the file
	   descriptor inside a "standard I/O" stream and then attaches the
	   stream to a "filehandle".

       file test operator
	   A built-in unary operator that you use to determine whether some
	   thing is "true" about a file, such as "-o $filename" to test
	   whether youre the owner of the file.

	   A "wildcard" match on filenames.  See the glob function.

	   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 youre going to open and close several different
	   files in succession, its fine to open each of them with the same
	   filehandle, so you dont have to write out separate code to process
	   each file.

	   One name for a file.  This name is listed in a "directory", and you
	   can use it in an open to tell the "operating system" exactly which
	   file you want to open, and associate the file with a "filehandle"
	   which will carry the subsequent identity of that file in your pro
	   gram, until you close it.

	   A set of directories and files residing on a partition of the disk.
	   Sometimes known as a "partition".  You can change the files name
	   or even move a file around from directory to directory within a
	   filesystem without actually moving the file itself, at least under

	   A program designed to take a "stream" of input and transform it
	   into a stream of output.

	   We tend to avoid this term because it means so many things.	It may
	   mean a command-line "switch" that takes no argument itself (such as
	   Perls -n and -p flags) or, less frequently, a single-bit indicator
	   (such as the "O_CREAT" and "O_EXCL" flags used in sysopen).

       floating point
	   A method of storing numbers in "scientific notation", such that the
	   precision of the number is independent of its magnitude (the deci
	   mal point "floats").  Perl does its numeric work with floating-
	   point numbers (sometimes called "floats"), when it cant get away
	   with using integers.  Floating-point numbers are mere approxima
	   tions of real numbers.

	   The act of emptying a "buffer", often before its full.

	   Far More Than Everything You Ever Wanted To Know.  An exhaustive
	   treatise on one narrow topic, something of a super-"FAQ".  See Tom
	   for far more.

	   To create a child "process" identical to the parent process at its
	   moment of conception, at least until it gets ideas of its own.  A
	   thread with protected memory.

       formal arguments
	   The generic names by which a "subroutine" knows its arguments.  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 $ARGV[0],
	   $ARGV[1], and so on.  Similarly, the formal arguments to a Perl
	   subroutine are $_[0], $_[1], and so on.  You may give the arguments
	   individual names by assigning the values to a my list.  See also
	   "actual arguments".

	   A specification of how many spaces and digits and things to put
	   somewhere so that whatever youre printing comes out nice and

       freely available
	   Means you dont have to pay money to get it, but the copyright on
	   it may still belong to someone else (like Larry).

       freely redistributable
	   Means youre not in legal trouble if you give a bootleg copy of it
	   to your friends and we find out about it.  In fact, wed rather you
	   gave a copy to all your friends.

	   Historically, any software that you give away, particularly if you
	   make the source code available as well.  Now often called "open
	   source software".  Recently there has been a trend to use the term
	   in contradistinction to "open source software", to refer only to
	   free software released under the Free Software Foundations GPL
	   (General Public License), but this is difficult to justify etymo

	   Mathematically, a mapping of each of a set of input values to a
	   particular output value.  In computers, refers to a "subroutine" or
	   "operator" that returns a "value".  It may or may not have input
	   values (called arguments).

       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

       garbage collection
	   A misnamed feature--it should be called, "expecting your mother to
	   pick up after you".	Strictly speaking, Perl doesnt 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 ref
	   erence-counting scheme as a form of garbage collection.  (If its
	   any comfort, when your interpreter exits, a "real" garbage collec
	   tor runs to make sure everything is cleaned up if youve been messy
	   with circular references and such.)


       GID Group ID--in Unix, the numeric group ID that the "operating system"
	   uses to identify you and members of your "group".

	   Strictly, the shells "*" character, which will match a "glob" of
	   characters when youre trying to generate a list of filenames.
	   Loosely, the act of using globs and similar symbols to do pattern
	   matching.  See also "fileglob" and "typeglob".

	   Something you can see from anywhere, usually used of variables and
	   subroutines 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 "package".  Global
	   variables can be declared with our.	See "our" in perlfunc.

       global destruction
	   The "garbage collection" of globals (and the running of any associ
	   ated object destructors) that takes place when a Perl "interpreter"
	   is being shut down.	Global destruction should not be confused with
	   the Apocalypse, except perhaps when it should.

       glue language
	   A language such as Perl that is good at hooking things together
	   that werent intended to be hooked together.

	   The size of the pieces youre dealing with, mentally speaking.

	   A "subpattern" whose "quantifier" wants to match as many things as

	   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 grep function that searches a list for elements matching
	   any given criterion, whereas the grep(1) program searches for lines
	   matching a "regular expression" in one or more files.

	   A set of users of which you are a member.  In some operating sys
	   tems (like Unix), you can give certain file access permissions to
	   other members of your group.

       GV  An internal "glob value" typedef, holding a "typeglob".  The "GV"
	   type is a subclass of "SV".


	   Someone who is brilliantly persistent in solving technical prob
	   lems, whether these involve golfing, fighting orcs, or programming.
	   Hacker is a neutral term, morally speaking.	Good hackers are not
	   to be confused with evil crackers or clueless script kiddies.  If
	   you confuse them, we will presume that you are either evil or clue

	   A "subroutine" or "method" that is called by Perl when your program
	   needs to respond to some internal event, such as a "signal", or an
	   encounter with an operator subject to "operator overloading".  See
	   also "callback".

       hard reference
	   A "scalar" "value" containing the actual address of a "referent",
	   such that the referents "reference" count accounts for it.  (Some
	   hard references are held internally, such as the implicit reference
	   from one of a "typeglob"s variable slots to its corresponding ref
	   erent.)  A hard reference is different from a "symbolic reference".

	   An unordered association of "key"/"value" pairs, stored such that
	   you can easily use a string "key" to look up its associated data
	   "value".  This glossary is like a hash, where the word to be
	   defined is the key, and the definition is the value.  A hash is
	   also sometimes septisyllabically called an "associative array",
	   which is a pretty good reason for simply calling it a "hash"

       hash table
	   A data structure used internally by Perl for implementing associa
	   tive arrays (hashes) efficiently.  See also "bucket".

       header file
	   A file containing certain required definitions that you must
	   include "ahead" of the rest of your program to do certain obscure
	   operations.	A C header file has a .h extension.  Perl doesnt
	   really have header files, though historically Perl has sometimes
	   used translated .h files with a .ph extension.  See "require" in
	   perlfunc.  (Header files have been superseded by the "module" mech

       here document
	   So called because of a similar construct in shells that pretends
	   that the lines following the "command" are a separate "file" to be
	   fed to the command, up to some terminating string.  In Perl, how
	   ever, its just a fancy form of quoting.

	   A number in base 16, "hex" for short.  The digits for 10 through 16
	   are customarily represented by the letters "a" through "f".	Hex
	   adecimal constants in Perl start with "0x".	See also "hex" in

       home directory
	   The directory you are put into when you log in.  On a Unix system,
	   the name is often placed into $ENV{HOME} or $ENV{LOGDIR} by login,
	   but you can also find it with "(getpwuid($<))[7]".  (Some platforms
	   do not have a concept of a home directory.)

	   The computer on which a program or other data resides.

	   Excessive pride, the sort of thing Zeus zaps you for.  Also the
	   quality that makes you write (and maintain) programs that other
	   people wont want to say bad things about.  Hence, the third great
	   virtue of a programmer.  See also "laziness" and "impatience".

       HV  Short for a "hash value" typedef, which holds Perls internal rep
	   resentation of a hash.  The "HV" type is a subclass of "SV".


	   A legally formed name for most anything in which a computer program
	   might be interested.  Many languages (including Perl) allow identi
	   fiers that start with a letter and contain letters and digits.
	   Perl also counts the underscore character as a valid letter.  (Perl
	   also has more complicated names, such as "qualified" names.)

	   The anger you feel when the computer is being lazy.	This makes you
	   write programs that dont just react to your needs, but actually
	   anticipate them.  Or at least that pretend to.  Hence, the second
	   great virtue of a programmer.  See also "laziness" and "hubris".

	   How a piece of code actually goes about doing its job.  Users of
	   the code should not count on implementation details staying the
	   same unless they are part of the published "interface".

	   To gain access to symbols that are exported from another module.
	   See "use" in perlfunc.

	   To increase the value of something by 1 (or by some other number,
	   if so specified).

	   In olden days, the act of looking up a "key" in an actual index
	   (such as a phone book), but now merely the act of using any kind of
	   key or position to find the corresponding "value", even if no index
	   is involved.  Things have degenerated to the point that Perls
	   index function merely locates the position (index) of one string in

       indirect filehandle
	   An "expression" that evaluates to something that can be used as a
	   "filehandle": a "string" (filehandle name), a "typeglob", a type
	   glob "reference", or a low-level "IO" object.

       indirect object
	   In English grammar, a short noun phrase between a verb and its
	   direct object indicating the beneficiary or recipient of the
	   action.  In Perl, "print STDOUT "$foo\n";" can be understood as
	   "verb indirect-object object" where "STDOUT" is the recipient of
	   the print action, and "$foo" is the object being printed.  Simi
	   larly, when invoking a "method", you might place the invocant
	   between the method and its arguments:

	     $gollum = new Pathetic::Creature "Smeagol";
	     give $gollum "Fisssssh!";
	     give $gollum "Precious!";

       indirect object slot
	   The syntactic position falling between a method call and its argu
	   ments when using the indirect object invocation syntax.  (The slot
	   is distinguished by the absence of a comma between it and the next
	   argument.) "STDERR" is in the indirect object slot here:

	     print STDERR "Awake!  Awake!  Fear, Fire,
		 Foes!	Awake!\n";

	   If something in a program isnt the value youre looking for but
	   indicates where the value is, thats indirection.  This can be done
	   with either symbolic references or hard references.

	   An "operator" that comes in between its operands, such as multipli
	   cation in "24 * 7".

	   What you get from your ancestors, genetically or otherwise.	If you
	   happen to be a "class", your ancestors are called base classes and
	   your descendants are called derived classes.  See "single inheri
	   tance" and "multiple inheritance".

	   Short for "an instance of a class", meaning an "object" of that

       instance variable
	   An "attribute" of an "object"; data stored with the particular
	   object rather than with the class as a whole.

	   A number with no fractional (decimal) part.	A counting number,
	   like 1, 2, 3, and so on, but including 0 and the negatives.

	   The services a piece of code promises to provide forever, in con
	   trast to its "implementation", which it should feel free to change
	   whenever it likes.

	   The insertion of a scalar or list value somewhere in the middle of
	   another value, such that it appears to have been there all along.
	   In Perl, variable interpolation happens in double-quoted strings
	   and patterns, and list interpolation occurs when constructing the
	   list of values to pass to a list operator or other such construct
	   that takes a "LIST".

	   Strictly speaking, a program that reads a second program and does
	   what the second program says directly without turning the program
	   into a different form first, which is what compilers do.  Perl is
	   not an interpreter by this definition, because it contains a kind
	   of compiler that takes a program and turns it into a more exe
	   cutable form (syntax trees) within the perl process itself, which
	   the Perl "run time" system then interprets.

	   The agent on whose behalf a "method" is invoked.  In a "class"
	   method, the invocant is a package name.  In an "instance" method,
	   the invocant is an object reference.

	   The act of calling up a deity, daemon, program, method, subroutine,
	   or function to get it do what you think its supposed to do.	We
	   usually "call" subroutines but "invoke" methods, since it sounds

       I/O Input from, or output to, a "file" or "device".

       IO  An internal I/O object.  Can also mean "indirect object".

       IP  Internet Protocol, or Intellectual Property.

       IPC Interprocess Communication.

	   A relationship between two objects in which one object is consid
	   ered to be a more specific version of the other, generic object: "A
	   camel is a mammal."	Since the generic object really only exists in
	   a Platonic sense, we usually add a little abstraction to the notion
	   of objects and think of the relationship as being between a generic
	   "base class" and a specific "derived class".  Oddly enough, Pla
	   tonic classes dont always have Platonic relationships--see "inher

	   Doing something repeatedly.

	   A special programming gizmo that keeps track of where you are in
	   something that youre trying to iterate over.  The "foreach" loop
	   in Perl contains an iterator; so does a hash, allowing you to each
	   through it.

       IV  The integer four, not to be confused with six, Toms favorite edi
	   tor.  IV also means an internal Integer Value of the type a
	   "scalar" can hold, not to be confused with an "NV".


	   "Just Another Perl Hacker," a clever but cryptic bit of Perl code
	   that when executed, evaluates to that string.  Often used to illus
	   trate a particular Perl feature, and something of an ungoing Obfus
	   cated Perl Contest seen in Usenix signatures.


       key The string index to a "hash", used to look up the "value" associ
	   ated with that key.

	   See "reserved words".


	   A name you give to a "statement" so that you can talk about that
	   statement elsewhere in the program.

	   The quality that makes you go to great effort to reduce overall
	   energy expenditure.	It makes you write labor-saving programs that
	   other people will find useful, and document what you wrote so you
	   dont have to answer so many questions about it.  Hence, the first
	   great virtue of a programmer.  Also hence, this book.  See also
	   "impatience" and "hubris".

       left shift
	   A "bit shift" that multiplies the number by some power of 2.

       leftmost longest
	   The preference of the "regular expression" engine to match the
	   leftmost occurrence of a "pattern", then given a position at which
	   a match will occur, the preference for the longest match (presuming
	   the use of a "greedy" quantifier).  See perlre for much more on
	   this subject.

	   Fancy term for a "token".

	   Fancy term for a "tokener".

       lexical analysis
	   Fancy term for "tokenizing".

       lexical scoping
	   Looking at your Oxford English Dictionary through a microscope.
	   (Also known as "static scoping", because dictionaries dont change
	   very fast.)	Similarly, looking at variables stored in a private
	   dictionary (namespace) for each scope, which are visible only from
	   their point of declaration down to the end of the lexical scope in
	   which they are declared.  --Syn. "static scoping".  --Ant. "dynamic

       lexical variable
	   A "variable" subject to "lexical scoping", declared by my.  Often
	   just called a "lexical".  (The our declaration declares a lexically
	   scoped name for a global variable, which is not itself a lexical

	   Generally, a collection of procedures.  In ancient days, referred
	   to a collection of subroutines in a .pl file.  In modern times,
	   refers more often to the entire collection of Perl modules on your

	   Last In, First Out.	See also "FIFO".  A LIFO is usually called a

	   In Unix, a sequence of zero or more non-newline characters termi
	   nated with a "newline" character.  On non-Unix machines, this is
	   emulated by the C library even if the underlying "operating system"
	   has different ideas.

       line buffering
	   Used by a "standard I/O" output stream that flushes its "buffer"
	   after every "newline".  Many standard I/O libraries automatically
	   set up line buffering on output that is going to the terminal.

       line number
	   The number of lines read previous to this one, plus 1.  Perl keeps
	   a separate line number for each source or input file it opens.  The
	   current source files line number is represented by "__LINE__".
	   The current input line number (for the file that was most recently
	   read via "") is represented by the $.  ($INPUT_LINE_NUMBER)
	   variable.  Many error messages report both values, if available.

	   Used as a noun, a name in a "directory", representing a "file".  A
	   given file can have multiple links to it.  Its like having the
	   same phone number listed in the phone directory under different
	   names.  As a verb, to resolve a partially compiled files unre
	   solved symbols into a (nearly) executable image.  Linking can gen
	   erally be static or dynamic, which has nothing to do with static or
	   dynamic scoping.

	   A syntactic construct representing a comma-separated list of
	   expressions, evaluated to produce a "list value".  Each
	   "expression" in a "LIST" is evaluated in "list context" and inter
	   polated into the list value.

	   An ordered set of scalar values.

       list context
	   The situation in which an "expression" is expected by its surround
	   ings (the code calling it) to return a list of values rather than a
	   single value.  Functions that want a "LIST" of arguments tell those
	   arguments that they should produce a list value.  See also "con

       list operator
	   An "operator" that does something with a list of values, such as
	   join or grep.  Usually used for named built-in operators (such as
	   print, unlink, and system) that do not require parentheses around
	   their "argument" list.

       list value
	   An unnamed list of temporary scalar values that may be passed
	   around within a program from any list-generating function to any
	   function or construct that provides a "list context".

	   A token in a programming language such as a number or "string" that
	   gives you an actual "value" instead of merely representing possible
	   values as a "variable" does.

	   From Swift: someone who eats eggs little end first.	Also used of
	   computers that store the least significant "byte" of a word at a
	   lower byte address than the most significant byte.  Often consid
	   ered superior to big-endian machines.  See also "big-endian".

	   Not meaning the same thing everywhere.  A global variable in Perl
	   can be localized inside a dynamic scope via the local operator.

       logical operator
	   Symbols representing the concepts "and", "or", "xor", and "not".

	   An "assertion" that peeks at the string to the right of the current
	   match location.

	   An "assertion" that peeks at the string to the left of the current
	   match location.

	   A construct that performs something repeatedly, like a roller

       loop control statement
	   Any statement within the body of a loop that can make a loop prema
	   turely stop looping or skip an "iteration".	Generally you
	   shouldnt try this on roller coasters.

       loop label
	   A kind of key or name attached to a loop (or roller coaster) so
	   that loop control statements can talk about which loop they want to

	   Able to serve as an "lvalue".

	   Term used by language lawyers for a storage location you can assign
	   a new "value" to, such as a "variable" or an element of an "array".
	   The "l" is short for "left", as in the left side of an assignment,
	   a typical place for lvalues.  An "lvaluable" function or expression
	   is one to which a value may be assigned, as in "pos($x) = 10".

       lvalue modifier
	   An adjectival pseudofunction that warps the meaning of an "lvalue"
	   in some declarative fashion.  Currently there are three lvalue mod
	   ifiers: my, our, and local.


	   Technically speaking, any extra semantics attached to a variable
	   such as $!, $0, %ENV, or %SIG, or to any tied variable.  Magical
	   things happen when you diddle those variables.

       magical increment
	   An "increment" operator that knows how to bump up alphabetics as
	   well as numbers.

       magical variables
	   Special variables that have side effects when you access them or
	   assign to them.  For example, in Perl, changing elements of the
	   %ENV array also changes the corresponding environment variables
	   that subprocesses will use.	Reading the $! variable gives you the
	   current system error number or message.

	   A file that controls the compilation of a program.  Perl programs
	   dont usually need a "Makefile" because the Perl compiler has
	   plenty of self-control.

       man The Unix program that displays online documentation (manual pages)
	   for you.

	   A "page" from the manuals, typically accessed via the man(1) com
	   mand.  A manpage contains a SYNOPSIS, a DESCRIPTION, a list of
	   BUGS, and so on, and is typically longer than a page.  There are
	   manpages documenting commands, syscalls, "library" functions,
	   devices, protocols, files, and such.  In this book, we call any
	   piece of standard Perl documentation (like perlop or perldelta) a
	   manpage, no matter what format its installed in on your system.

	   See "pattern matching".

       member data
	   See "instance variable".

	   This always means your main memory, not your disk.  Clouding the
	   issue is the fact that your machine may implement "virtual" memory;
	   that is, it will pretend that it has more memory than it really
	   does, and itll use disk space to hold inactive bits.  This can
	   make it seem like you have a little more memory than you really do,
	   but its not a substitute for real memory.  The best thing that can
	   be said about virtual memory is that it lets your performance
	   degrade gradually rather than suddenly when you run out of real
	   memory.  But your program can die when you run out of virtual mem
	   ory too, if you havent thrashed your disk to death first.

	   A "character" that is not supposed to be treated normally.  Which
	   characters are to be treated specially as metacharacters varies
	   greatly from context to context.  Your "shell" will have certain
	   metacharacters, double-quoted Perl strings have other metacharac
	   ters, and "regular expression" patterns have all the double-quote
	   metacharacters plus some extra ones of their own.

	   Something wed call a "metacharacter" except that its a sequence
	   of more than one character.	Generally, the first character in the
	   sequence must be a true metacharacter to get the other characters
	   in the metasymbol to misbehave along with it.

	   A kind of action that an "object" can take if you tell it to.  See

	   The belief that "small is beautiful."  Paradoxically, if you say
	   something in a small language, it turns out big, and if you say it
	   in a big language, it turns out small.  Go figure.

	   In the context of the stat syscall, refers to the field holding the
	   "permission bits" and the type of the "file".

	   See "statement modifier", "regular expression modifier", and
	   "lvalue modifier", not necessarily in that order.

	   A "file" that defines a "package" of (almost) the same name, which
	   can either "export" symbols or function as an "object" class.  (A
	   modules main .pm file may also load in other files in support of
	   the module.)  See the use built-in.

	   An integer divisor when youre interested in the remainder instead
	   of the quotient.

	   Short for Perl Monger, a purveyor of Perl.

	   A temporary value scheduled to die when the current statement fin

       multidimensional array
	   An array with multiple subscripts for finding a single element.
	   Perl implements these using references--see perllol and perldsc.

       multiple inheritance
	   The features you got from your mother and father, mixed together
	   unpredictably.  (See also "inheritance", and "single inheritance".)
	   In computer languages (including Perl), the notion that a given
	   class may have multiple direct ancestors or base classes.


       named pipe
	   A "pipe" with a name embedded in the "filesystem" so that it can be
	   accessed by two unrelated processes.

	   A domain of names.  You neednt worry about whether the names in
	   one such domain have been used in another.  See "package".

       network address
	   The most important attribute of a socket, like your telephones
	   telephone number.  Typically an IP address.	See also "port".

	   A single character that represents the end of a line, with the
	   ASCII value of 012 octal under Unix (but 015 on a Mac), and repre
	   sented by "\n" in Perl strings.  For Windows machines writing text
	   files, and for certain physical devices like terminals, the single
	   newline gets automatically translated by your C library into a line
	   feed and a carriage return, but normally, no translation is done.

       NFS Network File System, which allows you to mount a remote filesystem
	   as if it were local.

       null character
	   A character with the ASCII value of zero.  Its used by C to termi
	   nate strings, but Perl allows strings to contain a null.

       null list
	   A "list value" with zero elements, represented in Perl by "()".

       null string
	   A "string" containing no characters, not to be confused with a
	   string containing a "null character", which has a positive length
	   and is "true".

       numeric context
	   The situation in which an expression is expected by its surround
	   ings (the code calling it) to return a number.  See also "context"
	   and "string context".

       NV  Short for Nevada, no part of which will ever be confused with civi
	   lization.  NV also means an internal floating-point Numeric Value
	   of the type a "scalar" can hold, not to be confused with an "IV".

	   Half a "byte", equivalent to one "hexadecimal" digit, and worth
	   four bits.


	   An "instance" of a "class".	Something that "knows" what user-
	   defined type (class) it is, and what it can do because of what
	   class it is.  Your program can request an object to do things, but
	   the object gets to decide whether it wants to do them or not.  Some
	   objects are more accommodating than others.

	   A number in base 8.	Only the digits 0 through 7 are allowed.
	   Octal constants in Perl start with 0, as in 013.  See also the oct

	   How many things you have to skip over when moving from the begin
	   ning of a string or array to a specific position within it.	Thus,
	   the minimum offset is zero, not one, because you dont skip any
	   thing to get to the first item.

	   An entire computer program crammed into one line of text.

       open source software
	   Programs for which the source code is freely available and freely
	   redistributable, with no commercial strings attached.  For a more
	   detailed definition, see .

	   An "expression" that yields a "value" that an "operator" operates
	   on.	See also "precedence".

       operating system
	   A special program that runs on the bare machine and hides the gory
	   details of managing processes and devices.  Usually used in a
	   looser sense to indicate a particular culture of programming.  The
	   loose sense can be used at varying levels of specificity.  At one
	   extreme, you might say that all versions of Unix and Unix-looka
	   likes are the same operating system (upsetting many people, espe
	   cially lawyers and other advocates).  At the other extreme, you
	   could say this particular version of this particular vendors oper
	   ating system is different from any other version of this or any
	   other vendors operating system.  Perl is much more portable across
	   operating systems than many other languages.  See also "architec
	   ture" and "platform".

	   A gizmo that transforms some number of input values to some number
	   of output values, often built into a language with a special syntax
	   or symbol.  A given operator may have specific expectations about
	   what types of data you give as its arguments (operands) and what
	   type of data you want back from it.

       operator overloading
	   A kind of "overloading" that you can do on built-in operators to
	   make them work on objects as if the objects were ordinary scalar
	   values, but with the actual semantics supplied by the object class.
	   This is set up with the overload "pragma".

	   See either switches or "regular expression modifier".

	   Giving additional meanings to a symbol or construct.  Actually, all
	   languages do overloading to one extent or another, since people are
	   good at figuring out things from "context".

	   Hiding or invalidating some other definition of the same name.
	   (Not to be confused with "overloading", which adds definitions that
	   must be disambiguated some other way.) To confuse the issue fur
	   ther, we use the word with two overloaded definitions: to describe
	   how you can define your own "subroutine" to hide a built-in "func
	   tion" of the same name (see "Overriding Built-in Functions" in
	   perlsub) and to describe how you can define a replacement "method"
	   in a "derived class" to hide a "base class"s method of the same
	   name (see perlobj).

	   The one user (apart from the superuser) who has absolute control
	   over a "file".  A file may also have a "group" of users who may
	   exercise joint ownership if the real owner permits it.  See "per
	   mission bits".


	   A "namespace" for global variables, subroutines, and the like, such
	   that they can be kept separate from like-named symbols in other
	   namespaces.	In a sense, only the package is global, since the sym
	   bols in the packages symbol table are only accessible from code
	   compiled outside the package by naming the package.	But in another
	   sense, all package symbols are also globals--theyre just well-
	   organized globals.

       pad Short for "scratchpad".

	   See "argument".

       parent class
	   See "base class".

       parse tree
	   See "syntax tree".

	   The subtle but sometimes brutal art of attempting to turn your pos
	   sibly malformed program into a valid "syntax tree".

	   To fix by applying one, as it were.	In the realm of hackerdom, a
	   listing of the differences between two versions of a program as
	   might be applied by the patch(1) program when you want to fix a bug
	   or upgrade your old version.

	   The list of directories the system searches to find a program you
	   want to "execute".  The list is stored as one of your environment
	   variables, accessible in Perl as $ENV{PATH}.

	   A fully qualified filename such as /usr/bin/perl.  Sometimes con
	   fused with "PATH".

	   A template used in "pattern matching".

       pattern matching
	   Taking a pattern, usually a "regular expression", and trying the
	   pattern various ways on a string to see whether theres any way to
	   make it fit.  Often used to pick interesting tidbits out of a file.

       permission bits
	   Bits that the "owner" of a file sets or unsets to allow or disallow
	   access to other people.  These flag bits are part of the "mode"
	   word returned by the stat built-in when you ask about a file.  On
	   Unix systems, you can check the ls(1) manpage for more information.

	   What you get when you do "Perl++" twice.  Doing it only once will
	   curl your hair.  You have to increment it eight times to shampoo
	   your hair.  Lather, rinse, iterate.

	   A direct "connection" that carries the output of one "process" to
	   the input of another without an intermediate temporary file.  Once
	   the pipe is set up, the two processes in question can read and
	   write as if they were talking to a normal file, with some caveats.

	   A series of processes all in a row, linked by pipes, where each
	   passes its output stream to the next.

	   The entire hardware and software context in which a program runs.
	    program written in a platform-dependent language might break if
	   you change any of: machine, operating system, libraries, compiler,
	   or system configuration.  The perl interpreter has to be compiled
	   differently for each platform because it is implemented in C, but
	   programs written in the Perl language are largely platform-indepen

       pod The markup used to embed documentation into your Perl code.	See

	   A "variable" in a language like C that contains the exact memory
	   location of some other item.  Perl handles pointers internally so
	   you dont have to worry about them.  Instead, you just use symbolic
	   pointers in the form of keys and "variable" names, or hard refer
	   ences, which arent pointers (but act like pointers and do in fact
	   contain pointers).

	   The notion that you can tell an "object" to do something generic,
	   and the object will interpret the command in different ways depend
	   ing on its type.  [

Yals.net is © 1999-2009 Crescendo Communications
Sharing tech info on the web for more than a decade!
This page was generated Thu Apr 30 17:05:21 2009