OOUI-The future form of User Interface

DM.V.S..KARTHIK K.VENKATESWARA RAO B.C.S.V. PAVAN

sivakarthik.das@gmail.com nani.nani041@gmail.com bscvpavan@gmail.com

Ph no: 8125823017 Ph no: 9550593929 ph no: 8125576247

ECM Branch, KONERU LAKSHMAIAH UNIVERSITY

GREEN FIELDS, VADDESWARAM

VIJAYAWADA

Abstract: The Object-Oriented (OO) process is an

evolutionary approach to software
engineering. It encompasses the entire
This paper aims at highlighting the
software life cycle, from operational concept
importance of Object-Oriented approach through release. Object oriented technology
represents the methodologies which are
taking the user interface as study subject.
based on ‘Object’ approach.
The paper starts giving the classification of
Object Oriented Technologies in their basic
Object oriented Technology is seen in three
forms and defines the Object-Oriented
basic forms. They are,
approach. . The basic idea of object-
1. Object-Oriented User Interfaces
oriented approach promotes a ‘NO (OOUI)
COMPROMISE’ motto on both the product 2. Object-Oriented Programming
development and user interface efficiency. It Systems (OOPS)
then provides Object-Oriented User 3. Object-Oriented Database
Interface as a solution to the problems in Management (OODBM)

the present user interface giving rise to the

