009. Password is 'NeXTStep'

Back to 008. Competing with Steve Jobs (the First Time) [Chapter II]

It is only fitting that a post about an accomplishment by Steve Jobs would come on the eve of his birthday.

NeXT, founded and led by Steve Jobs, developed new hardware, a new OS, and, importantly, entirely new object-oriented tools to build programs for their platform. The computers were not selling well (yet), but there was a growing belief that the technology was unique and forward-looking. Due in no small part to Jobs himself, the industry stood up and took notice.

One person really noticed. That was BillG.

Steve Jobs was famously separated from Apple in 1985, and later created NeXT Inc. along with several key members of the Apple Macintosh team (he also started Pixar but that’s another story). NeXT produced three main products and had recently been refreshed with new models after the 1988 launch.

First there was the NeXT computer which was a blazing fast workstation class computer (along with an incredible display, fancy optical drive, and a laser printer). Second, was the operating system that ran on the computer, object-oriented (of course) with a graphical user-interface, called NeXTStep. And third, an incredibly rich set of tools for programmers to build object-oriented GUI programs for the hardware and OS, called Interface Builder. The whole product was launched in 1988 as almost a “super Macintosh” or at least was viewed that way by many. It was covered broadly across mainstream press because of the fascination with new home computers and of course Steve Jobs. By this point, many local newspapers were covering home computers as a regular section, something that seemed inconceivable just a few years earlier.

NeXTStep, while object-oriented, did not use C++ but a different object-oriented language which only made it seem cooler. BillG who believed strongly in having complete ownership of a programming language, thus his general reservations around C++ as I would soon learn, and his favorable views of Objective-C.

On my first college recruiting trip to Cornell in search of more Microsofties, I visited my old lab where many of the Macintosh computers were replaced with NeXT computers. Steve Jobs’ new company followed the same marketing plan that Apple followed with the launch of Macintosh, convincing a number of computer science departments to make a bet on NeXT. This would not be the first time a recruiting trip to Cornell would show me something unexpected.

ScottRa procured a NeXT computer, the new pizza box form factor (like a true workstation) and we would explore it late into the night, sharing our discoveries with each other and the rest of our team. It was truly a marvel of engineering and experience. It was amazing to me that a computer and software built from scratch could do so much (technically, much of the core operating system was built on a research project foundation from Carnegie Mellon University, known as Mach, which becomes important later in this story).

It ran at full 32-bits and running a variant of Unix under the graphical interface it rivaled the workstations I used in graduate school. It featured a level of sophistication in software and features that made Windows 3.0 PCs seem almost toy-like while having an ease of use of a packaged software product. It cost almost $10,000 1990 dollars and had minimal support from mainstream software makers who were already busy navigating MS-DOS, Windows, and OS/2.

Still the capabilities were so significant that NeXT was viewed as a major strategic “threat” (Microsoft, as I was learning, frequently used that to describe competitors). ScottRa explained to me the importance of competing with NeXT but I had difficulty grokking what that meant for our little team tasked with building cross-platform tools.

It became increasingly clear to me, however, why our source code server was named \OBJECTS. Scott cleverly named the share \DART, a joke that was lost on me for years. I’ll never forget the first time he told me the password. He said, “the password is ‘NeXTStep’, capitalized correctly.” Everyone by then knew it was “NeXTStep” or perhaps “NeXTSTEP”.

While I had no first-hand knowledge, the idea was in the air that BillG was frustrated at trailing a product by Steve Jobs. NeXT appeared to be a better product than anything Microsoft was about to ship or had planned for the foreseeable future. One of the things I am thankful for is having a direct competitor at such an early stage in my career. While how to compete was fuzzy, it was clear what we were supposed to compete with. Rumors of what BillG thought were cool or competing products or features would race around the company, and NeXT was one of those products. Microsoft was a product company, so the fact that it cost so much money or sold so few units was no excuse for not knowing what a product did or why it was viewed as good (and what we would do about it). BillG was (and remains) fiercely competitive and would often drive conversations about competitors in a relentless fashion, never allowing a team to dismiss one aspect of a competitor simply because of some relative weakness, no matter how overwhelming a weakness it might be. A product that is fantastic but not selling at all is every bit as formidable as your actual number one competitor, at least that is how we had to treat it when it came to BillG.

