Bill Gates–1986

As chief executive officer of Microsoft, William H. (Bill) Gates is considered one of the driving forces behind today’s personal computing and office automation industry. Gates started his career in computer software at a young age. Both Gates and Microsoft co-founder, Paul Allen, worked as programming consultants while attending high school in Seattle, Washington. In 1974, Gates, then an undergraduate at Harvard University, worked with Allen to develop a BASIC programming language for the first commercial microcomputer, the MITS Altair. After the successful completion of this project, the two formed Microsoft to develop and market software for the emerging microcomputer marketplace.
Microsoft has set standards for the software industry in languages, operating systems, and application software. Gates has provided the vision for the company’s new product ideas and technologies. He also provides hands-on guidance to the technology groups that develop new products, devoting his time to reviewing and refining the software that Microsoft sells.
Gates is a native of the Seattle, Washington area and resides there today. He was born in 1955.

INTERVIEWER: You obviously have a lot of responsibilities as chief executive officer of Microsoft. Do you still program?

GATES: No, I don’t. I still help design algorithms and basic approaches, and sometimes I look at code. But since I worked on the IBM PC BASIC and the Model 100, I haven’t had a chance to actually create a program myself.

INTERVIEWER: What kind of role do you play in the development of programs at Microsoft?

GATES: I do two key things. One is to choose features to put into programs. To do that, you have to have a reasonable understanding of what’s easy and what’s not easy to do. You also have to understand what sort of product “family” strategy you’re pursuing, and what’s happening with the hardware.
I also work on the best way to implement that new feature, so that it will be small and fast. For example, I wrote a memo about how to design and implement a feature we used on Excel to make the program recalculate the formulas every time the screen changes.
In the first four years of the company, there was no Microsoft program that I wasn’t involved in actually writing and designing. In all those initial products, whether it was BASIC, FORTRAN, BASIC 6800, or BASIC 6502, not a line of code went out that I didn’t look over. But now we have about 160 programmers, so I mostly do reviews of products and algorithms.

INTERVIEWER: What do you consider your greatest achievement ever in programming?

GATES: I’d have to say BASIC for the 8080, because of the effect it’s had, and because of how appropriate it was at the time, and because we managed to get it so small. It was the original program we wrote when we decided to start Microsoft.
Three of us knew that original program by heart. We got a chance to completely rewrite it one summer down in Albuquerque, and I thought we could save a few bytes and tighten things up. We just tuned the program very, very carefully, and ended up with a 4K BASIC interpreter.
When you know a program that well, you feel that nobody can look at the code and say, “There’s a better way to do this.” That feeling’s really nice, and the fact that the program was used on a lot of machines makes it an exciting program to have written.
I also feel really good about the software on the Model 100, especially about how we squeezed in a very useful small editor. I worked with Jey Suzuki, a Japanese programmer, to put that together. We had very limited time to finish the project. When you do software that gets burned into ROM, you don’t get an opportunity to make mistakes.

INTERVIEWER: What do you consider the most difficult part of computer programming?

GATES: The hardest part is deciding what the algorithms are, and then simplifying them as much as you can. It’s difficult to get things down to their simplest forms. You have to simulate in your mind how the program’s going to work, and you have to have a complete grasp of how the various pieces of the program work together. The finest pieces of software are those where one individual has a complete sense of exactly how the program works. To have that, you have to really love the program and concentrate on keeping it simple, to an incredible degree.

INTERVIEWER: With computers increasing so much in power and memory, are programs becoming more complex, or just sloppier? How is that affecting the way people write programs?

GATES: We’re no longer in the days where every program is super well crafted. But at the heart of the programs that make it to the top, you’ll find that the key internal code was done by a few people who really knew what they were doing.
It’s not quite as important now to squeeze things down into a 4K memory area. You’re seeing a lot more cases where people can afford to use C, instead of using assembly language. Unfortunately, many programs are so big that there is no one individual who really knows all the pieces, and so the amount of code sharing you get isn’t as great. Also, the opportunity to go back and really rewrite something isn’t quite as great, because there’s always a new set of features that you’re adding on to the same program.
The worst programs are the ones where the programmers doing the original work don’t lay a solid foundation, and then they’re not involved in the program in the future. Working with those programs gets to the point that I call “experimental programming.” The programmers understand so little about those programs that they can’t understand how changes might affect speed, for instance. They might use code that already exists, or they might not understand what dependencies will break if they change something. So they add new code, and then they run it and they say, “Oh look, it doesn’t work that way.” That’s a very, very inefficient way to deal with a program, but a lot of projects end up exactly like that.

