canspice.org

As I said I would earlier, I pledged $25 to support Geof in Blogathon 2005. Well, he posted 109 times in 24 hours, more than accomplishing the goal of 48 posts in 24 hours.

Geof isn’t seeing a cent of the money pledged but will still find immense pleasure in seeing all of it go towards the Blood:Water Mission. I’ve made my donation:

This is your receipt. You may print this page for your records.
This receipt has also been e-mailed to you if you provided a valid e-mail address.
Order Information
Merchant: Blood: Water Mission Inc
Date/Time: 07-Aug-2005 11:31:01 PM
Authorization: This transaction has been approved.
Authorization Code: 049050
Description: For Blood:Water Mission
Amount: 25.00 (USD)
Payment Method: Credit Card

OSCON 2005 ended yesterday afternoon, which means it’s time for me to leave sunny Portland and return to rainy Hilo, Hawaii. My plane boards in about an hour, and it’s rolling up right now. PDX has free wi-fi, something all airports should have, or, at the very least, have T-Mobile so I can use the work account. This means I can recharge my laptop’s battery and surf the web at the same time instead of just leaving it in my bag like I have to do at HNL, which has wi-fi through lava.net that costs me money. Yet another reason why HNL sucks.

For those who might be interested, I’m flying to San Fran first, staying there for a three hours, then on to Honolulu for a coule of hours, then back to Hilo. Total travel time is 12h24m, starting from the time I leave PDX at 10:00am PDT.

Last day of OSCON 2005, and it’s time for the keynote addresses. Nat’s got another amazing shirt on. He says he’s stacked the deck with mind-blowing speakers today…