future of user interface-the OOUI.
Introduction:
Object Oriented Technology (OOT)
Object-Oriented Programming systems
(OOPS):
Object-oriented programming (OOPS) is
a programming paradigm using "objects"
– data structures consisting of data
fields and methods together with their
interactions – to design applications and
computer programs. Programming
techniques may include features such as data
abstraction, encapsulation, messaging, modu
larity, polymorphism, and inheritance. Many
modern programming languages now
support OOP.
Object Oriented Database Management
(OODBM):
An object-oriented database is
a database model in which information is
represented in the form of objects as used
in object-oriented programming. When
database capabilities are combined with
object-oriented (OO) programming language
capabilities, the result is an object-oriented
database management system (OODBMS).
Object-Oriented User Interfaces (OOUI):
In computing an object-oriented user
interface (OOUI) is a type of user
interface based on an object-oriented
programming metaphor. In an OOUI, the
user interacts explicitly with objects that
represent entities in the domain that the
application is concerned with. Many vector
drawing applications, for example, have an
OOUI - the objects being lines, circles and
canvases. The user may explicitly select an
object, alter its properties (such as size or
color), or invoke other actions upon it (such
as to move, copy, or re-align it).
What is an object?
An Object is the basis for any OO
technology. It is defined as - "An object is
anything, real or abstract, about which we
store data and those operations that
manipulate the data."
The following definition gives the
clarification of essential properties of an
object:
An object is an abstraction of set of real-
world entities or things such that:
• All of the real-world things in the set
–the instances – have the same
characteristics
• All instances are subject to and
conform the same rules
The concepts in Object approach add many
advantages to the OO system such as
increased productivity, reduced
maintenance, standardization in case of
Inheritance and improved program
reliability, ease of coding, reusability in case
of encapsulation and so on the list continues.
But the thing to be observed here is that they
add value to the system.
Let us now see what a UI is.
User Interface (UI):
User interface is the space where interaction
between humans and machines occurs. The
goal of interaction between a human and a
machine at the user interface is effective
operation and control of the machine, and
feedback from the machine which aids the
operator in making operational decisions. In
case of computing it comprises of visual and
auditory information. GUI (Graphical User
Interface) is one such interface.
Graphical User Interface (GUI)
In computing a graphical user interface is a
type of user interface that allows users to
interact with electronic devices with images
rather than text commands. GUIs can be
used in computers, hand-held devices such
as MP3 players, portable media players or
gaming devices, household appliances and
office equipment. A GUI represents the
information and actions available to a user
through graphical icons and visual indicators
such as secondary notation, as opposed to
text-based interfaces, typed command labels
or text navigation. The actions are usually
performed through direct manipulation of
the graphical elements. The GUIs familiar to
most people today are Microsoft Windows,
Mac OS X, and X Window System
interfaces.
A GUI uses a combination of technologies
and devices to provide a platform the user
can interact w with, for the tasks of
gathering and producing information. A
series of elements conforming a visual
language have evolved to represent
information stored in computers. This makes
it easier for people with few computer skills
to work with and use computer software.
The most common combination of such
elements in GUIs is the WIMP ("window,
icon, menu, and pointing device") paradigm,
especially in personal computers.
Figure 1 : WIMP example
The WIMP style of interaction uses a
physical input device to control the position
of a cursor and presents information
organized in windows and represented with
icons. Available commands are compiled
together in menus, and actions are
performed making gestures with the
pointing device. A window manager
facilitates the interactions between windows,
applications, and the windowing system.
The windowing system handles hardware
devices such as pointing devices and
graphics hardware, as well as the positioning
of the cursor.
Flaws with present GUI
GUI has more advantages than other user
interfaces like CLI-command line interface.
The explanation is too simple- a CLI can be
run in GUI as some programmers and
advanced users would want it but it’s not
possible otherwise. Furthermore, multi-
tasking is quite simple with GUI when
compared to CLI. In spite of all this there
are some limitations or flaws to GUI. Let’s
have a look at them.
Figure 2: clutter of applications and
explorer windows
Consider a normal desktop usage. While
browsing the internet for example, I open
Google chrome for Facebook, Gmail and I
can’t use chrome for any more needs
because I follow the links in the mail and fb
in the same browser making the number of
tabs to 15 to 20. I use my favorite reader to
follow the RSS feeds of my favorite sites.
Many explorer windows would be kept open
where I store my graphics, save webpages,
and music. I use an audio player to play
songs meanwhile. And this clutter goes out
of hand when I am working on a project at
the same time.
Though this problem could be minimized by
using advanced software’s to group things
like Firefox grouped tab browsing remember
that more software leads to extra allocation
of memory resource, processing power etc.
which leads to slowing down the pc.
Besides this, there are other major flaws.
Let’s consider the example of a person
documenting his work. He inserts graphics
in to his word doc for easier representation
of data, includes references from the internet
in to his doc, screenshots his application
output or stats in his app and pastes them for
reference and etc... While this seems easier
can the opposite work be equally easier??
Consider that I have a document of abstract
and I need to prepare a presentation based
on it. Can this be equally easier as when you
knew all the sources? Will he be able to
retrace all them without too much of
unnecessary process?? There’s really no
good answer
. user interacts by dragging objects round on
The fundamental problems of modern user
interfaces are:
1. They’re application based – Modern UI’s
are focused on files and applications. They
don’t recognize most projects we work on
are multi-application, and so they don’t have
a good way of dealing with our need to open
and manage multiple apps when we are
working on a project.
2. They lock data up in a file format – This
isn’t just a matter of interoperability (i.e.,
opening docx files on Linux and the like.)
This is about the fact that the modern UI
does not recognize that inside a Word
document there might be pictures, and that I
might want to extract them for some other
purpose.
3. They lack a good way to share and
version – Obviously there are exceptions,
like with most document processing
software. However, the point is that
versioning is at an application level, not an
OS (this isn’t exactly UI, but I feel like it’s
in the same basic realm.)
Object Oriented User Interface
(OOUI) - the solution
A major part of that rethinking will borrow
heavily from the realm of object oriented
programming. The OOUI has three parts-
Objects, collections, and a canvas. Their
relationship can be summed up in the
following manner; Collections are a group
of objects arranged on a canvas. Those
objects can be anything; graphs, images, text
files, audio files, web pages, whatever. The
canvas can also be very flexible, 2D, 3D,
with an image background, with predefined
object slots (i.e. days on a calendar). The
the canvas in a very natural manner, much
like Bump Top. They can open an object
and edit it more fully, or change its
configuration so that it’s bigger, a different
color, transparent, etc. This combination of a
very natural user interface, and the ability to
save entire collections, helps address the
first problem of modern UI’s.
Bump Top (an advanced application that
implements collection strategy using the
icons of the respective files) offers a good
idea of what collections in an OOUI might
be like. However an OOUI would go one
step further by allowing this type of
interaction with more than just icons, but
with the actual content (text, images, audio,
etc).
The key thing is how the computer manages
these objects. Users can save and open
collections, so that everything, down even to
the layout, is preserved. Furthermore, the
OOUI thinks of objects much like objects in
object oriented programing. Each object has
attributes, its content, its name, its current
layout, etc. Each object also has methods
that allow the user to manipulate it, such as
save, edit, move, group, play, etc.
Here’s where the OOUI begins to solve the
second problem. Just like in OOP, objects in
the OOUI come in two flavors, primitives
and complex objects. The primitives are
your basic types of content. Text files,
images, sound, video, link, application
window, database table are some examples
of primitives. Complex objects are then just
a collection of primitives, with specially
designed methods to bring them together.
For example, a programmer could construct
a graph object which had one attribute to
specify a data source, and then methods to
create various kinds of graphs (bar, pie, plot,
etc.) Then the user could use this object to
create a variety of graphs for their
collection. Most importantly, users should
be able to easily “explode” these complex
objects into their component primitives,
letting them say extract all the images from
a power point presentation to use
somewhere else.
None of the elements, objects, canvas, or
collection, bears a direct resemblance to
Microsoft Word, or PowerPoint, or any
other of the applications we’re familiar with.
So what happens to the application in an
OOUI?
To understand its best if we start by thinking
about what an application now is. At its
heart, an application is a couple of different
things.
1. First an application is a set of tools to
manipulate a certain collection of data,
called a file. This manipulation may be just
a matter of viewing, or it may involve
editing
2. Second and application is an interface that
displays the data and the tools.
What’s important is that in a traditional
application these two elements are
inseparable. The tools are directly tied to the
interface. Adobe Photoshop offers a perfect
example of this. Photoshop has a very
powerful set of tools for manipulating
images. You can color, stretch, erase, apply
filters, etc. But you can only use these tools
in Photoshop. If you copy an image into
Microsoft Word, you can’t use Adobe’s
tools anymore, not unless someone designs a
plugin specifically to allow that sort of use.
Instead you’re stuck with the rather meager
image editing tools Word offers.
In short each application is a silo, and data
has to move between applications before
you can make use of the tools that
application offers. What’s important to note,
is that often you can’t import data directly
into a secondary application, instead you
have first open it in the primary application,
and then drag and drop into a secondary one.
Figure 3 : problem with conventional GUI
To put it simply, a set of tools is tied to a
specific interface, not to a specific type of
data. As you move from interface to
interface you gain and lose functionality
The OOUI however takes the philosophy
that tools should be tied to data. You should
be able to do the same things to an image in
Word that you do in Photoshop. It’s just an
image after all. Why does it matter what
other pieces of content you’ve put it in
relation to?
This radically changes the process of
application development, basically
completely abstracting the challenge of data
manipulation from interface design.
Interesting though, this is the direction that
programming has been going for years, to
the extent where a lot of modern application
development uses one language to do
interface (some sort of markup language,
like XAML, or XUL) and one language for
functionality. In some ways the OOUI is just
the logical end point of the abstraction
between functionality and interface.
OOUI application development comes in
three parts.
1. Object Definition – First the developer
needs to write the object defections for any
complex objects the application will need or
for any additional methods that the app will
enable for primitives. For an image editing
program, this might just be a new set of
filters to change an image. For a power point
style program this might be more
complicated. You might have to right the
definition for a slide object, which is a
collection of images and text, and then a
presentation object, which is a collection of
slides.
2. Canvas Definition – Then the developer
needs to define a default of canvas designed
for viewing and manipulating their data. For
a calendar application, the canvas might be
designed so that the background displayed
the days of the month. Furthermore, the
developer might design it so that you could
only layout objects on a specific date, not
anywhere on the canvas. It’s important to
note though, that users should be able to
move data off of this canvas.
3. Control Objects – Control Objects are a
special type of object that is designed purely
to give basic user interface points. On a
music player application, this might be the
stop, start buttons. And volume control. On
other applications this might be a search
box.
To design an application the developer
writes the object definition, sets up the
canvas, and the populates it with controls.
The result is a collection with a unique
canvas and application specific controls. The
user opens this up like any other collection,
and imports objects from the file system,
either manually or using some kind of
search based control object.

Conclusion:
The OOUI stands as a solution to
problems of present GUI and also offers
many advanced features. The basic idea of
objects promotes a ‘NO COMPROMISE’
motto on both the product development and
user interface efficiency. Thus the OOUI
can be seen as the future form of OOUI.

References:
• www.stason.org
• www.ksi.cpsc.ucalgary.ca

• www.wikipedia.org
• www.developers.com