The rivalry between Bill and Steve was real. Everyone knew about it. We’d been through yearly company meeting updates on the litigation between companies and could read the trade press reviews of Macintosh versus Windows. That’s why our little team was funded. It was why our conference room had a NeXT computer costing as much as four developer PCs.

The Systems division was responsible for delivering the SDK for the platform, though they relied on the Tools team to deliver the underlying compilers and other tools. The SDK was supposed to make it possible to build GUI applications. Unfortunately, the tools were mostly the bare minimum and lacked the elegance seen on Macintosh and NeXT.

The Systems team, aware of NeXT and the high bar it set, staffed an additional, smaller team to build much more innovative and competitive tools for OS/2 and Windows.

I had no idea what they were up to. BillG did of course. But now Microsoft had two small teams chartered to compete with NeXT while the much larger teams in Windows and Tools were not focused on NeXT as a competitor. This struck me as weird, but what did I know?

Jeff Harbers (JeffH) had firsthand knowledge of the BillG–Steve Jobs rivalry. Jeff was the engineering manager for Apps and led many of the earliest Apps products back when the team was merely one group of developers assigned to projects as needed, much like a typical start-up. He was hired to bring a level of experience and engineering quality to Apps and was part of the founding Apps team at Microsoft. Jeff was the first person hired by CharlesS. He had been in the middle of many technical conversations between BillG and Steve Jobs during the development of the Macintosh and Microsoft’s commitment to delivering Word and Excel with the release of the Mac in 1984. Above all, though, Jeff had a well-earned reputation for being direct and accountable, with a strong commitment to excellence in engineering and quality—owing to his background in traditional mechanical engineering more than the hacker ethos.

Jeff’s email name did not have the first letter of his last name, because there weren’t any other Jeffs when he arrived. I thought this was kind of cool. But it drove BillG kind of nuts. Still, Jeff insisted on maintaining Jeff as his email, so BillG created an alias that directed email sent to JeffH to his Jeff account, just so he didn’t have to see “Jeff.” Years later with Microsoft’s more friendly email system, the alias JeffH was spelled out as “Jeff Harbers forwarding alias for BillG.” That was what happened when stubborn met stubborn.

Given his skill and experience and his understanding of Apps development, BillG tasked Jeff with merging the two teams and creating a new group to take on NeXTStep and to bring innovation and object-oriented tools like NeXTStep to Windows and OS/2 development. OS/2 was still top of mind in 1990.

This marked the start of a Microsoft entry into object-oriented development tools.

Because this team spanned both Apps and Systems and Jeff was an Apps person, the team reported to Mike Maples (MikeMap), vice president of the Applications Software division. Little did I know, but this spanning of Apps and Systems, while reporting to Apps, was quite a crazy structure and was a “condition” upon which Jeff would run the team. Microsoft was still a startup in the sense of the CEO creating ad hoc organizations around an individual.

MikeMap transformed Microsoft and set it up to be the product company it is today, quite literally. He joined Microsoft in the summer of 1988, as one of the earliest VPs at the company. So much of Microsoft culture today—that of Office, the quality of the products, and most of all the scaling of Office from a chaotic, infinitely buggy, siloed organization to one of the largest and most profitable software engineering product teams in the world—is a debt owed to MikeMap.

Mike was the opposite of the Microsoft archetype, older than most, having graduated from college in 1965 (the year I was born). He grew up in Oklahoma and attended Oklahoma City University and earned an MBA as well. Prior to Microsoft he worked at IBM for more than two decades. The news of his hire caused a lot of worry about blue suits, white shirts, meetings (with “foils”), and even songs (yes, IBM had corporate songs). The stories of IBM’s process were legendary at Microsoft because of the close working partnership between companies in Systems. Instead, Mike, with his disarming Oklahoma accent, showed up in plaid button-down shirts.

