AppendixA.An Agile Java Glossary


Appendix A. An Agile Java Glossary

This appendix lists key terms. Most terms that appear in the text of Agile Java in italicized form appear here.

Each definition is brief but should provide you with a good idea what a given term means. Refer to the index in order to locate occurrences of the term within Agile Java. The context should provide you with a more robust understanding of a specific term.

abstract

representing concepts as opposed to concrete, specific details



acceptance test

a test that demonstrates functional behavior; also known as a functional test or customer test



access modifier

a keyword that identifies the level of exposure of a Java element to other code



action method

a method that effects an action, usually altering the state of an object



activation

a UML construct that represents the lifetime of a method in a sequence diagram



actual value

in an assertEquals statement, the expression or value that you are testing. The actual value immediately follows the expected value.



agile

a term for a body of lightweight processes; an agile process centers around the idea that requirements will change as a project progresses



annotation

a construct that allows you to embed descriptive information for Java elements in source code. An annotation is verified against an interface specification by the compiler.



anonymous inner class

an unnamed class that is dynamically defined within a method body



API

application programming interface



application

a computer-based system that provides value to humans or other systems



application programming interface

the published specification for other classes with which your code can interact



argument

an element that is passed to a method. Informal use of the term can indicate either one of the list of actual arguments passed in a method call or the formal parameters listed in the method's signature



argument list

the list of values or references passed to a method



array initializer

an initialization construct that allows provision of a set of initial values for elements in an array



assignment

the act of storing the result of an expression in a field or variable



assignment operator

the equals sign (=); used as part of an assignment



atomic

an operation that executes as a single indivisible unit



attribute

a general object-oriented term for a characteristic of an object. You define attributes on a class.



autoboxing

automatically enclosing a primitive with its corresponding wrapper type



autounboxing

automatically extracting a primitive from its corresponding wrapper type



bind

to supply a type for a parameterized class



boolean

a type that represents two possible values: true and false



bound

having supplied a type for a parameterized class



block

(n.) a section of code enclosed between braces; (v.) to wait until some other operation has completed



border

a buffer area between the edges of a container and any of its components



byte codes

the programming operations and other relevant information contained in a class file



callback

the technique of passing a function as a parameter so that the receiver can message to it



camel case

the mixed-case naming scheme preferred for Java identifiers



cast

to tell the compiler that you want to convert the type of a reference; to narrow a numeric value to a smaller type



catch

to trap a thrown exception



checked exception

an exception that your code must explicitly acknowledge



checked wrapper

a collection wrapper that ensures that objects stored in the collection are of the appropriate type



class

a template for creating objects; a class defines behavior and attributes



class constant

a reference to a fixed value that can be accessed irrespective of creating object instances



class diagram

a UML model that shows class detail and the static relationship between classes



class file

a file containing code that has been compiled from source code



class library

a collection of useful classes provided by a vendor or another developer as an API



class literal

a value that represents the sole instance of a class



class loader

code that dynamically reads a stream of bytes representing a Java compilation unit from some source location and converts it to a usable class



class variable

a variable defined on a class that can be accessed without using an instance of the class



classpath

a list of directories or JAR files that Java uses for compilation and execution



client

a class, or code in general, that interacts with a specific target class. The target class may be referred to as a server class.



clone

to create a copy of an object



close

to design a class so that it needs no further modification despite future changes



coding

the act of writing programs



collective code ownership

a team philosophy that allows anyone to modify any portion of the system



collision

when two elements hash to the same location in a hash table



compiler

an application that transforms source code into a binary form that a platform can understand and execute



command object

an object that captures information in order to be able to effect specific behavior at a later time



comment

a free-form annotation of code that is ignored by the compiler



complex annotation

an annotation that includes another annotation



compound assignment

a shortcut form of assignment that presumes that the variable being assigned to is also the target of the first operation in the right-hand expression



composition

an association between classes whereby objects of one class are composed of objects of another class



concatenate

append



connection pool

a group of shared database connections



constructor

a block of code that allows you to provide statements to initialize an object. Invoking a constructor using the new operator results in the creation of an object.



constructor chaining

calling one constructor from another



container

a component that can contain other components



controller

a class responsible for managing input from the end user



cooperative multitasking

a multithreading scheme in which the individual threads are responsible for yielding time to allow other threads to execute



couple

to increase dependencies between classes



covariance

the ability for a subclass to vary the return type of an overridden method



critical section

See [mutual exclusion]
customer test

See [acceptance test]
daemon thread

a secondary thread; an application can terminate regardless of whether or not daemon threads are active



declaration

the point at which something is defined



decouple

to minimize dependencies between classes



