understand Solaris; and Steve, you developed adb because
it was a technology that you needed to understand your
SB Exactly. It’s rather similar to Eric’s experience in that
the debuggers that existed at the time interpreted the
information a little more than I was comfortable with.
That was why I wrote adb—ju st so I knew that what I saw
was what I got.
BC Can you elaborate on that?
SB First of all, I couldn’t find the answers to my questions, because only a limited window of information was
coming out of the debugger at the time. DB was the
early debugger in Unix,
and that was fairly simple
but had a bunch of things
missing. Also, we were
moving to the separate I&D
space on the PDP, so there
were changes in the system
environment that needed
to be reflected in the debugger, and capabilities in the
a.out files that were being
changed that weren’t being
reflected in the debugger.
It wasn’t so much that
the debugger was broken
when it was written; it’s
that it wasn’t keeping track
of the changes in the system environment that we
BC Sounds like bit rot.
SB Yes, it was bit rot. Actually, at the time, I had written an Algol 68 compiler that
I was porting to the PDP- 11 and I wanted to have stuff in
there to interpret the Algol 68 stack trace.
BC This is the famous “$a”?
SB This is the $a, exactly.
BC I discovered $a when I attempted to write $q while
using adb at Sun in 1996. I typed $a by accident and
Steve Bourne, like an apparition from the past, whispered
to me, “No Algol 68 here,” which is the message you get
out of adb when you type $a.
I was flabbergasted! Suddenly, the deepest heart of the
system was speaking directly to me. No Algol 68 here?
There hadn’t been Algol 68 in Solaris ever, and so needless to say, $a has become something of legend. I believe
Steve knows, but I’ll let folks discover it for themselves,
in mdb we have implemented $a. In adb compatibility
mode it gives you the message, “No Algol 68 here.” Mdb
gives you its own smarmy message on $a.
One more question: What was the moment when you
knew that the investment in the tools you developed paid
EA Probably almost instantly. Syslog was one of those
things where it was just so obvious from the start that it
was going to be valuable. It wasn’t something where you
go, “Well, I’ll just build this little tool,” and then three
months later you say, “Oh, wow, I’m glad I wrote that
tool.” I was trying to debug
things that were basically
SB I don’t remember a
particular event, but I
knew fairly early on that
you couldn’t use the other
debuggers to do what
we were doing, so it was
almost like there wasn’t
another choice at the time.
It wasn’t until many years
later that an ACM Fellow,
whose name I’ll omit, said,
“Adb is really cool. It just
does what it does, and
EA I have another example, which is slightly different. I wrote a front end
for the SCCS (source code
control system) at Berkeley. I had written a source
management system while
I was in high school that did tape-to-tape stuff on the
IBM 1401, so I was actually an early adopter of that sort
of stuff. Back then people weren’t keeping change sets.
You couldn’t do deltas, you couldn’t see your history. So I
wrote this front end primarily for myself, but I was able to
convince Bill Joy et al. that they should use it on Berkeley
Unix. When we finally got to the point where we were
saying, “OK, everything in the system is actually going to
be under source management,” that was a real “Finally...
and I had something to do with that” kind of moment. Q
LOVE IT, HATE IT? LET US KNOW
firstname.lastname@example.org or www.acmqueue.com/forums
© 2008 ACM 1542-7730/08/0700 $5.00