Up first is Asa Dotzler (the “community guy” for Mozilla, talking about Linux - In Search of the Desktop, based on a blog post he made called Linux not ready for the deskop. Comments he received after that post seemed to be pretty infantile, at least the ones that were posted on his blog and on Slashdot, which doesn’t really surprise me. He had four key points. The first was migration: Linux should be installable next to Windows and bring along as many of their configuration options as possible. The second is stability: he doesn’t mean “it crashes four times in an hour” stability, he’s looking for stability in software and driver versioning. Third is simplicity: just because you can provide a feature doesn’t mean you should. “Complexity and choice frighten Regular People.” And the fourth is comfort: Linux must feel comfortable to Windows users. Asa says that he wants to see people to use Linux in the tens and hundreds of millions. People are hurting using Windows these days — it’s expensive and is a mess of malware. He made some good points that usually get flamed down in the Slashdot flood, and hopefully people smarter than me take some of his points and address them.

The second keynote is by Drew Endy and is titled Open Source Biology. If you want to make Open Source beer you need Open Source yeast. There was a brilliant article in 2600 called “Hack The Genome.” Okay, so what’s the problem in biology? There’s a balkanization of basic biological functions — various functions have different restrictions on them, licencing issues, patents, etc. The basic functions are being patented, which is extremely prohibitive. Quality of code: you don’t want wheat in 2050 to be running the biological equivalent of Windows 98. Right to reverse engineer, react, and reuse: he showed the example of the farmer in Canada who somehow got Monsanto-engineered canola growing on his farm and got sued. Three approaches to fix these: open up the common biological functions registry of standard biological parts. Approach 2: Open DNA, many eyes, fewer bugs. True? Approach 3: Release triggered by uncontrolled access to genetic information or material. BioBricks Foundation was started two days ago to promote openness in the biological community.

Tony Gaughan from Computer Associates is up now, giving a presentation called Open Source Evolution. It’s really turning into a bit of an advertisement for Ingres. I think he’s contradicting himself here: earlier he said it would be great if there were one SQL parser that all databases could use, then he goes on and describes how they came up with their own licence and rejected everything else out there. Worst keynote of the whole convention.

On Evil. Sounds ominous and hopefully funny. it’s by Danny O’Brien of NTK and To Evil! fame, so it’s got a good chance of accomplishing both. What I’m going to do is just give the transcript that Nat Torkington was typing up furiously in the #oscon IRC channel during the talk (with some fixing-up and links put in):

Danny O’Brien: On Evil

I’m a consultant on evil. I delay any evil projects I work on by six months.

It was intended to be more neutral than that. One problem in open source are flame wars: what you’re doing is wrong, what you’re doing is Lisp and therefore fairly neutral.

I wanted to be an objective view, a bit like wikipedia. An article on satanism has all points of view on satanism.

It’s not for me to say who is right or wrong, just who is good and evil.

“The only thing necesary for the triumph of evil is for good men to do nothing.” — Edmund Burke

When Nat came and asked if I could briefly summarize what was going to be coming up in the world of evil, I realized I was somewhat thrown. Generally I’m an observer rather than a participant. I didn’t have an insight into what made them good or evil, something I noticed the rest of civilization also lacked.

I broke the number 1 rule of journalism, tried to get involved and tried to in the gentlest way possible mess around with the very nature of good and evil: “Project Do Nothing” which I’ve been doing for the last four months

It primarily inovlves a lot of usenet, high traffic mailing lists, and an exhaustive review of RSS readers, because those blogs don’t read themselves.

Results for 2005: during the period I have been doing nothing, evil has triumphed. Microsoft censoring Chinese blogs, Apple switched to Intel, which isn’t technically evil, merely a sign of the apocalypse, Tim O’Reilly has been questioning the very existence of Perl. Poor Anakin Skywalker, something bad going on with him. Firefox greasemonkey extension problems. Maureen O’Gara writing all kinds of incredibly horrible things about other people. Google launching their Soul Devourer product, which went into beta in may and I haven’t heard very much about it. From what I can tell it was a reengineering of bitkeeper. All sorts of GPL violations, and poor Bruce Wayne’s family were killed.

Standing idly by not as much fun as predicted.

What do you do if you want to spread good in the open source community and the wider society as a whole? As a geek, I’m not terrifically emotionaly engaged in the rest of the world, so there is an extent to which I don’t really care. But while I don’t have that attachment, I do have some laws of robots. First law, through inaction causing harm.

When fighting good and evil, find old platitudes to buoy your confidence.

How to do fight evil? Find a bugtracking system for society. There is none. Or if there is, it’s full of Saddam, “rampant poverty, sorry cannot duplicate” and “please give another test case for your cure for cancer”

“First they ignore you, then they laugh at you, then they fight you, then you win.”

This quote is from Ghandi or Eric Raymond, not sure who said it first. I do know who would win in a fight, with you there Eric.

This is similar to the whole “sitting back and waiting for evil to take over the world” thing.

State diagram: ignore you -> laugh at you -> fight you -> you win

We don’t have a description of what moves from one state to another.

This is a problem for communities running on ghandi con e.g., clowns. Clowns have been at stage 2 for about 400 years. Sometimes they wander into ignore, but mostly they’re stuck there.

The movement between these states isn’t necessarily in sequential order

It’s much more like (horrendous diagram)

Good example: Ruby. It went from ignore you, to you win in what I estimate was three weeks.

I do not remember anyone laughing at Ruby. I have not found a single Ruby joke.

I didn’t find that model particularly useful.

Next model from Margaret Meade, popular anthropologist and nice little old lady: “Never doubt that a small group of thoughtful committed citizens can change tyhe world. Indeed, it is the only thing that has.”

I don’t think that’s true.

(slide of plate tectonics)

I understand she was an anthropologist taught before continental drift was a recognized theory in science. I suggest plate tectonics have been a far more powerful force … they make the FSF look frankly ridiculous.

This is an interesting picture.

I don’t know whether any of you read “To Good”, mirror universe of my column.

Lot of talk in it about software patents

As you know, patents are horrible things when mixed with your software, enabling other people to claim they own the idea you’re trying to implement.

Two years ago, the fight against sotware patents seemed to be a lost cause. One guy in an office.

Over that time Microsoft had done a mysterious switch from Bill Gates saying patents were a terrible burden in the community, to patents promoting innovation by locking it down.

This is the boat that MS hired in the final stages of the software patent fight.

They began to realize they were losing the hearts and minds of the members of European Parliament.

in a last ditch effort, they hired a boat and sailed it in front fo the members of european parliament. The sign on it read: “Vote for the CII Directive”

The FFII launched a kayak with a flag: “Software Patents Kill Innovation”. They hired canoes immediately when they saw it.

There’s a guy in a suit with three people in t-shirts. There’s a patent lawyer in that dinghy.

There was someone on the balcony looking out on this, saying “I think we know who’s pro-innovation here”

These small microscopic additions to the fight for good actually work. It’s something we recognize in open source software, something people looking in from the outside don’t get.

I remember all those reports proudly proclaiming that open source software wasn’t the anarchist hive mind we’d always thought. Linus wrote the kernel with just a few people helping around the sides, not a democratic supreme soviet.

There are clearly some people who do a lot of work who are clearly very effective. And others of us sit back and let things run of their own accord.

The interesting thing about open source that separates it from the more strongly structured things in society, is you don’t know which type of person you’re looking at. You don’t know how much effect you’re going to have until you get into the canoe and sail out to the boat. You don’t know who you’re going to change the mind of.

At the EFF, we secretly monitor all encrypted transmissions across the entirety of the internet, just a sideline with the NSA, is I get to see what people write to the politicians and what the politicans write back.

Politicians change their mind.

And the last keynote for today is Howtoons by Saul Griffith, completing the accent set (we’ve had Scottish, English, New Zealand, and now Australian). Howtoons are subversive science, technology and engineering tutorials for kids — a HOWTO in cartoon form. It all looks like incredibly fantastic stuff to get kids interested in engineering and science.

The second seminar I attended on Friday was You Can’t Get There From Here by the always-excellent Mark-Jason Dominus.

First off, buy his book, I’ve heard it’s excellent. Now on to the seminar.

If it’s green and wiggles, it’s biology. If it stinks, it’s chemistry, and if it doesn’t work, it’s physics. If nobody can figure it out, it’s computer science. There’s a heck of a lot of stuff that nobody can figure out. And it’s not just that’s because nobody’s smart enough, there are things that are provably unsolvable. MJD will solve a few of them in this seminar (just kidding!).

Trading, or the knapsack problem. You have a ship, and there’s a list of merchandise you can carry. Each item has value and size, but you can only carry so much, but you also want to exceed your budget by selling the stuff when you get to your destination. You could come up with an algorithm that just spits out every possible cargo, and if that cargo’s price is higher than the budget, you win. However, this is O(2ⁿ) which grows really really rapidly. Unfortunately nobody knows of an algorithm that’s substantially better than that, unless you use a quantum supercomputer that nobody has yet (although, of course, Damian Conway wrote a Perl module for quantum superpositions already named Quantum::Superpositions…). This problem is known as…

NP. It’s hard to find a solution to the knapsack problem, but it’s easy to verify if a solution is correct. Problems that can be checked efficiently are said to be “in NP”. But at least they can be solved, even if only by brute force, unlike…

“Is my program going to finish?” Some programs do, some don’t (see the opening sequence for Look Around You for an example), some do sometimes and sometimes don’t, and for some it’s just unknown (if even, divide by two, if odd, multiply by three and add one, and cycle through that). This is actually an undecidable problem over Turing machines.

Now for two topics that are solvable and deal with identifying yourself and enforced fairness.

How to flip a coin over the telephone. The problem is such: Alice and Bob are talking on the phone and want to flip a coin to choose where to go for dinner. Bob chooses heads or tails, Alice flips a coin, Alice says “sorry, you’re wrong!” Bob doesn’t know if Alice was telling the truth or not. A variation to make this more fair involves Alice committing to a choice first (i.e. puts a coin under a coffee cup), and then Bob makes a choice. The reveal is then done. But how do you do this over the phone? You need an electronic coffee cup. In other words, a cryptographic checksum. Alice chooses a string that ends with either heads or tails, then checksums the string and sends it to Bob. Bob chooses heads or tails and tells his choice to Alice. Alice divulges the original string. Bob calculates the checksum and verifies that the result is the same as what he got originally.

Hamiltonian Cycle, aka the Travelling Salesman problem. Suppose a salesman wants to visit N cities and return home, but there aren’t flights between every possible pair of cities. Is there an itinerary that visits each city exactly once and then returns home? The problem is NP-complete. Now suppose that P (the “prover”) actually knows the solution. He wants to prove to V (the “verifier”) that he knows a solution but he doesn’t want to tell V what the solution is. First off, P assigns random aliases to the cities in the map. He encrypts the alias list. Then he makes a list of the available routes, and encrypts each available route with a different key. He then sends all the encrypted stuff to V. Now V flips a coin and tells P what it is. If it’s heads, P reveals all the encryption keys. V can confirm that P did in fact encrypt the HC problem under discussion. If it’s tails, P reveals only the keys for the routes in the itinerary. V can readily verify that they do form an itinerary of the right length, but since she doesn’t know what the aliases represent she can’t verify the solution. Now suppose there’s an imposter named T who doesn’t actually know a solution, but is going to try to convince V otherwise. T needs to prepare the encrypted list of routes, so he does so, in case V flips heads. However, if V flips tails, he can’t come up with the itinerary because getting that itinerary from the list of nodes (because it’s NP-complete). Or T could make up an itinerary from scratch in case V flips tails, but if she flipped heads in this case V would get the made up data and realize T is faking. T will be caught 50% of the time, for only one round. Caught 75% of the time for two rounds. For 20 rounds he’s caught 99.999905% of the time.

The first session I’m attending Friday is Build Easily Extensible Perl Programs by Ask Bjørn Hansen. There are a few ways to extend a Perl program. First one is by hooks, where the extension tells the program that it’s responsible for a specific function. You get fine control, there’s a clear API, but it can be a pain to put in hook calls everywhere it’s possibly needed. Second one is delegation, which is sort of the other way around. The program tells the plugin what to do: “You take care of this stuff.” Third is mix-ins, which is good for adding new stuff to frameworks but not so good for changing how something works. Multiple inheritance is another method, but it’s tough to debug and isn’t really recommended.

Move as much as possible into plugins, and only keep the basic functionality in the application. When writing an application that’ll be plugin-able, make a clear API. You should be able to make a plugin without understanding all of the application internals.

At this point Hansen went on to describe how to write code in your application that’ll load plugins that’s a little complex for here.

The first session on Thursday I attended was given by Robert Lang, and it was titled Computational Origami: Mathematics, Tools and Algorithms. I was originally going to attend the Perl Lightning Talks, but when I went to those in 2003 I got bored real quick, and given Lang was interesting in the keynote earlier in the day I figured I’d find origami more interesting.

And it was. I had no idea that origami is studied as a mathematical topic. It’s algorithmically challenging, it’s computationally challenging. Check out Lang’s section on the science of origami. Also related is Erik Demaine’s page on the fold-and-cut problem. Go read those, I can’t do the mathematics any justice here.

And when you’re done there, go look at Lang’s origami gallery. It’s amazing what he can do with a piece of paper.

Thursday afternoon’s first session is Parsing, Analyzing and Manipulating Perl (without perl) given by Adam Kennedy. Adam is from Australia, and Australia is filled with criminals. I wish I’d known there were going to be chocolate-covered coffee beans handed out because I stopped at Starbucks before-hand.

Capitalization note: Perl is the language, perl is the program.

Standard thought is that only perl can parse Perl. ONLY pERL CAN PARSE PERL.

perl parses Perl programs pretty much like a stream. “Perl is what perl parses.” The trouble is, it’s difficult to define what Perl is (take a look at e.g. Acme::Buffy).

Perhaps a better saying is “perl can only run Perl”.

A better way to parse Perl is to parse it as a document. To this end, use PPI, which is a reverse backronym for “I Parse Perl”.

“Perl is basically a shared delusion between a bunch of software and a bunch of people.”

PPI gives 100% round trip safety, meaning if you pass in a string to parse, no matter what happens you’ll get that same string out the end if you serialize the object.

How to use PPI: read the documentation, I’m sure it’s all there. :-) The code’s flying fast and furious, too fast for me to keep up with here. PPI::Find uses the same interface as File::Find::Rule because Adam liked it. PPI::Transform is the main class for modifying documents, parsed or otherwise. PPI is a little slow, but they’re working on PPI::XS that’ll speed things up.