decrement

to subtract (usually one) from a value



decrement operator

--. A unary operator that subtracts 1 from the operand



default package

the unnamed package; classes that are defined without a package statement end up in the default package



dependency

a relationship between two classes (or any two entities) where one requires the existence of the other



dependency inversion

designing class associations so that classes are dependent upon abstractions instead of concrete implementations



deprecated

Java code intended for eventual removal from a class library



dereference

to navigate to a memory location based on the memory address stored in a reference



derived class

See [subclass]
deserialize

to "reconstitute" an object from a sequence of bytes



design by contract

a design technique that requires programmers to create a contract for how their software is expected to behave. and

See also [precondition]
See also [postcondition]
See also [invariant]


driver

with respect to JDBC, an API that meets Sun's specification for interfacing with a database



dynamic proxy class

a class that allows you to implement one or more interfaces at runtime



element

a Java construct that an annotation can possibly annotate: a class, enum, interface, method, field, parameter, constructor, or local variable



encapsulation

hiding implementation specifics from clients; a core object-oriented concept



erasure

the scheme chosen by Sun to implement parameterized types; it refers to the fact that parameterized type information is erased to its upper bounds



escape sequence

a sequence of characters within a String or character literal that maps to a single character. An escape sequence begins with the character \. Escape sequences allow you to represent characters that you may not be able to type directly.



exception

an object that encapsulates error information



expected value

in an assertEquals statement, the value you expect to receive when comparing to an actual result. The expected value immediately precedes the actual value.



factory method

a method responsible for constructing and returning objects



field

the Java implementation of an attribute. A field minimally specifies a type and name for a characteristic of a class



field initializer

a code expression used to provide an initial value for a field or local variable



formal parameter

a named argument listed in a method or constructor signature



format elements

substitution parameters in a resource defined in a resource bundle



format specifier

a placeholder for substitution values within a format string; defines the transformation from value to output string



frame

a top-level window



fully qualified

indicates that a class name contains its complete package information



garbage collection

the VM process of reclaiming memory that is no longer needed



garbage collector

the code that is responsible for garbage collection



generic method

a method that can be parameterized with one or more type parameters



generics

parameterized types



global

available to any interested client



guard clause

a code construct that defines an early return from a method in the event of an exceptional condition



hacking

informal: creating software with abandon. Originally, hacking was a positive term; modern use of the term (including its use in Agile Java) is usually pejorative



hash code

an integer generated by a hashing algorithm that is used as the key for locating elements in a hash table



hash table

a fixed-size collection that determines the location of its elements using a hash code



heavyweight

refers to a process that emphasizes written, up-front documentation and discourages deviation from an initial plan



i18n

Internationalization



identifier

the name given to a Java element, such as a field, method, or class



immutable

unchangeable. A class is immutable if its attributes cannot be altered. An immutable object is also known as a value object



implement

to provide code details. When you implement an interface, you supply concrete definitions for the methods it declares



increment

to add (usually 1) to a value



increment operator ++.

A unary operator that adds 1 to the operand



inherit

to extend from a base class



inheritance

a relationship between two classes where one class (known as the subclass or derived class) specializes the behavior of another class (known as the superclass or base class)



initial value

the value that a field or local variable has at the time of declaration



inline

to embed previously externalized code into a method body; i.e., to eliminate the need for a method call by moving the target method's code into the calling method



instance variable

See [field]
instantiate

to create an object



interface

general: the point of communication between two things, such as two systems or two classes; Java: a construct that allows you to define method specifications, but no implementation details



interface adapter class

a class that transforms an externally defined interface into one that is more useful in the context of the current system



internationalize

to code a system such that it can supports deployment to different localities



interpreter

an application that reads and executes compiled code;

See also [virtual machine]


invariant

an assertion that must always hold true while executing code;

See also [design by contract]


invert

to turn upside-down; used in the context of dependency inversion



jagged array

an array of arrays where each subarray can vary in size



JAR

Java ARchive



Java archive

a class container; implemented using the ZIP file format



layout

the arrangement of components in a user interface



layout manager

a class that can aid in arranging components in a user interface



lazy initialization

a programming technique whereby you do not provide an initial value for a field until it is used for the first time



lightweight

refers to a process that emphasizes adaptation over adherence to plan



linked list

a serial data structure that adds new elements by dynamically allocating memory. Elements of a linked list must refer to other elements by storing one or more references to them.



local variable

a variable defined within the body of a method



locale

a region that is defined by perhaps geography, culture, or politics



localize

to prepare an internationalized application for delivery to a locale



log

to record



logical operator

an operator that returns a boolean value



lower bound

