Glossary


Contents	Previous	Next

Glossary

For more etymology and history of the technical jargon in Linux and embedded communities, see the following HTML documentation:

The previous list of URLs is by no means exhaustive of the available content. Accordingly, it will continue to grow as the technology and the technology community grows.

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Application Binary Interface, which defines how programs should interface with the operating system, including specifications such as executable format, calling conventions, and chip-specific requirements.

A register being used for arithmetic or logic (as opposed to addressing or a loop index), especially one being used to accumulate a sum or count of many items.

A number identifying a location in the computer's memory that informs the computer where to find information such as a file name or data for processing. See also bus.

A Web server formed by the Apache group. Its name was formed by the group providing patch files for bugs in NCSA HTTPD 1.3, the result being "A PAtCHy " server. See also HTTPD, path, bug and the http://www.apache.org/docs documentation.

A pplication Programming Interface, which defines how programmers write source code that makes use of a library's or an operating system's facilities by accessing the behavior and state of classes and objects. EL/IX is the API for Embedded DevKit, for instance. See also classes and objects.

A term for a family of processors, generally used in reference to features common to all members.

Also, Annotated Reference Manual for C++, often used to describe a name-mangling style.

A collection of data items, all of the same type, in which integers designate each item's position.

American Standard Code for Information Interchange, the predominant character set encoding of present-day computers. The modern version uses seven bits for each character, whereas most earlier codes (including an early version of ASCII) had fewer assignments.

A tool that produces object files from assembly code like the GNU assembler, gas.

Used very generally as a sample name for absolutely anything, especially programs and files. Etymology from Army slang acronym, FUBAR (bowdlerized to mean "Fouled Up Beyond All Repair").

A basic command shell ("Bourne Again Shell"), typically for UNIX or Linux operating systems, based on the Bourne shell. See shell.

Background Debugging Mode, referring to the ability of the CPU32 sub-family (68302, 68360, etc.) of Motorola 68000 series chips and Motorola PowerPC chips to be directly controlled through a special set of pins.

B inary File Descriptor, the library used by GNU tools to read and write object files.

Refers to a processor or toolchain that supports both big-endian and little-endian code.

A byte-ordering scheme in which the most significant bytes are at lower addresses (big-end-first), such as the Motorola 68000 family of microprocessors and most of the various RISC designs, which use a big-endian microprocessor.

A multiple-precision computer representation for very large integers. Most computer languages provide a kind of "integer-based" data, but such computer integers are usually very limited in size; to work with larger numbers, use floating-point numbers, which are usually accurate to only six or seven decimal places. Computer languages that provide bignums can perform exact calculations on very large numbers, such as 1000! (the factorial of 1000, which is 1000 x 999 x 998 x ... x 2 x 1).

Base-two number system, of which the only digits are 0 and 1. Used as a signal for processing as either off (0) or on (1); from right to left, the digits have a binary value of 1, 2, 4, 8, 16, and so on in multiples of 2, exponentially (the binary number of 101, for instance, is equivalent to the decimal number, 5, and the binary number of 1011 is equivalent to the decimal number, 13). See also unary and ternary. Compare floating-point notation.

Basic Input Output System, which loads and executes operation functionality usually stored on the computer's hard disk (in ROM mode); also may be accessible from CD-ROM or floppy disk at install time.

A computational quantity that can take on one of two values, such as true and false or 0 and 1. A bit is said to be set if its value is true or 1, and reset or clear if its value is false or 0. One speaks of setting and clearing bits. To toggle or invert a bit is to change it, either from 0 to 1 or from 1 to 0.

With MIPS being an acronym for millions of instructions per second, bogoMIPS is a reference to the measure of the time elapsed for a Linux system to perform processes.

The action for a machine to run through its opening processes, for instance, for a compiler's initialization. Known by having to put on boots by pulling on the sidestraps before going out in the world. See also network boot.

Boot protocol, which lets a network user be automatically configured (for instance, to receive an IP address) and have an operating system booted or initiated without user involvement. A BOOTP server, managed by a network administrator, automatically assigns the IP address from a pool of addresses for a certain duration of time. BOOTP is the basis for a more advanced network manager protocol, DHCP. See DHCP.

What makes a program stop whenever a certain point is reached in a debugging process. See also catchpoint, watchpoint and tracepoint.

Berkeley Software Distribution, a family of UNIX software tools from U.C. Berkeley, originally licensed from AT&T, and later upgraded to all-free code. Formed the basis for SunOS, incorporating paged virtual memory, TCP/IP networking enhancements, among other features. See also FreeBSD.

Board Support Package, typically referring to the low-level code or scripts that build programs running on a particular chip on a particular circuit board. Provides memory sizing, testing, interrupt/DMA control, and other features. Also refers to the ROM that boots an RTOS onto a specific board. Exact meaning varies.

What happens when you try to stuff more data into a buffer than the buffer has been constructed to hold.