Documentation normalization with PPI::Normal means you can take a document and pull out all the stuff that doesn’t matter (like, say, whitespace). Can be used to check if two documents are functionally equivalent. Perl::Signature is essentially PPI::Normal with MD5 bolted on.

You could conceivably parse a Perl document with PPI, then punch it through Perl::SAX… conceivably producing Acme::PerlML — yes, XML that’ll be executable Perl. Awesome.

PPI::Metric can be used to determine document metrics. Perl::MinimumVersion, extending to find out which versions of use and require modules a program or module needs. Add AI and you can compare programmers’ programming style (i.e. “Am I Damian or Not?”). I suppose you could tweak this to find out how many Damians you are — or, for the vast majority of Perl programmers out there, how many milliDamians you are.

More information on Perl::Editor is available on SourceForge.

It’s Thursday morning at OSCON 2005 so that means it’s time for the keynote addresses.

Nat Torkington is waking us all up with his brilliant aloha shirt.

First up is Nick Gall talking about TCP/IP and Shipping Containers: How to Architect Freedom. Nick says that two important parts in the four freedoms are adapting and improving. He says that “Internetwork” architectures have sustained the freedom to change — look at things like email. Oh, some examples of an “Internetwork” are IP, email, web, and intermodal containerized shipping. An internetwork architecture should be interoperable (not tied to one platform architecture), composable (composition “on the fly” using a network of intermediaries), extensible (easily and dynamically adaptable to new uses and implementations), generic (to support a wide range of new applications), federated, and simple. Web 2.0 needs to come about to fix the two major compromises of Web 1.0: read/write web and interlinking, especially backlinking). “Links are King, Content is Queen, Code is the Prince, and all three must be free/open.”