a constraint that requires a wildcard to be a supertype of the specified class



marker annotation

an annotation that provides no arguments



marker interface

an interface with no method declarations; allows programmers to signal intent for a class



member

a constructor, field, or method defined on the instance side of a class



member-value pair

a key and corresponding value supplied in an annotation



memory equivalence

when two object references are equali.e., they point to the same object in memory



metadata

data about data



method

a unit of code that helps define the behavior of a class. A return type, name, and argument list uniquely define a method. A method consists of a number of statements



methodology

a process for building software



mnemonic

a single-letter shortcut for activating a button



mock object

an object used for creating context to aid in verifying assertions against target code. Loosely used, a mock is any object that substitutes for production code to aid in testing



model

a class that contains application or business logic



modulus

an operator that returns the remainder of a division operation



multiline comment

a comment that can span multiple source lines; you start a multiline comment with /* and end it with */



multithreaded

having the ability to execute certain code sections at the same time as other sections



mutual exclusion

a form of synchronization in which a section of code has exclusive attention from the Java VM while it executes



naked type variable

a use of a type parameter symbol within a type declaration



namespace

a namespace implies the ability to define unique names, such that entities with the same base name do not clash with one another. In Java, this is accomplished through the use of package names



nested

embedded within



nested class

a class defined within another class



nondeterministic

having the potential to return different results each time when given the same inputs and initial state



numeric literal

a code instance of a number, such as an integer or a floating-point number



object

an entity that has identity, type, and state; objects are created from classes



object-oriented

based on the concepts of classes and objects



operator

a special token or keyword recognized by the compiler. An operator takes action against one or more values or expressions



overload

to supply multiple definitions for a method or constructor. You vary the definitions by their argument list (or possibly their return value;)

See also [covariance]


overloaded operator

an operator that has different meanings depending on the context in which it is used



override

to provide a replacement definition for a method already defined in a superclass



package

an arbitrary collection of classes, defined either for deployment or organizational purposes



package import

a form of the import statement that indicates that any of the classes in the specified package might be used in the class



package structure

the current state of package organization



pair programming

a development technique in which two developers actively program at a single workstation



parameter

informally, another name for an argument



parameterized type

a class to which you can bind one or more classes; doing so supplies additional constraints on the types of object that the class can interact with



persistent

existing from application execution to execution



platform

an underlying system on which applications can be run



polymorphism

the ability of objects to supply variant behaviors, in response to a message, based on their type. Seen from the opposite direction, the ability of clients to send a message to an object without an awareness or concern for which object actually receives the message



postcondition

an assertion that must hold true after executing code;

See also [design by contract]


postfix operator

a unary operator that appears after the target it operates on



precondition

an assertion that must hold true prior to executing code;

See also [design by contract]


preemptive multitasking

a multithreading scheme in which the operating system (or virtual machine) is responsible for interrupting and scheduling threads



prefix operator

a unary operator that appears before the target it operates on



primitive type

non-object types in Java. Numeric types and the boolean type are primitive types



process framework

a foundation for creating and customizing a process tailored to your needs



process instance

a specific customization of a process framework



program

the body of code that comprises an application; often used interchangeably with the term "application"



programmer test

See [unit test]
programming

See [coding]
programming by intention

a programming technique whereby you first specify your intent for a solution (i.e., the general steps involved) before implementing it (i.e., providing the detailed code)



project

the related things that make up an effort



proxy

a stand-in. A proxy object is an object that might filter or control access to the object it stands in for. To a client, a proxy is indistinguishable from the real thing



public interface

the methods of a class that are exposed to any other client class



query method

a method that returns information to a client but does not alter the state of the object



queue

a serial data structure that returns the eldest object when a client requests an object from it Also known as a first-in-first-out (FIFO) data structure



random access file

a logical interpretation of a file that allows you to quickly seek to specific positions in the file and read from or write to that position



raw type

an unbound parameterized type



realizes

implements



receiver

the object to which a message is sent, directly or indirectly, as the result of a method call



recursive

calling oneself; sending a message to the same method that is currently executing



refactor

to transform code; by definition, refactoring should not change the behavior of code



refactoring

(n.) a code transformation; (v.) the act of applying transforms to code



reference

a memory address; a variable that points to an object



reflective

of or dealing with reflection



reflection

the capability in Java that allows you to dynamically derive information about types and their definitions at runtime



regression test

a test that ensures that the existing application still works after changes have been applied



regular expression

a set of syntactical elements and symbols that is used to match text



resource bundle

a collection of resources such as message strings; allows an application to dynamically load said resources by name. A resource bundle is usually an external file.



rethrow

to catch and subsequently throw the same or another exception object



