Close to the Machine_Technophilia and Its Discontents Page 9

  This process of remembering technologies is a little like trying to remember all your lovers: you have to root around in the past and wonder, Let’s see. Have I missed anybody? In some ways, my personal life has made me uniquely suited to the technical life. I’m a dedicated serial monogamist—long periods of intense engagement punctuated by times of great restlessness and searching. As hard as this may be on the emotions, it is a good profile for technology.

  I’ve managed to stay in a perpetual state of learning only by maintaining what I think of as a posture of ignorant humility. This humility is as mandatory as arrogance. Knowing an IBM mainframe—knowing it as you would a person, with all its good qualities and deficiencies, knowledge gained in years of slow anxious probing—is no use at all when you sit down for the first time in front of a UNIX machine. It is sobering to be a senior programmer and not know how to log on.

  There is only one way to deal with this humiliation: bow your head, let go of the idea that you know anything, and ask politely of this new machine, “How do you wish to be operated?” If you accept your ignorance, if you really admit to yourself that everything you know is now useless, the new machine will be good to you and tell you: here is how to operate me.

  Once it tells you, your single days are over. You are involved again. Now you can be arrogant again. Now you must be arrogant: you must believe you can come to know this new place as well as the old—no, better. You must now dedicate yourself to that deep slow probing, that patience and frustration, the anxious intimacy of a new technical relationship. You must give yourself over wholly to this: you must believe this is your last lover.

  I have known programmers who managed to stay with one or two operating systems their entire careers—solid married folks, if you will. But, sorry to say, our world has very little use for them. Learn it, do it, learn another: that’s the best way. UNIX programmers used to scoff at COBOL drones, stuck year by year in the wasteland of corporate mainframes. Then UNIX was relegated to servers, a corporate-strength version of Windows began stalking UNIX, and it’s time to move on again. Don’t get comfortable, don’t get too attached, don’t get married. Fidelity in technology is not even desirable. Loyalty to one system is career-death. Is it any wonder that programmers make such good social libertarians?

  Every Monday morning, three trade weeklies come sliding through my mail slot. I’ve come to dread Mondays, not for the return to work but for these fat loads of newness piled on the floor waiting for me. I cannot possibly read all those pages. But then again, I absolutely must know what’s in them. Somewhere in that pile is what I must know and what I must forget. Somewhere, if I can only see it, is the outline of the future.

  Once a year, I renew my subscription to the Microsoft Professional Developer Network. And so an inundation of CD-ROMs continues. Quarterly, seasonally, monthly, whenever—with an odd and relentless periodicity—UPS shows up at my door with a new stack of disks. New versions of operating systems, database software, developer libraries, development tools, device driver kits—everything you need to know to keep pace with Microsoft. The disks are barely loaded before I turn around and UPS is back again: a new stack of disks, another load of newness.

  Every month come the hardware and software catalogs: the Black Box networking book, five hundred pages of black-housed components turned around to show the back panel; PCs Compleat, with its luscious just-out laptops; the Programmer’s Supershop,“your voice for Internet, client/server and networking technologies”; and my favorite, the Programmer’s Paradise, on the cover a cartoon guy in wild bathing trunks sitting under a palm tree. He is all alone on a tiny desert island but he is happy: he is surrounded by boxes of the latest programming tools.

  Then there is the Microsoft Systems Journal, a monthly that evangelizes the Microsoft way while handing out free code samples. The Economist, to remind myself how my libertarian colleagues see the world. Upside, Wired, The Red Herring: the People magazines of technology. The daily Times and Wall Street Journal. And then, as if all this periodical literature were not enough, as if I weren’t already drowning in information—here comes the Web. Suddenly, monthly updates are unthinkable, weekly stories laughable, daily postings almost passé. “If you aren’t updating three times a day, you’re not realizing the potential of the medium,” said one pundit, complaining about a online journal that was refreshing its content—shocking!—only once a day.

  There was a time when all this newness was exhilarating. I would pour over the trade weeklies, tearing out pages, saving the clips in great messy piles. I ate my meals reading catalogs. I pestered nice young men taking orders on the other end of 800 phone lines; I learned their names and they mine. A manual for a new tool would call out to me like a fussy, rustling baby from inside its wrapping. I took it to bed, to the kitchen table; I read it at nights, on weekends. There was no satisfying this desire to know, and yet to know more. The fact that there seemed to be no end to the things one had to know was all the better. It was like riding in a powerful car in the days of cheap gas: more, faster, now.

  What has happened to me that I just feel tired? The weeklies come, and I barely flip the pages before throwing them on the recycle pile. The new catalogs come and I just put them on the shelf. My machines are three years old—ancient by my own standards. I haven’t loaded my last two Microsoft distributions; I tell myself it’s because I’m having a problem with the CD-ROM drive. The invoice for the Professional Developer subscription just came from Microsoft: I’m thinking of doing the unthinkable and not renewing.

  I’m watching the great, spinning, cutting edge slice away from me—and I’m just watching. I’m almost fascinated by my own self-destructiveness. I know the longer I do nothing, the harder it will be to get back. Techno-logic time is accelerated, like the lives of very large dogs: six months of inattention might as well be years. Yet I’m doing nothing anyway. For the first time in nineteen years, the new has no hold on me. This terrifies me. It also makes me feel buoyant and light.

  It could just be my age. I’m middle-aged, a time for consolidation, deepening what you know, ignoring distractions. Time tells me to stop chasing after the latest new everything. Biological life does not want to keep speeding up like a chip design, cycling ever faster year by year.

  And maybe there is something unseemly in an old programmer. Maybe the isolated compulsion of coding, its bottomless details, its narrow-well horizon—the sheer electric nervousness required for a relationship with the machine—is simply unnatural for someone over thirty-eight. Maybe an old programmer is like an old Mick Jagger. Past a certain age, it’s just creepy to keep sticking out your tongue and singing “Satisfaction.”

  Then again, the problem may just be too many updates to Microsoft Windows.

  A few months ago, I went to a Microsoft Professional Developers Conference. It was just after the company woke up to the possibilities of the Internet. They had been pushing a minor Web scripting language called Blackbird, which they decided to kill off, also killing off countless little Blackbird companies that had been racing to start themselves up.

  Microsoft had a new plan. What had started as the scripting language for a desktop tool called Access had by then evolved to the Visual Basic language, which became something called embeddable VBX controls, which became OCX controls operating under OLE and Networked OLE; which, at this very conference, had just evolved into ActiveX controls under Distributed OLE. Which meant, if you wanted them to interoperate with Java applets, you had to use under DCOM, Microsoft’s proprietary version of CORBA.15

  “It’s almost getting to be too much,” said a voice behind me on the escalator.

  I turned around. A man. Gray streaks showing in his pony tail. The beginnings of a paunch. Not a kid but not yet my age. The guy next to him was younger by ten years. Maybe it was just the older guy’s age. Maybe time did indeed explain everything.

  “How do you take it?” asked the younger one, the one without gray streaks or paunch or middle age. “How
