ActiveX control

An ActiveX control is a component program object that can be re-used by many

application programs within a computer or among computers in a network. The
technology for creating ActiveX controls is part of Microsoft's overall ActiveX set of
technologies, chief of which is the Component Object Model (COM). ActiveX controls
can be downloaded as small programs or animations for Web pages, but they can also be
used for any commonly-needed task by an application program in the latest Windows
and Macintosh environments. In general, ActiveX controls replace the earlier OCX
(Object Linking and Embedding custom controls). An ActiveX control is roughly
equivalent in concept and implementation to the Java applet.
An ActiveX control can be created in any programming language that recognizes
Microsoft's Component Object Model. The distributed support for COM is called the
Distributed Component Object Model (DCOM). In implementation, an ActiveX control
is a dynamic link library (DLL) module. An ActiveX control runs in what is known as a
container, an application program that uses the Component Object Model program
interfaces. This reuseable component approach to application development reduces
development time and improves program capability and quality. Windows application
development programs such as PowerBuilder and Microsoft Access take advantage of
ActiveX controls.

component
1) In programming and engineering disciplines, a component is an identifiable part of a larger
program or construction. Usually, a component provides a particular function or group of related
functions. In programming design, a system is divided into components that in turn are made up
of modules. Component test means testing all related modules that form a component as a group
to make sure they work together.
2) In object-oriented programming and distributed object technology, a component is a
reusable program building block that can be combined with other components in the same or
other computers in a distributed network to form an application. Examples of a component
include: a single button in a graphical user interface, a small interest calculator, an interface to a
database manager. Components can be deployed on different servers in a network and
communicate with each other for needed services. A component runs within a context called a
container. Examples of containers include pages on a Web site, Web browsers, and word
processors.
Sun Microsystems, whose JavaBeans application program interface defines how to create
component, defines "a component model" as typically providing these major types of services:

Component interface exposure and discovery. Thus, during application use, one
component can interrogate another one to discover its characteristics and how to
communicate with it. This allows different companies (possibly independent service
providers) to create components that can interoperate with the components of other
companies without either having to know in advance exactly which components it will be
working with.
Component properties. This allows a component to make its characteristics publicly
visible to other components.
Event handling. This allows one component to identify to one or more other components
that an event (such as a user pressing a button) has occurred so that the component can
respond to it. In Sun's example, a component that provided a button user interface for a
finance application would "raise" an event when the button was pressed, resulting in a
graph-calculating component gaining control, formulating a graph, and displaying it to the
user.
Persistence. This allows the state of components to be preserved for later user sessions.
Application builder support. A central idea of components is that they will not only be easy
and flexible for deploying in a distributed network, but that developers can easily create
new components and see the properties of existing ones.
Component packaging. Since a component may comprise several files, such as icons
and other graphical files, Sun's component model includes a facility for packaging the
files in a single file format that can be easily administered and distributed. (Sun calls their
component package a JAR (Java Archive) file format.)

object

In object-oriented programming (OOP), objects are the things you think about first in designing a
program and they are also the units of code that are eventually derived from the process. In
between, each object is made into a generic class of object and even more generic classes are
defined so that objects can share models and reuse the class definitions in their code. Each
object is an instance of a particular class or subclass with the class's own methods or procedures
and data variables. An object is what actually runs in the computer.

Component Object Model

Component Object Model (COM) is Microsoft's framework for developing and supporting
program component objects. It is aimed at providing similar capabilities to those defined in the
Common Object Request Broker Architecture (CORBA), a framework for the interoperation of
distributed objects in a network that is supported by other major companies in the computer
industry. Whereas Microsoft's Object Linking and Embedding provides services for the compound
document that users see on their display, COM provides the underlying services of interface
negotiation, life cycle management (determining when an object can be removed from a system),
licensing, and event services (putting one object into service as the result of an event that has

happened to another object).

OCX

An OCX is an Object Linking and Embedding (OLE) custom control, a special-purpose program
that can be created for use by applications running on Microsoft's Windows systems. OCXs
provide such functions as handling scroll bar movement and window resizing. If you have a
Windows system, you'll find a number of files in your Windows directory with the OCX file name
suffix.

