You are on page 1of 6

APPLICATION-ORIENTED OBJECT ARCHITECTURE: CONCEPTS AND

APPROACH
Ramesh K. Karne, Rajavardhan Gattu, Xubo Zhang, and Ramesh Dandu
Department of Computer and Information Sciences, Towson University, Towson, MD 21252

ABSTRACT (a) incompatibility among products and tools


(b) obsolescence due to hardware, software, tools and
The evolutionary computer systems and applications
applications
growth has been astronomical and spreads across many
(c) personnel re-training as a result of new
dimensions. We propose a radical architecture that is in
environments, programming languages, and tools
its conceptual phase, which is based on applications and
(d) wastage of hardware, software, applications, and
object-oriented paradigm, instead of computer and
skills (waste of money)
system environments. In its initial phases, the
(e) proliferation of products, languages, interfaces,
application-oriented object architecture has a potential
architectures, platforms, and tools
of running on a bare machine without any need for a
(f) dumping of obsolete computer hardware and
conventional operating system. This approach bundles
software products (environmental effects, dump
the operating system facilities needed with its
sites)
application program and expects the hardware to
(g) lack of portability, extensibility, maintainability
communicate with software in an intelligent manner.
and inter-operability
This paper presents the architecture, identifies its issues
(h) many layers between applications and hardware
related to design and implementation and describes its
resulting in numerous transformations.
current state. The proposed architecture is currently
demonstrated using existing computer environments
It is not proven, but apparent that the above
and small example applications. Further research is in
problems may have stem from the evolutionary path
progress to demonstrate complex examples that can be
chosen to build computer systems over the past few
run on the application-oriented object architecture.
decades. Our motivation emerged from the above
problems and frustration and resulted in a simple
KEY WORDS computer architecture that may possibly reduce above
AOA, application-oriented, bare machine, computer proliferations. It may seem that it is going back to a
environments. stone age by revisiting the evolution, however, it may
be the only approach available to reduce this
proliferation and obsolescence of computer
1. Introduction environments.
The evolution of information technology can be
The first and foremost software system that comes
viewed as having at least eight dimensions: 1. Vendors
close to hardware is an operating system. An operating
(each vendor has their own implementation and
system provides services to computer applications and
possibly different hardware organization) 2. Hardware
acts as a layer to shield user applications from hardware
releases (frequent product releases due to technology
intricacies. However, an application program to run in
improvements) 3. Software releases (frequent product
a given hardware has all the intricacies of hardware and
releases due to new functionality or improvements) 4.
its interfaces embedded into its program through
Operating systems (many types and versions), 5.
compilers, linkers, loaders, operating system libraries,
Programming languages and tools (proliferation of
device drivers and so on. An application program does
languages, paradigms, and environments) 6.
not see this complexity but the system does to run in its
Application environments (fast growth in desktop,
current environment.
Internet, multimedia, database, networking, security,
etc) 7. Applications (exponential growth in real-world
We propose a solution that focus on repackaging the
computer applications) 8. Secure systems (secure
application programs with operating system and
protocols and architectures). As technology evolves in
environment related programs (bundle them together).
these multiple dimensions, it spawns increasingly
That means, there is only one program unit that has the
complex computer systems and environments.
sole knowledge of its creation, execution and retention.
The program can also runs on a bare machine so that
It can be inferred that current computer systems and
there is no other program loaded a priori before an
environments cause the following problems:
application program is run.
2. Related Research introduced by the PI in [13], and the global computer
architecture described in [14], led to the Application-
Over the years, related research has explored
oriented Object Architecture (AOA) proposed here.
different paradigms and methodologies to make
computing more effective and efficient for
computations. Such approaches spread across many
fields in computer science, and address some of the 3. Architecture
problems in current computer systems. In the early The proposed Application-oriented Object
80’s, Myers [1] clearly identified the existing semantic Architecture (AOA) solution is simply a two-layer
gap between computer applications and computer architecture consisting of an application layer and a
implementations, concluding that it is necessary to hardware layer. The application layer is implemented
reduce this gap to achieve maximum performance and using application objects (AOs). The hardware layer is
stability in computer systems. The object-oriented implemented using application units (AUs). AOs and
paradigm offers many benefits and provides features to AUs communicate through standard interfaces shown in
extend the existing objects to future objects; object- Figure 1. For example, a display AU has its own
oriented technology is mature and became the de-facto interface with its AO. A CPU AU has another interface
standard in many areas. Object-oriented programming with its own AO. For example, a given application
languages such as Java provide platform independent object can request a CPU directly for its time, starting
software and offer portability and reusability. Open- of execution, stopping of execution, availability of
systems and architectures such as Open Software CPU, and so on. Similarly, the application units will
Foundation (OSF), Common Object Request Broker also keep track of their own resources and interact with
Architecture (CORBA), Enterprise Java Beans (EJB), AOs. A set of application objects forms a computer
and Enterprise Frameworks [2] help to develop application. A set of application units forms a computer
interoperable systems. The building block approach in hardware system. Some of the features of the
software systems [3] provides easier techniques to build architecture are briefly described in this section. Due to
and extend software. Dedicated architectures [4] will space limitations, detailed descriptions and
help in speeding up some specialized applications. implementation issues are avoided. The major
However, research has shown that it is very difficult to characteristic of this architecture is that it does not
develop homogeneous software [5] to build require any operating system to be resident in the
interoperable systems, as there is an architectural hardware layer to run AOs.
mismatch in software systems. Exokernel research work
at MIT [6] focuses on increasing the performance of In this architecture there is a bare machine that can
applications using Exokernel instead of commercial communicate to an application object every time it
operating systems (treating operating system like an needs to be executed. The bare machine has to be
application). Bare PC research at Utah [7] may intelligent to keep track of its own resources and able to
eventually help users to write application programs with communicate with software (AOs). The application
the interfaces available in OS Kit, which enables PCs to object must contain all necessary programs to load,
run without major operating systems. The object-engine execute and manage its own resources. By bundling all
[8], and OO techniques in hardware design indicate that the programs with the application, it will help
there is a need for integrated hardware approaches to standardize the application units and avoid
address current computer system design problems. obsolescence and proliferation of products. Every AU
Virtual computer systems and global software [9,10] must follow the standard communication to their AOs.
provide an alternate approach to cope with the myriad The interfaces to AOs must be built right into AUs to
of platforms and millions of computers connected to the facilitate this communication. The current computer
Internet. It should be noted that most of these research systems do not do this as the AUs have no knowledge
efforts mesh with the evolution of technology [11] that of their own resources and they are being managed by
began decades ago. the operating system and also there is no well-defined
external interface to current AUs as they only interface
The above solutions address design issues such as with the host operating system.
portability, extensibility, reusability, interoperability,
and modularity, yet fail to pay attention to obsolescence
and the proliferation of computer systems and 3.1 AO/AU Objects
applications resulting from the "eight-dimensional A set of AOs forms a real-world application.
cube" (vendors, hardware, software, operating systems, Editing a resume is a real-world application that
programming languages, application environments, constitutes a set of AOs that may need to communicate
applications, and security). Consequently, despite many to a set of AUs. A real world application such as editing
technological advances, we still replace our desktops a resume consists of all knowledge and control needed
and operating systems every two years, and do not to execute its application. It is self-controllable and self-
recycle most of our computer hardware and software executable given required resources or AUs. It is self-
[12]. The object-oriented computer architecture
controllable as it has all the information related to a to a CPU AO and so on. Once these standard interfaces
given application and it is self-executable as it also sets are defined, they must only extend to cover new
an execution environment in AUs to run its own functionality, but not to abandon the old interface. That
application. Thus, an AOA application negotiates with means, the hardware and as well as software must
AUs for its resources, load itself, set up its resources, follow object-oriented methodology in their
execute itself, monitor errors, process exceptions, and architecture, design and implementation.
leave the AUs when it is complete. There is no other
program in the AUs other than the programs in the
AOs. 3.3 Example Illustration
The example shown in Figure 2 illustrates a resume
application in the AOA system. A resume application
has functions such as access control, signature
validation, edit, store, and spell-check. In a
AO AO AO AO
conventional environment, as shown in Figure 2(a),
Application Layer Microsoft Word, and the underlying OS will enable a
user to perform the above functions for the resume
AO/AU Interfaces application. In the AOA system, as shown in Figure
2(b), an AO consists of a program text object as well as
application control objects.
AU AU AU AU