do you keep up?”

  I strained to hear the answer, but the escalator was carrying us down to the conference floor, where Microsoft product managers were explaining how to “drill down” layer after layer into the heart of the operating environment, down and down into the new. The noise rose up at us, and the reply was swallowed into the general noise, into the general anxiety of unlearning Blackbird and relearning VBX, into the panic of letting go of OLE and embracing DCOM.

  So I never did hear the older one explain how you get used to it after a while, how it becomes normal to discard your certainty and hunker down into the newest thing, how it is no fun but there is a certain perverse satisfaction in reorienting your brain at a right angle to its previous position. And there, lost, you go ahead anyway. And there, somehow, you make it run.

  “We’re pitiful,” said Mark, the database programmer.

  “Pitiful,” said Sam, another database consultant I’d hired to work with us.

  It was somewhere in the middle of my time on the AIDS project. Mark, Sam, and I were trying to configure a database. We sat in the heat of the tiny machine room, nearly stupefied by fan noise and machine exhaust. Three hours had gone by. The database was still not configured.

  What was taking us so long? We each had over ten years of experience. We were all early employees of the company that had built the database software we were configuring. By any measure, we were experts. Still, a certain parameter escaped us. A certain setting stumped us. A certain option sent us hunting through the manuals. Then the manuals couldn’t help. We called other experts, other early employees of the company that built the database software, each with over ten years of experience. They didn’t know the answer either.

  For a moment: guilt. Three meters running by the hour: experts are expensive. We should know this, I thought. I imagined other, better experts who could do this job more quickly. But the guilt passed. I’d been doing this long enough to know that, pitiful as we were, we were it. The three of us struggling through the running of this database on a new operating system, flipping through incomplete documentation, using trial-and-error settings of options—this was what passed for expertise in our business.

  Finally a setting seemed to work. We started a configuration process, and we sat watching the screen. We talked bored programmer-talk as text scrolled up on the monitor.

  “I’d like to be doing Java programming,” said Mark.

  “Java?” I asked. “Who’ll pay you to learn Java?” Java was then a barely known computer language. It was the newest fashion, the language of the Internet. We all knew we’d have to learn it, but no one knew exactly how or when. “We’ve already forgotten our SQL,” I said, “and we’re barely fluent in C++. Do we have to move on to Java already?”

  Mark and I exchanged looks. We both came of age using a programming language called C, and neither of us liked its successor language, C++. But Mark didn’t want me to talk about it.

  “I’m learning Java from Randy,” said Mark. “He’s an old Java-head.”

  “Old Java-head?” I asked. “How old a head can he be? Java itself is only a year old.”

  “Oh, Randy learned it way back in May.”

  We were having this talk in September. “Oh, way back in May!”

  “Well, that’s old these days.”

  “Yeah,” I said, “Ancient.”

  “Shit!” said Sam. “Device allocation failure!”

  “Try changing the partition size—”

  “No, it’s the device name. Change the device—”

  “No, I think it’s the logical name, not the physical drive.”

  “Yeah, it conflicts with—”

  “Shit! You’re right.”

  The experts went back to fiddling. Many settings later, the configuration was completed successfully, and the project had a database. Eight months later, Mark had indeed became an old Java-head. The last I heard, his time was being billed at $160 an hour. He was not short of work.

  The corollary of constant change is ignorance. This is not often talked about: we computer experts barely know what we’re doing. We’re good at fussing and figuring out. We function well in a sea of unknowns. Our experience has only prepared us to deal with confusion. A programmer who denies this is probably lying, or else is densely unaware of himself.

  The awareness of my own ignorance came to me eight years into my career. I was still working for the company that built the software we were configuring at the AIDS project. I was having trouble getting a particular monitor to work with our software. I called the manufacturer of the monitor. I called the supplier of the keyboard. I called the company that wrote the device driver software, that built the mouse, that wrote the operating system. I received many answers, all contradictory. Somewhere through my fourth round of phone calls came two thoughts in horrifying succession. The first thought was: I suppose I know the answer better than anyone else in the world. The second was: I don’t know what the hell I’m doing.

  Over the years, the horrifying knowledge of ignorant expertise became normal, a kind of background level of anxiety that only occasionally blossomed into outright fear. Still, the fear was a great motivator. The desire to avoid humiliation was a strong concentrator of the attention. I even came to rely on it. When I interviewed Danny, the desktop programmer, to work on the AIDS project, I knew he had less experience than he was letting on. I knew he was taking on this job out of sheer will. But I hired him anyway. I did it because I saw the fear in his eyes.

  I told Mark, “The new guy is afraid.”

  “Oh, good,” said Mark, “then he’ll work out nicely. If you’re not terrified in this profession, you really don’t know what you’re doing.”

  “Open App Studio and get to the project,” said the lead engineer on my new contract. It was my second day. He had never seen a resume or my company brochure or talked to me about my experience. But it would never have dawned on him that anyone could be working as an engineering consultant without complete and utter knowledge of Microsoft Visual C++, Professional Edition.

  I looked at the screen. Everything on it—the tool, the language, the library they were using—had come into common use after I stopped programming full time. Since then, I had become what I was on this project: a designer, a manager, a maker of schedules and budgets. In the regular world, these responsibilities would be considered promotions. And I was certainly making more money than I used to. But this was not the regular world. The people I had to direct were programmers, and nontechnical managers don’t get away with directing programmers for very long. When they meet you, there is really only one thing programmers want to know: are you technical or not?

  I squinted at the code. It was the bizarre, ugly syntax of the C++ language. I came of technical age with its predecessor, C, which I could read and write like English, which I could debug just by having it read to me over the phone. But here it was as if I were a native speaker of Spanish trying to read Portuguese. Yes, the roots were the same, yes, these are the same words, but where had all these strange letters come from? How had this word turned into that? Clearly this language came from the other side of some political and cultural schism, a new and unknown country where I could just get by. “Thorny stuff,” I said, speaking sentences from a traveler’s phrasebook.

  The programmer hovered over me in the small cubicle. He was as high-strung and twitchy as any programmer I’d known. He literally bounced, elbows flapping. He felt like an electric buzz behind me.

  This was my test: Was I technical or not? Could I be the engineer of last resort? When he had a problem, was I going to be any use to him, or was I just another pain in the neck telling him what to do?

  He waited. I scrolled through the code. Then I scrolled some more. Object-oriented software: small hunks of code, understandable only if you know a whole hierarchy of logic. Tiny window, fifty-line viewport, to see little blocks in an elaborate pyramid. Murk and confusion.

  But just then some blessed instinct took over