INTERVIEWER: In a company like Microsoft, where you have 160 programmers, how do you go about creating an environment where you can develop successful programs?

GATES: One way is to have small project teams, typically four or five people, and one of those people has to have the proven ability to really absorb a program. And when that lead person is uncertain about something, he or she should be able discuss it with even more experienced programmers.
Part of our strategy is getting the programmers to think everything through before they go to the coding phase. Writing the design documents is crucial, because a lot of simplification comes when you see problems expressed as algorithms. They’re kind of in the smallest form then, where you can see what the overlap is.
Another important element is code review, making sure that you look through the code and see if senior people can provide hints about how to do something better. And you have to review similar projects that have gone super, super well; programmers can look at how those other people performed previously, and get ideas from the other project about how to improve their own program.

INTERVIEWER: Where do the ideas for programs come from?

GATES: Well, there’s no formal process, that’s for sure. At Microsoft, there’s usually a brainstorming session at night or on the weekends. Everybody has a general idea, like, we want to do the world’s best word processor. And we want it to allow a technical publications department to do everything they want to do. We’ll sit and talk. Well, how could we make it really fast? Could we put a drawing capability in, or could we do kerning without making the program super slow? A variety of problems will get talked through and some neat ideas will come up.

INTERVIEWER: Basically it’s a group effort?

GATES: In terms of deciding what programs are going to do, a fairly large group makes suggestions. Then there’s a filtering process. Eventually I’ll decide which of the ideas makes sense, and I’ll make sure we have champions who are personally involved in making that product succeed. We decide to do very, very few projects because it takes incredible focusing on a lot of resources to get a product out there and set a new world-class standard.

INTERVIEWER: There’s a lot of talk about how large software companies find it difficult to attract talented people who can produce great software, because these mavericks are so independent that they want to work on their own. How do you attract and keep good people at Microsoft?

GATES: Great programmers are critical to create software products. But we don’t believe in a prima donna approach, where just because somebody’s good we let him not comment his code, or not communicate with other people, or impose his beliefs on everyone else.
We want people who really respect each other. I think most great programmers like to be around other great programmers. When they think up an incredible algorithm, they like having peers who can appreciate the cleverness that went into it, because when you’re creating something like that and you have that model in your mind, it’s a lonely thing. If you thought a process had to be complicated, and then you figure out a way to make it simpler, that makes you feel great. But you want to get some feedback from other people. Once you get a few great people, then others come.
The old rule used to be that a manager of a programmer was always a better programmer, and there were no what we called “technical inversions,” where a programmer works for somebody who doesn’t know how to program. We still follow that philosophy: At certain levels we’ve got business managers, but we don’t have non-programmers really managing programming projects.
INTERVIEWER: Do you think there are any particular rules for creating a good program?

GATES: Some people just jump in and start coding, and others think it all through before they sit down, but I think you’d find that the programmers who sit down and code at the beginning are only using that as a scratch pad. It’s what’s going on in their heads that’s most important.
You’ve got to have somebody who’s super smart. A great programmer thinks about the program on a constant basis, whether driving or eating. That method takes an incredible amount of mental energy.

INTERVIEWER: How would you describe your style of programming?

