[ Summary | Objectives & Results | Work Packages | Deliverables | Partners | EC Projects | Re-Engineering Links ]
Abstract Data Types (ADT)
A type whose internal form is hidden behind a set
of access functions. Objects of the type are created and inspected
only by calls to the access functions. This allows the implementation
of the type to be changed without requiring any changes outside
the module in which it is defined. Abstract data types are central
to object-oriented programming where every class is an ADT. A
classic example of an ADT is a stack data type for which functions
might be provided to create an empty stack, to push values onto
a stack and to pop values from a stack.
Abstract Interpretation
A partial execution of a program which gains information
about its semantics (e.g. control structure, flow of information)
without performing all the calculations. Abstract interpretation
is typically used by compilers to analyse programs in order to
decide whether certain optimisations or transformations are applicable.
The objects manipulated by the program (typically values and functions)
are represented by points in some domain. Each abstract domain
point represents some set of real ("concrete") values.
Abstract Syntax
A compiler's internal representation of a program
will typically be specified by an abstract syntax in terms of
categories such as "statement", "expression"
and "identifier". The syntax is abstract in two senses:
it is independent of machine-oriented structures and encodings
and also independent of the source syntax (concrete syntax) of
the language being compiled (though it will often be very similar).
A parse tree is similar to an abstract syntax tree but it will
typically also contain features such as parentheses which are
syntactically significant but which are implicit in the structure.
Abstract Syntax Notation 1 (ASN:1)
The International Organization for Standardization's
open systems interconnection (OSI) language for describing abstract
syntax.
Abstract System
An abstract system is the system defined by a functional
design. It is not a physical system to be found in the real world,
but a conceptual system behaving as specified in the functional
design. It is our understanding of the abstract system that enables
us to reason about the specified behaviour and verify that it
will satisfy the functional requirements.
Abstraction
Generalisation, ignoring or hiding details. Examples
are abstract data types (the representation details are hidden),
abstract syntax (the details of the concrete syntax are ignored},
abstract interpretation (details are ignored to analyse specific
properties).
Agent
In the client-server model, the part of the system
that performs information preparation and exchange on behalf of
a client or server. Especially in the phrase "intelligent
agent" it implies some kind of automatic process which can
communicate with other agents to perform some collective task
on behalf of one or more humans.
Algorithm Animation
Algorithm animation is the process of abstracting
the data, operations and semantics of computer programs and then
creating animated graphical views of those abstractions.
American National Standards Institute (ANSI)
The United States government body responsible for
approving US standards in many areas, including computers and
communications. ANSI is a member of ISO. ANSI sells ANSI and ISO
(international) standards.
American Standard Code for Information Interchange
(ASCII)
The standard binary encoding of alphabetical characters,
numbers, and other keyboard symbols.
Application family
An application family is a generic representation
of application systems. One purpose is to allow several abstract
systems, possibly defined using different design languages, to
be composed in one application. A second purpose is to factor
out the support systems which are generic and evolve independently
from applications. The concept support heterogeneous applications,
not easily covered by a single system description expressed in
one of the design languages.
Application Generator
An application generator takes as input a specification
of the required product. This specification can be a 4GL program.
The product of the generator is usually only modified by rerunning
the generator with a changed specification. Building an application
generator for some problem domains is difficult and requires much
foresight.
Application System
The application part of a system instance implementation.
An application system defines the application (the behaviour)
a customer wants to buy in terms of implementation code. It is
normally a partial implementation lacking the necessary support
to execute. An application system is used to produce the concrete
systems that actually execute and is expressed using some high-level
programming language.
Applications Programmer Interface (API)
The interface (calling conventions) by which an application
program accesses operating system and other services. An API is
defined at source code level and provides a level of abstraction
between the application and the kernel (or other privileged utilities)
to ensure the portability of the code. An API can also provide
an interface between a high level language and lower level utilities
and services which were written without consideration for the
calling conventions supported by compiled languages. In this case,
the API's main task may be the translation of parameter lists
from one format to another and the interpretation of call-by-value
and call-by-reference arguments in one or both directions.
A set of calling conventions defining how a service
is invoked through a software package.
Architectural Design
Large systems are divided into smaller subsystems
and modules which import from each other. The subsystems and modules
and their use relationship is called the architectural design.
Attachment
An encapsulated data object inside a document.
Automated Reverse Architectural Design
The architectural design of a system and its components
can be recovered automatically using certain tools. Some approaches
are able to subsume modules into an automatically derived subsystem
structure.
Backwards Compatibility
A property of hardware or software revisions in which
previous protocols, formats, layouts, etc. are irrevocably discarded
in favour of "new and improved" protocols, formats and
layouts, leaving the previous ones not merely deprecated but actively
defeated. (Too often, the old and new versions cannot definitively
be distinguished, such that lingering instances of the previous
ones yield crashes or other infelicitous effects, as opposed to
a simple "version mismatch" message.) A backwards compatible
change, on the other hand, allows old versions to coexist without
crashes or error messages, but too many major changes incorporating
elaborate backwards compatibility processing can lead to intractably
complex software.
CASE Based Reasoning
A technique for problem solving which looks for previous
examples which are similar to the current problem. This is useful
where heuristic knowledge is not available. Some key research
areas are efficient indexing, how to define "similarity"
between cases and how to use temporal information.
Class
A class defines an software object's interface and
implementation. It specifies the object's internal representation
and defines the operations that the object can be instructed to
perform.
Client
A computer system or process that requests a service
of another computer system or process (a server). For example,
a workstation requesting the contents of a file from a file server
is a client of the file server.
Client-Server
A common form of distributed system in which software
is split between server tasks and client tasks. A client sends
requests to a server, according to some protocol, asking for information
or action, and the server responds. There may be either one centralised
server or several distributed ones. This model allows clients
and servers to be placed independently on nodes in a network,
possibly on different hardware and operating systems appropriate
to their function, e.g. fast server/cheap client.
Client-Server, two-tier
If most, or all, of the business logic for an application
resides on the client (known as Fat Client syndrome) or on the
server (known as Fat Server syndrome), the architecture is a classic
2-tier Client/Server architecture.
Client-Server, three-tier
Application partitioning, or three-tier architectures
are expected to be the next generation of client-server systems.
A three-tier system adds a third component (the application server)
in between the current client and server. The application server
maintains some data and behaviour which reflects business rules.
With a two-tier system if business rules change, then all client
workstations have to be upgraded. In contrast a three-tier's application
server provides a central location and transparent updating of
the rules with respect to the clients.
Client-Server, n-tier
See the definition for "Client-Server, three-tier"
COCOMO
A method for evaluating the cost of a software package
proposed by Dr Barry Boehm. There are a number of different types:
The Basic COCOMO Model estimates the effort required
to develop software in three modes of development (Organic Mode,
Semidetached Mode, or Embedded Mode) using only DSIs as an input.
The Basic model is good for quick, early, and rough order of magnitude
estimates.
The Intermediate COCOMO Model an extension of the
Basic COCOMO model. The Intermediate model uses an Effort Adjustment
Factor (EAF) and slightly different coefficients for the effort
equation than the Basic model. It produces better results than
the Basic model because the user supplies settings for cost drivers
that determine the effort and duration of the software projects.
The Intermediate model also allows the system to be divided and
estimated in components. DSI values and cost drivers can be chosen
for individual components instead of for the system as a whole.
The Detailed COCOMO Model differs from the Intermediate
COCOMO model in that it uses effort multipliers for each phase
of the project. These phase dependent effort multipliers yield
better estimates because the cost driver ratings may be different
during each phase. The detailed model also provides a three-level
product hierarchy and has some other capabilities such as a procedure
for adjusting the phase distribution of the development schedule.
Cohesion
A measure of the level of functional integration
within a module. High cohesion implies well defined modules serving
one dedicated purpose, low cohesion implies ambiguity. See also
coupling.
Common Gateway Interface (CGI)
A standard for running external programs under a
World-Wide Web HTTP server. Current version 1.1. External programs
are known as gateways because they provide an interface
between an external source of information and the server.
Common Object Request Broker Architecture (CORBA)
An Object Management Group specification which provides
the standard interface definition between OMG-compliant objects.
Complexity
A code measure, which is a combination of code, data,
data flow, structure and control flow metrics.
Complexity Analysis
In structured program design, a quality-control operation
that counts the number of "compares" in the logic implementing
a function; a value of less than 10 is considered acceptable.
Component Integration Laboratories (CIL)
An effort to create a common framework for interoperability
between application programs on desktop platforms, formed by Apple
Computer Inc., IBM, Novell, Oracle, Taligent, WordPerfect and
Xerox.
Component Services
Component services provide the underlying component
software infrastructure for managing compound documents, i.e.
cross platform portability, and interoperability with non OpenDoc
applications.
Component Software (Component Object Model, COM)
Compound documents and component software define
object-based models that facilitate interactions between independent
programs. These approaches aim to simplify the design and implementation
of applications, and simplify human-computer interaction. Component
software addresses the general problem of designing systems from
application elements that were constructed independently by different
vendors using different languages, tools, and computing platforms.
The goal is to have end-users and developers enjoying the same
level of plug-and-play application interoperability that are available
to hardware manufacturers. Compound documents are one example
of component interoperability.
Compound Document (Compound Object Model, COM)
Compound documents and component software define
object-based models that facilitate interactions between independent
programs. These approaches aim to simplify the design and implementation
of applications, and simplify human-computer interaction. A compound
document is a container for sharing heterogeneous data, which
includes mechanisms which manage containment, association with
an application, presentation of data/applications, user interaction
with data/applications, provision of interfaces for data exchange,
and more notably linking and embedding. Data can be incorporated
into a document by a pointer (link) to the data contained elsewhere
in the document, or in another document. Linking reduces storage
requirements, and facilitates automatic transparent updates. Embedding
is where the data is physically located within a compound document.
Computer Aided Software Engineering (CASE)
A technique for using computers to help with one
or more phases of the software life-cycle, including the systematic
analysis, design, implementation and maintenance of software.
Adopting the CASE approach to building and maintaining systems
involvessoftware tools and training for the developers who will
use them.
Computer Supported Cooperative / Collaborative
Work / Groupware (CSCW)
Software tools and technology to support groups of
people working together on a project, often at different sites.
Concept Assignment
The process of matching human-oriented concepts to
their implementation-oriented counterparts. This type of conceptual
pattern matching enables the maintainer to search the underlying
code base for program fragments that implement a concept from
the application, which is advantageous since change requests are
usually couched in end-user terminology, not in that of the implementation.
Concept assignment is pattern-matching at the end-user application
semantic level. It is a process of recognising concepts within
the source code and building up an "understanding" of
the program by relating the recognised concepts to portions of
the program.
Concept Assignment Problem
A person understands a program because they are able
to relate the structures of the program and it's environment to
their human-oriented conceptual knowledge about the world. The
problem of discovering individual human oriented concepts and
assigning them to their implementation oriented counterparts for
a given problem is the concept assignment problem.
Concept Recognition
A knowledge-based technique that automates the recognition
of functional patterns in the code.
Conceptual Abstraction
Semi-formal, human-oriented and domain-specific abstractions
play a critical role both in reverse and forward engineering,
and therefore also in reengineering. Such conceptual abstractions
are fundamental to the reengineering process whether it is a totally
manual or partially automated process.
Concrete System
A concrete system implements the behaviour of one
or more abstract systems. A typical concrete system will consist
of hardware and executable code, and is what users actually use.
Each concrete system will be distinct and will operate in a particular
application context.
Configuration Item
Hardware or software, or an aggregate of both, which
is designated by the project configuration manager (or contracting
agency) for configuration management.
Configuration Management
A discipline applying technical and administrative
controls to:
Identification and documentation of physical and
functional characteristics of configuration items.
Any changes to characteristics of those configuration
items.
Recording and reporting of change processing and
implementation of the system.
Configuration Programming
An approach that advocates the use of a separate
configuration language to specify the coarse-grain structure of
programs. Configuration programming is particularly attractive
for concurrent, parallel and distributed systems that have inherently
complex program structures.
Coupling
The degree to which components depend on one another.
There are two types of coupling, "tight" and "loose".
Loose coupling is desirable for good software engineering but
tight coupling may be necessary for maximum performance. Coupling
is increased when the data exchanged between components becomes
larger or more complex.
Database
One or more large structured sets of persistent data,
usually associated with software to update and query the data.
A simple database might be a single file containing many records,
each of which contains the same set of fields where each field
is a certain fixed width.
Database, Hierarchical
A database whose structure is hierarchical - an organisation
with few things, or one thing, at the top and with several things
below each other thing. An inverted tree structure. Examples in
computing include a directory hierarchy where each directory may
contain files or other directories; a hierarchical network, a
class hierarchy in object-oriented programming.
Database Management System
A suite of programs which typically manage large
structured sets of persistent data, offering ad hoc query facilities
to many users. A database management system is a complex set of
software programs that controls the organisation, storage and
retrieval of data (fields, records and files) in a database. It
also controls the security and integrity of the database. The
DBMS accepts requests for data from the application program and
instructs the operating system to transfer the appropriate data.
When a DBMS is used, information systems can be changed much more
easily as the organisation's information requirements change.
New categories of data can be added to the database without disruption
to the existing system.
Database, Network
xxx
Database, Object Oriented
A system offering DBMS facilities in an object-oriented
programming environment. Data is stored as objects and can be
interpreted only using the methods specified by its class. The
relationship between similar objects is preserved (inheritance)
as are references between objects. Queries can be faster because
joins are often not needed (as in a relational database). This
is because an object can be retrieved directly without a search,
by following its object id.
The same programming language can be used for both
data definition and data manipulation. The full power of the database
programming language's type system can be used to model data structures
and the relationship between the different data items.
Database, Relational
A database based on the relational model developed
by E.F. Codd. A relational database allows the definition of data
structures, storage and retrieval operations, and integrity constraints.
In such a database, the data and relations between them are organised
in tables. A table is a collection of records and each record
in a table contains the same fields. Certain fields may be designated
as keys, which means that searches for specific values of that
field will use indexing to speed them up. Records in different
tables may be linked if they have the same value in one particular
field in each table. INGRES, Oracle and Microsoft Access are well-known
examples.
Data Centered Program Understanding
Instead of focusing on the control structure of a
program (such as call graphs, control-flow graphs and paths) data
centered program understanding focuses on data and data-relationships.
Data Flow Analysis
A process to discover the dependencies between different
data items manipulated by a program. The order of execution in
a data driven language is determined solely by the data dependencies.
Data Flow Diagram (DFD)
A graphical notation used to describe how data flows
between processes in a system. An important tool of most structured
analysis techniques.
Data Name Rationalisation (DNR)
A special case of data re-engineering. DNR tools
enforce uniform naming conventions across all software systems.
Debug
With software, to detect, locate, and correct logical
or syntactical errors in a computer program.
Debugger
A program designed to help in debugging another program
by allowing the programmer to step through the program, examine
data, and check conditions. There are two basic types of debuggers:
machine-level and source-level. Machine-level debuggers display
the actual machine instructions (disassembled into assembly language)
and allow the programmer to look at registers and memory locations.
Source-level debuggers let the programmer look at the original
source code (C for example), examine variables and data structures
by name, and so on.
Decomposition
The process of taking a program and creating objects
and relationships from it for the information base. The objects
and relationships aid analysis, transformation and extraction
of other information.
Design
The phase of software development following analysis,
and concerned with how the problem is to be solved.
Design, Modular
Modular is pertaining to the design concept, in which
interchangeable units are used to create a functional end product.
Design Pattern
A design pattern systematically names, motivates
and explains a general design that addresses a recurring design
problem in object-oriented systems. It describes the problem,
the solution, when to apply the solution and it's consequences.
It also gives implementation hints and examples. The solution
is a general arrangement of objects and classes that solve the
problem. The solution is customised and implemented to solve the
problem in a particular context.
Design Recovery
A subset of reverse engineering in which domain knowledge,
external information and deduction or fuzzy reasoning are added
to the observations of the subject system to identify meaningful
higher level abstractions beyond those obtained directly by examining
the system itself. Design recovery recreated design abstractions
from a combination of code, existing design documentation (if
available), personal experience, and general knowledge about problem
and application domains.
supporting program understanding for maintenance
(what are the modules? What are the key data items? What are the
software engineering artifacts? What are the other informal design
abstractions?); supporting population of reuse and recovery libraries
(The design abstractions of the former step are generalised and
integrated into the reuse library and the recovery knowledge base);
Applying the results of design recovery (The abstract
design components stored in the domain model now become the starting
point for discovering candidate concrete realisations of themselves
in a new system's code).
Disassembler
A program that converts machine code into assembly
language source code. Most debuggers have some kind of built-in
disassembler, allowing the programmer to view an executable program
in terms of human-readable assembly language.
Distributed Computing Environment (DCE)
An architecture consisting of standard programming
interfaces, conventions and server functionalities (e.g. naming,
distributed file system, remote procedure call) for distributing
applications transparently across networks of heterogeneous computers.
DCE is promoted and controlled by the Open Software Foundation.
Documentation Management
Document management is concerned with locating, creating,
filing, versioning and tracking documents and the information
they contain. Documents may be realised electronically, or in
hard-copy form.
Domain
A specific phase of the software life cycle in which
a developer works. Domains define developers' and users' areas
of responsibility and the scope of possible relationships between
products.
Domain Analysis
The set of activities aiming at identifying, collecting,
organising, analysing and representing the relevant information
in a domain, based on the study of existing systems and their
development history, knowledge captured from domain experts, underlying
theory, and emerging technologies within the domain. Domain analysis
aims at producing domain models and analysing commonalities and
variants among a family of products.
Domain Architecture / Domain Architectural Model
/ Family Design
An architecture applicable to a family of applications
belonging to the domain. Sometimes called the "generic architecture".
Domain Engineering
An encompassing process which includes domain analysis
and the subsequent methods and tools that address the problem
of development through the application of domain analysis products
(e.g., domain implementation).
Domain Model
Domain models are the result of domain analysis.
A domain model is a definition of domain abstractions (objects,
relationships, functions, events, etc.) It consists off a concise
and classified representation of the commonalities and variabilities
of the problems in the domain and of their solutions. It is a
representation of a family. Domain models include domain requirements
models (the problem) and domain architecture (the solution).
Domain Requirements Model
A model of the requirements for a family of applications
belonging the domain (sometimes called "generic requirements").
Such a model may be a model of user requirements, or a model of
software (or system) requirements.
Encapsulation / Information Hiding
The result of hiding a representation and implementation
in an object. The representation is not visible and cannot be
accessed directly from outside the object. Operations are the
only way to access and modify an object's state.
The ability to provide users with a well-defined
interface to a set of functions in a way which hides their internal
workings. In object-oriented programming, the technique of keeping
together data structures and the methods (procedures) which act
on them.
Entity
International Organization for Standardization's
open systems interconnection (OSI) terminology for a layer protocol
machine. An entity within a layer performs the functions of the
layer within a single computer system, accessing the layer entity
below and providing services to the layer entity above at local
service access points.
In object-oriented programming, an entity is part
of the definition of a class (group) of objects. In this instance,
an entity might be an attribute of the class (as feathers are
an attribute of birds), or it might be a variable or an argument
in a routine associated with the class.
In database design, an entity is an object of interest
about which data can be collected. In a retail database application,
customers, products, and suppliers might be entities. An entry
can subsume a number of attributes: Product attributes might be
color, size, and price; customer attributes might include name,
address, and credit rating.
Entity-Relationship Model (ERM)
The Entity-Relationship (ER) model views the world
as consisting of entities and relationships between them, where
an entity is a thing that can be distinctly identified,
e.g. a chamber, a wire, a point, a track, a vertex, etc., a relationship
is an association between entities, e.g. point belongs to track
is an association between a point and a track.
Evolution Planning
Evolution planning is the process of identifying
constraints, formulating an evolution strategy, scheduling and
monitoring an evolution project. Formulating an evolution strategy
involves deciding whether to keep an application in service with
continued maintenance support, to reengineer the application,
or to redevelop the application. A hybrid approach may be most
appropriate. This decision must be made after performing cost-benefit
analysis, and calculating the risks involved for each strategy.
Family
A set of systems sharing some commonalities (equivalent
to product line).
File Transfer Protocol (FTP)
A client-server protocol which allows a user on one
computer to transfer files to and from another computer over a
TCP/IP network. Also the client program the user executes to transfer
files.
Forward Engineering
The set of engineering activities, using the output
of software reengineering, that consume the products and artifacts
derived from legacy software and new requirements to produce a
new target system.
Framework
In object-oriented systems, a set of classes that
embodies an abstract design for solutions to a number of related
problems.
Function Point Analysis
A standard metric for the relative size and complexity
of a software system, originally developed by Alan Albrecht of
IBM in the late 1970s. Functon points (FPs) can be used to estimate
the relative size and complexity of software in the early stages
of development - analysis and design. The size is determined by
identifying the components of the system as seen by the end-user:
the inputs, outputs, inquiries, interfaces to other systems, and
logical internal files. The components are classified as simple,
average, or complex. All of these values are then scored and the
total is expressed in Unadjusted FPs (UFPs). Complexity factors
described by 14 general systems characteristics, such as reusability,
performance, and complexity of processing can be used to weight
the UFP. Factors are also weighted on a scale of 0 - not present,
1 - minor influence, to 5 - strong influence. The result of these
computations is a number that correlates to system size.
Although the FP metric doesn't correspond to any
actual physical attribute of a software system (such as lines
of code or the number of subroutines) it is useful as a relative
measure for comparing projects, measuring productivity, and estimating
the amount a development effort and time needed for a project.
Functional Abstraction
The process, by automation or by hand, of generating
a functional specification in abstract terms out of a segment
of source code.
Functional Design
A functional design serves to define behaviour on
an abstract form that can be understood, communicated and analysed
as much as possible without binding the implementation. It will
be expressed using design languages such as SDL, HOOD, and MD.
Functional Design Implementation
A functional design implementation is the description
of an abstract system in an implementation language such as C++
plus object code. It is the result of mapping a functional design
into the implementation language.
Gopher
A popular distributed document retrieval system which
started as a Campus Wide Information System at the University
of Minnesota. Many hosts on the Internet now run Gopher servers
which provide a menu of documents. A document may be a plain text
file, sound, image, submenu or other Gopher object type. It may
be stored on another host or may provide the ability to search
through certain files for a given string.
Heterogeneous Network
A network composed of systems of more than one architecture.
Contrast with homogeneous network.
Hierarchy
An organisation with few things, or one thing, at
the top and with several things below each other thing. An inverted
tree structure. Examples in computing include a directory hierarchy
where each directory may contain files or other directories; a
hierarchical network, or a class hierarchy in object-oriented
programming.
Hierarchical Subsystem Structures
Structures that are formed by imposing equivalence
relations on the resource-flow graphs of the source code.
Homogeneous Network
A network composed of systems of only one architecture.
Contrast with heterogeneous network.
Human Oriented Concepts
An approach to knowledge-based concept assignment.
Human oriented concepts are often rather informal or semi-formal.
They can't always be expressed in structural information alone.
Therefore a pure parsing approach which depends on structural
plans fails to assign human oriented concepts.
Hypermedia
An extension of hypertext to include graphics, sound,
video and other kinds of data.
Hypertext
A term coined by Ted Nelson around 1965 for a collection
of documents (or nodes) containing cross-references or links which,
with the aid of an interactive browser program, allow the reader
to move easily from one document to another.
Hypertext Markup Language (HTML)
A Hypertext document format used on the World-Wide
Web. Built on top of SGML. "Tags" are embedded in the
text. A tag consists of a "<", a "directive",
zero or more parameters and a ">". Matched pairs
of directives, like "<title>" and "</title>"
are used to delimit text which is to appear in a special place
or style.
Hypertext Transport Protocol (HTTP)
The client-server TCP/IP protocol used on the World-Wide
Web for the exchange of HTML documents. It conventionally uses
port 80. Version 1.0 is the current standard.
Impact Analysis
Impact Analysis is the task of assessing the effects
of making a set of changes to a software system.
Implementation Design Description
An implementation design description is a complete
description of all the information needed to produce a concrete
system from one or more functional designs. It describes which
components of a generic system family must be used, and which
tools must be invoked with which parameters. The implementation
design description acts as meta-description referring to other
descriptions.
Implementation Model
The implementation model consists of the code files
and the used work structure. It includes the application software
description as well as the support software description. While
the design model is a more abstract view, the implementation model
contains the full information necessary to build the system.
Informal Reasoning
An approach to knowledge-based concept assignment.
Informal reasoning is based on human oriented concepts, but takes
knowledge like natural language comments, or grouping in account
too. The needed base of knowledge about the problem for the informal
reasoning is called the domain model. It is assumed that the domain
model (problem, program and application) knowledge can be usefully
represented as patterns of informal and semi-formal information,
which are called conceptual abstractions.
Information Base
The main repository of information about the software.
It can be created by decomposing any number of views of a system.
Interaction Diagram
A diagram that shows the flow of interaction between
objects.
Interface
A boundary across which two systems communicate.
An interface might be a hardware connector used to link to other
devices, or it might be a convention used to allow communication
between two software systems. Often there is some intermediate
component between the two systems which connects their interfaces
together.
The part of a program that defines constants, variables,
and data structures, rather than procedures.
The equipment that accepts electrical signals from
one part of a computer system and renders them into a form that
can be used by another part.
Hardware or software that links the computer to a
device.
To convert signals from one form to another and pass
them between two pieces of equipment.
International Organization for Standardization
(ISO)
A voluntary, non-treaty organisation founded in 1946,
responsible for creating international standards in many areas,
including computers and communications. ISO produced the seven
layer model for network architecture (Open Systems Interconnection).
Its members are the national standards organisations of 89 countries,
including the American National Standards Institute.
Internationalisation
The process of altering a program so that it is portable
across several native languages. This portability may support
both different character sets, such as the 8-bit ISO 8859/1 (ISO
Latin 1) character set and the 7-bit ASCII character set, and
different languages for documentation, help screens, and so on.
Internet
Generally speaking, an internet is any set
of networks interconnected with routers. The Internet is the biggest
example of an internet. The Internet is the largest internet in
the world. It is a three level hierarchy composed of backbone
networks (e.g. ARPAnet, NSFNet, MILNET), mid-level networks, and
stub networks. These include commercial (.com or .co), university
(.ac or .edu) and other research networks (.org, .net) and military
(.mil) networks and span many different physical networks around
the world with various protocols including the Internet Protocol.
Intranet
A network which provides similar services within
an organisation to those provided by the Internet outside it but
which is not necessary connected to the Internet. The common example
is a company which sets up one or more World-Wide Web servers
on an internal network for distribution of information within
the company.
Java
A simple, object-oriented, distributed, interpreted,
robust, secure, architecture-neutral, portable, multithreaded,
dynamic, buzzword-compliant, general-purpose programming language
developed by Sun Microsystems around 1995. Java supports programming
for the Internet in the form of platform-independent Java "applets".
Knowledge Base
A collection of knowledge expressed using some formal
knowledge representation language. A knowledge base forms part
of a knowledge-based system (KBS).
Knowledge-Based Concept Assignment
There are a few approaches to knowledge-based concept
assignment, examples being: program plans; human oriented concepts;
and informal reasoning. They differ in the kind of knowledge they
use and which technique they apply to find concepts in the source
code.
Knowledge-Based Systems (KBS)
A program for extending and/or querying a knowledge
base.
Language, 3rd Generation (3GL)
A language designed to be easier for a human to understand,
including things like named variables. A fragment might be let
c = c + 2 * d.
FORTRAN, ALGOL and COBOL are early examples of this sort of language.
Most "modern" languages (BASIC, C, C++) are third generation.
Most 3GLs support structured programming.
Language, 4th Generation (4GL)
An application specific language. The term was invented
to refer to non-procedural high level languages built around database
systems. The first three generations were developed fairly quickly,
but it was still frustrating, slow, and error prone to program
computers, leading to the first "programming crisis",
in which the amount of work that might be assigned to programmers
greatly exceeded the amount of programmer time available to do
it. Meanwhile, a lot of experience was gathered in certain areas,
and it became clear that certain applications could be generalised
by adding limited programming languages to them. Thus were born
report-generator languages, which were fed a description of the
data format and the report to generate and turned that into a
COBOL (or other language) program which actually contained the
commands to read and process the data and place the results on
the page. Some other successful 4th-generation languages are:
database query languages, e.g. SQL; Focus, Metafont, PostScript,
RPG-II, S, IDL-PV/WAVE, Gauss, Mathematica and data-stream languages
such as AVS, APE, Iris Explorer.
Language, Interface Definition (IDL)
To accomplish interoperability across languages and
tools, an object model cspecifies standards for defining application
interfaces in terms of a language independent - an interface definition
language. Interface definitions are typically stored in a repository
which clients can query at run-time.
Language, Markup
Languages for annotation of source code to simply
improve the source code's appearance with the means of bold-faced
key words, slanted comments, etc. See also reformatting.
Language, Module Interconnection (MIL)
A module interconnection language is a language that
is separate from and complementary to a program implementation
language. MILs are concerned with the overall architecture of
software systems. They deal with the composition of large systems
out of modules, the interfaces between these modules & their
specification, and the versioning of the resulting architecture
over time. The purpose of MILs is to describe a system so that
it can be constructed, unequivocally identified, and identically
reproduced. A MIL is both a notation for design, documentation
& communication, and a means of enforcing system architecture.
Language, Object Oriented
A language for object oriented programming. The basic
concept in this approach is that of an object which is a data
structure (abstract data type) encapsulated with a set of routines,
called methods which operate on the data. Operations on the data
can only be performed via these methods, which are common to all
objects which are instances of a particular class (see inheritance).
Thus the interface to objects is well defined, and allows the
code implementing the methods to be changed so long as the interface
remains the same. Each class is a separate module and has a position
in a class hierarchy. Methods or code in one class can be passed
down the hierarchy to a subclass or inherited from a superclass.
Procedure calls are described in term of message passing. A message
names a method and may optionally include other arguments. When
a message is sent to an object, the method is looked up in the
object's class to find out how to perform that operation on the
given object. If the method is not defined for the object's class,
it is looked for in its superclass and so on up the class hierarchy
until it is found or there is no higher superclass. Procedure
calls always return a result object, which may be an error, as
in the case where no superclass defines the requested method.
Language, Program Description/Design (PDL)
Any of a large class of formal and profoundly useless
pseudo-languages in which management forces one to design programs.
Too often, management expects PDL descriptions to be maintained
in parallel with the code, imposing massive overhead of little
or no benefit.
Language, Structured
A programming language where the program may be broken
down into blocks or procedures which can be written without detailed
knowledge of the inner workings of other blocks, thus allowing
a top-down design approach.
--
A class of data structures described by means of
a set of operations rather than by physical representation, such
as a class in object-oriented programming.
--
A description of a data structure that is independent
of machine-oriented structures and encodings.
--
An ISO/CCITT standard for the description of data.
It is intended to facilitate the exchange of data between application
programs.
--
Parameterisation, making something a function of
something else. Examples are lambda abstractions (making a term
into a function of some variable), higher-order functions (parameters
are functions), bracket abstraction (making a term into a function
of a variable).
--
An organization that reviews and approves product
standards in the United States. In the electronics industry, its
work enables designers and manufacturers to create and support
products that are compatible with other hardware platforms in
the industry. Examples are PHIGS and GKS. See also International
Organization for Standardization (ISO).
--
American National Standards Institute, responsible
for approving U.S. standards in many areas, including computers
and communications. ANSI is a member of ISO.
--
The predominant character set encoding of present-day
computers. The modern version uses 7 bits for each character,
whereas most earlier codes (including an early version of ASCII)
used fewer.
--
The interface to a library of language-specific subroutines
(such as a graphics library) that implement higher level functions.
--
The specific components of a computer system and
the way they interact with one another.
--
Design, the way components fit together. The term
is used particularly of processors, both individual and in general.
It may also be used of any complex system, e.g. software architecture,
network architecture.
--
The prototype for an object in an object-oriented
language; analogous to a derived type in a procedural language.
A class may also be considered to be a set of objects which share
a common structure and behaviour. The structure of a class is
determined by the variables which represent the state of an object
of that class and the behaviour is given by a set of methods associated
with the class.
--
A grouping of data having similar characteristics.
A class definition defines instance and class variables and methods,
as well as specifying the interfaces the class implements and
the immediate superclass of the class.
--
In the client-server model for communications, the
client is a process that remotely accesses resources of a compute
server, such as compute power and large memory capacity.
--
3-tier Client/Server architecture comes about when
the business logic of the application can be moved off from either
the client and the server and placed on a third tier, or application
server. Once the ability exists to move business logic to separate
application servers, an infinite array of possible n-tier (or
multi-tier) architectures opens up.
--
COM supports a client-server model where clients
are service users, OLE objects are data, and OLE servers are the
applications which implement OLE objects.
--
Compound documents are containers and composed of
(possibly nested) parts, organised by end-users. A part contains
one or more types, e.g. sound, text, image. End users access and
manipulate parts via component handlers.
--
A representation of the domain model (problem, program
and application) knowledge in the form of informal and semi-formal
information.
--
The process of identifying, defining, recording and
reporting the configuration items in a system and the change requests.
Controlling the releases and change of the items throughout the
life-cycle.
--
Loosely, any aggregation of data; a file consisting
of a number of records (or tables), each of which is constructed
of fields (columns) of a particular type, together with a collection
of operations that facilitate searching, sorting, recombining,
or similar activities.
--
A software system facilitating the creation and maintenance
of a data base and the execution of programs using the data base.
--
To attempt to determine the cause of the symptoms
of malfunctions detected by testing or by user complaints.
--
Design recovery recreates design abstractions from
a combination of code, existing design documentation, personal
experience and general knowledge about problem and application
domains. The recovered design abstractions must include conventional
software engineering representation such as formal specifications,
module breakdowns, data abstractions, data-flows, and program
description languages. In addition they must include informal
linguistic knowledge about problem domains, application idioms,
and the world in general.
--
The design recovery process consists of three steps:
--
A functional area covered by a family of systems.
--
The base of knowledge about the problem required
for an informal reasoning approach to knowledge-based concept
assignment. It is assumed that the domain model (problem, program
and application) knowledge can be usefully represented as patterns
of informal and semi-formal information, which are called conceptual
abstractions.
The traditional process of moving from high-level
abstractions and logical implementation-independent designs to
the physical implementation of a system.
90]
--
A set of cooperating classes that make up a reusable
design for a specific class of software. A framework provides
architectural guidance by partitioning the design into abstract
classes and defining their responsibilities and collaborations.
A developer customises the framework to a particular application
by sub-classing the composing instances of framework classes.
--
Impact Analysis is the activity aimed at determining
the impact of a change before its actual implementation, in order
to anticipate the extent of its effects, and thus the associated
risk and cost.
--
The point at which independent systems or diverse
groups interact. The devices, rules, or conventions by which one
component of a system communicates with another. Also, the point
of communication between a person and a computer.
--
In computerised document preparation, a method of
adding information to the text indicating the logical components
of a document, or instructions for layout of the text on the page
or other information which can be interpreted by some automatic
system.