Typing Ada

[munck@MITRE-BEDFORD.ARPA (Bob Munck)]

It has occurred to me recently that one of the most primitive,
labor-intensive operations in our current Ada technology is the
actual entry of code by programmers.  For example, it appears that
most programmers type an IF .. THEN statement by pressing SHIFT and
typing "I" and "F", releasing SHIFT and typing SPACE, the boolean,
and SPACE, pressing SHIFT and typing "T", "H", "E", and "N", etc. 
They type lots of tabs and spaces to indent the code, take at least
three keystrokes for an assignment, have to type closing quotes,
right parenthesis, and right brackets, have to type the package or
procedure name a second time after the END, etc. etc.

I'd like to think that most programmers are using some kind of
Ada-aware editor, but I fear it isn't so.  I'd appreciate an e-mail
note describing what you do and what other programmers in your
company/institution do.  (People who read Ada-Info are apt to be an
unrepresentative sample.)

However, the simple Ada-aware editor is only a beginning.  Editors
could do line-wrapping and spelling checking on comments as they're
typed, they could let you use a mouse to re-arrange code, and they
could display it with keywords in bold and comments in italic fonts. 
They could allow abbreviation of identifiers and expand them as
they're typed, fill in the rest of an identifier when you've typed
enough for a unique selection, or let you pick names from the
declarations with the mouse.

At the next level of sophistication, an editor could contain a lot
of the compiler and use information from the current compilation
unit and the Ada library to help the programmer.  This is a fairly
obvious approach that several systems already incorporate, sometimes
without doing the simpler things mentioned above.

I first saw an outline processor about twenty years ago, Doug
Englebart's fantastic system with the mouse and chord keyboard. 
Currently I use a commercial product named "ThinkTank" and it
frustrates the dickens out of me not to be able to do similar things
when writing code.  "Outliner-like" facilities would be great for
those who must maintain and update the code, also.

My current work is "operating system-type" code which, by its
nature, consists mostly of assignment statements, conditionals, and
complex data and code structures.  I've found it useful to maintain
a drawing of the complete data structure using a CAD tool and to
write a tool that extracts a picture of the code structure to the
procedure level from the listings.  I keep both of these up-to-date
and tacked to the wall in front of me.  The point is, it would be
wonderfully convenient if these two pictures could be in windows on
the screen and allow me to pick names from them with the mouse. 
Given that I can request statement skeletons by hitting function
keys with the left hand, I'd rarely have to move my hands to the
keyboard.  Of course, it would be great to be able to update the two
pictures and have the changes propagate into the code.

Is anyone out there doing research into this kind of thing?  I've
about reached the limit of macros for my emacs-like editor (Final
Word).
                         -- Bob Munck, MITRE