ugh.book

xxiv Preface

Date: Fri, 27 Feb 87 21:39:24 EST

From: John Rose

To: sun-users, systems

Pros and Cons of Suns

Well, I’ve got a spare minute here, because my Sun’s editor window

evaporated in front of my eyes, taking with it a day’s worth of Emacs

state.

So, the question naturally arises, what’s good and bad about Suns?

This is the fifth day I’ve used a Sun. Coincidentally, it’s also the fifth

time my Emacs has given up the ghost. So I think I’m getting a feel

for what’s good about Suns.

One neat thing about Suns is that they really boot fast. You ought to

see one boot, if you haven’t already. It’s inspiring to those of us

whose LispMs take all morning to boot.

Another nice thing about Suns is their simplicity. You know how a

LispM is always jumping into that awful, hairy debugger with the

confusing backtrace display, and expecting you to tell it how to pro-

ceed? Well, Suns ALWAYS know how to proceed. They dump a

core file and kill the offending process. What could be easier? If

there’s a window involved, it closes right up. (Did I feel a draft?)

This simplicity greatly decreases debugging time because you imme-

diately give up all hope of finding the problem, and just restart from

the beginning whatever complex task you were up to. In fact, at this

point, you can just boot. Go ahead, it’s fast!

One reason Suns boot fast is that they boot less. When a LispM loads

code into its memory, it loads a lot of debugging information too. For

example, each function records the names of its arguments and local

variables, the names of all macros expanded to produce its code, doc-

umentation strings, and sometimes an interpreted definition, just for

good measure.

Oh, each function also remembers which file it was defined in. You

have no idea how useful this is: there’s an editor command called

“meta-point” that immediately transfers you to the source of any

function, without breaking your stride. ANY function, not just one of

a special predetermined set. Likewise, there’s a key that causes the

calling sequence of a function to be displayed instantly.