Rules For Revolutionaries (2000 edition)

April 7, 2020

The below message is from 2000 but I think it still applies to open source collaboration in the 21st century.

I wasn’t part of the Apache Jakarta story myself but have heard of that a few times ;-)

It was written by James Duncan Davidson, I don’t take any credit for what follows – I just copied it back here from a public archive, to make it easier to find it next time I need to quote it.

Date: Thu, 13 Jan 2000 15:46:41 -0800
Subject: RESET: Proposal for Revolutionaries and Evolutionaries
From: James Duncan Davidson
To: general@jakarta.apache.org
CC: tomcat-dev@jakarta.apache.org

Ok, the logical place for this is general@jakarta, but I’m including tomcat-dev@jakarta so that the people who are there and not on general can see it. Please do not discuss on tomcat-dev, please only discuss on general.

In a closed source project where you’ve got a set team, you make decisions about where the entire team goes and somebody takes the lead of deciding what gets done when. In the discussions about Craig’s long term plan, this metric was applied by several of us in thoughts about where to go next.

After pondering this for a while, it’s (re)become obvious to me that there’s no way that anybody can expect an open source organization to work the same way that a team in a corporate setting can. Ok, so this is pretty freaking obvious, but I’ve been watching people that are not from Sun and who have been doing open source for a while talking and proposing things that come from this line of thought as well. Its not just people from Sun or people from any particular entity.

So — in any software development project there is a natural tension between revolution and evolution. In a closed source environment, you make the call at any particular time on whether you are in revolutionay mode or evolutionare mode. For example, JSDK was in evolutionary mode for years.
Then in Nov 98, We made a decision to go revolutionary. Of course, at the time the project team was composed of 1 person — me, so it was an easy decision. After that revolution was over in Jan 99, Tomcat was in evolutionary mode getting JSP bolted in and working with J2EE. We (Sun
folks) could do that because that was what suited the goals best at the time.

However, Open source is chaotic. With its special magic comes a different reality. This is:

1) People work on their own time (even people paid by a company can be considered to be working on their own time in this situtation as each company is going to have different cycles and things they want)

2) People work on what they want to. If you are working on your own time, you are going to do what you want or you do something else.

3) Some people are evolutionaries, other are revolutionaries, and some are both at different times.

4) Both approaches are important and need to be cultured.

5) You really can’t afford to alienate any part of your developer community. Innovation can come from anywhere.

To allow this to happen, to allow revolutionaries to co-exist with evolutionaries, I’m proposing the following as official Jakarta policy:

1) Any committer has the right to go start a revolution. They can establish a branch or seperate whiteboard directory in which to go experiment with new code seperate from the main trunk. The only responsibility a committer has when they do this is to inform the developer group what their intent is, to keep the group updated on their progress, and allowing others who want to help out to do so. The committer, and the group of people who he/she has a attracted are free to take any approaches they want too free of interference.

2) When a revolution is ready for prime time, the committer proposes a merge to the -dev list. At that time, the overall community evaluates whether or not the code is ready to become part of, or to potentially replace the, trunk. Suggestions may be made, changes may be required. Once all issues have been taken care of and the merge is approved, the new code becomes the trunk.

3) A revolution branch is unversioned. It doesn’t have any official version standing. This allows several parallel tracks of development to occur with the final authority of what eventually ends up on the trunk laying with the entire community of committers.

4) The trunk is the official versioned line of the project. All evolutionary minded people are welcome to work on it to improve it. Evolutionary work is important and should not stop as it is always unclear when any particular revolution will be ready for prime time or whether it will be officially accepted.

What does this mean?

In practice, this means that Craig and Hans and anybody else that wants to run with that revolution is welcome to do so. The only change is that it’s not called Tomcat.next — it’s the RED branch or GOOGLE branch or whatever they want to call it.

Whenever Craig (or anybody else working on that codebase) wants to bring stuff into the trunk, they propose it here and we evaluate it on it’s merits.

If somebody disagrees with Craigs approach (for the sake of argument here), they are free to create a BLUE whiteboard and work out what they think is a good solution. At that point, the community will have to evaluate both approaches. But since this is a populist society, with such a structure it is hoped that it becomes clear which is the preferred approach by the community by their participation and voting. Or maybe the best solution is something in the middle and the two parties work together to merge.

Irregardless, the point is to allow solutions to happen without being stalled out in the formative stages.

An important point is that no one revolution is declared to be the official .next until it’s ready to be accepted for that.

There is the side effect that we could potentially end up with too many revolutions happening, but I’d rather rely upon the natural inclination of developers to gravitate towards one solution to control this than to try to control it through any policy statement.

