Robert Lefkowitz - arguably the most entertaining speaker on software development processes, gave a vindicating (for me, at least) talk at OSCON.
As an aside, it is surprising to some that software process people tend to be very engaging, humorous people - given the material they think about. However, they’re often successful and reknowned precisely for this trait. Steve McConnell, The Three Amigos (Grady, Booch and Rumbaugh), Joe Spolsky, Fred Brooks, and recently Scott Berkun amongst many others - are men and women who while gifted engineers have distinguished themselves in their field by sparking ideation in and around how software is built (they’ve revamped the wetware of software). They could only get people talking about software process if they made it interesting - which means both fun and technically deep with the world of geeks.
Robert “roml” Lefkowitz gave a talk on the concept of an open source software development methodology - something I’ve thought about and written on and off for a few years now. Being a methodology nerd, the idea of bringing to bear the metrical niceties and rigor of a even a semi-formal process to open source development is very exciting. I think it’s the last barrier to entry for a lot of private enterprises who view open source communities as untamed, unpredictable beasts who may become hostile, recalcitrant or simply flee at a moments notice. Business prefer predictable pessimism over volatile optimism; which is the reverse of how open source works.
Without repeating too much what roml so cogently articulated (you can watch a video of his presentation at Blip’s OSCON coverage ) I’ll observe two salient arguments he made that connect to two memes I’ve hitched on to - firstly he talks about software methodology has being both a very old idea (about 2000 years) and most methodologies describe the same processes and merely quibble over the particular manifestation (rather than internal logic) of these different steps. Lefkowitz attributes the invention of this process to Marcus Fabius Quintilian in his treatise Institutio Oratoria, written in the last days of the Flavian Dynasty in 95 CE.
Quintilian agregated in this twelve-volume collection what he believed to be the step-wise process of developing formal rhetoric. That is the assembly of a coherent logic, its expression in language and finally its articulation in speech. roml makes the observation that this basic process maps pretty cleanly into at least three major development methodologies (roml uses Microsoft Solutions Framework, (Rational) Unified Process and Agile/eXtreme Programming as test cases - but I can attest that such things would apply to clean-room or any PM compatabile system).
What roml has really demonstrated here is not just that these processes have commonality, he’s outlined what it is to be a process methodology - these are the essential qualities of a process. Without the steps of inventio, dispositio, elocutio, memoria and pronuntiatio you’ve either got an incomplete process or something else.
roml also argues that open source ecologies cannot use a traditional “inventio” phase in the way UP, Agile, MSF and others envision it. The unspoken reasons are simple - open source projects aren’t directed and they don’t have clean states. Open source projects aren’t directed in the sense that contributors aren’t employees, by and large, and thus aren’t obligated to develop a specific piece of functionality or fix a particular bug; so requirements can’t be used as an imperative device, at best they are declarative and thusly used as a measuring stick of system process. OS projects don’t have clean states in that the project exists in all areas of the process at all times - there are always some people in each of the phases at any given time with any given section of the system. This breaks most methodology since they rely on a universal comprehension of the system and a mtutal understanding of a projects location in this process. By knowing where you are in the process you know who is active and what is being done - that is a huge part of its power.
The other meme of mine that roml informs is the nature of the relationship between policy development and software development. A huge stumbling block in the argumentation that two are fundamentally the same process is that the trappings of software development methodologies are all expressed using a software paradigm and vocabulary. By connecting software development methodology with the age of the abacus, roml has leap-frogged this issue by finding a common root origin.
This brings me to an interesting conclusion. To what extent can policy devleopment bodies be measured under the capability maturity model integration? The CMMI (ISO 15504) is a collection of tools for measuring the capacity and capabilities of organizations’ processes - how efficient is your “team software” for getting a product out the door is the question that’s asked.
The CMMI is designed to examine organizations who produce software at least as complex as the policy systems of firms - perhaps even some governments. Systems with greater formality (code versus “natural” language - natural is quoted since policy is about as opaque as it can get for human comprehensible language)
What if laws could be written as code? What if the tools that help us produce better software can be used to produce better policy? The key here is perhaps the pedantic argument separating law from policy - positive from normative. Code is unambiguously positive - it is a single solution and self-same takes no normative position (this normative stance is articulated in the requirements).
But, what if roml’s process were used? There are no requirements - everything is an exception. Now we’re getting somewhere closer to the reality of our legal system - a hugely complicated mesh of exceptions with normative guidelines applying only to highly localized sub-systems.
What if we had some of the contrivances of open source development for our legal system? A bazaar for law - with upstream interaction, branching, forking and constant evolution all arbitrated by module-owners/Ministers/Secretary/Senator/Congressperson etc. What if this process was entirely public?
The ideal of Homeric democracy became untenable when the populi couldn’t fit in a forum (power relationships aside) - now we have an infinitely large forum with an emergent organizational scheme.
This isn’t an alternative - this is the reality, this is the only possible method we have for fair law making - everything else is less democratic, less inclusive, more closed, more power-consolidating and thusly, more evil. The only excuse we have for not having done this before is that it wasn’t possible - something that’s not true any more.
I am excited for the day when people who reject systems like the above are viewed as outmoded duplicitous power-mongerers; it’s coming fast.