The Microsoftie Who Embraced the Dark Side (Open Source)

At the University of Michigan in the early 1990s, I knew I wanted to go work for Microsoft. I had long been a fan of Apple, but their computers cost so much I felt they would be relegated to a niche in the computer industry. I thought Microsoft had a much more expansive view of the power of the PC. Even on my Mac Plus, I spent nearly all of my time inside Word and Excel.

I took lots of interesting CS classes in college, but I wanted to learn about real software, like how a word processor stores text. I knew you couldn’t just store text in one big array, because typing text at the beginning of a document would be very slow as it shifted down all of subsequent characters in the memory buffer. I wanted to see production code and learn the craft of programming, and I felt MS would be the best place to do it.

Microsoft’s reputation has taken a hit over these last 15 years, but at the time, it was the best option for me. They had people working on many aspects of software: kernels, compilers, class libraries, word processors, databases, and researchers doing fancy things. And they were just getting going!

In 1993, I got a job as a summer intern in the FoxPro group. It took me a day of hard interviews, where I had to write little routines to do bit manipulation, and be generally grilled by smart and experienced programmers, but I passed and got hired as an intern programmer in FoxPro. At the end of the summer, I asked if I could stay on and not go back to school, and they offered me a full-time job, which I accepted.

I worked for my first two years of MS in that team. I got paid, while I was learning more about programming that I could possibly have learned in my last year of school. I had read enough Homer and psychology for a lifetime and was ready to get down to the business of working on computers, which I loved. Getting paid to learn is not a bad thing. If only college worked that way!

FoxPro was not my ideal choice of technologies to work on. I thought the xBASE language was bizarre but it was my step in the door, and the team was friendly and smart. I absorbed a lot from my team, and from people working on other teams. I remember spending some late nights browsing through the source code to NT, porting FoxPro to the MIPS processor, reading the fascinating discussions on the internal perf alias, etc.

After that, I left and worked for five years on text engines, two years in Sweden on mobility and server software, where I also learned about .Net, which was a major epiphany for me. I then returned to Redmond to work on the watch and accompanying data network, Spot.

All were interesting and my experience gave me a flavor of many aspects of software technology, from embedded to internationalization to databases and services.

One day it just hit me — I should quit. There were no big reasons, only a lot of little ones. I had just launched v1 of the client and server side of Spot, and while it contained sophisticated technologies, I didn’t really believe it would take off in the marketplace. I had gained lots of knowledge yet only understood the Microsoft world. I had made some good money, but I had no time to enjoy it. Though my boss was happy with me, I was losing motivation to just keep doing the same thing I had been doing for over a decade. I looked around the company and saw a lot of ancient codebases and unprofitable ventures.

My mom didn’t approve of my quitting before finding my next job, but I knew I could only properly figure out what was next after I left.

Little did I know what was in store for me.

A few weeks after leaving, I decided to try Linux. I had played with Firefox and OpenOffice for a few hours while at the company, and even wrote an e-mail to our legal team telling them that my friend Alex Mogilevsky’s patented work on background spell-checking had been stolen by OpenOffice. But I had never used those apps beyond my brief testing, and had never run Linux.

I have forgotten more about Windows than most people will ever bother to learn, so I was extremely scared about setting Linux up, because I didn’t want this little experiment to screw up my main environment.

Every little decision was big for me: do I dual boot or should I be safe and get another machine? Which distro? Will it corrupt my hard drive or should I get another hard drive? I got some tips and assurance from a former co-worker who had installed Fedora, and with that help I proceeded with the installation.

While I came to not be all that thrilled with Fedora Core 3 itself, I was floored merely by the installation process.

It contained a graphical installer that ran all the way to completion, it resized my NTFS partition, setup dual boot, and actually did boot, and let me surf the Web. I didn’t have a clue what to do next, but the mere fact that this all worked told me more about the potential of Linux than anything I had read so far.

Before I had started this, I told myself that I would force myself to boot into Linux to try it out even though it meant losing my place, waiting for the reboot, and not being nearly as comfortable. But several months later – and by this time I had started using Ubuntu Breezy Badger – I was using Linux all the time.

I ran into various stumbling blocks along the way: I had to learn about the xorg.conf file, dig into superuser and Linux file permissions, learn about SSH, and compile some Intel wireless drivers. But each stumbling block gave me a worthy challenge, and also newfound knowledge, and the fact that I was able to succeed every time gave me courage to continue.

And what impressed me was the power of it all.

Linux came with tons of applications: OpenOffice, GIMP, Audacity, Nvu, Eclipse, Apache, MySQL, and thousands more for me to discover. I could spend years in the command line and never learn all of the applications and capabilities. Installing Apache took just a few seconds, and gave me access to a vast world of PHP. Installing WordPress took me 15 minutes the first time, but I knew when I became better at things, I could do it in one.

I came to understand that beyond its poorly debugged device drivers, a Windows computer is a sad joke. By mid-2005, I was in love with computers again!

However, I had also started to realize that while Linux had lots of amazing capabilities, it was not on a trajectory to kill Windows very fast. I wrote a post on my blog on October 2005, listing a bunch of bugs I had found and filed, but I also started to notice that the bugs weren’t getting fixed.

“After The Software Wars” by Keith Curtis

As a side note, while Microsoft doesn’t have a great reputation right now, especially because of Vista and malware, there is a lot of clever code and brilliant engineers inside the company. I was fortunate to learn with a bunch of great people, in groups that fostered cultures of very high quality software. Don’t blame me for Vista bugs! People forget all that, but this is why Word beat WordPerfect, IE beat Netscape, Excel beat Lotus 1-2-3, VC++ beat Borland’s compilers, ad infinitum. (Microsoft’s biggest problem today is they are overwhelmed with the complexity of their software and hampered by their ancient code and old tools.)

Anyway, as I got more comfortable with free software, I saw all of these bugs and became frantic. What was the problem? Where was everybody? Why was Ubuntu shipping with 10,000 active bugs? Why was Debian’s big team not helping Ubuntu on them, and why were they even split off in the first place? It seemed to Ubuntu, the bug list was a potentially useful management tool, not the single most important thing their entire organization could possibly be focused on.

I started writing several blog entries describing my thoughts on the state of Linux and what steps it needed to do to take over, like this one (about Linux’s bugs), this one (about challenges for Debian), and this one (about challenges for Ubuntu). I eventually decided to put all of my thoughts together into a book, which I have just finished.

It took me quite a while to get all of this together. I went to many conferences, talked to hundreds of programmers, read lots of source code, magazines and books, visited many Websites, did a little hacking, and otherwise gathered a ton of data. This allowed me to put a book together that talks about why free software kicks ass, but also what steps are remaining for total world domination, and other related topics I discovered as important along the way.

(In fact, I’m still working on the Web chapter! If you read it, feel free to send me your thoughts.) One chapter even started as an explanation of why Java is the future of programming, but evolved into a chapter on why we should kill it.

Free software could have become the dominant model years or decades ago. Some wonder whether free software and proprietary software will live in some indefinite détente. I think it is the sort of détente that exists between a farmer and his turkey — until Thanksgiving. Let’s eat! A 21st century renaissance beckons, with free software at the center of it.

The book isn’t really about Microsoft as much as it is about the Microsoft proprietary development model that has pervaded or even infected computing. Microsoft could even be a part of this future, a topic I take up in the book’s Afterword. Although Microsoft as a free software company would be something we would not recognize today, and one reader suggested this Microsoft as a free software company is was more like science fiction than the book’s section on driverless cars.

The download page for Keith Curtis’s book is here: After the Software Wars