Glossary	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
absolute positioning When placing components into containers in a graphical user interface using absolute positioning, component positions are specified as co-ordinates within the container. Contrast with use of a layout manager for the same task.
abstraction Abstraction is the process of describing some system in a way that highlights relevant properties and suppresses irrelevant details.
abstract class definition A class definition that cannot be instantiated.
abstract data type A specification of a type by giving only the operations that may be applied to values of that type (and, often, some properties of those operations). The term means much the same as interface but is used particularly when specifying data structures.
abstract method A method definition that specifies the method interface but gives no method implementation (i.e. there is a header but no body).
accessor Same as getter.
actual argument Same as actual parameter.
actual parameter A value given to a method during method invocation to initialise its formal parameters. Contrast with formal parameter. Note that actual parameters are sometimes called actual arguments or just actuals.
ADT An acronym for abstract data type.
analysis In the simplified software development methodology described in this course, analysis is the process of identifying a problem, exploring it and specifying requirements of a solution.
anonymous class A local class that has no name.
argument The word 'argument' used without the word 'actual' or 'formal' before it probably refers to an actual argument, although, depending on context, it can refer to a formal argument.
black-box testing Testing a program or part of a program using test data that has been chosen by consideration of the desired functionality of that program, with no regard to how the program is implemented.
block A sequence of zero, one or more statements enclosed within { and }.
call-by-reference Method invocattion is call-by-reference if formal parameters are initialised with a copy of the actual parameters included in the message that invokes the method.
call-by-value Method invocattion is call-by-value if formal parameters are initialised with a copy of the address in memory of the actual parameters included in the message that invokes the method.
casting Changing a value from one type to another type.
class (1) A category of objects. (2) The set of objects that belong to a category. (3) The word 'class' is often used where the phrase class definition would be more appropriate. This abbreviation is so common that many people would define 'class' to mean the same as class definition.
class definition A specification (usualy in some programming language such as Java) of the behaviour of a class of objects. The definition will certainly specify the objects' interface and will specify implementations of some or all of the behaviours in the interface.
class hierarchy A collection of classes organised by generalisation relationships.
class method A named unit of behaviour of a class.
class variable A variable that is created on a per- class basis, rather than on a per-instance basis. Contrast with instance variable.
client An object or class that requests a service (i.e. sends a message to invoke some behaviour) from another object or class.
coding The process of translating from a detailed design to statements in a programming language.
cohesion The cohesion of a group of program elements (e.g. statements in a method or methods and variable declarations in a class definition) is the degree to which the elements in the group are directed at a single purpose.
compile-time error An error in a program that is discovered by the compiler. Such errors will typically be syntax errors (where the program deviates from the grammatical rules of the language) or certain semantic errors that are checked for by the compiler (e.g. mismatched types in a statically-typed language).
component (1) In the context of graphical user interfaces, a component is an object within the interface. It will usually have some visual apperance, and it will usually be something with which the user can interact (e.g. using the mouse). (2) In software engineering in general, components are replaceable units within an implementation of a system (e.g. run-time objects), implementing certain interfaces.
constant See named constant.
constructor A special routine within a class definition that, on creation of an instance of that class, initialises the state of the instance.
container (1) In the context of graphical user interfaces, a container is a component in which other components may be placed (e.g. a window is a container since menu bars, buttons, etc. may be added to it). (2) An object is a container if it contains, and gives access to, other objects. In this sense, the word means pretty much the same as data structure.
control In the context of graphical user interfaces, this word is used to mean the same as component.
controller See Model-View-Controller.
coupling Coupling is the degree to which groups within a program (e.g. methods or class definitions) depend on each other.
data abstraction The process of organising access to a program's data (e.g. arranging variable declarations and methods for accessing data into class definitions).
data structure An organised aggregate of data items.
debugging The process of identifying a program error and the circumstances in which the error occurs, locating the source(s) of the error in the program and fixing the error.
declaration See variable declaration.
delegation-based event model One of the polices by which a program could determine which handler in which listener to invoke in response to an event in an event-driven program. In this policy, the program includes statements in which one or more listener objects (containing suitably named methods that can act as handlers) are registered with the objects that may be the source of events. At run-time, these are the objects to whom event response is delegated.
design In the simplified software development methodology described in this course, design is the process of formulating and describing alternative solutions to a problem, comparing them, choosing between them on the basis of how well they meet the requirements, and elaborating the detail in the descriptions of the chosen one(s) to the point where they are ready for implementation.
direct subclass Same as immediate subclass.
direct superclass Same as immediate superclass.
dynamic method binding Method binding is dynamic if it is not done until run-time. Contrast with static method binding.
dynamically-scoped A programming language is dynamically-scoped if the scope of identifiers can only be determined by considering program execution. Contrast with statically-scoped.
dynamically-typed In dynamically-typed programming languages, the type of every variable and expression may not be known (from the program text) at compile-time, and may be known only at run-time. Hence, checking for certain type violations can only be done at run-time. Contrast with statically-typed.
empty string A sequence of characters whose length is zero, i.e. there are no characters in the string.
encapsulation In this course, encapsulation refers to a way of organising a program such that implentations are hidden behind interfaces. This is done not for security or privacy, but to reduce dependencies between parts of a program.
equivalence partitioning In testing a program, choosing test data that is representative of whole collections of other data, usually because it is impractical to exhaustively test the program on all possible test data.
event An occurrence. (Events are objects hence they must be identifiable occurrences of interest.)
event-dispatch loop In an event-driven program, the event-dispatch loop is responsible for taking events that have been generated in turn and invoking appropriate handler methods to respond to the events. (Typically, the programmer does not code up the event-dispatch loop: it is part of the operating system or some other piece of systems software.)
event-driven A program is event-driven if method invocation may happen in response to events.
formal argument Same as formal parameter.
formal parameter A variable declared in the header of a method whose initial value is obtained during method invocation (using the actual parameter). Contrast with actual parameter. Note that formal parameters are sometimes called formal arguments or just formals.
functional requirements The functionality we desire of a problem solution.
garbage collection The process of removing from memory any objects to which there are no longer any references.
generalisation The relationship that holds between a more specific class and a more general class. (The inverse of specialisation.)
generalisation hierarchy Same as class hierarchy.
getter A method that does not alter the state of an object or class; it only returns information about the object or class state.
generic data structure A data structure which can contain data items of an arbitrary type.
glass-box testing Testing a program or part of a program using test data that has been chosen by consideration of the implementation of that program, i.e. the way the data is stored and the flow of control among statements of the program.
graphical user interface An end-user interface to a program that presents information using windows, menus, buttons, textfields, etc., and with which the user interacts using a mouse or other pointing devices in addition to the keyboard.
GUI Pronounced gooey; an acronym for graphical user interface.
handler A method within a listener object that will be invoked in response to events in an event-driven program.
heavyweight component A component in a graphical user interface is heavyweight if it is rendered in its own native window (i.e. a window that is provided by the platform's operating system/window manager).
helper method A method which gets invoked by some other method within the same class definition and whose sole purpose is to help the other method carry out some computation.
identifier The name of something in a program. E.g. in Java, the name of a variable, method, class, interface or package.
identifier scope See scope.
immediate subclass A class that is the child of another class in a generalisation relationship.
immediate superclass A class that is the parent of another class in a generalisation relationship.
immutable An immutable object is one that, after creation, is 'read-only'; it cannot be changed; none of its methods changes it.
implementation (1) In the simplified software development methodology described in this course, implementation is the process of constucting an actual artifact from a design. In software development, this includes at least the steps of coding, testing and debugging. (2) A class definition is split into an interface and an implementation (the 'what' and the 'how'). The implementation defines how the services offered in the interface are implemented.
information hiding In this course, information hiding refers to encpasulation of a program's data.
inheritance The mechanism by which class definitions for subclasses incorporate instance variables and instance methods from class definitions for superclasses.
inheritance-based event model One of the polices by which a program could determine which handler in which listener to invoke in response to an event in an event-driven program. In this policy, handlers/listeners are sought by climbing up the class hierarchy until a superclass with a suitably named method that can act as the handler is found.
initialisation See variable initialisation.
inner class definition A class definition that is declared within another class definition.
inspection Inspection is the process of manually reading program documentation and code with a view to detecting errors. Inspection processes in industry are done with varying degrees of formality and sometimes the word 'inspection' is reserved for the more ceremony-heavy instances of this practice.
instance An object of some class.
instance method A named unit of behaviour of an object.
instance variable A variable that is part of every instance of a class.
instantiation The creation of new instances from class definitions.
interface (1) The services an object or class provides to its clients. (2) The Java language provides a construction for defining interfaces, and the word 'interface' or the phrase 'Java interface' would be used to refer to these language constructs. In this sense, the word refers to a type that is defined by supplying, in an interface definition, a set of instance method signatures (method headers with no bodies), these being the operations that constitute the interface and that define the type. (3) The word 'interface' also refers to a program's end-user interface, i.e. the way it presents information to the user and receives data from the user; these days, this interface would most typically be a graphical user interface.
interface definition A specification (usualy in some programming language such as Java) of the interface of a class of objects.
invocation See method invocation.
layout manager When placing components into containers in a graphical user interface, an object called a layout manager may be associated with the container and will implement a policy for deciding how the components are positioned and sized within the container.
lexically-scoped Same as statically-scoped.
lifetime The lifetime of a variable is the period of the execution of the program between allocating memory for the variable and releasing that memory.
lightweight component A component in a graphical user interface is lightweight if it is not rendered in its own native window (i.e. a window that is provided by the platform's operating system/window manager), but is instead 'painted' onto a heavyweight component.
listener An object to which has been assigned the task of responding to events in an event-driven program.
local class A class whose definition has block scope. (Local class definitions are examples of inner class definitions).
local variable A variable with block scope.
logic error An error in a program that is not manifested as a compile-time error or a run-time error, but as a failure of the program to meet its requirements. Most typically, the actual output will not match the required output.
look-and-feel The look-and-feel of a graphical user interface (or a component within such an interface) concerns the way it is presented to the user (e.g. its visual appearance) and the way the user interacts with it (e.g. whether the user moves the cursor over it using the mouse, clicks, double-clicks, or whatever).
magic number A number that is hard-coded into the statements of a program. One might similarly refer to 'magic strings' and 'magic chars'.
maintenance Any software development that a program undergoes after it has been released to users. Maintenance might be corrective (bug fixing), adaptive (porting), perfective (extending) or preventative (refactoring).
message A request sent from a client to an object or class, requesting a service (i.e. invoking some behaviour from the target).
method A named unit of behaviour. (Methods correspond to procedures or functions in other languages.) See also instance method and class method.
method binding Determining which method is being invoked by a particular message.
method invocation Causing a method to be executed. This is a general term that covers two possibilities: in some cases, an event will invoke a method; in other cases, a method will be invoked as a response to a message from a client. The latter case is sometimes also known as calling the method (which is a usage that comes from non-object-oriented languages where one talks of calling a procedure or function).
model An artifact that represents a part of a world at some level of abstraction that can be used to explain or predict features of the world that is being modeled.
Model-View See Model-View-Controller.
Model-View-Controller An architecture for programs that have graphical user interfaces. The architecture separates those parts of the program that handle the application data (the model) from those that present that data to users (e.g. graphically, on the screen) (the views) and from those parts that respond to changes made to the data (e.g. by the user manipulating the data presented on the screen) (the controllers). The architecture defines the ways these parts of the program communicate. The parts of the architecture have high cohesion and they are connected in such a way as to give low coupling.
mutator Same as setter.
MVC An acronym for Model-View-Controller.
named constant A variable whose value cannot be changed by the program after initialisation.
native look-and-feel A graphical user interface to some program running on some computer platform has native look-and-feel if the look-and-feel of the program's interface is the same as that of the operating system or windows manager that is presently running on that platform. (The phrase usually also implies that if the program is ported to some other platform, the look-and-feel of its interface will then match that of the new platform.) Contrast with pluggable look-and-feel.
non-functional requirements The qualities we desire of a problem solution other than those concerning its functionality, e.g. its robustness, its efficiency, its security, its extensibility, its maintainability, its portability, etc.
object In an executing object-oriented program, an object is a representation, in memory, of an identifiable thing of interest.
overloading Overloading occurs when an identifier or operator has more than one definition within a single scope. In Java, certain operators are overloaded. But the most common forms of overloading in Java occur when there are several methods with the same name or several constructors within a single class definition.
overriding Overriding occurs when a method definition in the class definition of a subclass redefines a method that would otherwise be inherited from a superclass definition. The overriding method must have the same identifier and signature (including return type) as the method in the superclass definition.
package A named collection of class definitions. Typically, packages are used to group together related class definitions within large programs.
parameter The word 'parameter' used without the word 'actual' or 'formal' before it probably refers to a formal parameter, although, depending on context, it can refer to an actual parameter.
pass-by-reference Same as call-by-reference.
pass-by-value Same as call-by-value.
pluggable look-and-feel A graphical user interface to some program running on some computer platform has pluggable look-and-feel if the look-and-feel of the program's interface can be easily changed to some other look-and-feel. (The phrase usually also implies that the look-and-feel can be chnaged dynamically, at run-time.) Contrast with native look-and-feel.
polymorphism The ability of a variable to hold values of more than one type.
primitive type The fundamental, built-in types within the Java programming language, whose values have direct machine representations.
procedural abstraction The process of organising a program's computation (e.g. arranging the statement into methods).
random testing Testing a program or part of a program using test data that has been chosen at random.
reference A pointer to an object.
reference type In Java, these are types whose values are ultimately constructed from primitive types either through class definitions, interface definitions or the use of arrays.
regression testing Re-testing a program. Regression testing is needed following changes made to a program to discover whether parts that were working are no longer working.
requirements The behaviour and other qualities we desire of a problem solution. See functional requirements and non-functional requirements.
reuse Using pre-existing artifacts to construct a new artifact.
RGB An acronym for Red-Green-Blue, referring to one way of specifying colours, i.e. by their amounts of red, green and blue light.
run-time error An error in a program that causes execution of the program to be terminated. These are caused by misuses of the language that the compiler cannot detect and so are detected only when the program is run. They might include sending messages to null, dividing integers by zero, trying to access non-existent elements of an array, etc.
scope The scope of an identifier is the portion of the program over which the identifier is known.
setter A method that (only) alters the state of an object or class.
signature The number, types and order of the formal parameters of a method. A signature may also specify a return type.
specialisation The relationship that holds between a more general class and a more specific class. (The inverse of generalisation.)
state The state of an object is given by the contents of its instance variables.
static method Same as class method.
static method binding Method binding is static if it is done before run-time, e.g. by the compiler. Contrast with dynamic method binding.
static variable Same as class variable.
statically-scoped A programming language is statically-scoped if the scope of identifiers can be determined from the text of the program, without executing it. Contrast with dynamically-scoped.
statically-typed In statically-typed programming languages, the type of every variable and expression is known (from the program text) at compile-time. Hence, checking for type violations can be done at compile-time. Contrast with dynamically-typed and do not confuse with strongly-typed.
strongly-typed In a strongly-typed programming language, every variable must have a type, and the system guarantees that it will use this to restrict the values a variable can hold, the operators that may be applied to values and the messages that can be sent to objects. Contrast with weakly-typed and do not confuse with statically-typed.
subclass A class that is the descendant of another class in a sequence of one or more generalisation relationships. In certain contexts, the word subclass will be used where immediate subclass might be more accurate.
superclass A class that is the ancestor of another class in a sequence of one or more generalisation relationships. In certain contexts, the word superclass will be used where immediate superclass might be more accurate.
symbolic constant Same as named constant.
testing The process of revealing that an artifact fails to satisfy a set of requirements. In the case of programs, this is done by executing the program on different items of data, the test suite.
test-driver Program code whose sole purpose is to test parts of a program.
test-suite The collection of test data used for testing a program.
type The type of a variable or other expression is the set of values that may be stored in the variable or that the expression may evaluate to and the operations that can be applied to these values.
type error Same as type violation.
type mismatch Same as type violation.
type violation Any attempt to store a value of one type in a variable of an incorrect type or to apply operators to values or variables whose types do not support those operators or to send messages to objects that do not support the requested methods is a type violation.
variable A named storage location.
variable declaration Introducing a variable into a program.
variable initialisation Assigning an initial value to a variable.
view See Model-View-Controller.
visibility The degree to which something in a program (e.g. a variable, method, class, interface, or package) may be seen from other parts of the program.
walkthrough Same as inspection.
weakly-typed A weakly-typed programming language is one that is not strongly-typed: either variables do not have associated types or type restrictions are not rigorously enforced.
widget Supposedly short for 'window gadget', this refers to components in a graphical user interface.
wrapper In Java, a wrapper class definition allows you to turn primitive values into objects.