When would this be official?

Well, if this is well recieved, we’d want to word it up and make it a bylaw (with approval by the PMC — this is one of the areas in which the PMC has authority). Hopefully soon.

Comments? Suggestions?

James Davidson duncan@
Java + XML / Portable Code + Portable Data !try; do()


Stefano’s Mazzocchi’s Busy List Pattern

December 6, 2011

Since being part of a larger company, I’m hearing people saying “we need a new mailing list for that” way too often.

People are afraid of busy mailing lists sometimes, but in terms of fostering open collaboration and communities a busy list is excellent.

Another problem is people writing 1-to-1 emails instead of writing to the list, as an attempt to avoid making the list even noisier. If your message is on-topic with a well written subject line, and as concise as possible, it’s not noise and definitely belongs on the list.

Stefano’s Mazzocchi briefly explains this in his ApacheCon 2006 slides titled all you wanted to know about Open Development community building but didn’t know who to ask. I haven’t found that pattern described in a more accessible way than among Stefano’s 303 PDF slides so far, so here’s a summary that I hope is faithful to the original idea.

The Busy List Pattern

Here’s my summary of that part of Stefano’s slides (starting at page 200 in his PDF file), with some additional comments of mine.

The pattern starts with somebody suggesting that the mailing list is too noisy and should be split in multiple ones.

Restaurants and night clubs, however, know that packed rooms help marketing…what’s more boring than being alone in a restaurant?

But we’re not a bar…we can’t go on getting 200 messages on that list every day, can we?

Actually we can…if everybody who posts to the list is extra careful about how they post, a list with 200 or more messages per day is perfectly manageable – but only if the subject lines are very carefully chosen and evolved (see below), and only if people are very careful about what they post, to maximize clarity and avoid wasting other people’s time.

We should strive to keep our lists as packed as possible. It’s hard to set a limit, but before splitting a list you might ask if people are using it efficiently. First try to improve the signal to noise ratio, and if that really fails you might consider splitting the list.

If you really need to split the list, do it by audience and not by topic – a consistent audience will lead to an interesting list, whereas scattering topics all around makes cross-topic discussions painful.

Careful with those subject lines

The subject line of messages makes all the difference between a noisy list an a useful one.

Choose sensible subject lines that allow people do decide if they want to read your message or not.

Reread your subject line before sending – does it really express what your message is about, and does it contain any relevant call to action?

Change those subject lines when the thread changes topics.

Address one topic only per thread.

Use [MARKERS] in subject lines to tag messages.

Simple rules like this will boost your list’s efficiency tremendously – there’s more good stuff like this in Stefano’s slides, make sure to have a look!

Update (8 years later…this is still as valid as ever!): my survival guide has more guidelines on how to cope with large mailing lists.


Adobe, Day and Open Source: a dream and a nightmare

July 30, 2010

What does the acquisition of Day by Adobe mean for Day’s open source activities? Some people are disappointed by the lack of comments about this in the official announcements to date.

Thankfully, Erik Larson, senior director of product management and strategy at Adobe, commented on Glyn Moody’s blog post quite early in the frenzy of tweets and blog posts that followed yesterday’s announcement.

Quoting him:

…we are very excited for Day’s considerable “open source savvy” to expand Adobe’s already significant open source efforts and expertise. That is a strategic benefit of the combination of the two companies. I have personally learned a lot from David Nuscheler and his team in the past few months as we put the deal together.

Not bad for a start, but we’re engineers right? Used to consider the worst case, to make sure we’re prepared for it.

Me, I’m an engineer but also an optimistic, and I’m used to start with the ideal, happy case when analyzing situations. It helps focus my efforts on a worthy goal.

So let’s do this and dream about the best and worst cases. This is absolutely 100% totally my own dreams, I’m not speaking for anyone here, not wearing any hat. Just dreamin’, y’know?

The Dream

This is late 2011.

The last few months have more than confirmed that Day’s acquisition by Adobe, one year ago, happened for strategic reasons: a big part of the deal was filling up gaps in Adobe’s enterprise offering, but Day’s open source know-how and network have brought a lot of value as well.

Day folks have played an important role in expanding the open development culture inside Adobe; Photoshop will probably never be fully open source, but moving more key components of the Adobe technology stack to open source, and most importantly open development, has paid off nicely. In terms of reaching out to developers and customers, in getting much better feedback at all levels, and in terms of software quality of course. It’s those eyeballs.

The Apache Software Foundation’s Incubator has been quite busy in the last few months. The new platinum sponsor enjoys a fruitful relationship with the foundation.