GATES: I like to think the whole program through at a design level before I sit down and write any of the code. And once I write the code, I like to go back and rewrite it entirely one time.The most important part of writing a program is designing the data structures. The second most important part is breaking the various code pieces down. Until you really get in there and write it out, you don’t have the keenest sense of what the common subroutines should be.
The really great programs I’ve written have all been ones that I have thought about for a huge amount of time before I ever wrote them. I wrote a BASIC interpreter for a minicomputer in high school. I made massive mistakes in that program, and then I got to look at some other BASIC interpreters. So by the time I sat down to do Microsoft BASIC in 1975, it wasn’t a question of whether I could write the program, but rather a question of whether I could squeeze it into 4K and make it super fast. I was on edge the whole time thinking, “Will this thing be fast enough? Will somebody come along and do it faster?”
I have an image in my head of this person named Norton that I met at TRW. He always showed me when I wasn’t doing super well. So if I’m sloppy or lazy, I always imagine that he’s going to walk up, look at the program, and tell me, “Look, here’s a better way to do that.” Little inefficiencies can slip into the program along the way, and if you want to really feel good about it, you’ve got to maintain the thought that you’re not going to let that stuff creep in. That’s why it’s kind of painful sometimes if you have somebody else working on the project. They never code stuff exactly the way you like to see it coded. I remember when we were working on BASIC, I’d go back and recode other people’s sections of code, without making any dramatic improvement. That bothers people when you go in and do that, but sometimes you just feel like you have to do it.
INTERVIEWER: When you were working with a group, were you always the design lead?
GATES: Yeah, on all the programs I’ve been directly involved with, I was the design lead. On the original BASIC, I scribbled out the design on pieces of paper. Paul Allen, who is a co-author, designed an implemented all the development tools.
Before I sit down to code something, most of the instructions have already run through my head. It’s not all laid out perfectly, and I do find myself making changes, but all the good ideas have occurred to me before I actually write the program. And if there is a bug in the thing, I feel pretty bad, because if there’s one bug, it says your mental simulation is imperfect. And once your mental simulation is imperfect, there might be thousands of bugs in the program. I really hate it when I watch some people program and I don’t see them thinking.
One of the most fun programming experiences I ever had was when we were doing BASIC. I had done the 8080 BASIC, and then I had about two weeks allocated to work with Mark Chamberlain on the 6809 version of BASIC. I read the instruction set at the start of those two weeks, and I wrote about three or four programs. And I looked at some other programs to see how people used the instruction set. It was great fun to take a problem I understood and map it onto this new instruction set, and see how tightly we could put the thing together.
Programs today get very fat; the enhancements tend to slow the program down because people put in special checks. When they want to add some feature, they’ll just stick in these checks without thinking about how they might slow the thing down. You have to have a programmer who knows the program inside out to guard against that. In the case of our BASIC, after I and the other original people moved away from it, we went through a period of about three years when we didn’t do anything innovative. It’s only in the last year and a half that we’ve gotten people in who feel total ownership and total understanding of our BASIC and can say, “Oh, yeah, putting subroutines in and getting rid of line numbers is easy.” We’ve always had those goals, but until you’ve got that person who knows how to go into the middle of the parts or the statement analyzer and not just tack things on, you don’t feel comfortable fiddling with it.
It’s true that we’re going to allow programs to be a little fatter than they have been. But in terms of speed, it’s just laziness not to allow something to be as fast as possible, because users, even though they might not be able to say so explicitly, notice programs that are really, really fast. In the most successful programs, the speed of execution is just wonderful.
INTERVIEWER: How do you decide on the trade-offs between speed and performance?
GATES: Sometimes it’s a trade-off between adding features and executing really fast, but there are ways of having lots and lots of features and still making things fast. Basically you want to decide what the common cases are in a program, and make sure that they go straight through, that they don’t get bogged down with all these special case checks. If your main interactive loop has all sorts of checks in it, then your program is going to be slower than somebody else’s.
INTERVIEWER: When you come up with an idea to do the greatest word processor in the world, what do you do? How do you design it? Do you look at all the other word processors that are out there?
GATES: Yeah, feature-wise, you look at all the other word processors out there and you say, “Does anybody do kerning on the screen, or do they show you exactly what the printed page is going to look like? How fast do they do it?” Usually, at the top of the product line, there’s somebody who took very, very expensive hardware and used brute force to solve a problem. We can’t do that; the computer we’re working with has very finite speed. A lot of things we do have been done on more powerful computers; we’re just trying to make it reasonable to do them on the machine that there are millions of.
You can do an amazing number of tricks inside of a product. You build up your feature list at the same time you’re trying to answer the question, “Why will our algorithms be better than anybody else’s?” Features are kind of crummy in a way, because the more features you have, the bigger the manual is. And features are only beneficial if people take the time to use them, whereas speed–if you can print the pages faster, or show it on the screen faster, or recalc it faster–that’s worth an incredible amount. If you can give the users a few simple commands and make the program efficient enough to do what they want with those few commands, then you’re much better off One sign of very good programs is that even internally they follow that philosophy of simplicity. If they want to do something complex, they call the code with simple operations internally, rather than doing the complex operation from scratch.
INTERVIEWER: How important is the end user? How do you know what the database manager out there really needs or wants in his database or in his spreadsheet?
GATES: Well, some programmers don’t pretend to have any intuition for exactly what end users want, and they’re still world-class programmers. But that knowledge of the market is important, especially in the applications group, so we have full-time people who just show customers the code, or look at other specifications, and things of that nature. When Microsoft first started, we did only systems programs. We knew what programmers wanted, because we’re programmers. So we wrote BASIC.
INTERVIEWER: What was the most innovative aspect of BASIC?
GATES: The way we allowed the person to get at the full power of the machine. We put in PEEK and POKE, where you can read and write the machine status. We put in tracing routines called TRON and TROFE. We still let the users, even though they were up in this high-level language, get at all the crazy little things they might want to add onto the machine. And they can understand how memory is used without BASIC. We let them feel like they are in control of their machines.
To fit BASIC into 4K, we used a scheme called a single-representation interpreter. It was a very good choice. I’d never seen an interpreter done that way before. It was kind of risky to do it that way, but I felt incredible confidence in the scheme. I’d run it through in my head and felt good about it.
INTERVIEWER: When you were writing it, did you have any idea it would be as successful as it was?
GATES: No, no way. Paul Allen had brought me the magazine with the Altair on it, and we thought, “Geez, we’d better get going, because we know these machines are going to be popular.” And that’s when I stopped going to classes and we just worked around the clock. The initial program was written in about three and a half weeks. We ended up spending about eight weeks before I had it fully polished the way that I really liked it. And then I later went back and rewrote it.
No great programmer is sitting there saying, “I’m going to make a bunch of money,” or, “I’m going to sell a hundred thousand copies.” Because that kind of thought gives you no guidance about the problems. A great programmer is thinking: Should I rewrite this whole subroutine so that four people, instead of three, could call it? Should I make this program 10 percent faster? Should I really think through what the common case in here is so I know how to order this check? If you’re a great programmer, you make all the routines depend on each other, so little mistakes can really hurt you. That’s why you have to have such fine judgment, and be willing to back up and change things.
INTERVIEWER: When more than one person works on a program, how can you make sure all the different elements are working together property?
GATES: Well, first of all, the programming team has got to be made up of people who respect each other, because the work is really intimate; it’s like being in the same play together. So much judgment and creativity goes into a programming project. Some of the great programmers can’t work on teams; they just like to work on their own. But I think there’s an element of greatness that comes in learning how to work with other people and teach them. I really get satisfaction from somebody else on the team becoming a great programmer. Not quite as much as I do from writing the program myself, but that is really a positive event. The way I make someone else a great programmer is to sit and talk with him a lot, and I show him my code. In a team project, you make the code everybody’s code.
INTERVIEWER: Did this kind of process just evolve here or was it through deliberate implementation?
GATES: Before Paul and I started the company, we had been involved in some large-scale software projects that were real disasters. They just kept pouring people in, and nobody really knew how they were going to stabilize the project. We swore to ourselves that we would do better. So the idea of spending a lot of time on structuring groups has always been very important.
The best ideas are the obvious ones: Keep the group small, make sure everybody in the group is super smart, give them great tools, and have a common terminology so everybody can communicate very effectively. And outside the small groups, have some very experienced senior people around who can give advice on problems. There is an amazing commonality in the types of difficulties you run into. In design reviews, I really enjoy being able to provide advice, based on programs that I have done.
INTERVIEWER: Do you think there will ever be a radical change in the way people go about programming, or in the way computers operate?
GATES: Software tools are getting so much better. It is possible that we will eventually be able to take just specifications and a description of what the machine is efficient at, and then have some super high-level compiler do a lot of the work that programmers do now.
People still get great satisfaction out of the fact that a compiler, like the C compiler, still can’t write code as well as a human being. But we may mechanize some parts of the process quite a bit over the next three or four years. People will still design algorithms, but a lot of the implementation could be done by machines. I think that within the next five years we’ll have tools that will be able to do as good a job as a human programmer.
INTERVIEWER: You mentioned mathematics earlier. What’s the relationship between computer science and mathematics?
GATES: Math really affects computer science. Most great programmers have some mathematical background, because it helps to have studied the purity of proving theorems, where you don’t make soft statements, you only make precise statements. In mathematics, you develop complete characterizations, and you have to combine theorems in very non-obvious ways. You often try to prove that a problem can be solved in less time. Math relates very directly to programming, maybe more so in my mind than in other people’s minds, because that’s the angle that I came from. I think there’s a very natural relationship between the two.
INTERVIEWER: Is computer science really a science?
GATES: It will be. See, it’s such a new thing. People used to get Ph.D. theses for doing work that we now expect programmers to do as part of their jobs. Computer science is developing very quickly, but unlike math, where they’ve had 300 years of geniuses developing mathematical theory, we just have our 20 or so years of the people who decided to get involved. Really brilliant people are getting involved and contributing; programming is much more of a mainstream activity now. The fact that people are getting exposed to computers at such young ages now will help change the thinking in the field. A lot of great programmers programmed when they were in their teens, when the way you think about things is perhaps more flexible.
In the past, it wasn’t considered enough just to be a wonderful programmer; you had to manage people or go do other things. Fortunately, that’s changing. Now people realize that it’s a science that is worth sticking to and teaching other people.
INTERVIEWER: Does accumulating experience through the years necessarily make programming easier?
GATES: No. I think after the first three or four years, it’s pretty cast in concrete whether you’re a good programmer or not. After a few years, you may know more about managing large projects and personalities, but after three or four years, it’s clear what you’re going to be. There’s no one at Microsoft who was just kind of mediocre for a couple of years, and then just out of the blue started optimizing everything in sight. I can talk to somebody about a program that he’s written and know right away whether he’s really a good programmer. If he’s really good, he’ll have everything at the tip of his tongue.
Its like people who play cress. When you’re really into playing chess, it’s easy to memorize every move in ten chess games, because you’re involved in it. Other people look at that recall in chess players, or in programmers, and they think it’s like some freak show. But it’s completely natural. To this day, I can go to the blackboard and write out huge slabs of source code from the Microsoft BASIC that I wrote ten years ago.
INTERVIEWER: What does it feel like when you are programming?
GATES: When I compile something and it starts computing the right results, I really feel great. I’m not kidding, there is some emotion in all great things, and this is no exception. It’s tempting to just start typing the code in, but there’s nothing worse than typing in a routine just to get the results, and then realizing that all the hard stuff still has to be written. Because if that’s true, you’re going to have to change what you’ve already done. I like to wait and really build the foundation before I let myself have the enjoyment of coding it and seeing it run. It’s like saving the best thing on my plate for last.
INTERVIEWER: Do you see a difference between the way young programmers go about programming and the way older programmers do?