A holding area in a program's memory (like an Emacs buffer) for text waiting to be edited.

A problem with software that needs a patch. Etymology obscured by various myths such as the Naval Surface Warfare Center story, with a picture of the logbook and the purported moth taped into it, recorded in Annals of the History of Computing [Vol. 3, No. 3 (July 1981), pgs. 285--286], as well as the electrical handbook, Hawkin's New Catechism of Electricity [Theo. Audel & Co.], which says, "The term, bug, is used to a limited extent to designate any fault or trouble in the connections or working of electric apparatus." See also patch.

The process of configuring, compiling, and linking a set of tools. Also used as a noun, for denoting the results of the process.

Collection of wires through which data is transmitted. Buses consist of two parts: an address bus and a data bus. The data bus transfers actual data whereas the address bus transfers information about where the data should go.

In networking, a bus is a central cable that connects all devices on a local-area network (LAN).

Machine-independent code generated by a compiler and executed by an interpreter.

Recently accessed data in storage on disk on a computer or network, using a process for filing the boot process, as well as archives, kernel information and other data. See also disk caching.

A cross-compilation in which a program being compiled is a cross compiler for some other host/target pair. Example: building a Motorola 68000 cross compiler that runs on a 486 PC using a Sun SPARC station.

The standard state or manner or usage in technical terminology, derived from computation theory and mathematical logic, when, for instance, two formulas such as 1 + x and x + 1 are said to be equivalent because they mean the same thing, but the second one is in canonical form because it is written in the usual way, with the highest power of x first. Also refers to the naming of host operating system combinations with target boards, such as the i386-pc-linux-gnu canonical name.

A special breakpoint when debugging that stops your program when a certain kind of event occurs, such as the throwing of a C++ exception or the loading of a library.

Complex Instruction Set Computer, a class of machines typically having variable-length instructions with a variety of addressing modes.

A class definition defines instance and class variables and methods, specifying the interfaces a class implements and the immediate superclass of the class. In Java, a type defining implementation of a particular kind of object. See objects.

The Java binary file format for the Java Virtual Machine (JVM) for the .class file that, after compiling, contains bytecode and symbols (like an object file); see also bytecode.

Common Object File Format, a format that appeared with UNIX SVR3, formerly common for UNIX, and still used by some embedded systems.

In source code, explanatory text that the compiler ignores. In most code, comments are delimited using // or /*...*/.

A tool that translates high-level source code in a language such as C or Pascal into machine-executable programs. The term may also refer specifically to the tool that translates from source to assembly language.

A shell script that sets up an environment in which your programs will compile correctly for your machine and operating system, and will install in proper places.

The copyright notice for GNU Emacs and other GNU software, the GNU General Public License, which grants reuse and reproduction rights to all users.

Common Object Request Broker Architecture, from Xerox PARC, a system to define and document interfaces between the modules of non-distributed programs.

A segment of code in which a thread uses resources (such as certain instance variables) that can be used by other threads, but that must not be used by them at the same time.

A carriage return (CR; for the ASCII, 0001101...for the octal, \015...for the hex, 0x0f) followed by a line feed (LF; for the ASCII, 0001010...for the octal, \012...for the hex format, 0x0c).

A different target machine than the development tools themselves, which run on the host--for example, when working on a software application with a SPARC station that generates and debugs code for a Motorola Power PC-based board.

From hand cruft as a pun on hand craft for, perhaps, writing assembler code when an application or project could be more expediently performed by a compiler.

C shell, a command shell for users to type commands, interacting with the operating system. Uses a C-like command syntax, typically for UNIX or Linux developers.

A ROM monitor with a command-line interface, it supports ASM-level debugging without need of a host-based debugger. Allows for setting and clearing breakpoints, disassembling code, examining memory, and using system call handler to support newlib bindings.

Cygmon has basic program handling and debugging commands, programs can be loaded into memory and run, and the contents of memory can be viewed. There are several more advanced options that can be compiled in, such as a disassembler. (This of course increases the code size significantly) Since Cygmon contains a GDB remote stub, full debugging can be done from a host running GDB to a target running cygmon. Switches between CygMon monitor mode and GDB stub mode are designed to be transparent to the user, since CygMon can detect when GDB is communicating with the target and switch into stub mode. When GDB stops communicating with the target normally, it sends a termination packet which lets the stub know when to switch to the CygMon monitor mode.

The command parser was written specifically for Cygmon, to provide the necessary functionality in limited space. All commands consist of words followed by arguments separated by spaces. Any unique subset of a command is recognized as being that command, so du is equivalent to dump. The user is prompted to resolve any ambiguities. Generally, a command with some or all of its arguments empty will either assume a default set of arguments or return the status of the operation controlled by the command.

A UNIX emulation library for Windows 95/98/NT operating systems. Cygwin is a UNIX or Linux shell environment and portability layer enabling delivery of open source projects to Windows. Cygwin provides corporate IT and software developers a solution for integrating a heterogeneous environment of Windows and UNIX-based systems. In addition, developers can use Cygwin to quickly migrate applications from UNIX or Linux to Windows. For more information detailing Cygwin, see the following documentation:

A continuously running server process, waiting for some condition(s) to occur. The idea is that the perpetrator of the condition need not be aware that a daemon is lurking. See also HTTPD.

The layout of debugging information within an object file format. Debug formats include stabs, COFF, DWARF, and DWARF 2.

A tool that allows programmers to examine and control a program, typically for the purpose of finding errors in the program.

A regression testing framework for use on nearly any program, based on the embeddable scripting language, tcl , and its derivative, expect, which runs scripts that can simulate input.

A quantitative change, especially a small or incremental one, used in general in physics and engineering. Often represented as

Means of operating systems to use high-speed network cards in order to have cheaper and faster access with networks than with local disk access or LAN.

Dynamic Host Configuration Protocol, a protocol for getting an IP address, specifically, an Ethernet address. DHCP assigns IP addresses, delivering TCP/IP stack configuration parameters, while also providing other configuration information such as addresses for routers, printers, time and news servers. A demonstration program, dhcpd, comes with the Embedded DevKit software to show this protocol's usage. See also BOOTP.

GNU file-comparison utilities (diff, diff3, sdiff, and cmp), which generate a listing of changes, especially giving differences between (and additions to) lines of source code or between different formats. See also patch.

A program's link against a shared library that, when run, is locatable by the appropriate shared library, arranging to have inclusion in the program that is running.

A debugging format based on attribute records. Versions include DWARF 1, 1.1, 2, and extensions to 2.

Extended Binary Coded Decimal Interchange Code, a character set used by IBM before its open-systems policy, allegedly adapted from punched card code.

Extended COFF, a format used with MIPS and Alpha processors, both for workstations and embedded uses.

Embedded Configurable Operating System, a complete, open-source run-time environment, allowing embedded system developers to focus on differentiating their products instead of developing, maintaining, or configuring proprietary, real-time kernels.

Electrically Erasable Programmable Read- Only Memory, a special type of EPROM that can be erased when exposed to an electrical charge and reprogrammed. EEPROM retains its contents even when the system powers down.

GNUPro compiler tool, EGCS is the actual name for the current version of the GNU compiler; EGCS is pronounced eggs with the C silent.

Extended Linker Format, which appeared with UNIX SVR4 and used on many systems, including Solaris/SunOS, Irix, Linux, and many embedded systems.

An API, a layered subset of the POSIX API, that is scalable, configurable and meant for development of embedded and real-time applications, using Linux or other compliant embedded operating systems. See also Embedded DevKit.

A programmable text editor (derived from Editing MACroS), including facilities to run compilation subprocesses and send and receive mail. Originally written by Richard Stallman at the MIT AI lab.

Using software applications with cross-configuration (working with a different target machine than the development tools themselves, which are used from the host)--for example, a SPARC host operating system generating and debugging code for a Motorola Power PC-based target processor board.

IDE software for developing embedded and real-time applications, using Linux operating systems. As an interface enabling the extraction of source code in C, C++, Java, Tcl, [incr tcl] (the C++ extension for Tcl), FORTRAN, Cobol, and assembly program languages, engineers can use this information to build project databases. The database represents internal program structures and relationships between program components so that engineers can query symbols and relationships between components and graphically display them.

Also referred to as EDK or DevKit, it is a set of open-source tools for embedded development (an infrastructure of compilers, debuggers, utilities and libraries) with the Source-Navigator IDE, providing the world's most advanced browsing environment (with symbol browser, code editor, class browser, hierarchy browser, cross-reference browser, editor and access to the Insight debugging utilities).

Use of algorithms to alter data, making it incomprehensible to unauthorized viewers.

Usually, a host operating system. In the case of a target environment, this means a host operating system and a target (usually, a processor board) when working together with an executable application.

Assignments for an operating system server or client, dependent upon discretion of the user's or the developer's requirements.

Erasable Programmable Read-Only Memory, non-volatile memory chips that are programmed after they are manufactured, and, if necessary, made erasable and reprogrammed. A special type of ROM that retains its contents until it is exposed to ultraviolet light. Compare with diskless, EEPROM, and PROM.

Software for booting x86 PCs over a network, useful for booting PCs diskless, for maintaining software for a cluster of equally configured workstations centrally, for an X-terminal, for platforms where remote partitions are mounted by NFS and there are no problems with the slowness of data transfers that results from NFS (compared to a local disk, for various kinds of remote servers, such as a tape drive server that can be accessed with the RMT protocol), for routers, and for machines doing tasks in environments unfriendly to disks. See also boot/bootstrap, BOOTP, Ethernet, network boot, and RAM Disk.

An event during program execution that prevents the program from continuing normally; generally, an error.

Event that occurs when a block of code reacts to a specific type of exception. If the exception is for an error from which the tool, the debugger, for instance, can recover, the debugger resumes its process.

