|
Glossary
Add-in
When a new modular capability can be added to an already
developed system via exposed interfaces.
- ANSI
American National Standards Institute. This organization
is responsible for approving U.S. standards in many areas,
including computers and communications. Standards approved
by this organization are often called ANSI standards (e.g.,
ANSI C is the version of the C language approved by ANSI).
ANSI is a member of ISO.
Binding Time
The time at which decisions are made. In software, binding
times vary from conceptual, to design, to coding, to compile
time, to execution. Static binding happens at compile
time and certain type information is used and sometimes then
thrown away; dynamic binding happens at run time.
Class Libraries
Class libraries are collections of class definitions and
implementations.
Component
Any software (sub)system that can be factored out and has
a potentially standardizable or reusable exposed
interface. Components in a software architecture can be identified
at different levels of abstraction, and the components identified
at these different levels may not be in one-to-one correspondence.
(issues with components)
- least common denominator component interfaces so that
resulting implementations do not meet anyone's needs
- portmanteau standards (that become increasingly complex,
overloaded, heavyweight) that include features anyone wanted
but few implement or include but not by reference other
standards and are not further decomposable.
- interface versus implementation factoring and composition.
- implementations that expose additional interfaces beyond
standard ones (special features) that some users want or
find useful and take advantage of - use of these features
means the resulting system cannot be ported (as easily),
a pay-me-now or pay-me-later tradeoff where the more
expedient possibly more expensive pay-me-later usually wins.
- APIs with many, many user accessible interfaces
Delegation
Like inheritance in that a class definition is defined in
terms of other class definitions but not necessarily via a
static class hierarchy and often dynamically at runtime so
that new dependencies can be added. Microsoft COM does not
support inheritance but does support a kind of delegation
allowing new behaviors to be added to running systems (an
advantage).
Integration
To put parts together into a whole somehow. "The goal
of integration is to combine the required elements into a
needed capability".
Interoperation
When systems work together, they are said to be interoperating.
Object
An encapsulated software unit consisting
of both state (data) and behavior (code).
Object Model
A specific collection of classes in some object modeling
formalism.
Plug-and-Play
(General) when new components can be added to a (running)
environment without an extensive system configuration effort
or integration effort.
Plug-In
Plug-Ins are not guaranteed to be portable
across environments. Plug-Ins are programs that are
downloaded to the client, they are not guaranteed to be portable
across environments.
Three tier architecture
(Web) Many Web tools use this phrase to indicate the three
layers of web architecture characterized by web client - web
server - CGI-gatewayed-backend server. The backend server
(for instance, a DBMS) takes parameters typically embedded
in URLs and returns html pages that it constructs on the fly.
Plug-Ins and Java provide other interesting Web extensional
architectures.
(Enterprise) A client/server architecture
consisting of three layers: "thin clients" primarily implementing
presentation services (e.g., graphical interfaces); "application
servers" implementing business functions and business logic;
and "database servers" managing persistent data. In some variants,
interfaces to legacy systems may also be included in the database
server layer.
Wrapper
Several mechanisms that are used to attach together other
software components. A wrapper may encapsulate a single system,
often a data source, to make it usable in some new way that
the unwrapped system was not. Wrappers are often assumed to
be simple but in general they can be used
- to expose all or some of the functionality of the thing
they are wrapping
- to present a simplified or standard interface to make
a component more available (as when legacy systems are wrapped
with IDL or Java beans)
- to wrap diverse systems so that they can be federated
together to present a common interface
- to add functionality to a system for some or all users
- to be added to a legacy system at a later date to make
it easier for developers in other environments to access
the legacy system. IDL and Java are used for this purpose.
- to expose some of a system's internal interfaces. This
can often not be done very efficiently as with preprocessors
for languages like C++ or query optimizers. Compilers, DBMS
systems, and other complex systems do not often expose interfaces
to internal components like optimizers or code generators.
- Often the system continues to expose its old interface
to legacy applications that still use it. If the system
evolves, the wrapper often needs to evolve too, which can
be a maintenance headache.
Request
more Information
|