Hardware Layer
Object-oriented analysis and design could be
performed on similar applications such as books,
documents, newspapers, magazines and technical
Figure 1. Application-oriented Object Architecture journals that may share common objects with the
(AOA) resume object. These similar entities form the basis to
build AOs that constitute a specific application domain.
In general, we can capture AOs based on applications
A set of AUs are real-world hardware objects in and hide all the necessary data and control. Also, once
hardware layer that provides all the required resources all application domains are modeled as application
for a given application. It is simply a hardware unit objects, much redundancy will be avoided.
consisting of a processor, memory, disk, display,
network card and other related elements required for
AOs. An AU acts like a server to an AO, in the sense 4. Design and Implementation
that an AO can make service requests to the AU. Some
of the AO’s requests are as follows: allocate memory, Today’s hardware such as a 386 chip does not
acquire a CPU for execution (and possibly for a given provide the interfaces that are required for the AOA.
amount of time), de-allocate memory, put the processor One possible approach is to define the AU component
in a wait state, start loading a program, stop the interfaces such as CPU, memory, keyboard, display,
processor, check authentication, validate its signature, network card, mouse, and disk in assembly language or
and request processor or memory availability. As there C, letting these interfaces enable communication
is no operating system in an AU, the AU unit and its between AU elements and AOs. However, when such
elements should keep track of their own resources in an assembly language interface objects are developed to
intelligent manner. For example, a CPU element or an interface with AOs, they should use BIOS calls for
AU will keep track of its AO currently in execution and hardware functions to make the interfaces stable
the AO’s execution time, its interface to the AOs, the (assuming that BIOS are part of hardware). The BIOS
amount of time allocated for each AO, whether it can calls only work in real mode; thus, one must learn how
serve a given AO request or not. If the AUs manage to swap back and forth from real mode to protected
their own hardware resources intelligently, and the mode, if protected mode is used for high memory and
AOs have all the necessary software, then these units 32-bit addressing. We need a clean approach to develop
could function in harmony eliminating the need for an these interfaces that are stable and robust for all
external operating system. application objects.