The process of running a compressed data set through an algorithm that restores the data set to its original size.

A specification for an address or numeric value. An empty expression has no value (being either whitespace or null). An integer expression is one or more arguments delimited by operators. Arguments can use symbols, numbers or sub-expressions. Sub-expressions have a parenthetical usage containing an integer expression, or they are a prefix operator followed by an argument. See Using as in GNUPro Utilities for more discussion of these subjects.

An hierarchical directory structure where files may exist at any level of the directory hierarchy. See also cache/cache file system.

A variation of EEPROM that can be erased and programmed as units of memory called blocks. EEEPROM is erasable and is rewritten at the byte level, which is slower than flash memory updating. Flash memory is used with digital cellular phones, digital cameras, LAN switches, embedded controllers, and other embedded devices.

A number representing a mantissa (usually a value between 0 and 1) and an exponent according to a given base (usually a value of 2).

Numeric system used to represent very large and very small real numbers. With two parts, a mantissa and an exponent; for example, 153,000,000 and 0.0009375 have the floating point notation, respectively, of 153E4 and 9375E-7. See also FLOPS.

Floating-point operations per second, a measure of computer's speed of performing floating-point operations. Compare MIPS.

Used very generally as a sample name for absolutely anything, especially programs and files. Etymology from Army slang acronym, FUBAR (bowdlerized to mean Fouled Up Beyond All Repair).

When debugging, the location of a function call, arguments about the call and called local variables, are within a block of data called the stack frame. When stopping a program or when a program stops, debugging commands for examining the stack allow developers who are debugging to have access to all this information. See also stack and stack frame.

File Transfer Protocol, based on TCP/IP, which enables getting and storing files between hosts on the web. Uses the ftp command to direct files to new location.

Segments of C or C++ programming languages which provide a means for a program to transfer and to generate data in a modular way. A program can have many functions but only one main function to which all other functions address. See also program.

The automatic detection and freeing of memory that is no longer in use. A runtime system performs garbage collection so that programmers never explicitly free objects.

Front end to GCC that is able to read Java .class files, generating assembly code.

A small special-purpose debugging application running on a target. gdb connects to the gdbserver using either a serial or an Ethernet (TCP/IP) connection.

GNU ANSI C library, a fully POSIX and ANSI compliant C library, more suited to native UNIX systems and heavily used for Linux. See newlib.

Recursive acronym for GNU's Not UNIX. A project to build a free operating system, started by Richard Stallman in 1985, with many useful spinoffs, such as the Emacs text editor, a C compiler (gcc or egcs), a debugger (gdb), and many other programming tools.

Freeware 32-bit DOS extender. Also the name for GNU tools ported to DOS using GO32.

UNIX command for rapidly scanning a file or directory of files, searching for a specific pattern or specific data.

Graphical User Interface, which refers to an interface and the techniques involved in using a keyboard or a mouse, for instance, to provide an easy-to-use interface to some software. Arguments ensue over the pronunciation (gooey or gee-you-eye).

The numbering system that uses 16 as its base. The code signified by 0-9 and a-f (or equivalently A-F) represents the digits, 0 through 15.

Hyper Text Transfer Protocol daemon, a Web server program providing information to a client using the HTTP protocol (the standard for communicating information on the World Wide Web). See also Apache.

Name for the 32-bit members of the Intel x 86 family. Members include 386, 486, Pentium (i586), and Pentium Pro (i686).

In-Circuit Emulator, a hardware device that gives an engineer control over the execution of a processor while it's connected to the rest of a system's circuitry. Emulators are powerful hardware debugging tools that can connect to debuggers.

Integrated Development Environment, a GUI tool or a set of tools that uses GUI functionality.

Often designated as #include files, using or assigning duplication of a portion (or whole) of another file, sometimes leading to excessive multi-leveled inclusion (as within a newsgroup's discussion thread, a practice that tends to annoy readers).

Command for initializing the RAM Disk with a Linux operating system. See RAM Disk.

An object (not a reference) is defined as an instance of exactly one class (in classical object oriented programming), called its most derived class. An object not directly contained in any other class is called the complete object.

A module that alternately decodes and executes every statement in some body of code.

Internet Protocol, the basic protocol of the Internet, enabling the delivery of individual packets from one computer to another across the web. A packet may not be instantly delivered, or if multiple packets are sent simultaneously, they may not simultaneously arrive in the order they were sent. Protocols built on top of this add the notions of connection and reliability. See also TCP/IP.

Instruction Set Architecture bus, a means to carry signals for transferring data between the processor and any peripheral devices.

Joint Test Advisory Group, referring to a type of hardware interface that allows the testing of chips and boards within a complete system; programs running on processors with JTAG support may be controlled through the processor's JTAG port.

The core of an operating system, where all the drivers are that a system needs for associating with hardware such as Etherboot and other devices.

Local Area Networking that connects systems in order to share information and expensive computing resources.

