Tuesday Jun 14, 2005

Open




Ok, guys, we're open. Finally! I thought this thing would never be born. It's been quite a year around here, both internally at Sun and within the OpenSolaris Pilot Program. So I thought I'd talk a bit about the pilot program itself, how we built it, why we built it, and how it all worked out.

The Pilot Plan

The plan was simple -- get a small group of people together from the Solaris market to work with Sun's Solaris engineers on opening 10 million lines of code. Call it a "pilot program" or something, but just grab some guys and get going. But, wait. What about all that IP? No problem. Call the lawyers and write an NDA until we have an open source license. Get going. That's how the OpenSolaris Pilot Program began -- under an NDA with literally a handful of people internally and externally. Over 9 months (almost to the day) the pilot program grew to 145 guys externally from 12 countries, and we turned away dozens more (due to lack of time, basically). Today the project is open, the pilot program ends, and I never never want to see another NDA in my life.

Building the OpenSolaris Pilot Community

Initially, no one around here had a clue what the Solaris community looked like. I sure as hell didn't, but there were many opinions. Also, we had data and a dripping gallon of slideware on what the Solaris market looked like. But a market is not a community. Does the community even exist? Everyone agreed that the largest collection of Solaris developers in the world lived right here at Sun. There are about 1,000 of them under the Sun roof. Well, there's a nice little community we can start with, right? But what about the external community?

I became convinced, however, that the community did, in fact, exist for two really simple reasons: (1) The Solaris market surely exists, and (2) Sun's competitors attacked us hard and said that "the community doesn't exist." They were so consistent and so loud with this line that it became clear that a lot of people were nervous. But where is it? Simple: it lives all around us and has for decades -- it lives within the Solaris market. It's the individual developers, the system administrators and engineers, the professors, the students, and the users of Solaris. I don't care how big or how small it is, it's there. It's very much alive. It simply needs a few things to assert itself: (1) some code and tools, (2) an open source license, (3) a place to collaborate, and (4) community advisors for representation. Well, ok, there are a few more elements we're still working on, but you get the idea. Let's get the basics first.

So, for the pilot program, we simply took a snapshot of the current Solaris market and then grabbed some key slices of that market. Initially, we were going to keep it small, around 50 people or so. But since the launch date kept gyrating (read: slipping) all over the place, we just keep on adding people till we ran out of time. As it is, we had more than a dozen engineers from China that didn't get in on time due various legal approvals. (Sorry, guys.) The pilot program ran from September 10, 2004 to June, 14 2005 -- about 9 months. Also, the program was an extension of the early feedback meetings we did with our customers, developers, the x86 community, and the open source community. So, about a year in total.

We were basically looking for a mix of these sorts of guys:
  • sys admins
  • OS & kernel developers
  • app developers
  • users
  • computer science profs & students
We found this crew in these places:
  • x86 Solaris cabal community (the largest single group)
  • various open source communities (Apache, KDE, Gentoo)
  • universities
  • financial services industry
  • ISVs
  • defense industry
  • and customers generally

How

Actually implementing the pilot recruiting process was pretty simple. Initially, I knew no one, of course, so I went about stealing people from other programs here internally. First stop was Alan Duboff and Eric Boutilier. They had been hanging out with the Solaris x86 cabal and seemed to have a little community going over there, along with Blastwave and Sunfreeware. So, that was about 25 people or so. Next, we went to existing Solaris beta programs (such as Platinum Beta) to steal some of their people. Next we tapped the various Solaris engineering groups for names and got a few dozen that way. Marketing jumped in with some good people at ISVs, customers, and universities. Then people externally started pinging my blog begging to come in.

Word spread slowly at first but then picked up rapidly. More than a dozen people throughout Sun's software organization participated in providing access to customers, ISVs, and developers who would come into the pilot program. Eventually, I was swamped with hundreds of requests, and my office was littered with NDAs because we made people fax them and mail hard copies. Just a mess. Some companies wanted their entire engineering departments involved. Yah, right, like what am I going to do with a 100 engineers from one company? I'm going one guy at a time here! Slow down! Also, once we started bringing people into the program, they started having babies and recommending their coolest friends and neighbors. Frankly, the entire thing was an easy sell -- virtually everyone wants to see the Solaris source; the hard part was trying to get the right kinds of people who wanted to contribute to a very, very early program. Had we built a recruiting system that could scale, we could have easily put 500 or a 1,000 people into the program without breaking a sweat. I know, I know ... the Solaris community is not supposed to exist, but we all know that's competitive PR bull. Whatever. We started small because we needed to start small.

Why

Why a pilot program? Simple -- to begin the conversation between the Solaris engineers and the external community, to begin formally building a community, and to actually find out what we needed to do in the first place. That's pretty much it. We wanted to launch with a small group of people already talking on mail lists and already familiar with the sources and tools, so they could help build the community. We wanted to literally point to a community that was already underway and build from that pilot after the launch. No big secret here.