As shown in Figure 2 for resume object, in general,


we need to develop generic interfaces to communicate
3.2 AO/AU Interfaces between AOs and AUs. Once these interfaces are well
There is a need for standard interface between AUs understood and defined, then it is possible to integrate
and AOs. For example, a keyboard must have a these interfaces into AUs. For example, a CPU
standard interface (similar to BIOS calls) to a keyboard interface can be integrated into the CPU, and a memory
AO. Similary, a CPU should have a standard interface interface can be integrated into memory. In this
approach, a memory unit knows how much of it is operating system resident in the hardware. However,
being used and who is using it. It also knows how to the ROM BIOS need to be resident in the machine.
communicate with an AO and respond according to its
available memory and performance. If the AOA system A bootable disk is created with AOA interfaces
becomes a commodity, then it is possible to envision where upon booting the machine with a floppy disk will
custom designs for AUs using a coarse-grained load the AOA interface programs in the memory below
approach, in which multiple elements can be integrated 1M range. This AOA interface programs will enable the
into a single AU, and dynamically re-configured for AO user to load AOA applications and run them with out
requirements. This means there will be many AUs for any assistance from the standard operating system calls.
specific application objects; such AUs will become a
commodity in computer systems. We need further In order to do that, the application programs must be
research for a variety of design approaches for AUs, written without any *.h files that are related to
and their pros and cons. operating systems. Instead, the programmer must use
AOA interface calls.

5. Prototype A real-mode to protected mode and vice versa


interface is also developed which will enable the
We have built an AOA prototype using 386 based
applications to be loaded above 1M and use real-mode
PC and Visual C++ 6.0 and MASM 6.11 assembler
facilities such as keyboard, and monitor. An
programs. This prototype does not use any operating
application program can be loaded any where above 1M
system related functions except ROM BIOS (we
as specified by the user. When a program is complete,
assume ROM BIOS are hardware related and stable).
the control is returned back to the user program to
We have modeled about three small applications such
terminate.
as resume, bubble sort, and hello and these applications
can run with out any use of DOS or Windows or NT
In protected mode, we have also written AOA
operating system. Some of the high lights are listed
interfaces for keyboard, and display using interrupts
below:
and BIOS calls.
ƒ functions for application operating objects for a
resume object are identified and implemented
Currently, all the programs have to be loaded
ƒ requirements for AO design and implementation
through a floppy disk, however, one can modify the
are identified
interface to load it from a hard disk.
ƒ AO designs for a resume object and other sample
objects are complete
• created a bootable disk whereby the resident We are also studying more complex applications
operating system can be bypassed such as TCP/IP to run with the AOA system. The
• created protected mode where 32-bit addressing prototype is also being used to develop other AO and
and large physical memory can be accessed AU interfaces and serves as a Testbed for AOA
applications.
• wrote a loader program which can read programs
from a floppy disk and load them into selected
locations in memory
• created a user interface for AOA where different 6. Further Research
application programs (such as a resume object, Initial work in exploration of AOA indicate that
bubble sort, etc.) can be defined, loaded, and there are no major road blocks to pursue this
executed in the AU exploration. However, demonstration of AOA using the
• implemented all hardware interfaces and operating existing computer environment is a daunting task. We
system type interfaces using ROM BIOS calls identify the following research areas to make AOA
• implemented call gates to provide inter-segment successful in real world applications:
transfers in memory and task gates to create multi-
tasking environment ¾ demonstrate a complex application using AOA
• replaced JMP, CALL, and RET instructions which ¾ develop the standard interfaces for AOs/AUs
are linker and loader sensitive with the AOA based ¾ study the integration of AO/AU interfaces into
interfaces AU
• found many Web sites and related interest groups ¾ study the issues related to AO communication
(DJGPP, NASM, OSKIT, Exokernel) for free code and sharing of resources
that works with non-commercial OS environment. ¾ study the multi-processing issues related to
AOA implementation
¾ study performance and memory needs for
The prototype demonstrates that a C++ application
AOA.
program can run on a bare machine without any
The above research issues identified requires vast
amount of research and funding resources. We believe [8] F.Cummins, R.Cunis, and G.Harris, The Object
that when a complex application such as TCP/IP Engine: Foundation for Next Generation
protocol is demonstrated on AOA, then this research Architectures,” OOPSLA ‘95, 123-127.
will become more fruitful and it will demonstrate a
greater potential for laying a foundation for future [9] J.Z.Gao, C.Chen, and D.Leung, Engineering on the
computer architectures. Internet for Global Software Production, Computer,
May 1999, 38-47.