Now David Heinemeier Hansson talking about High Order Bit: Secrets Behind Ruby on Rails. Nat says Ruby on Rails (hereafter RoR) might just be another Open Source killer app. I can’t say, given I have no idea what RoR is. It’s an “integrated stack of web-application framework,” or a meta-framework (or “a bunch of stuff that makes web developers happy”). RoR has has about 100,000 downloads, which is about 20 times more popular than the next web-related Ruby stuff. Given there’s one book out and seven more coming out soon, it looks like RoR is the Next Big Thing. Good things about RoR: “Convention over configuration” “Change is instant” (no compilation, no deployment, no server restarts, no code generation) “Complete, integrated, and familiar stack”

Ruby looks cool, Ruby on Rails looks cool too. It’s a shame there aren’t enough minutes in the day to learn all these things that look cool.

Now Kartik Subbarao, the Global Lead for Linux Technology Profession at Hewlett Packard is talking about Enterprise IT: Open Source Powerhouse. He says that one of the problems with Open Source is defining it, it should be defined as an element like water: it’s fluid and transparent. Closed Source is earth, it’s solid, transported explicitly, and you can’t look inside easily. HP uses Postfix for all inbound email. Kartik’s a good speaker, very energetic. HP uses Net::LDAP for directory infrastructure tools and processes, and Storable.pm for persistent data structures. Essentially he’s saying that HP is taking the best from open source and the best from closed source.

