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