21 March 2010

Open Source's (Not-so-)Secret Sauce: Modularity

Why does open source succeed? Apart, that is, from the fact that it is created by huge numbers of amazingly clever and generous people? Or, put another way, what is a key ingredient that must be present for the open source methodology to be applicable to other spheres?


If the stuff to hand isn't modular, you can't really share, because your stuff isn't compatible with other people's stuff. If it isn't modular, you can't share out tasks and scale. If you can't share out tasks, you can't have people working independently, at their own pace and in their own way, which means the project isn't really open. If it isn't modular, you can't swap in some new elements while leaving everything else untouched, which means no "release early, release often", no experimentation, no rapid evolution. Modularity is indispensable.

I think that's why open source hardware has singularly failed to take off. It's difficult to make bunches of atoms modular in the way that bunches of bits are (at least until we have general 3D printers, in which case we're done...)

But could there be a way of introducing that modularity at a higher level so as to enjoy the benefits outlined above? I do believe there is, and with hindsight, it was pretty obvious (er, so why didn't I think of it?). It's called OpenStructures:

The OS (OpenStructures) project explores the possibility of a modular construction model where everyone designs for everyone on the basis of one shared geometrical grid. It initiates a kind of collaborative Meccano to which everybody can contribute parts, components and structures.

As you can see, the clever people behind this project have the magic word "modular" in there. Specifically, they have devised a very simple grid system that ensures that things fit together, even when they're made by different people at different times and for different purposes. Significantly, the grid is based on binary multiples and subdivisions:

If you choose to apply the OS grid for the dimensions of a part, at least one of the measurements of this part (length, wideness and thickness or height) should correspond to either 0,125cm / 0,25cm / 0,5cm / 1cm / 2cm and multiples of 2cm in order to be compatible with other parts. (see part examples)

What's really impressive about this project is not just this insight into the modularity of elements, but the completeness of the vision that results. For example, there is an explicit hierarchy of elements, starting from OS Parts, which combine to form OS Components, from which are made OS Structures, and finally OS Superstructures.

It's an amazing vision, and I think it could have a major impact on the world of open source hardware, at least of this particular construction-set type. If you want to see some of the exciting objects that have already been created, don't miss the fab photos on the project's blog. (Via @opensourcerer.)

Follow me @glynmoody on Twitter or identi.ca.


PV said...

As far as I know, the Arduino is supposed to be open-source hardware and it has been selling like hotcakes (from the original seller, despite the fact that there are free online DIY manuals that could potentially spawn competitors).
a Linux Mint user since 2009 May 1
Please take a look at and comment on my blog!

Glyn Moody said...

@PV: yes, I know Arduino has been selling well...and yet.

I can't see any real modularity there - just lots of really cool projects that draw on common ideas, common code and commons standards.

That's not to criticise them: they're clearly doing a great job, users love them etc. But I don't feel they are fully modular in the way that this new project is. That's why I think the latter is so important.

guy said...

Oddly enough one of the few lasting results that emerged from Charles Babbage's (mostly failed) attempts to build his difference engines was the standardization of parts produced by his engineers (Clement and Whitworth).

Another echo of how Babbage was a pioneer but not quite in the way he intended. He suffered almost all the same problems as his modern counterparts: specification problems, feature creep, project management problems, funding problems etc.

Doron Swade's (http://www.computerhistory.org/staff/Doron,Swade/) books on Babbage are well worth a look.

Glyn Moody said...

@guy: interesting - thanks for that