With JCR moving to their core, Adobe’s enterprise applications are starting to reach a new level of flexibility. Customers are enthusiastic about being able to access their data via simple and standards-based interfaces. Enterprise-level mashups, anyone?

JCR is not just that minor content repository API pushed by that small swiss software vendor anymore: being adopted by a major player has made a huge difference in terms of market recognition (I’m sure my friends at Hippo, Jahia and Sakai, among others, will love that one). The added resources have also helped improve the implementations, and people love the book!

With this, Apache Jackrabbit and Apache Sling have reached new levels of community participation and quality. Although quite a few new committers are from Adobe, a number of other companies have also pushed their developers to participate more, due to the increased market visibility of JCR.

Adobe’s additional resources, used wisely to take advantage of the Day team’s strengths, have enabled them to fully realize the CQ5 vision. Everything is content, really.

As in all fairy tales, the former Day team and Adobe live happily ever after. (Editor’s note: this is not Disney, can we strike that one please?)

The Nightmare

This is late 2011, and I can hear the programmers complaining in their bland cubicles.

Aaarrggghhhhh.

The few Day folks who still work at Adobe did try to convince their management to continue on the open source and open development track. No luck – you can’t argue with an US company making 4 billion a year, can you?

CQ5 customers are too busy converting their websites to native PDF (this is about documents, right?) to realize what’s going on. The most desperate just switched to DrooplaPress, the newest kid on the LISP-based CMSes block. That won’t help business much but at least it’s fun to work with. If you love parentheses, that is.

Adobe’s competitors who really jumped on the open source and open development train are gone for good, it is too late to catch up. You should have sold you shares a year ago.

Luckily, Apache Jackrabbit and Apache Sling are still alive, and increased involvement of the “Benelux Gang” (ex-Day folks spread over a few Benelux content management companies) in those projects means there’s still hope.

You wake up wondering why you didn’t accept that job at the local fast food. Computers are so boring.

Coda

I know life is more complicated than dreams sometimes, but I like dreams much better than nightmares, and I’m a chronic optimistic. So you can easily guess which scenario I’m going to work towards!

I’ll keep you posted about what really happens next. Once I wake up, that is.

Just dreamin’, y’know?

Related reading

Open Source at Adobe by my colleague and fellow Apache Member Jukka Zitting.

Open innovation in software means Open Source, a recent post of mine.

See also my collected links related to the announcement at http://delicious.com/bdelacretaz/adobeday.


This is how we work at Apache

July 16, 2010

I just had to (re-)explain how the Apache way of working makes a difference by enabling a continuous flow of information between developers.

No more begging for reports, no more boring meetings where you only exchange information: who could say no to that?

Here it is for your enjoyment. This is the same thing that I’ve been saying in my recent talks on this topic, reduced to the bare minimum.

  • All technical discussions and decisions on public mailing lists.
  • Speak in URLs: if you reference something (discussion, vote,
    code…anything) include its URL, which must be permanent.
  • Shared code repository, commit early, commit often (as in: daily at least, from day one)
  • Commit events sent to mailing lists and/or RSS feeds to which people
    can subscribe.
  • Shared issue tracker and “if you’re working on something it must be
    an issue in the tracker”
    so that progress reports are automatic. Also generates mail/RSS events.
  • Commits are linked to tracker issue IDs – by speaking in URLs in your commit messages, mostly.
  • Automatic archiving of all this information, for self-service access.

All this is public and centrally accessible of course, so everybody
gets the same information.

The main reluctance that I see when trying to convince people to work
in this way is the fear of exposing your mistakes and initial bad
designs in public. My answer is to just get over it: you’d find tons
of such blunders if you were to analyze my work at Apache in the last
ten years, yet I’m reasonably alive and kicking.


Open innovation in software means open source

July 2, 2010

Here’s a “reprint” of an article that I wrote recently for the H, to introduce my talk at TransferSummit last week.

According to Henry Chesbrough[1], Open Innovation consists of using external ideas as well as internal ideas, and internal and external paths to market, to advance a company’s technology.

Software architects and developers are usually not short of ideas, but which of those ideas are the really good ones? How do you select the winning options and avoid wasting energy and money on the useless ones?

Feedback is the key to separating the wheat from the chaff. Fast and good quality feedback is required to steer any fast vehicle or sports device, and it works the same in software: without a performant feedback loop, you’re bound to fall on your face – or at least to be slower than your competitors on the road to success.

Innovation is not invention – it’s about value

In a recent blog post on the subject, Christian Verstraete, CTO at HP, rightly notes that innovation is not invention. Whereas the value of a new invention might be unknown, the goal of innovation is to produce value, often from existing ideas.