Contributions

So, how has the pilot community contributed? Lots of ways, including:

  • Finding bugs in the source and offering fixes
  • Providing critical feedback on the license
  • Giving guidance on governance, development tools, source code management systems, and documentation
  • Electing their own representatives to the Community Advisory Board
  • Testing the building of OpenSolaris and the viability of the set of components that were offered
  • Starting work on 3rd party distributions and ports
  • Organizing a PowerPC community with little involvement from Sun
  • Blogging in support of the project and posting screen shots of fresh OpenSolaris builds
  • Engaging in interviews with the press and defended Sun and OpenSolaris from competitive attacks
  • Offering feedback on the technical and artistic direction of the web site
  • Offering feedback (sometimes painfully) on marketing, launch, trademark, and branding issues
  • Supporting the January 25th release of DTrace and the CDDL license
  • Participating in executive-level feedback programs
  • Contributing to more than 7,500 messages of content on the pilot's mail lists
  • Telling us we were full of garbage (more than a few times) when needed
  • Trusting us (sometimes more than we trusted them ... but we improved over time)
  • A bunch of stuff technical stuff I really didn't understand, to be honest


Lessons

So, when we build another pilot program like this, I'll keep these lessons in mind from this year's experience:
  • Don't waste too much time recruiting big name customers for PR purposes. Focus instead on a few developers within those customers who are hungry to collaborate and who already contribute to open source communities. We found some extraordinary people this way, and I bet there are a bunch more out there.
  • Don't bring in people simply because they want to see the code (hell, everyone wants to see the code). Focus instead on individuals who want to learn about the code, share their experiences with the other members of the community, and take on new responsibilities.
  • Keep the program relatively small. We could have easily put 500 hundred of people in this program, but I doubt that would have helped one bit. Start small. Grow slow. Release when ready.
  • Leverage pre-existing Solaris communities more -- in this case Blastwave, SunFreeware, and the Solaris x86 cabal.
  • Get more recommendations from top performers who are already in the pilot. Some of our best guys came from pilot recommendations.
  • Get more recommendations from the core kernel engineering team. They wrote all this stuff, right?
  • Decide early on that the pilot community is equal to the internal team and that nothing will be held back. Nothing. In other words, don't have an internal team and an external team. Blend them into one team so that the NDA actually means something. It's much easier to do this with a small pilot community, so you can run under the radar and not upset too many people internally. We grew big enough so people internally noticed, but sometimes we had to trust to open up more. We could have opened up a lot more, but hey, this was a learning experience. Look at where were last year. We've come a long way.
  • Don't worry about leaks. Let marketing and PR deal with them. They are largely irrelevant. During the entire program, the pilot community didn't leak any NDA information or code. Leaks represent an old, closed mindset.
  • Focus more on individual developers (as opposed to "customers" or "ISVs"). Communities are all about people and people come one at a time and have first and last names, not company names and titles.
  • And finally, your best people will come from places you don't expect. Look there.

This is really wild for me. I remember way back at JavaOne 2002 when I was in PR ... I was in a briefing with Rob Gingell (then Sun Chief Engineer, Sun Fellow, and Chair of the JCP), who was supposed to be talking to the press about, well, Java. But Rob wanted to talk about Solaris, and how we were going to open source the system. He's talking open source Solars at JavaOne? Nice. He was determined, he said. I was just looking for some air cover since that wasn't the "PR message" of the day. Anyway, very few people externally listened back then, but I thought this was pretty cool. So, I set up a little media tour for Rob to talk Solaris (here, here, here, here, here). Good stuff from a class act.

Things didn't really heat up till Schwartz want to China, though. Remember that one? I joined the Solaris engineering team a few months before that keynote in 2004 when the new boss announced our intentions on stage at SunNetwork. Ok, now we're off to the races (here, here, here). In between Schwartz's announcement and now, we did extensive briefings with our customers, we built a pilot program, we wrote a license (that was a wild one), we released DTrace, we opened an initial web site, and we formed a Community Advisory Board. While all that was happening, the engineers (primarily Andy Tucker, Keith Wesolowski, Mike Kupfer, Derek Cicero, Bonnie Corwin) were working with the pilot developers and building the guts of the program. How Karyn, Stephen, and Claire managed it all I'll never know. I sure as heck couldn't.

So, although we are "launching" today, the project has been discussed quite openly for years internally and externally in multiple events, releases, announcements, and keynotes. True, this is the largest bit in that string, but there will be more. OpenSolaris changes everything at Sun. Everything.

Technorati Tags: |
About


Search

Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today
Bookmarks

No bookmarks in folder