March 93 - THE VETERAN NEOPHYTE
THE VETERAN NEOPHYTE
TOWER OF BABBLE
I recently started learning MacApp. (I know, I know, I can see you shaking your great shaggy
collective head, chuckling to yourself, asking where I was three years ago when MacApp was still
news. Let's just say I'm a late bloomer.) People weren't kidding when they said that the learning
curve is long and steep. They also weren't kidding when they said that it's absolutely worth it.
For me, it was a double whammy: learning MacApp and transitioning from THINK C to MPW.
(See, if I'd only learned it in the MacApp 2.0 days I could have used THINK Pascal, but noooo, I
had to wait till
now.) I've been using THINK C for virtually all my programming since 1986 or so. Using MPW for
my own little exploratory projects would be like calling in a highly trained, ultramodern, rapid-
deployment mobile emergency medical team to remove a splinter from my thumb. The job would
get done, and beautifully, but it'd be an absolutely colossal waste of time, effort, and expense.
Frankly, I'd rather just have a good pair of tweezers.
But alas, if I want to use MacApp (and I do!) the days of coding on my PowerBook 100 in the
backyard with loyal hounds lolling at my feet are gone for good. Now I need 16 MB of RAM
minimum and atleast40 MB of hard disk space (120 to be really comfortable). And I'm not even
going to mentionMacApp compile times; it hurts me too much.
But all that's really just logistics and can be gotten used to pretty quickly. The real difference is in the
very nature of my interaction with the machine: It used to be that when I'd think of something that
needed doing, I'd just go do it. It was like building a machine from scratch, piece by handcrafted
piece. Now, using MacApp, when I think of something that needs doing I conduct massive, cross-
referenced searches through megabytes of source code to figure out where it's already been done,
because no doubt somebody already thought of it, or something very much like it, and implemented
it better than I ever could. It's as though I'm running around on top of a giant, humming machine
that stretches to the horizon on all sides, hunting for just the right place to reach down into the dark
recesses, pull up a live, vibrating cable, and splice in my little special-purpose unit. Often I've spent
an hour hunting around for the right place to insert some code, only to discover that to do what I
want I just need to set the value of some out-of-the-way Boolean deep inside an object's remote
Well, I could ramble forever about my learning experiences, but those of you who've been there
know all about it, and those of you who haven't probably don't want to hear it. But this is the first
time since I discovered the Macintosh and switched from FORTH to C that thefeelof programming
has been completely transformed for me. It occurred to me that the fact that programming is the
kind of thing that canhave a feeling to it is noteworthy. Programming computers is an activity
unlike any other. It's a human-machine interaction, but
because the machine is very special, interacting with it is also very special. Programming has a depth
that other machine interactions don't, so it can assume qualities not normally associated with the
operation of machinery. It can be a creative act, akin to building an intricate, glittering crystal
clockwork out of gossamer strands of pure thought; and it can also be formidable drudgery, a
mountain of mind-numbing details, endless in their intricacy, interrelatedness, and total irrelevance
to the real task at hand. These are not normally the kinds of things you'd say about operating your
dishwasher or toilet.
Computers are something truly new on earth. They're machines that can simulate any other
machine; they're somehow potentiallyeverymachine in one. A well-known computer luminary put it
It [the computer] is a medium that can dynamically simulate the details of any other medium, including
media that cannot exist physically. It is not a tool, although it can act like many tools. It is the first
metamedium, and as such it has degrees of freedom
for representation and expression never before encountered and as yet barely investigated. -- Alan Kay, "Computer Software,"Scientific
American, September 1984.
Other machines are physical extensions of ourselves; they let us sense and manipulate our physical
world with more power and flexibility than we can by ourselves. But they're justphysicalextensions.
Computers, though, manipulate and embody abstractions and symbols; they operate on patterns
of electrical activity, on imagination, on mindstuff.
If you can imagine a machine or a medium in detail, you can program a computer to simulate it. So
programming computers is much, much more than telling them what to do -- it's telling them what
Of course, all this philosophical and poetic mumbo-jumbo crashes to the ground when faced with
reality. Try telling my friend Michele -- who wrote an entire book on her Macintosh SE and just
recently realized that she can use Standard File dialogs to navigate her hard disk -- that her
computer "has degrees of freedom for representation and expression never before encountered."
Yeah, right. Admittedly, the computer is much more fluid-seeming to programmers than to users
(someday, hopefully, a moot distinction), but there's still a large discrepancy between the promise
and the realization. Computers still feel more like erector sets -- lots of hard, inflexible little parts --
than like clay.
Boiled down to its thick, syrupy essentials, computer programming is quite simply the creation and
communication of detailed instructions. The creation is the really exciting part, and is (or should be)
the main task. But the communication is what really defines the experience of programming; it's the
part that has afeelto it.
All this touchy-feely talk smacks of natural language. Are programming languages really just another
class of natural languages? Is that why programming can feel so rich? I found a great book that
addressed this very question (among others):The Cognitive Connectionby Howard Levine and Howard
Programming languages and natural languages do indeed have deep similarities, and share essential
features found in any language. They're both sets of abstract symbols that have meaning only by
mutual agreement between communicating parties. They're both open-ended: they have an
underlying structure and system of rules that allow an infinite variety of correct sentences to be
constructed. (Even more remarkably, any correct sentence can later be deciphered by anyone who
knows the language, even though they've never seen that sentence before.)
Linguists say that a language has three parts: phonology, syntax, and semantics. Phonology is the way
a language is turned into sounds, and is irrelevant to programming languages since they're never
spoken. Syntax is the set of rules that specify how the parts of the language -- words and phrases --
are put together to form sentences. Programming languages obviously have strict and unforgivingsyntax. But syntax by itself is an empty shell, telling us only whether a sentence is well formed, not
what it means. That's the function of semantics.
Ah, sweet semantics! This is where the rubber meets the road, linguistically speaking, and where
significant differences between natural languages and programming languages begin to appear.
and Howard illustrate one big semantic difference between natural languages and programming
languages by comparing their dictionaries. (Dictionaries are, in a sense, the embodiment of a
Natural language dictionaries are written in natural languages, so the language must be rich and
flexible enough to describe itself. When you look up an English word in Webster's, you get a
definition written in English. This is only possible because words in natural languages can have more
than one meaning.
Programming language dictionaries, on the other hand, are never written in a programming
language. When you look up the definition of a Pascal word, the description is written in English (or
Portuguese or Swahili or whatever), not Pascal or C++ or LISP. Unfortunately, the duplicity of
meaning that allows a natural language to describe itself opens the door to paradox and self-
contradiction, something programming languages can't tolerate.
But there's another, even more apparent semantic difference between programming languages and
natural languages. As the Howards so aptly put it:
. . . although philosophers and linguists have struggled for centuries to give precise meaning to the word
"meaning," you don't need a degree in either discipline to realize that what constitutes meaning for a
programming language is dramatically different from what constitutes meaning for a natural language.
Semantically, programming languages are only a sort of horribly stunted subset of natural languages,
because the world they describe -- the operations of computers -- is only a sort of horribly stunted
subset of the natural world. So "conversations" in a programming language aren't conversations at
all; they're one-sided and one-dimensional commands whose conversational interest is on a par with
the instructions on the back of a shampoo bottle: Lather, rinse, repeat.
We are, of course, in the infancy of our relationship with computers, still drooling and babbling
experimentally most of the time. Look at MacApp: compared to other available methods of
programming the Macintosh, it's astoundingly elegant and streamlined, but even MacApp's most
vocal devotees don't want to stop there. Far from being the end product of the evolution of
programming, MacApp is only one of the first teetering steps toward more natural and more fluent
communication with computers.
A big question is whether our interactions with computers willever be totally fluent, where fluency
means the complete subsumption of syntax, so that we can go directly from meaning to expression
with no conscious effort. Some people insist it will happen, that there's a future of instant, effortless
communication with computers, a wide and crystal clear pathway between us and them, but somehow
I can't buy it.
I suspect that instead, computer communication will just get more and more like natural
Fraught with misunderstanding and misinterpretation, blocked by its implicit awkwardnesses and
incompleteness, human language is nevertheless rich beyond depth. Its infinite flexibility allows it to
carry and contain the full spectrum of human thought and feeling, and provides a ground for endless
creativity. Indeed, there is an intense joy to using language --anylanguage -- well. If we get only
half as far with our computers as we have with our words, we'll have come a very long way indeed.
- The Cognitive Connection by Howard Levine and Howard Rheingold (Prentice-Hall Press, 1987).
- Scientific American, September 1984.
- The Happy Birthday Present by Joan Heilbroner, pictures by Mary Chalmers (Harper & Row, 1962).
DAVE JOHNSON recently bought some Crash Dummies and peripheral equipment. These are little "action figures,"
modeled after real crash dummies, that fly apart in various ways upon impact. You can buy a car to crash them in, crash
dummy pets (named Bumper and Hubcat), crash dummy babies in strollers or car seats, crash dummy pedestrians, and
even a crash dummy torture chair with straps and clamps and cranks to pull the dummies apart more slowly, one limb at a
time. Dave is convinced that if he preserves all the parts in their original packaging he can sell them for some huge
amount of money in the future, or at least that's how he's justifying the expense. *
Dave welcomes feedback on his musings. He can be reached at JOHNSON.DK on AppleLink, firstname.lastname@example.org on the
Internet, or 75300,715 on CompuServe.*