GATES: Programmers just starting out today never had to squeeze, so it’s a little harder for them to get the right religion because they always think of resources as being immediately available. Ten years ago every programmer ran into resource limitations, so the older programmers are always thinking about those things.
Programming takes an incredible amount of energy, so most programmers are fairly young. And that can be a problem, because programming requires so much discipline. When you’re young, your goals aren’t as stable; you may get distracted by one thing or another. Young programmers should stick with it, though, and they’ll get better. I think I improved dramatically as a programmer between 1975 and 1980. In ’75, I would have said, “Hey, watch out, I can do anything.” I really thought I could, because I had read so much code, and I never found a piece of code that I couldn’t read very quickly. I still think that one of the finest tests of programming ability is to hand the programmer about 30 pages of code and see how quickly he can read through and understand it.

INTERVIEWER: Do you think that’s a talent?

GATES: It’s a talent, you bet. It’s kind of like pure I.Q. You have to just concentrate on the code and relate back to programs you’ve written. A lot of people would say, “I want days and days to read this.” A really good programmer would say, “Let me take that home with me. I’ll just spend an hour tonight and go through the whole thing.” The difference of ability there is vast.

INTERVIEWER: Is studying computer science the best way to prepare to be a programmer?

GATES: No, the best way to prepare is to write programs, and to study great programs that other people have written. In my case, I went to the garbage cans at the Computer Science Center and I fished out listings of their operating system.
You’ve got to be willing to read other people’s code, then write your own, then have other people review your code. You’ve got to want to be in this incredible feedback loop where you get the world-class people to tell you what you’re doing wrong. You can’t let little idiosyncrasies get in the way of getting that feedback. Some of the world-class people will harp on some purely idiosyncratic detail, like how you comment the program. You have to cut through all that stuff, because in a way, they’re trying to create programmers in their own image; they’re trying to get you to do arbitrary things the same way they do. And it may not relate to pure quality issues.
If you ever talk to a great programmer, you’ll find he knows his tools like an artist knows his paintbrushes. It’s amazing to see how much great programmers have in common in the way they developed–how they got their feedback, and how they developed such a refined sense of discipline about what’s sloppy and what’s not sloppy. When you get those people to look at a certain piece of code, you get a very, very common reaction.

