there are many additional commands specific to programming languages,
especially Lisp. It's customizable (you can change key bindings and set
various parameters) and extensible (you can write your own commands,
using the underlying "Zwei" primitives). It uses windows for many
things, and there are many commands that involve the mouse, although you
can avoid the mouse if you want to. It's completely written in Lisp and
lives in the Lisp address space. The editor is incorporated into other
parts of the programming environment, such as the mail reader.
(It doesn't have a name.) There is a resident debugger. It
has two user interfaces, one of which uses a multi-paned window frame,
and one of which does not. However, even using the latter interface,
the mouse can be used for many useful commands, such as selecting the
current stack frame out of a backtrace, and pointing at objects to be
described or evaluated, or selecting proceed options. It's tied into
the editor so that a single keystroke can position you at the source
code of the function at a stack frame. (Since you asked, it cannot
position you at the exact point of the error within the source code; we
almost got this working for 7.0, but not quite.) You can set traps on
exits from particular frames, or on references to particular locations.
You can set breakpoints within functions, by pointing with the mouse.
You can return from or restart any stack frame. Errors can have various
proceed types, and programs can set up restart handlers, and errors can
have associated special commands, all of which are offered to the user.
Error messages are written in clear English. You can see the names and
values of all arguments and local variables. There is extensive on-line
help. Commands can be given either with English-like command names
(such as Next Frame) or one-or-two character commands (such as c-N), or
with the mouse. If you type a Lisp form to the debugger, it is
evaluated in the lexical and dynamic environment of the current frame.
Large Program Management:
There is the "System Construction Tool"
(a.k.a. "defsystem" but completely reimplemented for 7.0, mainly to be
easier to use and understand), which is roughly like the Unix "make"
command: it groups many files that constitute a program, and shows their
dependencies on each other, so that they'll be loaded and compiled in
the proper order. SCT also maintains numbered versions of systems,
keeping track of the versions of each file that were used to make the
system, and particular versions can be designated as "Released" or what
have you. Closely related is the patch system, which lets a developer
install a small patch to an installed system, and lets users load in the
patches quickly and conveniently. SCT also drives the distribution tape
generator, which makes tapes suitable for distributing software to other
sites. The "logical pathname" feature makes it possible for different
sites to use different operating systems to store software, without
modifying the software (this is a very brief description!). In
addition, there are several tools for cross-referencing large programs,
most accessed via Zmacs, such as "List Cal1ers" which finds all callers
of a given function. There is also an elaborate electronic mail system
which we find indispensible for groups of people working on a single
There is a Lisp data structure Inspector, which lets you look
inside Lisp objects and examine and modify their components. It uses a
multi-paned window frame and is primarily used via the mouse. In 7.0,
you can use the mouse on most ordinary Lisp typeout, and clicking the
middle button generally means "describe", so much of the functionality
of the inspector can also be had from an ordinary Lisp Listner window,
including the non-windowish interface to the debugger.