Now for Computational Origami: From Flapping Birds to Space Telescopes by Robert Lang. Modern origami was reborn when Akira Yoshizawa created new figures of artistic beauty and developed a written instructional language — “the hypertext transfer protocol of origami”. Check out origamidatabase.com for over 20,000 published origami designs. Artists applied mathematical principles to origami to advance the art to undreamt-of levels. Holy shit. Cuckoo clock, ibex, carp, all done with one sheet of paper and no cutting. TreeMaker for creating a crease pattern to generate any origami out of a weighted graph. He showed a reindeer, a bull moose, a grizzly bear (with teeth!), a tree frog, a tarantula, a murex, a spindle murex. So how does this get to the “space telescopes” in the title? Lawrence Livermore is developing a space telescope with a big 10 meter Fresnel lens that needs to unfold in space — enter TreeMaker and similar software to design the folds. Medical stents that are folded up, put into an artery or vein, and opened up. Airbags — simulating the deployment as the airbag unfolds from the steering wheel. Aces, definitely the presentation of the morning.

Nat is now doing an Oprah-style interview with Mitchell Baker of the Mozilla Foundation. She says “a quarter of a million people a day come to get Firefox.” Not bad numbers. Sorry this was short, I wasn’t paying attention.

Dick Hardt is up now, he’s the founder and CEO of Sxip Identity. He’s moving fast, he must have a zillion slides. He’s moving too quickly to keep up with, so I’m going to stop typing now. (this is where you go get a cup of tea to simulate the passing of time) Oh wow, he’s an excellent presenter. The basic theme was that we need to come up with something like drivers licences for the web, and that’s what Identity 2.0 is all about. Good stuff. If anybody reading this gets the opportunity to see Dick Hardt give a presentation, take it.

[Alasdair also blogged the keynotes]

Practical Perl Testing, consisting of the final two sessions of Wednesday afternoon, is a tag-team presentation by chromatic, Ian Langworth, Andy Lester, and Bill Odom.

Unfortunately in their first example they misspelled poutine and say that vegemite is a Canadian food. Not off to a good start with errors in your test. Even if they’re not syntactical errors or logic errors… [Update: I'm going to correct Ian after the session is over. :-) ] [Update 2: Ian was surrounded by people and I had to meet up with Alasdair so I didn't get the chance to correct him.]