INTERVIEWER: Has anyone in particular influenced you in the way you write code?
GATES: Everybody who wrote the PDP operating system influenced me. And John Norton from TRW, who wrote memos about people’s code–I’d never seen anything like that before. I started trying to do that with other people’s code myself.
There’s been a mixing of ideas between Paul Allen and me, because so much of the programming we’ve done, we’ve done together. It is nice to have somebody who’s up to speed to talk to when you’re debugging code or you aren’t sure about some particular trade-off. In a sense, it’s a way of taking a break, relieving the intensity without having to switch topics, just going in and discussing it with somebody. In the creative process, it’s good to have the pressure off a little bit and yet still have your attention focused. Paul and I learned how to work together in an effective way. You don’t find too many partnerships like that. He’s had a huge influence on me. And then, in the Microsoft period, Charles Simonyi and some of the other people here have influenced me, too.
INTERVIEWER: What do you think is in store for software? Are we just going to keep doing another great word processor or another great spreadsheet? Or will computers branch out into areas we don’t even dream of today?

GATES: We’re just moving down the spectrum of more and more thinking on the part of the computer. I’ve coined the term “softer software.” That refers to a program that molds itself to the user’s needs and the user’s interests over time. There are going to be more great word processors and spreadsheets, and we’ll use networking and graphics and new architectures. And there’ll be massive storage with compact disks (CDs), where you can store encyclopedias.

