THE VETERAN NEOPHYTE

TOWER OF BABBLE

DAVE JOHNSON

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 ancestor.

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 this way:

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 to be.

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 Rheingold.

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. Howard 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 language's semantics.)

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 communication.

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.

RECOMMENDED READING

• 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, dkj@apple.com on the Internet, or 75300,715 on CompuServe.*