Test::Differences can be used to show a side-by-side comparison between two different data structures with eq_or_diff.

Who are these guys that they can’t get Niagara right either? Sheesh. [Update: And I'll correct this one too.] [Update 2: see above.

Test::Deep has a function called cmp_deeply that can be used to make sure that a data structure is of a specific format.

Now they're moving into writing your own test harness using Test::Harness, which doesn't really seem that applicable for my programming. And it's kind of scary that they haven't even written the design for Test::Harness yet, doesn't make me want to use it if the goalposts keep shifting. [Update: chromatic commented below that it's not that Test::Harness is new or undocumented, it's that internally it's a mess and using Test::Harness::Straps could be much easier to use. Fair point. Use Test::Harness::Straps instead. :-) ]

Shock and horrors! They’re recommending a book titled “Pragmatic Unit Testing in Java and JUnit”. Of course, it probably presents useful information that can be transferred to different programming languages (which is why I went to the PHP Security tutorial on Monday).

Test::Exception can be used to test for exception handling and throwing from modules or functions.

Five minute break, now we’re back. The applause-o-meter scores testing web applications most popular.

Web applications can be tested with WWW::Mechanize, apparently. Something to look at for the OMP… An audience member uses Apache::Test that’s reportedly different. WWW::Mechanize acts like a web browser and can mimic a user moving through a website. Team it up with something like Test::More in your test scripts and you can make sure that a webpage is returning what it should. Useful for testing CGI, definitely. It’s a subclass of lwp, so you can do complex things like pass complex headers or use cookies.

Devel::Cover can be used to create a little database of how the code coverage is for a certain module. This can be used to make show how well each statement, branch, conditional test, subroutine and POD was covered by tests. It’s useful to make sure you’re actually testing everything in your code.

Further information on testing and quality assurance in Perl can be found at the Perl Quality Assurance Projects website.

The first session on Wednesday afternoon I’m attending doesn’t have anything to do with Perl. It’s titled Switching from CVS to Subversion: Case Studies in Migrating Your Team to a New Tool and is presented by Brian W. Fitzpatrick.

Both CVS and Subversion are document versioning systems that allow one or more developers to track changes to documents as time progresses. At the Joint Astronomy Centre we use CVS. At least once a week Tim complains about something in CVS and says Subversion would be so much better. I don’t know what the odds are of us moving to Subversion are, but I figured I should at least learn something about it. I’m not going to describe the merits of either system, mostly because I know next to nothing about Subversion.

The focus is on the transition, not the technical details. Many people are making the switch to Subversion: both closed and open source projects, along with people who haven’t used software version control before. From January 2003 to February 2004, the number of public Subversion DAV servers increased from 70 to 1307, and up to 11534 in June 2005.

When transitioning, it’s easy to focus on the good things of the new tool, along with the problems it solves and the shiny baubles attached to it, and it’s harder to focus on the big picture: how to support the new product, considering the edge cases, and integration is key. You should be willing to re-evaluate and re-create some of your project’s procedures.

So, to ease the transition, the first step must be communication. Manage the expectations, and test a lot. Make sure it works for everyone in the group that’s going to be using the new tool. Iterate if possible, working towards a solution in small steps (try it out with a small project first). Keep your end goals in mind. Don’t be afraid of the showstoppers: work to address them, wait for the technology to catch up, don’t be afraid to back up if you find things aren’t going well. Ignore the “noisy minority”.

Case studies to be talked about: Mono, KDE, Apache Software Foundation (in progress), GCC (soon).

Mono: over 400 committers, little preparation was done. They botched the migration a few times, and were unhappy with the speed of svn blame (which shows author and revision information for a file). Several lead developers refused to change their processes, like having a checked-in ChangeLog file or doing multiple commits. This resulted in a painful and rough transition.

KDE: over 1000 committers, but the switch was developer-driven. Preparation was done very carefully over eight months. They created a test repository early on to let people try it out, and they dealt with small difficulties quickly. The transition went smoothly.

Apache Software Foundation: over 1300 committers, administrator- and developer-driven. They went with an iterative conversion process, doing one project at a time. It’s still ongoing, and a number of people (particularly the Java developers) are waiting for some of the tools to catch up before transitioning. The process was documented for projects to use. Many test conversions were done.

GCC (soon): about 40 committers, developer-driven switch. Found a showstopper: the slowness of svn blame. They fixed the bug (went from O(n²) to O(n)). The transition is still ongoing.