How characters in source code are translated into tokens that the compiler interprets.

Nested functions that can access all the variables of the containing function that are visible at the point of its definition.

GNU library for manipulating machine opcodes. Its main use is disassembling binary files. Distributed under the GPL, this is currently only used by the GNU binary utilities, the GNU assembler and the GNU debugger.

A collection of precompiled routines that a program can use. The routines, sometimes called modules, are stored in object format. Libraries are particularly useful for storing frequently used routines because you do not need to link them explicitly to every program that uses them. The linker automatically looks in libraries for routines not found elsewhere.

GNU command-line editing program, and it is distributed under the GPL. This library implements full Emacs or vi key bindings with history support. Used by gdb.

GNU object file manipulation library, and is distributed under the GPL. libbfd is used by the GNU debugger, assembler, linker, and the binary utilities. It can read and write files in any supported object file format, and presents a somewhat loosely defined standard for manipulating object files. See also BFD and FreeBSD.

Library comprising the precompiled routines for embedded environment development. See also library.

A tool that merges object files and library archives (such as compiled classes), building an executable, a complete program or a single executable file. For GNU, ld is the linker tool.

A set of programmer-supplied instructions that tell the linker how to handle object file sections, how to lay out memory, and so forth. For native linking, the contents of the linker script are normally determined by the needs of the operating system; for embedded targets, the programmer explicitly supplies the linker script.

A free UNIX operating system for many kinds of computers, created by Linus Torvalds and friends starting about 1990 (the pronunciation of /lee-nuhks/ is preferred, accenting the first syllable, since the name Linus has an /ee/ sound in Swedish).

The basic representation of any integer, floating point, or character value. For example, 3.0 is a single-precision floating point literal, and "a" is a character literal.

A data item known within a block, but inaccessible to code outside the block. For example, any variable defined within a Tcl method is a local variable and can not be used outside the method.

A byte-ordering scheme, such as used by the Intel x 86 family, which is all little-endian. Describes a computer architecture in which, within a given 16- or 32-bit word, bytes at lower addresses have lower significance (the word is stored little-end-first). See also big-endian.

Used for general register (for intermediary and temporary results), index register (for arithmetic operation and addressing memory), pointer register (for arithmetic operation and addressing memory), and segment register (for built-in memory management) purposes.

The GNU reconfiguration utility for automating recompilation, linking, etc., of programs, taking account of the interdependencies of modules and their modification times. make reads instructions from a makefile, Makefile, which specifies a set of targets to build, a set of files on which the targets depend and the commands to execute in order to produce them. If make is run with no arguments, it looks for a makefile, Makefile. For historical purposes, see also Make: A Program for Maintaining Computer Programs by A.I. Feldman (a Bell Labs publication).

A specific script which tells a UNIX program, make, how to build a particular computer program or set of programs. A makefile contains variable assignments and rules that which, with input, say if any files have been modified more recently than a target file (or if the target does not exist), then execution of specific commands will normally build the target from the inputs. For an example of a makefile, see "A simple makefile" and "Writing makefiles" with Using make in GNUPro Utilities.

The process by which C++ types and classes are turned into symbols in object files that are compatible with other languages.

A procedure, function, or routine in programming languages, usually associated with a class.

A tutorial version of UNIX, written by Andy Tanenbaum and described in his textbook. Minix is said to have been the inspiration for Linux.

Massachusetts Institute of Technology, the birthplace of the Artificial Intelligence (AI) Laboratory and the Tech Model Railroad Club (TMRC), one of the wellsprings of hacker culture. Notably, the main location of GNU conception.

Process or command for remote systems to use to move files from one location to another system.

A collection of libraries built with different GNU compiler options, for target processors having several variants that require changes in code generation, one for each variant. This ensures that a program using -msoft-float (enabling software floating point functionality) will link with libraries built using the same option.

Functionality of a program that is designed to have parts of its code execute concurrently. See also thread.

To make changes to a file, irrevocably, such as a comprehensive rewrite of a routine, data structure or a whole program. Often an unintentional process of corrupting a file or memory block so that it's unusable, unreadable, unviewable or unrecoverable.

The process by which C++ types and classes are turned into symbols in object files that are compatible with other languages.

An ANSI/ISO standard in development for the C++ libraries, allowing users to identify the scope for selecting specific functions by class or type from separate libraries, while still being able to let libraries work together and separately.

A process for getting system files over a network link, allowing any updating of files to happen at that single, robust server. See also boot/bootstrap and BOOTP.

Two C libraries, libc (C library), and libm (C math library) for embedded systems work.

The ASCII LF character (for 0001010), used under UNIX as a text line terminator. See also CRLF.

Network File System, a way to share files between machines as if shared on a local hard drive. With NFS, export files systems to other systems, and mount file systems exported from other machines. See also BOOTP, filesystem, network boot and RAM Disk.

A machine instruction that does nothing (sometimes used in assembler-level programming as filler or for overwriting code to be removed in binaries).

