Thursday Jan 28, 2010

OpenSolaris: My Original Pre Launch Email in 2005

Earlier today I was thinking about the original "good luck" email I sent to the OpenSolaris Pilot Community just before we opened the project in June of 2005. Fortunately, the opensolaris-discuss public archive actually goes back 9 months before we launched, so this mail survives in the open and from the other threads you get a glimpse into some of the very earliest conversations taking place when the project was private. Anyway, what strikes me is how different the situation was back then, how utterly conservative we were, and how my thinking has changed as a result of my experiences all along the way. A day after I sent this email, we opened. See my opening blog here, and the result of that opening announcement here. History. Always enlightening.

[osol-discuss] Good Luck and Thank You

Jim Grisanzio Jim.Grisanzio at Sun.COM
Mon Jun 13 17:27:01 PDT 2005

Hello, OpenSource Pilot Community.

I just wanted to chime in before the fur really flies around here:

 Good Luck, and Thank You!

You all deserve Sun's thanks for your efforts and your patience this 
year. It should be wild day tomorrow, for sure, so light up those blogs 
and start talking, guys. The engineers are leading this launch tomorrow, 
make no mistake about it.

Oh, and if you want to bring someone into the program, you \*don't\* have 
to call me and sign another f\*\*\*\*\*\* NDA. Just do it. I can't tell you 
how happy I am to not have to dig out another NDA. Not that I could read 
the damn thing but whatever. It's such a cold way to start a friendly 
little conversation, don't you think? Also, I've tried to honor as many 
of your requests (and those from internal people) as possible to get 
people into the program. We ended up with 145, but quite frankly, dozens 
and dozens of developers never made it in due to lack of time or 
resources. We even had a dozen Chinese engineers all briefed, 
translated, and NDA-signed but couldn't get export control approval in 
time. It drove me nuts for three months. I'm more than a bit pissed 
about that one.

Anyway, I hope you are happy with the results of what we are all 
releasing. The core team here has worked almost non-stop for weeks on 
this to get ready for the final push. We wanted to do more, you know 
that, but hey, look at where we were last year and look at the potential 
tomorrow brings. Also, the OpenSolaris team internally really has been 
genuine in their intentions, I can assure you. At times we've not been 
as open as we could have been -- we get that -- but I hope you believe 
me when I say that many people on the team fought hard on your behalf 
all year long. Every time you told us we were full of shit on something 
we took it to heart and it went up line. There were a few, ah, heated, 
conversations regarding some of the issues that were discussed in the 
pilot. We won some and we lost some, but every time we moved a little 
closer to our goal of openness. As you've seen, this stuff takes time. I 
wish we could have exposed more of that process to you. Next time it 
will probably be easier to do that.

As this program has grown it's garnered attention from all across Sun 
and from Sun's competitors and supporters. Just recently, I've heard 
from executives and engineers traveling to South America and to Asia, 
and they report that there \*absolutely\* is massive community interest 
out there. Even Wall Street has noticed. Some people are probably a bit 
confused since the Solaris community was supposed to be dead by now. 
Well, too bad. It's too late. They lost their window of opportunity to 
crush us. Our next step is to stay positive and to engage the interest 
we know is there, make it tangible, and grow this OpenSolaris community.

In a very real way, you've all been part of something special here. 
You've helped change this company and potentially an entire market along 
the way. Some people may not know this quite yet, but they'll surely 
find out tomorrow. You are some of the most knowledgeable people in the 
world about Solaris, and you've help make OpenSolaris a possibility. 
Congratulations and we'll see you on the other side.


Friday Oct 16, 2009

Looking Back: Spamming the Linux Kernel Mailing List

I subscribed to the Linux kernel mailing list recently. It`s way too technical for me to really follow very closely, but I just wanted to get a feel for the personality of the community. It`s interesting. And things move very rapidly.

But watching all this Linux kernel mail flowing by all day long reminds me that I do actually have some experience posting to the list. Twice, in fact. And it was by far the single most embarrassing moment in my OpenSolaris life, although I must admit it stings much less now all these years later. Here it is. Back before we opened the OS/Net consolidation in June of 2005 (that`s what people consider the main opening of the project), we had been collecting email addresses on our temporary site that hosted the DTrace code, which we had previously opened in January of 2005. People would enter their email addresses into a database on the site so we could then alert them when we opened the main code base. I hated the idea of doing this but obviously lost the argument. Also, I was asked to write the email that we would send to these people announcing the opening of our kernel. The whole thing made me nauseous. But, so be it. On opening day my mail shot out to well over 7 thousand people via our corporate systems. It didn`t come from my mailer, that`s for sure. I just submitted the text to another team and ducked. And did we clean the list beforehand? Of course not. We just let all fly. And it ended up in some rather interesting places -- one of which being the Linux Kernel Mailing List. Here it is. I was mortified. And here is my apology to the entire Linux kernel community shortly thereafter. Like I said, I hated the idea of any mass mailing outside for just this reason. Sure, it was well intentioned, but it was also unnecessary, poorly implemented, and easily gamed. Obviously. Anyway, I did get a few private responses from list members who were very kind and understanding. That made all the difference in the world.

Lessons learned, eh? Hey, you have to go through some pain to learn this community business, right? Fun stuff.

Tuesday Jun 14, 2005


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


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 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.


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


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: |


« June 2016

No bookmarks in folder