, a subliminal skill still there after all those years of reading code. Something surfaced, miraculously, out of the murk.

  “Here it is,” I said. “Here’s what you’re looking for.”

  “Where?”

  “Here. This CGXView thing.”

  “Oh great! So we can put the grid in a view.”

  “Yeah. Not just in a window.”

  That was it: test over. I gave him his chair and he immediately set to programming, his knees opening and closing, opening and closing, as if he were some huge, manic clam. I was sweating. But I had passed. For one more day at least, I would still be thought of as “technical.”

  I remembered a birthday party many years ago. The woman who would become my partner of eight years ordered the cake for me. It arrived in a huge box that all but filled the table. This woman gathered the guests around and made a big fuss about everyone being there to see the box cover opened. Everyone waited. She lifted the cover. She beamed. There sat an enormous sheet cake with a greeting scripted in lemon butter cream. It said: “Happy Birthday, Senior Engineer Ullman.”

  I held a small, white, spiral-bound book. I waved it at Brian. “In here was the entire UNIX operating system,” I said, “all of it, down to the bottom.”

  We were sitting on the floor by the fire. It was sometime during the first long night we spent together.

  “You could sit and read this one book and know everything about the entire operating environment,” I said. “System calls. Commands. Network interface. Input devices. File system. The whole environment—in one book. I spent my life with this thing. I mean, it was my life for a while.”

  The book was a Bell Laboratories manual for UNIX Release 3.0. It measured six by nine inches, held about 500 pages. On the cover was the old Ma Bell logo and the date: June 1980. It came from the days when I stopped being a mere programmer and was first called a “software engineer.” I looked on the inside cover where I’d written my name. Funny: my signature hadn’t changed in all those years.