Dealers of Lightning (36 page)

What
had changed by mid-1972
was
their recognition
of how
quickly memory and computing power
were
sliding
down the cost
curve. "It
was only when we realized
that
memory
would get really
cheap, when we understood Moore's
Law
and internalized it,"
recalled Thacker, "that it became clear that this is what
Bob
had
been
saying all along. All of a sudden it was perfectly sensible to build a
computer that used two-thirds of its processor cycles
and three-
fourths of its memory to run the display. From then on it
was
all
downhill.
The
engineering was easy. But getting that basic idea
required
understanding that eventually you'd have so much
power
in
a machine that running the display wouldn't require anywhere near
two-thirds
of it."

Thacker still had to solve numerous problems in designing a service­able personal computer that would be fast and compact without sacri­ficing versatility and power, and that would also have a display clear,
sharp, and nimble enough to keep up with the processor without driv­ing the user blind. In the end he found the crucial answers inside
PARC itself.

His first inspiration was the concept of "microparallel processing." The
basic idea came from a singular aspect of MAXC s operation—what Ed
McCreight had described as "hijacking" the central processing unit.
Thanks to a common bottleneck in computer architectures, the proces­sor, or brain, of a typical machine shared access to the computers main
memory with all the machine's peripheral devices. Because only one
device could be serviced at a time, the processor was often left idle
while some other component temporarily monopolized the memory.
"While the disk was accessing the memory, for instance," Thacker said,
"the processor essentially stopped because it was waiting its turn."

Thacker's inspiration was to shift the bottleneck from the memory to the
processor itself. In his design, only the CPU, which after all was the most
important component of the machine, would be permitted to address the
main memory at any time. The CPU would take over the computing func­tions of all the peripherals—disk drive, keyboard, and display—deciding
on its own when they needed servicing and for how long.

Thacker reasoned that if each of the computer's routine tasks could
somehow be ranked by urgency and funneled through the processor in
appropriate order, he could keep the processor occupied almost full­time. If the ranking was correct, every task would be handled when it
needed to be, no sooner and no later. Low-priority tasks could be
interrupted for brief periods to make way for more urgent ones, then
resumed later, when nothing more pressing was in the way. The gain in
efficiency, speed, and hardware was potentially huge. Whole circuit
boards that served as the ancillary brains of disk drives and other units
could be dispensed with. The Alto's CPU would be drafted into doing
the thinking for all of them.

Thacker's second crucial inspiration involved the question of how to
power a high-performance display without busting the budget on
memory. This was not trivial: He understood that the quality of the dis­play would make or break his new computer.

Up until then, computer designers wishing to provide an interactive
display faced two equally unappetizing choices: They could give the
display little memory support, which
led
to flickering and slow perfor­mance, or they could provide backup memory through a character
generator, which meant burdening the
system
with another and bug-
prone peripheral the size of a washing
machine.

Thacker struggled at length with
the riddle
of how to direct a suit­able volume of information to the
screen
without adding excess hard­ware. The answer came to him one
day
while he was watching a
demonstration of one of Kay's graphics programs in the Systems Sci­ence
Lab.

The
demo utilized a character generator designed by a former
Engel­bart
engineer named Roger Bates (with
Lampson's
assistance). This unit,
which
had thousands of dollars' worth
of
memory inside, was a distant
relative of the one Ron Rider would later build for the
SLOT. It
was
designed to store custom fonts by allowing each character
to
occupy a
small rectangular patch of memory until summoned to the screen.
Most
of the
PARC
engineers considered it a disappointment, largely because
the designers' ambition to reproduce book-quality pages on the
POLOS
screen turned out to be a tougher programming challenge than they
anticipated.

Kays
group was an exception. Bored with the idea of painting text on
the screen but fascinated with the possibility of displaying images, they
had appropriated the system
—
"perverted it," in Lampson's unpejora-
tive
phrase
—
to use for their graphics and animation programs
by
load­ing its memory not with print characters, but graphical designs.
The
result was a rudimentary black-and-white "bitmap"—a block of mem­ory in which each bit corresponded to a dot on a display screen.
Flip
a
given
memory bit "on" and the corresponding dot lit up on the display;
turn
on these bits in a given pattern and you could map the same
image to the screen.

As
Lampson explained, "In the normal deal there would be a little
bitmap for the character
'A'
in the font memory and a bitmap
for 'B'
and
'C'
and so on, and then the character memory would say display
an A,'
an
'h,' and an 'a,' and aha, you have 'Aha.' Alan said, 'We'll have a whole
bunch of artificial characters numbered 1 through 500, and the character
memory will say display 1, then 2, then 3.' The result was
to
take the font
memory and turn it into a bitmap"—that is, well before the lab had the
resources to build a full-scale bitmap.

Kay's group had only begun to investigate the potential of this new
way of displaying information (although they had done enough to help
persuade Thacker and Lampson of the need to equip the Alto with a
high-resolution display). Among their first simple programs was one
that could embed "icons," or thumbnail-sized pictures, within blocks
of text. Another was a painting system in which users wielded square
"brushes" up to four pixels wide to draw or erase lines and curves on
the screen.

Impressed as he was by these applications, Thacker was struck more by
the underlying principle by which Kay's system used the memory blocks.
He realized that just as Kay's team had turned the character generator
into a simple bitmap, he could convert idle blocks of the Alto's main
memory into a bitmap for the display screen. Forcing the memory to per­form this double duty would eliminate the need for a separate character
generator. This required cutting a few corners, because the display would
now have to compete with all of the machine's other functions for mem­ory blocks. When the Alto placed a text document on its screen, for exam­ple, it would economize by omitting from the bitmap any part of the page
that lacked text, such as the white spaces between lines and at all four
margins. Also, whenever there were competing demands for memory
from data and display, the display lost. Users had to be alerted to expect
a strange phenomenon: During a work session the image of the docu­ment they were writing or editing would gradually shrink, like a window
shade rolling up from the bottom. The reason was that as the increasing
volume and complexity of the data claimed more memory, less remained
for the bitmap. The same phenomenon accounted for what happened
whenever the Alto displayed a full-screen graphical image. On those
occasions it tended to run agonizingly slowly, in part because so many
processor cycles were consumed in painting the screen, but also because
the display consumed so much memory there was barely enough left to
keep the program percolating along.

Without this sort of artfulness the Alto display would not have been
possible at all. Even within its limits it made severe demands on the
machine; its resolution of 606 by
808 pixels
meant that nearly a half-
million bits needed to be refreshed
thirty
times per second.
(Kay
envisioned
a one-million-pixel display
for his
Dynabook,
but had to
be
satisfied with what he got.)

Once
it was running, however, it made
believers
out of skeptics.
Not
the
least important of these was Jerry
Elkind.

Elkind
had returned to
PARC
from
his task
force assignment in the
late fall.
Already uneasy at the necessity
of
reasserting his authority fol­lowing a nearly six-month absence, he
was even
more
put
out to find
that
a full-scale skunk works had been
launched
behind his back to
pursue
a project whose value he questioned.