JANUARY/FEBRUARY 2006 (Vol. 23, No. 1) p. 99
0740-7459/06/$31.00 © 2006 IEEE
Published by the IEEE Computer Society
Published by the IEEE Computer Society
Software engineering glossary
|Software Construction, Part 1|
PDFs Require Adobe Acrobat
Software Construction, Part 1
abstraction : A view of an object that focuses on the information about the object that's relative to a particular purpose and ignores other information.
access routine : A routine that provides access to a data structure that's hidden, usually because it's a global variable or used in an abstract data type.
architecture : The organizational structure of a system and its implementation guidelines; sometimes refers to the design of a system's hardware and software components. Similar to high-level design.
assertion : A function or macro that complains loudly if a design assumption on which the code is based isn't true.
bottom-up design : A design approach in which low-level pieces of a system are combined into an overall design.
class : A static programming entity in an object-oriented program that contains a combination of functionality and data. Class is a design and code-time concept but is often used interchangeably with object.
code tuning : The process of making statement-level changes to a program to make it more efficient.
complexity : The degree to which a system's design or code is difficult to understand because of numerous components or relationships among components.
constant : A numeric or string value that doesn't change during program execution. See also literal.
construction : The activity in software development consisting of detailed design, coding, unit testing, and debugging. Also called programming or development.
coupling : A measure of how closely connected two routines or modules are. The more remote the connection, the looser the coupling. In general, loose coupling is a desirable design characteristic.
defensive programming : A general approach to programming that assumes that errors will occur during both initial development and maintenance and, as a result, creates code in such a way that the program still operates properly when errors occur.
design : The process of conceiving, inventing, or contriving a scheme for turning a computer program specification into an operational program; activity that links requirements analysis to coding and debugging; also refers to the design activity's result.
detailed design : See low-level design.
encapsulation : The idea that a module has an outside that's distinct from its inside—that it has an external interface and an internal implementation. Similar to information hiding.
error processing : The process of detecting and responding to a program's errors.
exception handling : A programming-language mechanism that passes error information by throwing and catching exceptions.
function : A routine that returns a value; in C, the entity called a function.
global data : Data that can be accessed by two or more routines not in the same module without being explicitly passed between them as parameters.
high level : General; abstract.
high-level design : The process of defining the high-level concepts that guide low-level design and implementation. High-level design typically involves organizing a system into subprograms and specifying the interfaces between them. Similar to architecture.
implementation : Archaic term for construction; now primarily refers to the installation and customization of packaged software.
information hiding : Containment of a design or implementation decision in a single module so that the decision is hidden from other modules. The secret might be an area that's likely to change, the format of a file, the way a data structure is implemented, or an area that must be walled off from the rest of the program so that errors in it cause as little damage as possible. Similar to encapsulation.
layout : The physical organization of source code including the use of white space, grouping, blank lines, alignment, indentation, and parentheses.
level of abstraction : A view of an object at a specific level of detail.
line of code : A programming-language statement, often defined as a noncomment, nonblank deliverable source statement.
literal : A number or string that's used by a program directly rather than being embedded in a named constant or variable.
local data : Data that can be accessed only within the routine in which it's declared.
low level : Specific; detailed.
low-level design : The process of design at the individual-routine or, sometimes, class level under the guidance of a more general design.
Steve McConnell is CEO and chief software engineer of Construx Software. Contact him at email@example.com.