What’s going to really be different is rule-based programming. It’s different, because instead of just writing the program and saying: “If this happens, do this and if this happens, do this,” which is the way programs work now, you’ll write rules, and then you have this little reasoning engine that looks at the current set of facts and the rules. Then it tries to derive new facts and act appropriately. For example, the program might have rules about gravity, and if something falls off the table, the program knows that if it’s glass, it might break. So the program generates results in a very non-obvious fashion, compared to normal-type programming.
This is the technique on which so-called expert systems are built. Rule-based programming is the idea of having the derivations done through a proving machine, not just laid out explicitly in the program. Perhaps these techniques won’t have an impact for four or five more years. A young programmer who wants to make his mark might be smart to focus on this new type of programming.
INTERVIEWER: Can rule-based programming handle disparate information more effectively than traditional programming?

GATES: Well, it’s somewhat hard to explain. Let’s say you have a program that figures out how to build bridges. It’s got all this stuff about stress and bending and the properties of metal. Embedded into that program is knowledge about engineering and materials and things of that nature. If you come along and say, “We want to build bridges out of plastic,” to that program, that’s as massive a change as to say, “I want to build bridges on Mars.”
In rule-based programming at its extreme, all the physical principles embodied in how much stress metal can take, and how gravity works, would be stated explicitly as rules. And all the deductions would come from examining those rules and working them through. Today we don’t have good enough rule-proving engines; it is unbelievably inefficient to try to do things this way. But this is one of the techniques we are making progress in, and it is on the horizon as something that might change programming. That, and another idea: that we might have hundreds of computers all running in parallel at the same time. In fact, that might help us to run this rule-based stuff efficiently. That sort of major architectural change might influence how people program or how they think about programming.
The scariest thing to programmers is that compilers will get so good or computers will get so fast that programmers won’t count any more. I used to always have the fear that when I chose to specialize in something, its importance might diminish over time.
INTERVIEWER: Microsoft is a broadly based company and the industry as a whole is changing rapidly. How do you keep up with everything?
GATES: Well, I don’t keep up with everything. I’m working with the top people at IBM, at Apple, at DEC, and in Japan. I have to know what’s going to happen; I can’t waste a lot of time guessing. When I fly somewhere with somebody from Microsoft, we talk about what’s happening. And the E-Mail system at Microsoft is an efficient vehicle that helps me keep up.
One way to keep up is to use personal computers, and to make sure that I’ve read the manuals and used the top ten software products. Those products don’t change so often that I can’t be very familiar with each of them. If you really give a darn about personal computing, you will have used every one, and know something about them and think about how you could do better than those packages.
In a sense, personal computers have become simpler. Now we have just the two architectures: the PC and the Mac. Back in the good old days we had thirty or forty different machines that were totally incompatible, and there were a whole bunch of languages that people were messing around with. Because we’ve brought millions and millions of people in, we’ve had to make it more homogeneous, more standardized, so that they can get some sense of what’s going on. A lot of what goes on in the industry doesn’t really advance the state of the art. I like to concentrate on networking or graphics, because what we’re going to do there might have something to do with the state of the art, instead of concentrating on did this retail chain go bankrupt, did this guy bribe that guy, or did this company give this guy enough stock? Who cares? The really smart people here are focused on their areas; they bring me anything they think is of significance, any project that’s going to have real impact.
INTERVIEWER:: Where do you see Microsoft in ten years?
GATES: Our goals are very simple. We’re going to create the software that puts a computer on every desk and in every home. I don’t know if that’ll take ten years–that’s not my expertise, guessing those exact time frames. Microsoft also wants to participate in helping to make sure those machines are good machines, building the system software into them, and then doing a lot of the important applications they’ll use.
And even though there’ll be more and more machines, our present thinking is that we won’t have to increase the size of our development groups, because we’ll simply be making programs that sell in larger quantities. We can get a very large amount of software revenue and still keep the company not dramatically larger than what we have today. That means we can know everybody and talk and share tools and maintain a high level of quality.
One of the new areas we’re focusing on at Microsoft is compact-disk applications. CD ROM is the technology we’re going to use to get personal computers into the home.
INTERVIEWER:: Why do you think it will succeed in the home when other things haven’t?
GATES: Today, if you buy a computer, and then go buy an educational program, you’ll find the process is not very educational. The number of responses, the variety, and the way that the program simulates real life is just nothing. With the massive storage of the CD, we can create a situation you can directly relate to, where the amount of information, the variety of responses, the involvement you feel in it, will be just so dramatic.
It’s a competitive world. With educational software, we’re competing with newspapers, books, and TV. The software programs we put out today just aren’t competitive. Unless you’re just trying to save your kid from being dumb or something, then there’s no real reason to buy the machine; it doesn’t engage you. It doesn’t engage a non-computer person.
INTERVIEWER:: Do you think the new CD ROM applications will compete with television?
GATES: Television is passive entertainment. We’re betting that people want to interact, choose different paths, and get feedback from the machine about what they’ve really learned. They can look up something specific that they’re interested in. It’s the interactive nature of the device that differentiates CD ROM from just turning on a TV and watching something.
INTERVIEWER:: Will you apply a lot of the same principles that go into designing your applications to CD ROM software products?
GATES: CD ROM is totally different. We hope with CD ROM you’ll be able to look at a map of the United States, point somewhere, click, zoom in and say, “Hey, what hotels are around here?” And the program will tell you. And if you’re in the encyclopedia and you point to one of Beethoven’s symphonies, the computer will play the song. It’s a new interface; it’s got nothing to do with productivity tools like word processors or spreadsheets. CD ROM programs will solve totally different problems. Like any new media, it’ll be incredibly competitive. How can we use programming skills to make a better CD ROM application than somebody else? That requires some very profound thinking. It’s not another market for programs we have already done. It’s a market where we hope our intelligence will allow us to create something new and appropriate.
INTERVIEWER:: So it’s not so simple as taking a bunch of newspapers and putting them on a CD ROM and writing a retrieval program?
GATES: Well, some people will do that, but we won’t; that’s not exciting. We really believe we’re going to have CD ROM machines in every car and in every house. And when you go to a new area of the country, you’re going to stick that little disk in there and pan around and have it show you routes, and have it tell you about points of interest.
Take an area like sports. You’ll have a sports disk that you push in and you’ll get records and pictures of the guys. You’ll be able to look at the old games, and you’ll be able to look up rules. Every single disk will have lessons to teach you an area you want to learn about. Every single disk will have quizzes, like, “Hey, you think you’re so smart about baseball. Well, who was this guy, or what did he do?”
Every disk will have interactive games on it; on the sports disk that’s pretty obvious. On the music disk, the game will be “Name That Tune,” and you’ll be able to look at scores, look up people who wrote music, and hear how different instruments sound. You’ll sit there and type in your own little scores. And if you’re a pilot, you’ll probably be interested in pictures of airports and planes, and stuff like that; we’ll have it on a disk for you.
INTERVIEWER:: Will these CD ROM applications be sold in bookstores?
GATES: Eventually. In the bootstrap period, we are trying to decide which channels we appeal to. Specifically, is there a role for the specialty computer retail store? I personally don’t think so, but it’s hard to say.
Some CD applications sound like a fantasy. But how often is a new media invented? Almost never. Videotape’s not a new media, it’s just delayed broadcast to TV; there’s nothing different about videotapes. Interactive video disk had a chance to be a new media, but it didn’t reach critical mass. It didn’t get enough material, low-cost players, convenience; it didn’t get absorbed into the culture. Compact disks are a superset of interactive video, but we’ll have to do even better.
The changes that CDs cause will be great. I just don’t see parts catalogs being issued in print form ever again. For anything that’s reference oriented, where you don’t want to just turn pages, but want to look up the information and manipulate it and see it in different ways, this electronic form is just far, far superior to most other forms. Our toughest competition is clearly books. We’re not going to really hurt the book market, but CDs will substitute for catalogs and certain types of reference materials.
INTERVIEWER:: Do you think a culture is going to grow out of this, like the television culture?
GATES: I don’t know what a culture is, but CDs are more interactive than television. The CD isn’t just specific to programming like personal computing is today. And yet it has the same sort of addictive, involved-type attributes. You’re going to be involved, you’re going to be quizzed, you’re going to say, “I’m a superstar, let me try this out.” We’ll do the quiz so you can have multiple people involved in picking a question for the other person to answer. If a kid is addicted to a personal computer, I think that’s far better than watching TV, because at least his mind is making choices. I’m not one of these npeople who hates TV, but I don’t think it exercises your mind much. I don’t happen to own one.