7. Conclusions [10] A.S.Grimshaw, Wm.A.Wulf, and the Legion


team., The Legion Vision of a Worldwide Virtual
This paper presented a radical architecture that
Computer, Communications of the ACM, January 1997,
bundles operating system functions and applications as
Vol. 40, No. 1, 39-45.
a single object. The architecture presented is at a
conceptual level and only simple applications are
[11] J.Hennessy, The future of systems research,
demonstrated at this point. The architecture poses many
Computer, August 1999, 27-33.
questions than answers, however, we believe that it has
tremendous potential to develop a new generation of
[12] J.Whitley, A Study of Computer Obsolescence and
computer systems and applications for the future.
Its Impact, M.S Thesis, Department of Computer and
Information Sciences, Towson University, Towson,
MD 21252, December 2001.
8. Acknowledgements
This research was supported by National Science [13] R.K.Karne, Object-oriented Computer
Foundation, SGER grant, CCR-0120155. Dr. Frank Architectures for New Generation of Applications,
Anger and Dr. Spencer Rugaber’s support and Computer Architecture News, December 1995, Vol. 23,
confidence in this project started a first milestone for a No. 5, 8-19.
possible revolution in computer architectures.
[14] R.K.Karne, and J.Bradley, A Global Computer
Architecture: A Revolutionary Approach For Global
Computing of the Future, AoM/AΦM 14th Annual
REFERENCES International Conference, Conference Proceedings,
Toronto, Canada, August 1996, 213-225.
[1] G.J.Myers, Advanced Computer Architecture (John
Wiley & Sons, 1982, 17).

[2]G.Larsen, Component-based Enterprise Frameworks,


Communications of the ACM, October 2000, Vol. 43,
No. 10, 2530.

[3] F.J.Van Der Linden, and J.K.Muller, Creating


Architectures with Building Blocks, IEEE Software,
November 1995, 51-60.

[4] G.Borriello, and R.Want, Embedded Computation


Meets the World Wide Web, Communications of the
ACM, May 2000, Volume 43, Number 5, 59-66.

[5] D.Garlan, R.Allen, and J.Ockerbloom, Architectural


Mismatch: Why Reuse Is So Hard, IEEE Software,
November 1995, 17-26.

[6] D.R.Engler, The Exokernel Operating System


Architecture, Ph.D. Thesis, MIT, October 1998.

[7] B.Ford, G.Back, G.Benson, J.Lepreau, A.Lin, and


O.Shivers, The Flux OSKit: A Substrate for OS and
Language Research. In Proc. of the 16nth ACM Symp.
on Operating Systems Principles, St. Malo, France, Oct.
1997, 38-41.
(a) Conventional
Resume Resume Application
Application
Environment

Microsoft Word

Windows NT OS

Hardware

spell printing file


check char.

ac erm
ce s
p
Application security life

ss
text
program

-
cycle
object
Layer loader
fonts editor
negotiator network signature
o n trol
p plic ation C
A s
Object Keyboard Interface

Memory Interface
Network Interface
Display Interface

Printer Interface
Mouse Interface
Bootup Interface

Disk Interface

(b) AOA Resume


CPU Interface

Application
Environment

ts
onen network bootup
U C omp
A card
security disk CPU
display
Hardware Keyboard
Interrupts
printer memory
Layer speaker
mouse
modem

Figure 2. Resume Object

You might also like