Object Linking and Embedding was designed to support compound documents (which
contain multiple information types, such as text, graphic images, sound, motion video).
The Windows desktop is an example of a compound document and Microsoft used OLE
to build it. OLE and the Component Object Model (COM), a more general concept that
succeeded OLE, support the development of "plug-and-play" programs that can be
written in any language and used dynamically by any application in the system. These
programs are known as components and the application in which they are run is known as
a container. This component-based approach to application development reduces
development time and improves the program capability and quality. Windows application
development programs such as PowerBuilder and Microsoft Access take advantage of
OCXs.
Microsoft now calls an OCX an ActiveX control, the component object under Microsoft's
set of ActiveX technologies, of which the fundamental concept is the Component Object
Model (COM) and, in a network, the Distributed Component Object Model (DCOM).
An OCX or ActiveX control is actually implemented as a dynamic link library DLL
module. (You can think of a DLL program as a "subprogram" that can be used by any
number of application programs, each of which is a "container" for the DLL or
OCX/ActiveX control "object.") Visual Basic and C++ are commonly used to write OCX or
ActiveX controls.

DCOM
DCOM (Distributed Component Object Model) is a set of Microsoft concepts and program
interfaces in which client program objects can request services from server program objects
on other computers in a network. DCOM is based on the Component Object Model (COM),
which provides a set of interfaces allowing clients and servers to communicate within the same
computer (that is running Windows 95 or a later version).
For example, you can create a page for a Web site that contains a script or program that can be
processed (before being sent to a requesting user) not on the Web site server but on another,
more specialized server in the network. Using DCOM interfaces, the Web server site program
(now acting as a client object) can forward a Remote Procedure Call (RPC) to the specialized

server object, which provides the necessary processing and returns the result to the Web server
site. It passes the result on to the Web page viewer.
DCOM can also work on a network within an enterprise or on other networks besides the public
Internet. It uses TCP/IP and Hypertext Transfer Protocol. DCOM comes as part of the
Windows operating systems. DCOM is or soon will be available on all major UNIX platforms and
on IBM's large server products. DCOM replaces OLE Remote Automation.
DCOM is generally equivalent to the Common Object Request Broker Architecture ( CORBA) in
terms of providing a set of distributed services. DCOM is Microsoft's approach to a network-wide
environment for program and data objects. CORBA is sponsored by the rest of the information
technology industry under the auspices of the Object Management Group ( OMG).
A dynamic link library (DLL) is a collection of small programs, any of which can be called when
needed by a larger program that is running in the computer. The small program that lets the larger
program communicate with a specific device such as a printer or scanner is often packaged as a
DLL program (usually referred to as a DLL file). DLL files that support specific device operation
are known as device drivers.

The advantage of DLL files is that, because they don't get loaded into random access
memory (RAM) together with the main program, space is saved in RAM. When and if a
DLL file is needed, then it is loaded and run. For example, as long as a user of Microsoft
Word is editing a document, the printer DLL file does not need to be loaded into RAM. If
the user decides to print the document, then the Word application causes the printer DLL
file to be loaded and run.
A DLL file is often given a ".dll" file name suffix. DLL files are dynamically linked with
the program that uses them during program execution rather than being compiled with the
main program. The set of such files (or the DLL) is somewhat comparable to the library
routines provided with programming languages such as C and C++.

container

1) In Sun Microsystems' JavaBeans component architecture and in Microsoft's Component Object

Model (COM), a container is an application program or subsystem in which the program building
block known as a component is run. For example, a component - such as a button or other
graphical user interface or a small calculator or database requestor - can be developed using
JavaBeans that can run in Netscape containers such as browsers and in Microsoft containers
such as Internet Explorer, Visual Basic, and Word.

2) In the Common Object Request Broker Architecture (CORBA) Interface Repository, a

hierarchy for metadata, a Container is one of three abstract superclasses (along with
IRObject, and Contained).