43.

Glossary of Terms

A-E

Acceptance test (a.k.a., system test)

An automated test that determines if a program meets some part of its specification. In contrast, unit tests check that some part (unit) of the implementation behaves as expected.

Accessor (a.k.a., getter)

A method that reports some aspect of an object's state. In general, accessors should not modify the state of the object being accessed in the process of accessing it.

Agile methods

Methods of software development that acknowledge and leverage the frequent changes in specification, and the relatively low cost of modification, inherent in software development.

Antipattern

A pattern of poor software design that is nevertheless commonly employed. Unlike bug patterns, antipatterns tend to focus on the level of design, not coding.

Aspect-oriented programming

A style of programming in which global program properties, or aspects (e.g., the handling of checked exceptions, the encapsulation of object state), are maintained through the automatic insertion of code into method bodies.

Assertion

A claim about the state of a computation during execution, expressed in a formal language that is checkable either dynamically (when the program is run) or statically (before it is interpreted or compiled).

Broken Dispatch

A bug pattern signaled by a method call in a program that is broken by the addition of new code.

Bug

An aspect of program behavior that does not match the specification.

Bug pattern

A recurring relationship between signaled errors and underlying bugs in a program.

Checked exception

An exception that can be caught and handled within a program. Checked exceptions are best reserved for unexpected events that do not indicate bugs in a program.

Composite design pattern

A design pattern in which an operation is encapsulated within an object, so that it can be handled and passed around as data.

Controller

One of the three types of components in a Model-View-Controller architecture. The controller is responsible for connecting a model to its view(s).

Dangling Composite

A bug pattern whose cause is a composite class hierarchy in which various base cases are represented as null values.

Data type base case

A part of a recursive data type that contains no subcomponents of the data type.

Design by contract

A style of programming in which the services and responsibilities of each class (or, more generally, each program component) are specified explicitly. Design by contract allows for the precise determination of which component(s) are to blame for a bug.

Design pattern

A solution to a program design problem that has shown itself to work well in a variety of contexts, given a particular design goal.

Double Descent

A bug pattern whose cause is a recursive descent over a composite data structure that proceeds too far.

Encapsulation

The hiding of the details of an implementation from that implementation's clients.

Extreme programming

An agile programming practice that emphasizes incremental development, perpetual refactoring, unit testing, and pair programming.



Bug Patterns in Java
Bug Patterns In Java
ISBN: 1590590619
EAN: 2147483647
Year: N/A
Pages: 95
Authors: Eric Allen

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net