Non- Recurring Engineering, typically used to refer to one-time-only development, such as re-targeting to a new architecture or adding a feature.

The principal building blocks of object-oriented programs. Each object is a programming unit consisting of data variables and functionality. See also classes.

A binary-format file containing machine instructions and possibly symbolic relocation information. Typically produced by an assembler.

Assembler macros that provide commands instructing a specific device to perform a specific task.

A flag on some processors indicating an attempt to calculate a result too large for a register to hold.

The swap space on a system's disk for storing idle portions of the memory used by running programs, and the filesystem space to store directories and files.

Also a file that contains changes to source code; specifically, the results of a differentiation and comparison between the new file(s) and the old file(s). See diff utilities and bug.

A filename, fully specified relative to the root directory (as opposed to relative to the current directory; the latter is sometimes called a relative path).

Also called a pathname or full path. With UNIX and MS-DOS, the search path uses an environment variable, specifying the directories in which the shell (Command.com, under MS-DOS) should look for commands. Other similar constructs abound under UNIX (for example, the C preprocessor has a search path it uses in looking for #include files).

Peripheral Component Interconnect bus, a high performance means to carry signals for transferring data between the processor and any peripheral devices.

Practical Extraction Report Language, a scripting language that Larry Wall designed which interprets data from text files and converts the data into an intermediate form before executing the data as a program. See http://www.perl.com/, the Perl Home Page.

PowerPC family of RISC processors, designed jointly by IBM and Motorola. Versions include the 601, 604, 401, 403, 750, 801, and 860 processors.

For instance, you create, compile and then link a software program file, foo.exe. Type foo at the shell window's prompt. Your operating system will call the main() function of the program; the program runs and, when it finishes, control goes back to the system.

A typical example in most C and C++ books would be the following code, that prints "Hello." on a system's terminal or shell window.

Programmable Read-Only Memory, ROM that can be programmed using special equipment. PROMs can be programmed only once. See also ROM and EPROM.

Command-line option for enabling UNIX-like functionality in Windows-type systems.

Pseudo registers can only contain scalar variables that cannot be aliased. This means that global variables, local variables that have their addresses taken, and aggregates (such as structures and unions) cannot be stored in pseudo registers, and thus they must be accessed with separate load and store instructions. Because of the guarantee that pseudo registers are not aliased, they are ideal targets for optimization.

The UNIX system call, traditionally used by debuggers to control other UNIX processes. ptrace arguments may include commands to read/write registers, single-step, etc.

Random-Access Memory, the volatile memory of an operating system, from which a microprocessor can read data or to which a microprocessor can write data.

A disk drive that resides in memory, taking up very little space, for storing temporary work files or to help decrease the I/O load on a system's disks. Can use RAM from the buffer cache to dynamically grow in size. See also RAM.

A shell, for interactive use or for use with scripts, providing C-syntax features with better quoting rules then C or Bourne shells.

runcom files, using a startup script file that contains startup instructions for an application program (or an entire operating system), usually a text file containing commands of the sort that might have been invoked manually once the system was running but are to be executed automatically each time the system starts.

Revision Control System, the tools for controlling software revisions. See also CVS.

An open-source tools and services company providing solutions to the Linux and embedded product developer community. See http://www.redhat.com for more information on training, consultation services and custom development engineering.

A characteristic of library functions which allows multiple processes to use the same address space with assurance that the values stored in those spaces will remain constant between calls. The libm library functions ensure that, whenever possible, they are reentrant.

Registers are settings representing values that serve as temporary storage devices in a processor, allowing for faster access to data. Registers are divided into several classes: pseudo registers, temporary registers, and machine registers.

When doing assembly, assigning run-time addresses to sections, which includes the task of adjusting the mention of object-file addresses so that they refer to the proper run-time addresses. See section.

Request For Comment(s), one of a long-established series of numbered Internet informational documents and standards widely followed by commercial software and freeware in the Internet and UNIX communities.

Reduced Instruction Set Computer, machines typically having fixed-length instructions, limited addressing modes, many registers, and visible pipelines. Examples include MIPS, ARM, SH, PowerPC.

Read-Only Memory, non-volatile memory that can be read, but not written, by the microprocessor, pre-recorded, often holding critical programs, such as boot data.

In a hierarchy of items or of separate files in a directory, the one item or directory from which all other items or directory paths descend. Also the name of the primary administrative account on Linux and other UNIX machines.

Network device that determines the optimal path along which network traffic should be forwarded, using packets from one network to another based on network layer data.

Red Hat Package Manager, a means for having all the necessary components of the Linux software in a single file, from which an install process unpackages and then moves to appropriate directories.

Remote shell protocol that allows a user to execute commands on a remote system without having to log in to the system.

A real-time operating system: telephones, automobile control systems, kitchen appliances, complex air traffic control systems, military weapon systems, production line control including robotics and automation and other rapidly changing technology.

The software system or environment in which compiled programs can run. The runtime system includes all the code necessary to load programs, dynamically link native methods, manage memory, handle exceptions, and an implementation of what may be an interpreter.

Rules determining where a name is usable, such as a function or variable name (the general rule being that a name can be used from the point of declaration to its innermost enclosing compound statement).

A terminal line that disgorges an infinite number of random characters at an operating system. See also tty.

Stream-oriented version of the ed editor. For running repetitive edits on files or on files in several directories. Also for creating conversion programs.

Object files and executables that are composed of a range of addresses, having optional data and optional relocation information. The GNU linker,ld, reads many object files (partial programs) and combines their contents to form a program that will run. When the GNU assembler, as, emits an object file, the partial program is assumed to start at address, 0. Then, ld assigns the final addresses for the partial program, so that different partial programs do not overlap. This is actually an oversimplification of relocation, but it suffices to explain how as uses sections.

ld moves blocks of bytes of your program to their run-time addresses. These blocks slide to their run-time addresses as rigid units; their length does not change and neither does the order of bytes within them. Such a rigid unit is called a section. Assigning run-time addresses to sections is called relocation. It includes the task of adjusting mentions of object-file addresses so they refer to the proper run-time addresses. For the H 8/300 and 8/500, and for the Hitachi SH, the GNU assembler pads sections if needed to ensure they end on a word (sixteen bit) boundary.

An object file written by as has at least three sections, any of which may be empty. These are named text data and bss sections.

An error in which a running program attempts to access memory not allocated to it and core dumps with a segmentation violation error.

When configuring libraries, the linker's usage of source in libraries, whereby the linking explicitly includes those libraries in the linking instruction.

Standardized Generalized Markup Language, an ISO/ANSI/ECMA standard that specifies a way to annotate text documents with information about types of structure for a document.

A library of functions used by many executables without having been linked into each executable.

An interface program for accessing resources and for performing tasks. The original Multics shell ran programs by starting processes that were dynamically linking programs into existing code, calling them as subroutines (see stub) and dynamically de-linking them on return.

A means to interpret, classify and present information about an embedded system's behavior that is being modeled, comprising both hardware and software elements.

A component of Embedded DevKit, an open-source embedded development infrastructure, this IDE provides the world's most advanced browsing environment (with symbol browser, code editor, class browser, hierarchy browser, cross-reference browser, and editor functionality as well as access to debugging utilities). With this as an interface enabling the extraction of source code in C, C++, Java, Tcl, [incr tcl] (the C++ extension for Tcl), FORTRAN, Cobol, and assembly program languages, engineers can use this information to build project databases. The database represents internal program structures and relationships between program components so that engineers can query symbols and relationships between components and graphically display them. The minimum requirements for building source code include specifying which source files should be included, the path to the directory in which the build should be stored, the linking rules used, the debugging and optimization flags used, and included paths.

A binary download format, consisting of a series of records, each beginning with S, with symbolic data encoded as hexadecimal digits. Before downloading to a board, for instance, a program must be converted using S-records.

Based on symbol tables, a debug format originally introduced with the Berkeley UNIX system, which records debugging information in certain symbols in the object file's symbol table. stabs information may also be encapsulated in COFF or ELF files.

The layers (TCP, IP, and sometimes others) through which all data passes at both client and server ends of a data exchange. A data area or buffer used for storing requests that need to be handled, as in a list of tasks or, specifically, the contiguous parts of the data associated with one call to a specified function in a frame. The frame contains the arguments given to the function, the function's local variables, and the address at which the program is executing. In The Art of Computer Programming [2nd edition, vol. I, pg. 236], Donald Knuth writes, "Many people who realized the importance of stacks and queues independently have given other names to these structures: stacks have been called push-down lists, reversion storages, cellars, nesting stores, piles, last-in-first-out (LIFO) lists, and even yo-yo lists!"

When debugging, the location of a function call, arguments about the call and called local variables, are within a block of data called the stack frame. Stack frames are allocated in a region of memory called the call stack. When stopping a program or when a program stops, debugging commands for examining the stack allow seeing all this information.

A small piece of code that executes on the target and communicates with the debugger, acting as its agent, collecting registers, setting memory values, etc. Also, in a native shared library system, the part of the shared library that actually gets linked with a program. See also subroutine.

Part of a program which calls another part of a program so that developers can simplify code in their programs and save memory.

Moving blocks of information in units known as pages between memory and disk as necessary during execution of an application; for instance, moving data from fast-access memory to a slow-access memory (swap out) or reverse (swap in). Supported by operating systems such as Linux, Windows NT/95/98, and OS/2, the process of exchanging two values--for example, exchanging values between two variables. Especially for use as temporary storage during reconfiguration.

Symbols are used to refer to variables, labels, and procedures in a program; basically, symbols are names and addresses. Typically every global function and variable in a C program will have an associated symbol.

Usage varies: (1) an actual physical device, such as a target microprocessor motherboard that gets files from a host operating system, or (2) an application run on a target board, or (3) a class of devices.

A host operating system and a target (usually, a processor board) when working together with an executable application.

The code language used to develop an IDE. Tcl/Tk is a programming system developed by John Ousterhout. Easy to use with very useful graphical interface facilities, Tcl is the basic programming language while Tk is a toolkit of widgets (graphical objects similar to those of other GUI toolkits, such as Xlib, Xview and Motif). Unlike many of the other toolkits, it is not necessary to use C or C++ in order to manipulate the widgets, and useful applications can be built very rapidly with Tcl/Tk. For more information, see ftp://ftp.scriptics.com/pub/tcl (the FTP master distribution site) or http://www.scriptics.com/ftp/ (HTML distribution sources), http://www.scriptics.com (John Ousterhout's company site), and http://www.tclconsortium.org (Tcl/Tk consortium).

Transmission control protocol (based on IP), an internet protocol that provides for the reliable delivery of streams of data across the web.

Standard terminal emulation protocol in the TCP/IP protocol stack, when using a remote terminal connection, enabling remote log in to systems, thereby using resources as if connected to a local system.

Temporary registers are used to hold intermediate results of computations within a basic block. Each temporary register must be defined and used in exactly one place, and never assign a value to a temporary register that is never used, and do not use the value in a temporary register more than once.

Trivial File Transfer Protocol, used when getting an IP address with the tftpboot command-line input. A restricted version of TCP with no authentication, using UDP rather than TCP. See also TCP/IP and UDP.

The basic unit of program execution. A process can have several threads running concurrently, each performing a different job, such as waiting for events or performing a time-consuming job that the program doesn't need to complete before resuming. When a thread finishes its job, the debugger suspends or destroys the thread running in the debugging process.

Informal term for the programs that make up a complete set of GNU tools for a particular native or host architecture and a target environment, typically consisting of the following example's collection:

On-the-fly generation by a compiler (such as gcc) of small executable code objects that do indirection between code sections, taking the address of a nested function.

A small and insignificant change to a program. Derived from squiggle, or in ASCII shorthand, tilde (for the ASCII character definition, 1111110, of the character, ~).

Any serial port, whether or not the device connected to it is a terminal; so called because under UNIX such devices have names of the form, tty*. Its derivation is from "teletype."

User Datagram Protocol, for a diskless computer to use when downloading. Its code size can be small in order to fit on ROM. Block oriented, as opposed to stream oriented. See also TFTP and DHCP.

Uniform Resource Locator, the standard for writing a text reference to an arbitrary piece of data over the Internet. A URL looks like "protocol://host/localinfo" where protocol specifies a protocol to use to get the object (like http or ftp), host specifies the Internet name of the host on which to find it, and localinfo is a string (often a file name) passed to the protocol location on the remote host.

UNIX operating system (lowercase spelling of Unix used interchangeably). Invented in 1969 by Ken Thompson after Bell Labs left the Multics project, UNIX subsequently underwent mutations and expansions under many different hands, resulting in a uniquely flexible and developer-friendly environment, becoming what was once the most accepted multiuser, general-purpose operating system in the world.

For transmitting binary files over any media that support ASCII data transmission.

A variable is a name used in a program to stand for a value. Global variables have one value at a time, and this value is in effect for the whole system. Constant variables have values that never change. Instance variables are defined as of exactly one class, called its most derived class. Local variables help create variable values that exist temporarily while within a certain part of the program; these values are called local, and the variables so used are called local variables. For example, when a function is called, its argument variables receive new local values that last until the function exits. Void variables use symbols that lack values.

Visual Interface, a screen editor crafted together by Bill Joy for an early BSD release. Became the de facto standard UNIX editor and a nearly undisputed hacker favorite (arguably) outside of MIT until the rise of Emacs after about 1984. See also ed and Emacs.

Virtual File System; its functionality, among other things, is to flush the read buffer when it detects a disk change on the floppy disk drive.

An abstract specification for a computing device that can be implemented in different ways, in software or hardware. Compiling to the instruction set of a virtual machine is much like compiling to the instruction set of a microprocessor, using a bytecode instruction set, a set of registers, a stack, a garbage-collected heap, and an area for storing methods.

A special breakpoint that stops a program's debugging process when the value of an expression changes.

In code, newlines, spaces and tab characters which the compiler treats as a contiguous, single character. An instance that is noticeable for the program output, and only as formatting for human readability.

The components of software by which we get many of the interface features that provide interoperability, such as the scrollbars or the means of selecting text with a cursor or pointer, using object-oriented programming.

Name for Intel's 80x86 processor chip family (the first chip from Intel being the 8086).

A way of implementing a big-endian ISA. See MIPS and PPC (PowerPC) for example members.

GNU parser generator that takes a description of tokens in the form of a grammar and generates a parser in the form of a C program.

Name for the Z8000, a long-obsolete 16-bit descendent of the Z80 8-bit microprocessor.