A Voyage of Discovery

A web site is designed to enable interaction with the end user.  Interaction styles refer to all the different ways in which technology enables the user communicate with the system. Historically, it all began with the text terminal.  Commands were entered as lines of text and the output was a text.  With increasing use of CRTs and other output devices graphical user interfaces gained importance.  The Microsoft Windows, Mac OS and the X Windows system have gained popularity.  A logical development that happened was the object oriented approach to web design that was driven by a need to view all elements of interface design as objects that can be manipulated and optimized.  In this chapter we shall be focusing on the different aspects of web Interface design and gain a general understanding of the development of concepts relating to positioning of elements on the web page and web site. 

Command Line Interfaces:

A Command Line Interface(CLI) is a text tool that is used to command the computer perform some operations and provide the end user with desired outputs.  The output that is obtained is also text.  The concept of CLI originated from the teletype machine and represented an advance from the punch card system.  Even today a number of users prefer to CLIs which provide an environment with increased productivity such as embedded systems and other network devices.  Programmers and Systems Administrators (especially those who use Unix based operating systems) and scientists and engineers prefer the CLI to the Graphical User Interface (GUI) as they deal more with text rather than graphics.  Persons with visual disability also prefer CLI.

The core of the CLI is the command line interpreter or shell. The command prompt is an example of a Shell.  Microsoft is working on a WindowsPowerShell code named MONAD.  This combines the traditional Unix shell with object oriented .NET framework.

The CLI is composed of syntax and semantics.  The syntax forms the grammar of the commands that are given to the operating system.  Unix and MS-DOS have their own unique syntax.  Embedded systems such as Nortel, Juniper Networks or Cisco have their own peculiar syntax and rules.  These rules are intended to guide the user navigate through the system of commands.

The semantics of the CLI refer to the types of operations that can be performed using the CLI.

The user sees a command prompt and he is expected to type his command on the prompt.  The command is usually terminated with an enter key.  A textual output is generated when the command is executed. 

Command lines are self documenting and set forth exactly what the user wants done.  Lengthy commands can be saved with alias. These stored commands are called command procedures and calling the procedure will result in the execution of the command.

Navigation is another important aspect of the Command line interface.  The user may have to specify the relative and absolute paths to command and data in some CLI, while others may require him specify the hierarchy and the options available within the hierarchy while issuing his commands referred to as mode. Most CLIs have two types of modes—System and Interface.  Systems commands cannot be issued from within the interface mode and vice versa.

CLI vs GUI

Die hard graphical user interface fans would probably point out the CLI is not relevant anymore.  However, they forget that graphics and command lines are orthogonal.  Text user interfaces and graphic application like CAD still use the CLI.  It is true that GUI interfaces are visual and simple to learn, but CLI is a powerful tool in the hands of the learned. Moreover, behind every GUI, the command line is at work!

The argument that is often advanced against CLI is that a lot of commands have to be memorized or looked up in the manual.  The lay user would be disadvantaged in the process.  GUI on the other hand can be tailored to require almost no command line skills from the user.  He gets what he sees on the screen. All commands can be attractively packaged into menus, toolbars, dialogs and other graphical means.

CLI users would point out that large graphical interface applications are cumbersome and often require consultation with the manual.  They are resource intensive and limit the interaction of the user with the system.  Repetitive tasks which can be achieved using loops in CLI will have to be done manually by clicking through a number of screens.  A single script cannot be written to execute the tasks automatically.

While both have their advantages and disadvantages, it is important to understand that both have a significant place in the different kinds of operating systems and platforms that we work with today.

Command line interfaces are not all used by experts alone.  Non expert users can also interact with the application in multitude of ways.  Forms created using CLI are typical examples of such interfaces approximating to GUIs, that can be used by non expert users.  Menus and direct manipulation of objects on screen are also part of CLI application interfaces.

CLI also approaches the object oriented approach when it uses abstract and default CommandListener classes, 118N/L10N Support, POSIX style support; joined option support and so on. The above features make the library easy to use and helps encapsulate the operations of individual options.  The code also becomes easier to write, debug and maintain.

The future of CLI appears to be very interesting.  The past –the MSDOS—continues to be a part of the Windows application and the future is here as Windows Vista tries to integrate it with its operating system to empower its power users!  Voice command Interfaces for the blind, artificial intelligence programs, and countless other CLI based interfaces are being used for a variety of purposes. However, these interfaces are increasingly becoming the domain of the scientist and the administrator.   The common man prefers to use the Graphical User Interface, which delivers exactly what he sees! 

The Graphical User Interface

Most users are top-level users.  They want to give high-level commands to the computer and wait for it to process the command at the backend without bothering their heads about how the command gets executed in the guts of the machine.  GUI, despite its several drawbacks, is easier to learn and simpler to understand.   

The GUI interface takes advantage of computer graphics and displays images that approximate to real life functional expectations from objects.  For instance a button is to be clicked, pages can be picked up and dropped into folders; all papers are to be stored in categories and so on.  The cut, copy and paste function that has become part of the GUI has revolutionized computing for the common man.  He can share data and images across applications working on a common platform.  The objects continue to be visible to the user and can be manipulated by him without remembering a large amount of syntax or typing in lengthy commands. All commands are encapsulated and the actions performed by the end user tell the computer which commands to execute. 

