Date: 24th April 1994
Subject: Do HyperTerminals Exist?
Summary: Or what do you get when you cross xterm, ksh and an OO-shell?
Synopsis: Requirement for a combined OO Shell and Terminal Emulator.
Hi,
In this letter I describe a tool that I would really like to possess.
My question to you, dear reader, is does such a wonder exist? If it
does not I challenge the programming community to implement one for
public consumption and enjoyment.
Bill
Date: 24th April 1994
Summary: Or what do you get when you cross xterm, ksh and an OO-shell?
Synopsis: Requirement for a combined OO Shell and Terminal Emulator.
You are all experts with ASCII terminals and command-line interfaces
such as the bourne shell. You are also conversant with hypertext and
object-oriented file managers. What I want is an amalgamation of all
these with a solid OO framework. A hyperTerminal session may proceed
as follows:
Imagine you are using X-windows, on your screen is an xterm-like
terminal emulator window running a shell. You type "ls" and a list of
files is printed, neatly arranged in columns. With the mouse, you
double-click on one of the filenames (foo.cc). An emacs window is
popped up open on the file. You notice that unseen hands have entered
the command "emacs foo.cc &", and the prompt has been re-printed.
Now you move the pointer over another file (bar.cc) and you
click-and-hold the mouse button. You drag the filename (which follows
the pointer) until it is over another filename (dir/). You release the
mouse button, and "bar.cc" disappears. You notice that unseen
hands have again been at work, having typed "mv bar.cc dir".
You double-click over the "dir/" text and the command "cd dir; ls" is
typed for you. Your prompt changes to show the new directory and a
directory listing is printed as before. You notice that "bar.cc"
appears among the entries.
A HyperTerminal provides all the functions of a standard xterm yet it
also understands the information it displays. HyperTerminal displays
a continuous stream views of underlying objects. It still manages to
preserve the familiar textual presentation of an ASCII terminal.
Since it is displaying views of objects, the objects can be directly
manipulated by the user with a mouse.
Commands such as "ls" are re-written or wrapped so that they output a
stream of view objects rather than a stream of characters. Hyperterm
can be programmed to understand all classes of objects ranging from
fragments of a text file, through to a UNIX process.
Users can browse the object classes with a graphical browser,
re-structuring inheritance relationships and defining shell scripts to
be executed for each method the object class supports.
Here are some of the things that a HyperTerminal could do:
* Fragments of ASCII files output by commands like "head", "grep" or
"cat" can be edited by positioning the cursor over the text, and
inserting or overtyping characters. The changes are committed to the
files.
* Directories displayed with "ls -l" can be modified by positioning
the cursor over the relevant attributes and over-typing. Filenames,
permissions and dates can be modified by altering the corresponding
part of the output.
* Files can be moved between directories by drag-and-drop.
* File links can be established by drag&drop with the shift key held.
* Files can be deleted by selecting of a filename followed by hitting
the delete key. a confirmation dialogue may appear depending upon
options.
* Programs such as compilers output references to fragments of ASCII
files. Double-clicking on an error message opens an editor on the
relevant file, positioned at the line in question. HyperTerminal
keyboard focus enables you so step between error messages with the
cursor keys.
* Job control and process management is simplified. For example,
selecting processes displayed with the "ps" command allows you to
kill the process with the delete key.
* Non-wrapped commands output straight text which HyperTerminal
treats identically to the ASCII terminal it emulates.
By now the general character of HyperTerminal is becoming clearer. It
allows you to use all the power of the scripted interface (and all
those familiar commands) yet providing object-oriented direct
manipulation of the results of those commands.
Because HyperTerminal belongs to that large family of windows-based
programs, it comes with the usual framework which includes:
* Pull-down menus from a menu-bar. These allow you to call up generic
methods shared by almost all objects. Some of the standard ones might be:
File
New...
Open
Copy
Move
Delete
Print...
Properties...
Run
Save // saves the current session a la "script"
Edit
Cut
Copy
Paste
Options
Display
Class Browser
...
Window
Help
* The right mouse button would support a pop-up menu showing all the
actual methods supported by the selected object(s)
* Selection of many objects via the shift key, polymorphic method
execution over the selected objects.
* HyperTerminal would also provide users with many presentation
options for each class including: font, text style, colour and use of
icons. For example executable files might always be displayed in Red.
* Because HyperTerminal is pretending to be an ASCII terminal on X,
it could also be induced to display graphical representations of
objects. Thus icons could be used to display files in the output of an
"ls" command; tick boxes might replace permission switches.
HyperTerminal is extensible allowing users to add object classes and
methods of those classes. It supports inheritance and polymorphism,
and maybe multiple inheritance. To make this easy, it comes with
a graphical class browser.
Since HyperTerminal continues to know about the under-lying objects
it is displaying, it could update the display to reflect the execution
of subsequent commands or change to show the state of the objects.
For example, deleting a file may cause it's entry in previous "ls"
output to change into passive, black text.
Despite offering more functions than xterm, it would not consume much
more than "xterm" and "sh" combined. (The class browser would probably
be a separate process.) It would be fast and efficient, allowing users
to run dozens of HyperTerminal windows.
The source code of Hypterterminal would ideally be freely available
along with ports to most UNIX systems.
Hyperterminal would probably continue with the UNIX style of working
by interpreting a stream of characters on its standard input. A clever
arrangement of escape sequences would delimit the objects it displays
along with their class and identity. The sequences would be published
thus allowing users to write programs that output object views into
Hyperterminal.
Ok so you have read my cursory description of the mythical
Hyperterminal. I hope it was reasonably clear :-). My questions are:
Does such an animal exist?
Would anybody else like one?
If there is one where is it, and how can I get one?
If there is nothing like Hyperterminal, I re-iterate my challenge to
the programming community, please, write one!
Bill Birch, Thursday, March 04, 1999