Both MikeMap and JeffH would become two of the most important mentors at Microsoft, for me and for many others.

Under direction of BillG, Jeff assembled a new founding team. It included two developers who I was in in awe of, Brad Christian (BradCh) and Rick Powell (RickP), and from Systems, Microsoft legend Neil Konzen (NeilK) and Garth Hitchens (GarthH). Plus me, the new kid. ScottRa reported to Jeff. He would quickly attract more from inside the company and we were soon about ten SDEs. BradCh was one of the main developers on Windows Word. RickP was likewise a key developer on Excel. NeilK was an original original, joining Microsoft while in high school biking over to the offices. He worked on the Apple Z-80 Softcard, Multiplan, Windows, and was leading the graphical subsystem of OS/2, and much more. Famously, Neil wrote the BASIC game DONKEY that shipped with MS-DOS originally. His initials, NK, were also embedded in every MultiPlan file as an identifier.

I could not resist making a quick video of DONKEY.BAS. This is running on original PC XT hardware under MS-DOS 1.1 in EGA graphics mode with 640K memory. Enjoy the sound, that’s the PC fan and 10MB hard drive [personal collection]

The charter of this new group was defined by the aggressive mission to utilize the latest in object-oriented C++ technology to provide tools and libraries for developers writing the most advanced GUI applications on the market. In the context of the time, this was wide-open and, importantly, had all the buzzwords that mattered—object-oriented, GUI, C++, and for Microsoft, developers.

I was new to corporate organization tensions, but they were readily visible. Alone, and having not done much for a year, I felt it. Between the two parts of our new team, the Apps Tools part and the Systems part, there was somewhat of a rivalry given we were jammed together in a typical corporate reorg. Add to that a concern about having Jeff as our manager—at least that’s what I was hearing in the late-night hallway chats.

A big deal at the time, though one that had played out before my arrival, Jeff came with some history that made some people uneasy. Back when Jeff was as an overall engineering manager in Apps, the most significant and somewhat out-of-control project at the time was the first version of Word for Windows. This project became legendary as both an incredible success after the fact and an incredible death march while it was happening. The project was in a Harvard Business School case study that detailed the frustration the developers had with management (photocopies of photocopies of that case study seemed to be in everyone’s file cabinet). While not referenced by name, the case study stated that “upper management” referred to the Word team as the “worst in Applications development.”

The “worst” team description came from Jeff around the time he reached a breaking point that led to a 12-month leave (uncommon at the time, but his decision). His characterization of the team ruffled feathers even when he returned one year later. But in truth, the development of Word for Windows caused several people to reach their limits. Many moved on. As I learned from Zero Defects, the early “big” projects had a lot of problems and those had a lot of causes. Jeff was more of a symptom than the cause, at least that is what I came to conclude.

While we were eager to start, Jeff insisted we first come together as a team at a retreat to help alleviate the angst. The retreat felt like one of those Dilbert-esque corporate team-building offsites. Jeff was always a rugged individualist (he lived in Antarctica for a year before joining Microsoft), but his return from leave came with a bit of a reflective side that led to the offsite. Other than resident adviser training in college, I had never participated in anything like this. Our team went to the Westin Hotel in Seattle (cool because I walked to the hotel from my Capitol Hill apartment) and we stayed overnight.

Professional facilitators took us through a series of forgettable bonding and exploring exercises. We even lined up and passed oranges to each other from under our chins. It was like a scene from The Office. We spoke in pairs about our feelings and goals. We did trust exercises. JeffH talked a great deal about renewal, alluding to his Word experience.

At the end of the day, we had a fancy hotel dinner. It was the first time I ordered wine on Microsoft’s tab (actually ever, but that’s another story), a bottle of red, which I then promptly tipped all over the table onto BradCh. Later in the evening, KirkG suggested we raid the minibar. It sounded like a good idea at the time, so we did, but I was reprimanded by Jeff once he saw the bill afterward. It was so terrifying that I thought I would get fired, but it also instilled, for the first time, my sense that Microsoft was indeed a start-up when it came to spending money. The company had completed its first $1 billion sales year. I got a stern talking to over the minibar.