The predecessor to the GUI was the PUI or PARC User Interface.  Stanford Research Institute invented this interface and its primary contribution was the creation of text-based hyperlinks.  GUI later extended this to graphics. The widgets library invented by the PUI consisting of windows, menus, radio buttons, checkboxes and icons were adopted by GUI.  The pointing device and the keyboard were contributions of PUI.  

The GUI that is familiar to most users of Windows and Mac OS originated in Xerox Palo Alto research laboratory in the late 1970’s.  This interface was designed for the Applie computer and many of its features were adopted by Microsoft for the Windows operating system. 

Today, GUI is an important aspect of application programming.  The visible graphical interface enables the precise alignment and positioning of elements on the screen. The visible elements are known as Chrome and can be customized by the user by selecting different skins for the elements.  More recent interfaces allow the user to select the very elements he wants to make visible on the screen and to hide those he does not wish to have on his screen! 

GUI Interaction design is fundamental to any web design. Visually apparent interfaces are intrinsically forgiving and instill in their users a sense of control over the elements of the page.  It reveals at once the span of control, visually communicates the process of interaction and directs them in the execution of their tasks. The inner workings of the system is masked and work is unobtrusively and continuously saved so that the user is in a position to undo any work that he finds has been wrongly done.  In other words applications must work untiringly at the backend while requiring the user to input minimum information at the front end or the web page. 

GUI interfaces are designed to anticipate the user needs and to provide the user with all the tools needed for the interactive process. While “look and feel” of the page will provide the user with a sense of consistency, the status mechanisms can be used to keep the user informed while interaction causes changes in the condition of the page. This information can be communicated by changing the color of the text or the color of the page or the wait cursor or actual text at the status bar. 

The GUI was a natural reaction to the extended learning curve demanded by the Command line interface.

Modern operating systems provide both GUI and CLI interfaces, but end users prefer the former to the latter and are most often unaware that there is a CLI inbuilt into the OS. The GUI is popular for the following reasons: 

• Continuous visibility of objects of interest. For example, an object stays where it is until the operator moves it.
• Rapid, incremental reversible operations whose impact is immediately visible.
• Pointing, selecting and dragging techniques have replaced the need to type complex syntax, such as command lines like MS-DOS or shell interfaces.

The cross platform support promised by the GUI, however, is riddled with inconsistencies in the way in which different features can be implemented on different platforms.  Color usage is a major area of concern in this context. We will be dealing with the differences in a little more detail when we begin to discuss browsers and cross platform support for browsers.

Current research on user interfaces are focused on creating a zooming interface that blends 3D movement with 2D or 2 ½  D vectorial objects.  Application specific GUIs are also being designed to satisfy the requirements of vertical markets and are known as “application specific GUIs” such as the touch-screen software.   

Another important direction of development is the emergence of the object-oriented interface. Object oriented interfaces implement a system of objects that interact or are interrelated, non-nested objects.  The functions that are implemented when the classes are implemented are hidden from the user.  These interfaces provide greater flexibility and manipulative capability to the application designer.

Object Oriented Interfaces: 

Object oriented interfaces use objects as tangible and conceptual things that have definite attributes and expose specific methods.  The purpose is to break down the interface into modular, reusable chunks called classes.  The classes then act as blue prints for creating instances of the objects and implementing methods encapsulated in these objects.  This results in robust, reusable parts in the interface that can be removed and changed without impacting other parts of the interface.  The whole becomes easy to maintain and flexible in deployment.    

Object oriented interfaces are defined as a contract between a class and the user.  The implementation of the class implements the methods that it exposes and promises the user certain functionalities from the interface.  This contract is enforced at compile time. 

Object oriented interfaces provide the end user with easy to use applications and flexible services. Objects have attributes and methods and perform or enable the performance of some specific functions.  They have a state, which is internal to the object and visible to the end user.  An object can be static or dynamic.  Instances of objects are created out of the object and inherit all the features of the object or form a class of its own.  The latter types are called metaclasses.  Parameterized classes are templates for a class.  A non-class instance is an instance of a class without being a class in itself. Aggregate objects and monolithic objects can be created to deliver specific functionalities.  However, the details are beyond the purview of this book and hence are only touched upon and not elaborated. 

Both PHP and ASP.NET offer OOP paradigms to application development and support OOP concepts.  However, while PHP supports partial encapsulation and polymorphism ASP.NET offers a robust OOP scripting paradigm. ASP.NET is build on a framework called Common language runtime and offers an extensive series of well-organized class libraries that have inbuilt functionalities that enable easy creation of components for the web page. ASP.NET 2.0 takes the whole conceptualization a step further and allows users to drag and drop objects on the web page along with all the functionalities that come with the object! Master pages, personalization of pages, themes for pages and so on become possibilities in this object oriented world of ASP.NET 2.0!  Cross platform implementation is no longer a distant dream.