RE: Key descriptions in *Help* are too wide

[Drew Adams]

    BTW, if you do debugging with gdb, the left fringe is very
    useful as well.

I hope there is also some other, equivalent way to get the same
functionality, so users don't need to turn on fringe.

It's OK for a display feature such as fringe to provide some additional
_convenience_, that is, to provide some other feature/functionality in a
more convenient way, but it should not be the _only_ way to access that
other feature/functionality.

If that kind of design creeps in, it will progressively force users to turn
on fringe. Imagine if we did that with, say, the mouse, so that the only way
you could access some feature was by using the mouse, not the keyboard. That
kind of thing is never a good idea. Fringe, like the mouse, should remain an
inessential option; users should not require it simply to be able to use
some other feature.

An obvious exception is any feature that is somehow inherently related to
the convenience feature (fringe, mouse etc.).

    Also the indicate-buffer-boundaries variable makes good use of
    the fringes.

Here, it seems, one must turn on fringe to get such a feature - not good
design. How about also providing such a feature for people who don't have
fringe turned on?

For example, a one- or two-pixel horizontal line could be added to indicate
this. It could be solid for top and bottom of buffer and dashed for top and
bottom of window (with solid overwriting dashed when they coincide). This
display would be controlled by `indicate-buffer-boundaries', just as the
fringe indication is. Being flush against the window top and bottom, the
dashed line would hardly be a distraction, and likewise for the solid line
at buffer top. Only the solid line at buffer bottom would ever not be flush
against the window edge. Almost no screen real estate would be sacrificed
for this display, and the same functionality would be provided as the fringe
alone provides now.

Again, if buffer-boundary indication were somehow specifically, inherently
related to fringe, then that would be another story. That is not the case,
however. Someone has simply decided to implement a buffer-boundary
indication using only the fringe. That is not TRT, IMO.

I really think it is a mistake to implement things that depend on users
having fringe turned on. This should be a no-no in Emacs design philosophy.
Designers should be guided to think hard before they compromise this. I
don't suggest that it would always be easy to find a good non-fringe
equivalent, but the case of `indicate-buffer-boundaries' shows that it's not
always hard to find a reasonable alternative.