return type

indicates the class of object that a method must provide to the caller



runtime

refers to the scope of execution of a program; i.e., when it is running



sandbox

a customizable virtual Java place that defines boundaries for security purposes



scale

the number of digits to the right of the decimal point in a decimal number



scope

the lifetime of an object or variable; the sphere of influence it has



seed

a number used as the basis for determining a pseudorandom number sequence



semantic equality

when two objects are considered the same based on arbitrary criteria as supplied by a programmer. In Java, you use the equals method to define semantic equality



serializable

a class whose objects can be serialized; arbitrarily designated by a programmer



serialize

to convert an object to a sequence of bytes



server

a class or group of classes that provides a service to clients



singleton

a class that is coded to disallow creation of more than one instance of itself



signature

the information that uniquely identifies a method: its return type, name, and list of argument types



simple design

an approach to design that values testing, elimination of duplication, and code expressiveness. Simple design rules result in positive emergent behavior in code.



single-line comment

a comment that begins with //; an end-of-line character terminates the comment



software development kit

a bundle of applications and utilities designed to help developers build and execute custom applications



source file

a file containing code as typed by a programmer



spurious wakeup

an unexpected activation of an idling thread



stack trace

the execution summary that an exception generates. A stack trace shows, in reverse order, the chain of message sends leading up to a problem



stack walkback

See [stack trace]
state

a snapshot of what an object looks like at a current point in time, represented by the values in its attributes



statement

a line of Java code, terminated by a semicolon



static import

an import form that allows you to use class methods or variables defined in a different class as if they were defined locally



static initialization block

a block of code that executes when a class is first loaded by the VM



static method

a method you can invoke without first instantiating the class on which it is defined



static scope

having existence for the lifetime of a class



story

an informally stated requirement; a promise of further conversation



strategy

an algorithm; a variant way of accomplishing a task



stream

a sequence of data that you can write to or read from



string literal

a code instance of a String object, represented by text enclosed in double quotation marks



strongly typed

a characteristic of a programming language whereby variables and constants must be associated with a specific data type



subclass

the specialized class in an inheritance relationship



subscript

an index representing a position within an array



suite

a collection of unit tests



synchronization

the coordination of simultaneously executing threads to avoid data contention



target

the subject of desire; the object being operated on; in Ant, a process you want to execute



TDTT

test-driven truth table



temp variable

See [local variable]
temporary variable

See [local variable]
ternary operator

an operator that allows you to represent an if-else statement as an expression



test-driven

designed by virtue of programming specification tests prior to coding the corresponding implementation



test-driven truth table (TDTT)

a series of assertions to demonstrate the results for all possible combinations of bitwise and logical operators



token

an individual text component delineated by specially designated text characters



tolerance

the acceptable margin of error when comparing two floating-point quantities



thread

a Java unit of execution. A Java process may contain multiple threads, each of which can be executing simultaneously with the others



thread pool

a group of reusable threads



throw

to generate an exception; a transfer control mechanism



trace statements

code inserted in your application to allow you to monitor its behavior as it executes



two's complement

an scheme used for internal representation of negative integers. To obtain the two's complement representation of a number, take its positive binary representation, invert all binary digits, and add 1



type parameter list

in a parameterized type, the list of arguments that you must bind to



uncaught exception handler

a hook that allows you to trap executions thrown from a thread



upper camel case

a Java identifier naming scheme; camel case in which the first letter of the identifier is upper case



unary operator

an operator that has a single target



unchecked exception

an exception that does not require code to explicitly acknowledge it



unit test

a body of code that verifies the behavior of a target class (i.e., a unit); also known as a programmer test



upper bound

the constraint attached to a type parameter



user interface

the means with which a human interacts with an application



user thread

the main thread in an executing application; the existence of an active user thread sustains application execution



varargs

a variable number of arguments



view

a class responsible for displaying things to an end user



VM

virtual machine



virtual machine

an application that executes and manages custom programs. A virtual machine interacts with an underlying operating system as necessary; also referred to as an interpreter



walkback

See [stack trace]
weak reference

a reference that does not count for purposes of garbage collection



whitespace

space, tab, new line, form feed, and carriage return characters (collectively)



wildcard

a substitution character (?) in a type argument (for a parameterized type) that represents any possible type



wrapper

an object that contains another object or value. In Java, wrapper objects are used to contain primitives so that they can be used as objects





Agile Java. Crafting Code with Test-Driven Development
Agile Javaв„ў: Crafting Code with Test-Driven Development
ISBN: 0131482394
EAN: 2147483647
Year: 2003
Pages: 391
Authors: Jeff Langr

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