The output of our feedback loop must then be a measurement of value – and what better value for a software product than happy stakeholders? Other developers adopting your ideas, field testers happy with performance, experts suggesting internal changes which will make them feel good about your software’s structure. That kind of feedback is invaluable in steering your innovative software product in the right direction, quickly.

How fast is your feedback loop?

If you have to wait months to get that high-quality feedback, as you might in a corporate setting, your pace of innovation will be accordingly slow.

In the old world of committees, meetings and reports, things move at the speed of overstuffed schedules and overdue reports – slowly. In the new world of agile open source projects, fast and asynchronous Internet-based communication channels are your friends, helping people work at their own pace and on their own schedule, while collectively creating value quickly.

Open source organizations like the Apache Software Foundation provide standardised tools and best practices to foster efficient communications amongst project members. Shared source code repositories generate events to which project members can subscribe, to be informed immediately of any changes in modules that they’re interested in. Web-based issue trackers also use events and subscriptions to make it easy to collaborate efficiently on specific tasks, without requiring the simultaneous online presence of collaborators. Mailing lists also allow asynchronous discussions and decisions, while making all the resulting information available in self-service to new project members.

It is these shared, event-based and asynchronous communications channels that build the quick feedback loop that is key to software innovation. It is not uncommon for a software developer to receive feedback on a piece of code that they wrote, from the other end of the world, just a few minutes after committing that code to the project’s public code repository. Compared to a written problem report coming “from above” a few weeks later, when the developer has moved on to a different module, the value of that fast feedback is very high. It can feel a bit like a bunch of field experts looking over your shoulder while you’re working – scary but extremely efficient.

How good are your feedback “sensors”?

Fast feedback won’t help if it’s of low quality, and fortunately open source projects can also help a lot here. Successful projects can help bring together the best minds in the industry, to collectively solve a problem that benefits all of them. The Apache HTTP server project is one of the best examples, with many CTO-level contributors including a few that were involved in defining the protocols and the shape of today’s Web. If software developers (God forbid) were sold between companies the way soccer players are transferred between teams, we’d see millions of dollars flowing around.

Open source projects are very probably the best way to efficiently bring software experts together today. Industry associations and interest groups might fulfill that role in other industries, but developers like to express themselves in code, and open source projects are where that happens today.

You could of course hire experts to give feedback on your software inside your company, but it’s only a handful of companies who have enough money to bring in the level and number of experts that we are talking about – and that might well turn out to be much slower than the open source way of working.

What’s the right type of project?

Creating or joining an open source project that helps your business and attracts a community of experts is not that easy: the open source project space is somewhat crowded today, and those experts are busy people.

Judging from the Apache Software Foundation’s achievements in the last ten years, infrastructure projects have by far the highest success rate. If you can reduce (part of) your problem to a generalised software infrastructure that appeals to a wide range of software developers, those experts will see value in joining the project. Apache Hadoop is another very successful example of software architects and developers from different companies joining forces to solve a hard problem (large scale distributed computing) in a way that can benefit a whole industry. On a smaller scale, Apache Jackrabbit , one of the projects in which my employer is very active, brings together many experts from the content management world, to solve the problem of storing, searching and retrieving multimedia content efficiently. Those types of software modules are used as central infrastructure components in systems that share a similar architecture, while offering very different services to their end users.

Projects closer to the user interface level are often harder to manage in an open group, partly because they are often more specific to the exact problem that they solve, and also because it is often hard for people coming from different companies and cultural backgrounds to agree on the colour of the proverbial bike shed. An infrastructure software project can be well defined by an industry specification (such as JCR in Jackrabbit’s case), and/or by automated test suites. These are usually much easier to agree on than user interface mock-ups.

Where next?

I hope to have convinced you that open source projects provide the best feedback loop for innovative software. As a next step, I would recommend getting involved in open source projects that matter to you. There are many ways to contribute, from reporting bugs in a useful way, to writing tutorials, contributing new modules or extensions, or simply reporting on your use of the software in various environments.

Contributing, in any small or big way, to a successful open source project is the best way to see this high-quality feedback loop in action. You might also try to use the open source ways of working inside your company, to create or improve your own high-quality “innovation feedback loop”.

I cannot pretend to have the definitive answer to the “how do you select and execute the right ideas to innovate?” question. When it comes to software, however, the fast and high-quality feedback loop that open source projects provide is, in my opinion, the best selection tool.

[1] Chesbrough, H.W. (2003). Open Innovation: The new imperative for creating and profiting from technology. Boston: Harvard Business School Press