INTERVIEWER:: Do you think that the development of CD ROM could be crippled if different standards are used?

GATES: There is massive political maneuvering on the part of Microsoft and companies hundreds of times our size, to establish standards in this area. There is the potential for two, or even three, incompatible viewers. And given the cost to create the software for this stuff, that would be unfortunate. So that’s where a lot of our focus and attention goes. We’re trying to make sure that our standard is the standard. That’s going to be hard; it’s going to be a challenge. We have to move very, very quickly to get all the activity focused around one standard, and we have to make sure it’s a decent standard.
A viewer like this couldn’t be done if it wasn’t for the semiconductor industry. It’s the unbelievable low cost of memory and high-speed processors, video chips and audio chips, that allows us to make computers a multi-media thing. The semiconductor industry is performing the miracle. It’s only over the last two years that all the components have been purchased in incredibly high volume for other uses, and therefore have been driven to an attractive lower price.
INTERVIEWER: Do you see CD ROMs merging with expert systems?
GATES: No, the two don’t rely on each other. Eventually you may distribute the data for expert systems on a CD, because you can put quite a large database on it. But neither one requires the other. They both have their own difficult challenges to face.
The mix of skills required to do the world’s best CD is pretty intimidating, because it’s video, it’s audio, it’s programming, and it’s interactive. It’s hard, just like any new media. When people were first on TV, they felt they were so much better than people on radio, but they’d just stand there. It took a long time to invent the colorful peacock, all the action, the three-dimensional padding, and the special effects that you see on TV today. Just like TV, CDs will get better as we get more experienced with the media. I can sit here and tell you all the mistakes we won’t make, and five years from now, I could sit here and tell you all the mistakes that we did make. As creative as we are, we won’t be able to exploit the media to its absolute fullest right away.
INTERVIEWER: Do you ever wish you were back programming on your own again?
GATES: Oh, sure, absolutely. Then you control everything. There’s no compromise. Every line is yours and you feel good about every line. It’s kind of selfish, but it’s like being allowed to do pure mathematics, and yet you have the feedback of making something really work. I sometimes envy my colleagues who get to focus just on the program they’re writing.

Copyright 1986, 2008 All Rights Reserved.