“Art alone is not enough for a cook … the cook should have the taste of his master.”
—Martial, Epigrams, “The Cook” (first century AD)
“Real artists ship.”
—Steve Jobs, to the Macintosh team (1983)
In the summer of 2005 I gave up a good job to audition for a better one.
I was an IT architect in IBM Global Services, with a fine reputation and the glowing reviews to prove it, and I had spent years working my way out of writing code. Then I got to know the Jazz team, mostly the people who had built Eclipse, and found out that over there everyone wrote code: the developers, the architects, even the executives. It was Kurt Bittner, a product manager, who said what I hadn’t dared to: “You’ve got development experience. Why don’t you talk to Scott Rich about joining the development team?” Kurt believed I could do it before I did.
Nobody on that team cared about my reviews. They cared about what I could build, and they didn’t know yet, so Scott offered me a trial: two months, and if it didn’t work out, no harm done. They didn’t let just anyone in. I took that as a compliment, and as a lesson. I had a good job to lose, and I bet it anyway. Put me in, coach.
I worked harder those two months than I ever had. When Scott finally asked me, in a chat window, whether I’d like to join the team, I typed about eleven exclamation points. It felt like being called up to the big leagues, and it taught me the lesson I would build everything on: don’t tell people what you can do. Show them. The work speaks for itself.
What a team it was. Raleigh, Ottawa, Toronto, Zurich. People who had already changed how the world wrote software once and planned to do it again. You could throw a pass to anyone on that team and they’d catch it, and usually do something with it you hadn’t imagined. Everyone was smart. I mean everyone. We were, I was quite sure, the best and the brightest.
The culture came from OTI, the little Ottawa company IBM had bought that became Eclipse’s heart, and Ottawa leaders like Dave Thomson and Jean-Michel Lemieux handed it to us in sayings that sounded like a creed. The team succeeds or fails together. You do not learn by agreeing with people. Get it done or get out of the way. We argued constantly, about the architecture, never about titles. When I broke the code freeze at the end of 2006 by delivering one fix too many in the middle of the night, John Wiegand and Scott didn’t yell. The penalty was coffee and donuts. When my subsystem was struggling, Erich Gamma opened our review by telling me everything that had gone well. Marcus Aurelius begins his Meditations by thanking the people he learned from, and I started keeping a list like that in my head.
Erich was at the top of it. He had co-written one of the most important programming books ever published, and as our overall product lead he still reviewed every component, right down to the web UI frameworks I led. I wanted to be him. Someday, I figured, I’d write a classic book of my own and build software that changed the industry. In the meantime I was, I think, a pretty good follower. It’s easy when you’re following people like that.
The best part of my week was design reviews with the UI designers in Toronto. Seeing a new design felt like Christmas morning. One of them, Jen Hayes, and I started reworking the UI together, live, instead of trading specs, and I swore I’d never go back.
And the thing we were building! Not another bug tracker or version control system, but a place: a single home where the whole team lived. The plans, the work, the code, the builds, and the conversations about them, all connected. We called it Jazz, and it was a platform. Products would come and go; the platform would last. Grady Booch had imagined something like it in a paper years earlier, and when I demoed him the dashboards Dejan Glozic’s team had built on our web frameworks, I floated home. Collaboration, I was certain, was the whole game. It was a great notion.
We ate our own dogfood, every day. Our bugs, plans, and source code lived on our own self-hosted Jazz server, so every rough edge cut us first. Every two-week sprint ended the same way: a new build, deployed to the server we all worked on. If it wasn’t good enough for us to live in, the sprint wasn’t done. That was how Eclipse had been built, and it felt about as fast as serious software could go. When Erich’s project dashboard ran eighteen queries at once, we joked that he’d caused the power outage in Toronto. When the server went down, everyone pinged Ritchie. We were our own first customer. We were the people this was for.
Early on, before it was even called Jazz, a few of us worried that marketing would name it something like the “Rational Team Collaboration Platform for Geographically Distributed Development and Governance.” We laughed. That wasn’t who we were.
In that first year I also got it into my head that tools like ours would eventually live on the web, as services, the way Salesforce did. I took it to my boss, and then to his boss. The answer, when it came, was reasonable: it made sense in principle, but not in practice. Our customers ran their own data centers, often with software from our sister division, Tivoli, and they were not about to put their source code on somebody else’s server. It was the rational answer. We were, after all, Rational. I let it go. There was a platform to build.
We opened our doors. Customers could watch our plans, read our bugs, and argue with us in public on Jazz.net, a site I ended up running. I spent a lot of energy coaxing colleagues to answer questions in the open forums instead of private email, and I imagined a day when every developer in IBM would work in one shared place like that, bumping into each other, learning from each other. It was slow going. Culture change takes time, I figured. We had time.
I’ll admit I didn’t have much patience for the rest of corporate life. Building slides for a talk in Beijing, I joked that PowerPoint was the IDE of corporate bureaucrats. Real engineers let the code do the talking. When other IBM teams saw our web framework and said it was really nice, really useful, and they’d get back to us, and then never did, I wasn’t worried. They’d come around.
In 2007 word came down: the platform needed a first killer product on top of it. Fair enough. Platforms need products. So we built one, a server, an Eclipse client, and a web UI, and called it Rational Team Concert.
Somewhere in there, a friend at an analyst firm and I traded notes on a question that seemed fun and a little academic: what does it even mean to ship software, now that so much of it lives on the web? Good question. We had a release to finish.
The spring of 2008 was the endgame for 1.0, and it consumed everything. It was like running rapids: everyone paddling, no one steering alone, and either we all made it or none of us did. Hundreds of unread emails, code cutoffs counted down to the minute, release candidates tested until we were sick of them. Out in San Francisco, a few people launched a website for sharing code. It didn’t feel like an inflection point. It felt like a Thursday. We were heads down.
In June our executives announced it from a big stage in Orlando, and on the 25th we put Rational Team Concert 1.0 up for download. It was the best day of my career, to date. The next morning I wiped my laptop and installed Ubuntu, just because I finally had the time. By the next week Erich was already measuring it against what it should be, not what it had been, and so was I. (My mom, meanwhile, had long since told her friends that I worked on Jazz. Several wrote back to say they hadn’t realized I’d become a musician.)
Then it sold. Really sold. Large enterprises loved it: companies with thousands of developers and auditors to answer to. They wanted control and traceability and approvals, and they paid very well for them, and we gave them what they asked for. I didn’t think much about the money. That was somebody else’s department. Besides, whoever built the developer tools of the future, it was going to be someone with resources like ours.
By 2009 I could see what came next, and it was thrilling. Everyone was talking about “cloud.” Most of it was hype, some of it wasn’t, and I read everything Tim O’Reilly and my friends at RedMonk wrote, trying to tell the difference. IBM announced a partnership with Amazon’s new cloud, which I loved, because Amazon ate its own dogfood, just like us. That spring IBM also announced that some folks in Research were teaching a computer to play Jeopardy! Good for them.
I wrote myself a goal: next year, bring the spirit of the web to Jazz. One afternoon that summer I deployed Team Concert into IBM’s brand-new cloud and watched our web UI load from a server I would never see or touch, and I sat back and thought: there it is. That’s the future. I didn’t need anyone’s spreadsheet to tell me. I could feel it.
Talking about where the industry was going was, for me, the most fun you could have without a compiler. But that was a hobby. Strategy, the real thing, was what executives were for. I’d read Lou Gerstner’s book about turning IBM around and enjoyed it the way you enjoy a good war story. My job was to build the thing, and build it well. Our general manager, Danny Sabbah, came down to visit the lab that fall. I knew him a little better than most non-executives did: I’d email him, he’d email back, and we’d had a mentoring chat or two. Good conversations. The kind of advice I figured I’d need someday, when I was an executive.
Life was good. Two little kids at home. A team I loved. Work I believed in. I was comfortable. Happily, completely comfortable. I couldn’t imagine working on anything else.
And I knew what to do next. I’d been taught that if you build the right thing, well, with great people, the work speaks for itself.
So I went back to work. It felt like a beginning.
A prequel to my strategy series. Once you’ve read it, here’s the foreshadowing key. Home