Glossary
- ABC
- Activity-Based Costing
- ABM
- Activity-Based Management
- abstract class
A class that provides common behavior across a
set of subclasses but is not itself designed to have instances. An abstract
class represents a concept; classes derived from it represent implementations
of the concept. See also base class. Contrast:
concrete class.- abstraction
- The creation of a view or model
that suppresses unnecessary details to focus on a specific set of details
of interest
-
The essential characteristics of an entity that distinguish it from all other
kinds of entities. An abstraction defines a boundary relative to the perspective
of the viewer.
- acceptance
- An action by which the customer accepts ownership of software products as
a partial or complete performance of a contract.
- access modifier
- A keyword that
controls access to a class, method, or attribute. The access modifiers in
Java are public, private, protected, and package, which is the default.
- accessor methods
- Methods that an
object provides to define the interface to its instance variables. The accessor
method to return the value of an instance variable is called a get method
or getter method, and the mutator method to assign a value to an instance
variable is called a set method or setter method.
- ACL
- Access Control List
- action
-
The specification of an executable statement that forms an abstraction of
a computational procedure. An action typically results in a change in the
state of the system, and can be realized by sending a message to an object
or modifying a link or a value of an attribute.
- action sequence
-
An expression that resolves to a sequence of actions.
- action state
-
A state that represents the execution of an atomic action, typically the invocation
of an operation.
- activation
-
The execution of an action.
- active class
- A class
representing a thread of control in the system.
-
A class whose instances are active objects. See active
object.
- active object
-
An object that owns a thread
and can initiate control activity. An instance of active
class.
- Active Server Pages (ASP)
- Active
Server Pages (Microsoft), a technology for providing dynamic behavior to web
applications.
- activity
- A unit of work a role may be asked to perform.
- activity-based costing (ABC)
- A
methodology that measures the cost and performance of activities, resources,
and cost objects. Resources are assigned to activities, then activities are
assigned to cost objects based on their use. Activity based costing recognizes
the causal relationships of cost drivers to activities.
- activity-based management (ABM)
- The
broad discipline that focuses on achieving customer value and company profit
by way of the management of activities. It draws on activity-based
costing as a major source of information.
- activity graph
-
A special case of a state machine that
is used to model processes involving one or more classifiers.
Contrast: statechart diagram. Synonym:
activity diagram.
- actor (instance)
- Someone or something, outside
the system that interacts with the system.
- actor class
- Defines a set of actor
instances, in which each actor instance plays the same role in relation to
the system.
-
A coherent set of roles that users of use cases play when interacting with
these use cases. An actor has one role for each use
case with which it communicates.
- actor-generalization
- An actor-generalization
from an actor class (descendant) to another actor class (ancestor) indicates
that the descendant inherits the role the ancestor can play in a use case.
- actual parameter
-
Synonym: argument.
- Advanced Program-to-Program
Communication (APPC)
- A
communication protocol used primarily in IBM environments.
- aggregate [class]
-
A class that represents the "whole" in an aggregation (whole-part)
relationship. See aggregation.
- aggregation
- An association that
models a whole-part relationship between an aggregate (the whole) and its
parts.
-
A special form of association that specifies a whole-part relationship between
the aggregate (whole) and a component part. See composition.
- American
Standard Code for Information Interchange (ASCII)
- American Standard Code for
Information Interchange. The 8-bit character encoding scheme used by most
PCs and UNIX systems. It supersedes an earlier 7-bit ASCII standard.
- analysis
- The part of the software development process whose primary purpose is to
formulate a model of the problem domain. Analysis
focuses on what to do; design focuses on how to do it. See design.
- analysis & design
- A discipline in the Unified Process, whose
purpose is to show how the system's use cases
will be realized in implementation; (general) activities during which strategic
and tactical decisions are made to meet the required functional and quality
requirements of a system. For the result
of analysis and design activities, see Design Model.
- analysis class
- An abstraction of
a role played by a design element in the system,
typically within the context of a use-case
realization. Analysis classes may provide an abstraction for several
roles, representing the common behavior of those roles. Analysis classes typically
evolve into one or more design elements; for example, design classes
and/or capsules, or design subsystems.
- analysis mechanism
- An architectural
mechanism used early in the design process, during
the period of discovery when key classes and subsystems
are being identified. Typically analysis mechanisms capture the key aspects
of a solution in a way that is implementation independent. Analysis mechanisms
are usually unrelated to the problem domain, but instead are "computer
science" concepts. They provide specific behaviors to a domain-related
class or component,
or correspond to the implementation of cooperation between classes and/or
components. They may be implemented as a framework.
Examples include mechanisms to handle persistence, inter-process communication,
error or fault handling, notification, and messaging, to name a few.
- analysis pattern
- [FOW97a]
speaks of analysis patterns as, “… groups of concepts that represent a common
construction in business modeling. It may be relevant to only one domain,
or it may span many domains.” Therefore, in this reference, the vocabulary
of the domain does intrude into the description of the pattern. There is no
reason why the definition in [FOW97a]
should not be extended to domains other than business modeling. Another aspect
of an analysis pattern is that it is an abstract, conceptual template, intended
(through binding as with any pattern) for instantiation in an analysis model,
which will then need further refinement through design. The scale of an analysis
pattern can vary widely, though those presented in [FOW97a]
are medium in scale, and would compose to form analysis models for entire
applications.
- analysis time
- Refers to something that occurs during an analysis phase
of the software development process. See design
time, modeling time.
- analyst
- Member of the project team who is responsible for eliciting and interpreting
the stakeholder needs, and communicating those needs to the entire team.
- API
- Application
Programming Interface
- APPC
- Advanced
Program-to-Program Communication
- applet
- A Java program designed
to run within a Web browser. Contrast: application.
- application
- In Java programming, a self-contained, stand-alone Java program that includes
main() method. Contrast: applet.
- application programming
interface (API)
- A software interface that enables applications to communicate with each
other. An API is the set of programming language constructs or statements
that can be coded in an application program to obtain the specific functions
and services provided by an underlying operating system or service program.
- architectural baseline
- The baseline
at the end of the Elaboration phase, at
which time the foundation structure and behavior of the system is stabilized.
- architectural mechanism
- Architectural mechanisms represent common concrete solutions to frequently
encountered problems. They may be patterns of structure, patterns of behavior,
or both. In the Unified Process for EDUcation (UPEDU), architectural mechanism
is used as an umbrella term for analysis mechanism, design mechanism, and
implementation mechanism.
- architectural pattern
- [BUS96]
defines an architectural pattern as:
“An architectural pattern expresses a fundamental structural organization
schema for software systems. It provides a set of predefined subsystems,
specifies their responsibilities, and includes rules and guidelines for
organizing the relationships between them.”
This is the interpretation we use in the UPEDU. To elaborate a little: an
architectural pattern is a pattern (that is, a solution template) at a particular
scale, and is a template for concrete software architectures. It deals in
system-wide properties and, typically, subsystem-scale (not class level)
relationships. Architectural patterns seem, by their nature, not to be application
domain dependent—the vocabulary of a particular domain seems not to intrude
into the description of the pattern—although there is no reason in principle
why architectural patterns cannot become specialized in this way. Compare
with analysis pattern. The Software
Architecture Document will present the architectural patterns used
in the system.
- architectural view
- A view of the
system architecture from a given perspective;
focuses primarily on structure, modularity, essential components, and the
main control flows.
- architecture
- The highest level concept of a system in its environment [IEEE].
The architecture of a software system (at a given point in time) is its organization
or structure of significant components interacting
through interfaces, those components being
composed of successively smaller components and interfaces.
-
The organizational structure of a system. An architecture can be recursively
decomposed into parts that interact through interfaces, relationships that
connect parts, and constraints for assembling parts. Parts that interact through
interfaces include classes, components
and subsystems.
- architecture, executable
- See executable architecture.
- argument
-
A binding for a parameter that resolves to a run-time instance. Synonym: actual
parameter. Contrast: parameter.
- A data element, or value, included as a parameter in a method call. Arguments
provide additional information that the called method can use to perform the
requested operation.
- artifact
- (1) A piece of information that (1) is produced, modified, or used by a
process, (2) defines an area of responsibility, and (3) is subject to version
control. An artifact can be a model, a model
element, or a document. A document
can enclose other documents.
-
A piece of information that is used or produced by a software development
process. An artifact can be a model, a description, or software. Synonym:
product.
- artifact guidelines
- A description of how to work with a particular artifact,
including how to create and revise the artifact.
- artifact set
- A set of related artifacts which presents one aspects of the system. Artifact
sets cut across disciplines, as several artifacts
are used in a number of disciplines; for example, the Risk
List, the Software
Architecture Document, and the Iteration
Plan.
- ASCII
- American
Standard Code for Information Interchange
- ASP
- Active
Server Pages
- assertion
- A logical expression specifying a program state that must exist or a set
of conditions that program variables must satisfy at a particular point during
program execution.
- association
- A relationship that
models a bi-directional semantic connection among instances.
-
The semantic relationship between two or more classifiers that specifies connections
among their instances.
- association class
-
A model element that has both association
and class properties. An association class can
be seen as an association that also has class properties, or as a class that
also has association properties.
- association end
-
The endpoint of an association, which connects the association to a classifier.
- asynchronous action
-
A request where the sending object does not pause to wait for results. Contrast:
synchronous action.
- attack
- A planned and methodical attempt to break or otherwise circumvent the normal
operation of a running computer software program. Often malicious in nature,
the concept of attacks on computer software originated from the community
known as software hackers or crackers who use various techniques to attack
software systems, typically to circumvent security software and gain illegal
entry to the host system. Examples of recognized attack techniques include
buffer overflow, denial of service, resource constraint and Trojan horse.
This term has now been adopted by computer software testing professionals
in discussing the methods by which they might expose potential bugs in a software
system.
- attribute
- An attribute defined by a class represents a
named property of the class or its objects. An attribute has a type
that defines the type of its instances.
-
A feature within a classifier that describes a range of values that instances
of the classifier may hold.
- base class
- A class from which
other classes or beans are derived. A base class may itself be derived from
another base class. See abstract class.
- baseline
- A reviewed and approved release of artifacts
that constitutes an agreed basis for further evolution or development and
that can be changed only through a formal procedure, such as change
management and configuration
control.
- Bean
- A small component that can
be used to build applications. See JavaBean.
- BeanInfo
- A companion class for a
bean that defines a set of methods that can be accessed to retrieve
information on the bean’s properties, events, and methods.
- behavior
-
The observable effects of an operation or event, including its results.
- behavioral feature
-
A dynamic feature of a model element,
such as an operation or method.
- behavioral model aspect
-
A model aspect that emphasizes the
behavior of the instances in a system,
including their methods, collaborations,
and state histories.
- beta testing
- Pre-release testing in which a sampling of the intended customer base tries
out the product.
- binary association
-
An association between two classes. A special
case of an n-ary association.
- binding
-
The creation of a model element from a template
by supplying arguments for the parameters of the template.
- boolean
-
An enumeration whose values are true and false.
- boolean expression
-
An expression that evaluates to a boolean
value.
- boundary class
- A class used to model communication between the system's environments and
its inner workings.
- break point
- A point in a computer program where the execution will be halted.
- build
- An operational version of a system or part of a system that demonstrates
a subset of the capabilities to be provided in the final product.
- business actor (instance)
- Someone or something, outside the business that interacts with the business.
- business actor class
- Defines a set of business-actor instances, in which each business-actor
instance plays the same role in relation to the business.
- business creation
- To perform business
engineering where the goal is to create a new business
process, a new line of business or a new organization.
- business engineering
- A set of
techniques a company uses to design its business according to specific
goals. Business engineering techniques can be used for both business
reengineering, business
improvement, and business creation.
- business entity
- A business entity
represents a "thing" handled or used by business
workers.
- business improvement
- To perform business
engineering where the work of change is local and does not span the
entire business. It involves trimming costs and lead times and monitoring
service and quality.
- business modeling
- Encompasses all
modeling techniques you can use to visually model a business. These are a
subset of the techniques you may use to perform business
engineering.
- business object model
- An object
model describing the realization of business
use cases.
- business process
- A group of
logically related activities that use the resources of the organization to
provide defined results in support of the organization's objectives. In the UPEDU, we define business processes using business
use cases, which show the expected behavior of the business, and business
use-case realizations, which show how that behavior is realized by business
workers and business entities.
See also process.
- business process engineering
- See business
engineering.
- business reengineering
- To perform
business engineering where the
work of change includes taking a comprehensive view of the entire existing
business and think through why you do what you do. You question all existing
business processes and try to find completely new ways of reconstructing
them to achieve radical improvements. Other names for this are business
process reengineering (BPR) and process innovation.
- business rule
- A declaration of
policy or condition that must be satisfied within the business.
- business use case (class)
- A
business use case defines a set of business
use-case instances, where each instance is a sequence of actions a
business performs that yields an observable result of value to a particular
business actor. A business use-case class contains all main, alternate
workflows related to producing the "observable result of
value".
- business use-case instance
- A
sequence of actions performed by a business that yields an observable result
of value to a particular business actor.
- business use-case model
- A model
of the business intended functions. The business use-case model is used as
an essential input to identify roles and deliverables in the organization.
- business use-case package
- A
business use-case package is a collection of business use cases, business
actors, relationships, diagrams, and other packages; it is used to structure
the business use-case model by dividing it into smaller parts.
- business use-case realization
- A
business use-case realization describes how the workflow of a particular
business use case is realized within the business
object model, in terms of collaborating business objects.
- business worker
- A business worker
represents a role or set of roles in the business. A business worker
interacts with other business workers and manipulates business
entities while participating in business
use-case realizations.
- call
-
An action state that invokes an operation
on a classifier.
- call level interface (CLI)
- A callable
API for database access, which is an alternative to an embedded SQL application
program interface. In contrast to embedded SQL, CLI does not require precompiling
or binding by the user, but instead provides a standard set of functions to
process SQL statements and related services at run time.
- capsule
- A specific design
pattern which represents an encapsulated thread
of control in the system. A capsule is a stereotyped
class with a specific set of required and restricted
associations and properties.
- capsule role
- Capsule roles represent
a specification of the type of capsule that
can occupy a particular position in a capsule's collaboration or structure.
Capsule roles are strongly owned by the container capsule and cannot exist
independently of it. A capsule's structural decomposition usually includes
a network of collaborating capsule roles joined by connectors.
- cardinality
-
The number of elements in a set. Contrast: multiplicity.
- CBD
- Component-Based
Development
- CCB
- Change
Control Board
- CDR
- Critical
Design Review
- CGI
- Common
Gateway Interface
- change control board (CCB)
- The role of the CCB is to provide a central control mechanism to ensure
that every change request is properly
considered, authorized and coordinated.
- change management
- The activity
of controlling and tracking changes to artifacts.
See also scope management.
- change request (CR)
- A general term for any request from a stakeholder
to change an artifact or process.
Documented in the Change Request is information on the origin and impact of
the current problem, the proposed solution, and its cost. See also enhancement
request, defect.
- checkpoints
- A set of conditions that well-formed artifacts
of a particular type should exhibit. May also be stated in the form of questions
which should be answered in the affirmative.
- child
-
In a generalization relationship, the
specialization of another element, the parent. See subclass,
subtype. Contrast: parent.
- class
-
A description of a set of objects that share the same attributes,
operations, methods,
relationships, and semantics. A class may
use a set of interfaces to specify collections of operations it provides to
its environment. See interface.
- class diagram
-
A diagram that shows a collection of declarative (static) model
elements, such as classes, types,
and their contents and relationships.
- class hierarchy
- The relationships
among classes that share a single inheritance. All Java classes inherit from
the Object class.
- class library
- A collection of classes.
- class method
- See method.
- classifier
-
A mechanism that describes behavioral and structural features. Classifiers
include interfaces, classes,
datatypes, and components.
- CLI
- Call
Level Interface
- client
-
A classifier that requests a service from
another classifier. Contrast: supplier.
- client/server
- The model of interaction
in distributed data processing where a program at one location sends a request
to a program at another location and awaits a response. The requesting program
is called a client, and the answering program is called a server.
- CM
- See Configuration
Management.
- COBOL
- Common Business Oriented
Language
- cohesion
- The congenital union of components of the
same kind that depend on one another. The act or state of sticking together;
close union. Contrast: coupling
- collaboration
- (1) Is a description
of a collection of objects that interact to implement some behavior within
a context. It describes a society of cooperating objects assembled to carry
out some purpose. (2) It captures a more holistic view of behavior in the
exchange of messages within a network of objects. (3) Collaborations show
the unity of the three major structures underlying computation: data structure,
control flow, and data flow. (4) A collaboration has a static and a dynamic
part. The static part describes the roles that objects and links play in an
instantiation of the collaboration. The dynamic part consists of one or more
dynamic interactions that show message flow over time in the collaboration
to perform computations. A collaboration may have a set of messages
to describe its dynamic behavior. (5) A collaboration with messages is an
interaction.
-
The specification of how an operation or classifier,
such as a use case, is realized by
a set of classifiers and associations playing
specific roles used in a specific way. The collaboration defines an interaction.
See interaction.
- collaboration diagram
- (1) A collaboration
diagram describes a pattern of interaction among objects; it shows the objects
participating in the interaction by their links to each other and the messages
they send to each other. (2) It is a class diagram
that contains classifier roles and association
roles rather than just classifiers and associations. (3) Collaboration diagrams
and sequence diagrams both show interactions, but they emphasize different
aspects. Sequence diagrams show time sequences clearly but do not show object
relationships explicitly. Collaboration diagrams show object relationships
clearly, but time sequences must be obtained from sequence numbers.
-
A diagram that shows interactions organized around the structure of a model,
using either classifiers and associations or instances and links. Unlike a
sequence diagram, a collaboration diagram shows the relationships among the
instances. Sequence diagrams and collaboration diagrams express similar information,
but show it in different ways. See sequence
diagram.
- COM
- Component Object Model (Microsoft)
- comment
-
An annotation attached to an element or a collection of elements. A note has
no semantics. Contrast: constraint.
- commit
- The operation that ends
a unit of work to make permanent the changes it has made to resources (transaction
or data).
- Common Gateway Interface (CGI)
- A
standard protocol through which a Web server can execute programs running
on the server machine. CGI programs are executed in response to requests from
Web client browsers.
- Common Object
Request Broker Architecture (CORBA)
- A
middleware specification which defines a software bus—the Object Request Broker
(ORB)—that provides the infrastructure.
- communicate-association
- An association
between an actor class and a use
case class, indicating that their instances interact. The direction
of the association indicates the initiator of the communication (Unified Process
convention).
- communication association
-
In a deployment diagram an association between nodes that implies a communication.
See deployment diagram.
- compile time
-
Refers to something that occurs during the compilation of a software module.
See modeling time, run
time.
- component
- A non-trivial, nearly independent, and replaceable part of a system that
fulfills a clear function in the context of a well-defined architecture.
A component conforms to and provides the physical realization of a set of
interfaces.
-
A physical, replaceable part of a system that packages implementation and
conforms to and provides the realization of a set of interfaces. A component
represents a physical piece of implementation of a system, including software
code (source, binary or executable) or equivalents such as scripts or command
files.
- component diagram
-
A diagram that shows the organizations and dependencies among components.
- component model
- An architecture
and an API that allows developers to define reusable segments of code that
can be combined to create a program. VisualAge for Java uses the JavaBeans
component model.
- component-based development
(CBD)
- The
creation and deployment of software-intensive systems assembled from components
as well as the development and harvesting of such components.
- composite [class]
-
A class that is related to one or more classes
by a composition relationship. See composition.
- composite aggregation
-
Synonym: composition.
- composite bean
- A bean that is composed
of other beans. A composite bean can contain visual beans, nonvisual beans,
or both. See also bean, nonvisual bean, and visual bean.
- composite state
-
A state that consists of either concurrent (orthogonal) substates or sequential
(disjoint) substates. See substate.
- composite substate
-
A substate that can be held simultaneously
with other substates contained in the same composite state. Synonym: region.
See composite state.
- composition
-
A form of aggregation association with strong
ownership and coincident lifetime as part of the whole. Parts with non-fixed
multiplicity may be created after the composite
itself, but once created they live and die with it; that is, they share lifetimes.
Such parts can also be explicitly removed before the death of the composite.
Composition may be recursive. Synonym: composite
aggregation.
- concrete
- An entity in a configuration
that satisfies an end-use function and can be uniquely identified at a given
reference point. (ISO)
- concrete class
-
A class that can be directly instantiated. Contrast:
abstract class.
- concurrency
-
The occurrence of two or more activities during the same time interval. Concurrency
can be achieved by interleaving or simultaneously executing two or more threads.
See thread.
- concurrent substate
-
A substate that can be held simultaneously
with other substates contained in the same composite state. See composite
substate. Contrast: disjoint substate.
- configuration
- 1) general: The arrangement of a system or network as defined by the nature,
number, and chief characteristics of its functional units; applies to both
hardware or software configuration.
- (2) The requirements, design, and implementation that define a particular
version of a system or system component. See configuration
management.
- configuration item
- An entity in
a configuration that satisfies an end-use function and can be uniquely identified
at a given reference point. (ISO)
- configuration management (CM)
- A supporting
process whose purpose is to identify, define, and baseline items; control
modifications and releases of these items; report and record status of the
items and modification requests; ensure completeness, consistency and correctness
of the items; and control storage, handling and delivery of the items. (ISO)
- constraint
-
A semantic condition or restriction. Certain constraints are predefined in
the UML, others may be user defined. Constraints are one of three extensibility
mechanisms in UML. See tagged value, stereotype.
- construction
- The third phase
of the Unified Process, in which the software is brought from an executable
architectural baseline to the point at which it is ready to be transitioned
to the user community.
- constructor
- A special class method
that has the same name as the class and is used to construct and possibly
initialize objects of its class type.
- container
-
(1) An instance that exists to contain other
instances, and that provides operations to access or iterate over its contents;
for example, arrays, lists, sets. (2) A component
that exists to contain other components.
- containment hierarchy
-
A namespace hierarchy consisting of model elements,
and the containment relationships that exist between them. A containment hierarchy
forms an acyclic graph.
- context
-
A view of a set of related modeling elements
for a particular purpose, such as specifying an operation.
- control class
- A class used to model behavior specific to one,
or a several use cases.
- conversational
- A communication
model where two distributed applications exchange information by way of a
conversation; typically one application starts (or allocates) the conversation,
sends some data, and allows the other application to send some data. Both
applications continue in turn until one decides to finish (or de-allocate).
The conversational model is a synchronous form of communication.
- Cookies
- Small files that your Web
browser creates at the request of Web sites you visit; the browser sends the
contents of the file to the site upon subsequent visits.
- CORBA
- Common
Object Request Broker Architecture
- coupling
- The degree to which components depend on
one another. There are two types of coupling, "tight" and "loose". Loose coupling
is desirable to support an extensible software architecture but tight coupling
may be necessary for maximum performance. Coupling is increased when the data
exchanged between components becomes larger or more complex. Contrast: cohesion.
- CR
- Change
Request
- CRC
- Class-Responsibility-Collaborators.
This is a technique in object-oriented development, originally proposed by
Ward Cunningham and Kent Beck, to help define what objects should do in the
system (their responsibilities), and identify other objects (the collaborators)
that are involved in fulfilling these responsibilities. The technique is described
in [WIR90]. CRC cards are
a way of capturing these results using ordinary index cards.
- critical design review (CDR)
- In
the waterfall life cycle, the major review held when the detailed design is
completed. See Guidelines:
Software Development Plan.
- customer
- A person or organization, internal or external to the producing organization,
who takes financial responsibility for the system. In a large system this
may not be the end user. The customer is the ultimate recipient of the developed
product and its artifacts. See also stakeholder.
- cycle
- One complete pass through the four phases: inception,
elaboration, construction
and transition. The span of time between
the beginning of the inception phase and the end of the transition phase.
See test cycle
- DASD
- Direct
Access Storage Device
- database
- (1) A collection of related
data stored together with controlled redundancy according to a scheme to serve
one or more applications. (2) All data files stored in the system. (3) A set
of data stored together and managed by a database management system.
- database management system
(DBMS)
- A computer
program that manages data by providing the services of centralized control,
data independence, and complex physical structures for efficient access, integrity,
recovery, concurrency control, privacy, and security.
- datatype
-
A descriptor of a set of values that lack identity and whose operations do
not have side effects. Datatypes include primitive predefined types and user-definable
types. Predefined types include numbers, string and time. User-definable types
include enumerations.
- DBA
- Database Administrator
- DBCS
- Double-Byte
Character Set
- DBMS
- Database
Management System
- DCE
- Distributed
Computing Environment
- DCOM
- Distributed Object Model (Microsoft)
- deadlock
- A condition in which two independent threads of control are blocked, each
waiting for the other to take some action. Deadlock often arises from adding
synchronization mechanisms to avoid race conditions.
- defect
- An anomaly, or flaw, in a delivered work product. Examples include such
things as omissions and imperfections found during early lifecycle phases
and symptoms of faults contained in software sufficiently mature for test
or operation. A defect can be any kind of issue you want tracked and resolved.
See also change request.
- defining model [MOF]
-
The model on which a repository is based. Any number of repositories can have
the same defining model.
- delegation
-
The ability of an object to issue a message
to another object in response to a message. Delegation can be used as an alternative
to inheritance. Contrast: inheritance.
- deliverable
- An output from a process
that has a value, material or otherwise, to a customer
or other stakeholder.
- de-marshal
- To deconstruct an object
so that it can be written as a stream of bytes. Synonym for flatten
and serialize.
- demilitarized zone (DMZ)
- This term is
now commonly used in the industry to describe a sub-network, typically used
for web servers that are protected by firewalls from both the external Internet
and a company’s internal network.
- dependency
-
A relationship between two modeling elements,
in which a change to one modeling element (the independent element) will affect
the other modeling element (the dependent element).
- deployment
- A discipline
in the software-engineering process, whose purpose is to ensure a successful
transition of the developed system to its users. Included are artifacts
such as training materials and installation procedures.
- deployment environment
- A specific instance of a configuration of hardware and software established
for the purpose of installing and running the developed software for it's
intended use. See test environment
and environment.
- deployment diagram
-
A diagram that shows the configuration of run-time processing nodes and the
components, processes,
and objects that live on them. Components represent
run-time manifestations of code units. See component
diagram.
- deployment unit
-
A set of objects or components
that are allocated to a process or a processor as a group. A distribution
unit can be represented by a run-time composite
or an aggregate.
- deployment view
- An architectural
view that describes one or several system configurations; the mapping
of software components (tasks, modules) to
the computing nodes in these configurations.
- derived element
-
A model element that can be computed from another element, but that is shown
for clarity or that is included for design purposes even though it adds no
semantic information.
- deserialize
- To construct an object
from a de-marshaled state. Synonym for marshal
and resurrect.
- design
-
The part of the software development process whose primary purpose is to decide
how the system will be implemented. During design, strategic and tactical
decisions are made to meet the required functional and quality requirements
of a system. See analysis.
- design mechanism
- An architectural
mechanism used during the design process, during the period in which
the details of the design are being worked-out. They are related to associated
analysis mechanisms, of which they
are additional refinements, and they may bind one or more architectural and
design patterns. There is not necessarily any difference in scale between
the analysis mechanism and the design mechanism—it is thus possible to speak
of a persistence mechanism at the analysis level and the design level and
mean the same thing, but at a different level of refinement. A design
mechanism assumes some details of the implementation environment, but it is
not tied to a specific implementation (as is an implementation
mechanism). For example, the analysis mechanism for inter-process
communication may be refined by several design mechanisms for interprocess
communication (IPC): shared memory, function-call-like IPC, semaphore-based
IPC, and so on. Each design mechanism has certain strengths and weaknesses;
the choice of a particular design mechanism is determined by the characteristics
of the objects using the mechanism.
- design model
- An object
model describing the realization of use
cases; serves as an abstraction of the implementation
model and its source code.
- design package
- A collection of
classes, relationships,
use-case realizations, diagrams,
and other packages, it is used to structure
the design model by dividing it into smaller
parts. It's the logical analogue of the implementation
subsystem.
- design pattern
- [GAM94]
defines a design pattern as:
“A design pattern provides a scheme for refining the subsystems or components
of a software system, or the relationships between them. It describes a
commonly-recurring structure of communicating components that solves a general
design problem within a particular context.”
Design patterns are medium to small-scale patterns, smaller in scale than
architectural patterns but typically independent of programming language.
When a design pattern is bound, it will form a portion of a concrete design
model (perhaps a portion of a design mechanism).
Design patterns tend, because of their level, to be applicable across domains.
- design subsystem
- A model
element which has the semantics of a package
(it can contain other model elements) and a class
(it has behavior). The behavior of the subsystem
is provided by classes or other subsystems it contains. A subsystem realizes
one or more interfaces, which define the behavior
it can perform. Contrast: design package.
- design time
-
Refers to something that occurs during a design phase of the software development
process. See modeling time. Contrast:
analysis time.
- developer
- A person responsible
for developing the required functionality in accordance with project-adopted
standards and procedures. This can include performing activities in any of
the requirements,
analysis & design,
implementation,
and test disciplines.
- development case
- The software-engineering
process used by the performing organization. It is developed as a configuration,
or customization, of the Unified Process product, and adapted to the project's
needs.
- development process
-
A set of partially ordered steps performed for a given purpose during software
development, such as constructing models or implementing models.
- device
- A type of node
which provides supporting capabilities to a processor.
Although it may be capable of running embedded programs (device drivers),
it cannot execute general-purpose applications, but instead exists only to
serve a processor running general-purpose applications.
- diagram
- A graphical depiction of
all or part of a model.
-
A graphical presentation of a collection of model
elements, most often rendered as a connected graph of arcs (relationships)
and vertices (other model elements). UML supports the following diagrams:
class diagram, object
diagram, use-case diagram,
sequence diagram, collaboration
diagram, statechart diagram,
activity diagram, component
diagram, and deployment diagram.
- Direct Access Storage Device
(DASD)
- A device that allows storage
to be directly accessed, such as a disk drive (as opposed to a tape drive,
which is accessed sequentially).
- discipline
- A discipline is a collection
of related activities that are related to a major 'area of concern'. The
disciplines
in UPEDU include: Business Modeling, Requirements, Analysis & Design,
Implementation, Test, Deployment, Configuration & Change Management, Project
Management, Environment.
- disjoint substate
-
A substate that cannot be held simultaneously
with other substates contained in the same composite state. See composite
state. Contrast: concurrent substate.
- Distributed Computing
Environment (DCE)
- Distributed Computing Environment.
Adopted by the computer industry as a de facto standard for distributed computing.
DCE allows computers from a variety of vendors to communicate transparently
and share resources such as computing power, files, printers, and other objects
in the network.
- distributed processing
- Distributed
processing is an application or systems model in which function and data can
be distributed across multiple computing resources connected on a LAN or WAN.
See client/server computing.
- DLL
- Dynamic
Link Library
- DMZ
- De-Militarized
Zone
- DNS
- Domain
Name Server
- document
- A document is a collection
of information that is intended to be represented on paper, or in a medium
using a paper metaphor. The paper metaphor includes the concept of pages,
and it has either an implicit or explicit sequence of contents. The information
is in text or two-dimensional pictures. Examples of paper metaphors are word
processor documents, spreadsheets, schedules, Gantt charts, web-pages, or
overhead slide presentations.
- document description
- Describes
the contents of a particular document.
- document template
- A concrete tool
template, such as Microsoft
Word template.
- domain
- An area of knowledge or
activity characterized by a family of related systems.
-
An area of knowledge or activity characterized by a set of concepts and terminology
understood by practitioners in that area.
- domain model
- A domain model captures
the most important types of objects in the context of the domain.
The domain objects represent the entities that exist or events that transpire
in the environment in which the system works. The domain model is a subset
of the business object model.
- domain name server
- A system for
translating domain names such as www.software.ibm.com into numeric Internet
protocol addresses such as 123.45.67.8.
- double-byte character set
(DBCS)
- A set
of characters in which each character is represented by 2 bytes. Languages
such as Japanese, Chinese, and Korean, which contain more symbols than can
be represented by 256 code points, require double- byte character sets. Compare
with single-byte character set.
- dynamic classification
-
A semantic variation of generalization
in which an object may change type
or role. Contrast: static
classification.
- dynamic information
- Information
that is created at the time the user requests it. Dynamic information changes
over time so that each time users view it, they see different content.
- dynamic link library (DLL)
- A file containing
executable code and data bound to a program at run time rather than at link
time. The C++ Access Builder generates beans and C++ wrappers that let your
Java programs access C++ DLLs.
- e-business
- Either (1) the transaction
of business over an electronic medium such as the Internet or (2) a business
that uses Internet technologies and network computing in their internal business
processes (via intranets), their business relationships (via extranets), and
the buying and selling of goods, services, and information (via electronic
commerce).
- earned value
- [MSP97]
defines this as:
" A measure of the value of work performed so far. Earned value uses
original estimates and progress-to-date to show whether the actual costs incurred
are on budget and whether the tasks are ahead or behind the baseline plan."
- EJB
- Enterprise
JavaBean
- elaboration
- The second phase
of the process where the product vision and its
architecture are defined.
- element
-
An atomic constituent of a model.
- encapsulation
- The hiding of a software
object’s internal representation. The object provides an interface that queries
and manipulates the data without exposing its underlying structure.
- enclosed document
- A document
can be enclosed by another document to collect a set of documents into a whole;
the enclosing document as well as the individual enclosures are regarded as
separate artifacts.
- enhancement request
- A type of stakeholder
request that specifies a new feature
or functionality of the system. See also change
request.
- Enterprise JavaBean (EJB)
- An EJB is a
non-visual, remote object designed to run on a server and be invoked by clients.
An EJB can be built out of multiple, non-visual JavaBeans. EJBs are intended
to live on one machine and be invoked remotely from another machine. They
are platform-independent. Once a bean is written, it can be used on any client
or server platform that supports Java.
- entity class
- A class
used to model information that has been stored by the system, and the associated
behavior. A generic class, reused in many use
cases, often with persistent characteristics. An entity class defines
a set of entity objects, which participate in several use cases and typically
survive those use cases.
- entry action
-
An action executed upon entering a state in a
state machine regardless of the transition
taken to reach that state.
- enumeration
-
A list of named values used as the range of a particular attribute
type. For example, RGBColor = {red, green, blue}. Boolean is a predefined
enumeration with values from the set {false, true}.
- environment
- (1) A discipline in the software-engineering
process, whose purpose is to define and manage the environment in which the
system is being developed. Includes process descriptions, configuration
management, and development tools. (2) A specific instance of a configuration
of hardware and software, established for the purpose of software development,
software testing, or in which the final product is deployed. See test
environment and deployment environment.
- ERP
- Enterprise Resource Planning
- evalution mission
- A brief, easy-to-remember statement that distills the essence of the work
objectives for the test team for a given work schedule. Typically defined
per iteration, the evaluation mission provides focus to keep the team working
productively to benefit the testing stakeholders. Some examples of mission
statements include: find important problems fast, advise about perceived
project risks, advise about perceived quality and verify to
a specification.
- event
-
The specification of a significant occurrence that has a location in time
and space. In the context of state diagrams,
an event is an occurrence that can trigger a transition.
- event-to-method connection
- A connection
from an event generated by a bean to a method of a bean. When the connected
event occurs, the method is executed.
- evolution
- The life of the software
after its initial development cycle; any subsequent cycle, during which the
product evolves.
- evolutionary
- An iterative development
strategy that acknowledges that user needs are not fully understood and therefore
requirements are refined in each succeeding iteration (elaboration
phase).
- executable architecture
- An executable
architecture is a partial implementation
of the system, built to demonstrate selected system functions and properties,
in particular those satisfying non-functional requirements. It is built during
the elaboration phase to mitigate risks
related to performance, throughput, capacity, reliability and other 'ilities',
so that the complete functional capability of the system may be added in the
construction phase on a solid foundation,
without fear of breakage. It is the intention of the UPEDU that the executable
architecture be built as an evolutionary prototype, with the intention of
retaining what is found to work (and satisfies requirements), and making it
part of the deliverable system.
- exit action
-
An action executed upon exiting a state in a state
machine regardless of the transition taken to exit that state.
- exploratory testing
- A technique for testing computer software that requires minimal advanced
planning and tolerates limited documentation for the target-of-test, relying
mainly on the skill and knowledge of the tester to guide the testing. Thought
to have first been first defined by Cem Kaner, Exploratory Testing has been
broadly publicized by the work of James Bach. James advocates a style of exploratory
testing where short sessions of exploration lasting approximately 90 minutes
are briefly planned, undertaken, and results recorded and reviewed.
- export
-
In the context of packages, to make an element
visible outside its enclosing namespace. See visibility.
Contrast: export [OMA], import.
- expression
-
A string that evaluates to a value of a particular type. For example, the
expression "(7 + 5 * 3)" evaluates to a value of type number.
- extend
-
A relationship from an extension use case to a base use case, specifying how
the behavior defined for the extension use case can be inserted into the behavior
defined for the base use case.
- extend-relationship
- An extend-relationship
from a use-case class A to a use-case class B indicates that an instance of
B may include (subject to specific conditions specified in the extension)
the behavior specified by A. Behavior specified by several extenders of a
single target use case can occur within a single use-case instance.
- facade
- A special package,
stereotyped «facade», within a subsystem that organizes and exports all
information needed by the clients of the subsystem. Included in this package
are interfaces (where the interfaces are
unique to the subsystem), realization relationships to interfaces outside
the subsystem, and any documentation needed by clients of the subsystem to
use the subsystem.
- factory
- (Java) A nonvisual bean capable of dynamically creating new instances of
a specified bean.
- failure
- The inability of a system or component to perform its required functions
within specified performance requirements [IEEE90].
A failure is characterized by the observable symptoms of one or more defects
that have a root cause in one or more faults.
- fault
- An accidental condition that causes the failure
of a component in the implementation model to perform its required behavior.
A fault is the root cause of one or more defects
identified by observing one or more failures.
- fault-based testing
- A technique for testing computer software using a test method and test data
to demonstrate the absence or existence of a set of pre-defined faults.
For example, to demonstrate that the software correctly handles a divide by
zero fault, the test data would include zero.
- fault model
- A model for testing computer software which uses the notion of a plausible
fault as it's basis and provides a test method
to uncover the fault. The good fault model provides a definition of the fault
or root cause, discussion of the observable failures
the fault can produce, a test technique for uncovering the fault and a profile
of appropriate test data.
- feature
- An externally observable
service provided by the system which directly fulfills a stakeholder
need.
- A property, like
operation or attribute, which is encapsulated within a classifier, such as
an interface, a class or a datatype.
- field
- See attribute.
- file transfer protocol (FTP)
- The basic Internet function that enables files to be transferred between
computers. You can use it to download files from a remote, host computer,
as well as to upload files from your computer to a remote, host computer.
- final state
-
A special kind of state signifying that the enclosing composite
state or the entire state machine
is completed.
- fire
-
To execute a state transition. See transition.
- Firewall
- A computer, or
programmable device, with associated software which can be used to restrict
traffic passing through it according to defined rules. Controls would
typically be applied based on the origin or destination address and the
TCP/IP port number.
- flatten
- Synonymous with de-marshal.
- focus
of control
-
A symbol on a sequence diagram that
shows the period of time during which an object is performing an action,
either directly or through a subordinate procedure.
- formal
parameter
-
Synonym: parameter.
- framework
-
A micro-architecture that provides an extensible
template for applications within a specific
domain.
- FTP
- File
Transfer Protocol
- FURPS+
- Functionality, Usability, Reliability, Performance, Supportability (+ others): this
acronym represents categories for both defining product requirements and assessing
product quality.
- gateway
- A host computer that
connects networks that communicate in different languages; for example, a
gateway connects a company’s LAN to the Internet.
- generalizable element
-
A model element that may participate in a generalization relationship. See generalization.
- generalization
-
A taxonomic relationship between a more general element and a more specific
element. The more specific element is fully consistent with the more general
element and contains additional information. An instance of the more
specific element may be used where the more general element is allowed. See inheritance.
- generation
- Final release at the end of a cycle.
- graphical user interface (GUI)
- A type of interface that enables users to communicate with a program by
manipulating graphical features, rather than by entering commands. Typically,
a GUI includes a combination of graphics, pointing devices, menu bars and
other menus, overlapping windows, and icons.
- green-field development
- Development "starting from scratch", as opposed to "evolution
of an existing system" or "reengineering of a legacy piece".
Originated from the transformation that takes place when building a new factory
on an undeveloped site—with grass on it.
- guard condition
- A condition that must be satisfied in order to enable an associated transition
to fire.
- GUI
- Graphical
User Interface
- home page
- See Start
page.
- HotJava
- A Java-enabled Web and
intranet browser developed by Sun Microsystems, Inc. HotJava is written in
Java.
- HTML
- HyperText
Markup Language
- HTML browser
- See web
browser.
- HTTP
- HyperText Transport Protocol
- HTTP request
- A transaction
initiated by a Web browser and adhering to HTTP. The server usually responds
with HTML data, but can send other kinds of objects as well.
- hyperlinks
- Areas on a Web page
that, when clicked, connect you to other areas on the page or other Web
pages.
- hypertext
- Text in a document that
contains a hidden link to other text. You can click a mouse on a hypertext
word and it will take you to the text designated in the link. Hypertext is
used in Windows help programs and CD encyclopedias to jump to related
references elsewhere within the same document. The wonderful thing about
hypertext, however, is its ability to link—using HTTP over the Web—to
any Web document in the world, yet still require only a single mouse click
to jump clear around the world.
- hypertext markup language
(HTML)
- The
basic language that is used to build hypertext documents on the World Wide
Web. It is used in basic, plain ASCII-text documents, but when those
documents are interpreted (called rendering) by a Web browser such as
Netscape, the document can display formatted text, color, a variety of
fonts, graphic images, special effects, hypertext jumps to other Internet
locations, and information forms.
- I/T
- Information Technology
- IDE
- Integrated
Development Environment
- idiom
- [BUS96]
defines idiom so:
“An idiom is a low-level pattern specific to a
programming language. An idiom describes how to implement particular aspects
of components or the relationships between them using the features of the
given language.” Also called an implementation pattern. When taking a
concrete design expressed in UML, say, and implementing it in Java for
example, recurring implementation patterns for that language may be used.
Idioms thus span design and implementation.
- IE
- Internet Explorer (Microsoft)
- IEEE
- The Institute of Electrical
and Electronics Engineers, Inc.
- IIOP
- Internet
Inter-ORB Protocol
- IMAP4
- Internet Message Access
Protocol-Version 4
- implementation
- A discipline in the software-engineering
process, whose purpose is to implement and perform developer testing on software
components.
-
A definition of how something is constructed or computed. For example, a class
is an implementation of a type, a method is an implementation of an operation.
- implementation
inheritance
-
The inheritance of the implementation of a more specific element. Includes
inheritance of the interface. Contrast: interface
inheritance.
- implementation mechanism
- An architectural
mechanism used during the implementation process. They are
refinements of design mechanisms,
which specify the exact implementation of the mechanism, and which will also
very likely employ several implementation patterns (idioms) in their
construction. Again, there is not necessarily any difference in scale
between the design mechanism and the implementation mechanism.
-
- For example, one particular implementation of the inter-process
communication analysis mechanism is a shared memory design mechanism
utilizing a particular operating system’s shared memory function calls.
Concurrency conflicts (inappropriate simultaneous access to shared memory)
may be prevented using semaphores, or using a latching mechanism, which in
turn rest upon other implementation mechanisms.
- implementation model
- The
implementation model is a collection of components,
and the implementation subsystems
that contain them.
- implementation pattern
- See idiom.
- implementation subsystem
- A collection of components and other implementation
subsystems used to structure the implementation
model by dividing it into smaller parts. Note that in the UPEDU, the
implementation model and the implementation subsystems are the target of the
implementation view and are, therefore,
of primary importance at development time. It is the physical analogue of
the design package. The name "implementation
subsystem" reflects a common usage of the term "subsystem"
to indicate something of a larger scale than a component. In UML terms, however,
it's a stereotyped package, not a subsystem.
- implementation view
- An architectural
view that describes the organization of the static software elements
(code, data, and other accompanying artifacts) in the development
environment in terms of both packaging, layering,
and configuration management
(ownership, release strategy, and so on). In the Unified Process, it's a
view on the implementation model.
- import
-
In the context of packages, a dependency that
shows the packages whose classes may be
referenced within a given package (including packages recursively embedded
within it). Contrast: export.
- import-dependency
- A stereotyped
dependency in the design whose source is a design
package, and whose target is a different design package. The import
dependency causes the public contents of the target package to be
referenceable in the source package.
- inception
- The first phase
of the Unified Process, in which the seed idea, request for proposal, for
the previous generation is brought to the point of being (at least
internally) funded to enter the elaboration
phase.
- include
-
A relationship from a base use case to an inclusion use case, specifying how
the behavior defined
|
References >
Glossary