Back at work, job one was NeXTStep.

We started building a cross-platform application framework, basically the starting point for using C++ and being object-oriented. The ET++ experiment we trained on was such a framework, but the marketplace was already flooded with such frameworks that aimed to make it easier to create GUI programs that worked easily on any GUI operating system. Borland, our real competitor, had such a framework, called Object Windows Library, or OWL.

NeXTStep was based on the Objective-C programming language, and not C++. The NeXT system was alone in embracing this language and that was the subject of much debate on the USENET discussion forums—USENET was among the earliest internet services where mostly grad students exchanged ideas (it is often likened to today’s Reddit). The main differentiator, and key point of conflict on USENET, was that Objective-C had garbage collection (via reference counting to be technically specific)—that memory management technique I favored in graduate school and then abandoned once I was schooled in the real world by JonDe.

Because we were to compete with NeXT, we needed to have everything NeXTStep had, but better. That was only logical. Our framework also used automatic garbage collection, which we were going to add to C++ (going against the grain of the C++ language purists and the most experienced people I knew, JonDe and DougK). Given the construct of our group—RickP, NeilK, who built the windowing system, ScottRa with experience in architecting applications, BradCh, GarthH, and so on, we were like the X-Men, each with a superpower destined to be part of one significant framework.

Except me. I had no experience doing anything. I brought to the table my academic background in data storage and what was known as object persistence and garbage collection, so I worked on the ability of the framework to save and load objects from memory to disk. Everything we were doing was our own invention—it was neither Windows nor OS/2; it was not standard C++; it wasn’t built using standard PC graphics. It was a perfectly consistent and well-architected system, unrelated to everything. To be fair to ourselves, that is how every application framework was done at the time.

Our project needed a name. We referred to it by the generic name af for application framework. One night, ScottRa and I were talking, and I mentioned that I saw an exhibit at Boeing about a new fighter jet, the FX or something. We joked about how there’s always an X in cool products and thus we christened the project AFX. Over the years we would make many jokes about what it stood for, like application frameworkx or application framework eXtentions, but it was never an acronym.

We spent about nine months building our framework. We were a product team. We were writing code, checking in code, building tests, and doing all the things I thought a product team did. I certainly was naïve.

Jeff didn’t see us making progress and the experienced product people on the team knew this. RickP bemoaned this fact to me in his straight-forward and honest manner at some of our nightly chats. We were spending a lot of time fighting the tools that didn’t help us to do the non-standard things we were trying to do, as well as debating esoteric, almost academic object-oriented philosophy all while NeXTStep was getting better.

To prove our work, Jeff declared App Month, which meant taking time to use our framework to build apps ourselves to determine if our product made it easy for developers to create apps. Though we didn’t realize it at the time, there was a method to Jeff’s madness. Jeff was obsessed with getting customer feedback and understanding the customer we were building product for, something already baked deeply into Apps culture. He told us to come up with an app on our own and spend a month building it, using our framework.

For my App Month I chose to build a personal finance app. I figured with our great framework and a month I would be able to beat the Microsoft Money team led by DougK, which at the time was only two or three developers. Really, I thought I could beat DougK because I had an application framework. I worked day and night, but I struggled with tools.

After a month, I created a bloated, slow, flaky program that only drew a check on a screen and saved it to a disk for a later reload. It didn’t have a check register. It didn’t print checks. It didn’t do any math. It didn’t have accounts, payees, categories, or, well, anything. I disliked it and I got the feeling everyone else did too.

I wasn’t alone. My teammates all experienced the same problems in their apps—games, utilities, and productivity apps alike. None of us achieved anything impressive.

Our mood sat somewhere between humiliated and disappointed. I was now 18 months or so into my career and was staring at the second time a project went nowhere.

On to 010. Our BillG Review

This is a public episode. If you would like to discuss this with other subscribers or get access to bonus episodes, visit hardcoresoftware.learningbyshipping.com