Home‎ > ‎

Dimensions of Openness

In the open source/free software world there has been much discussion on the free side: Free as in Speech, Free as in Beer, the various open source licensing issues, etc. The types of Freedom have been been well-documented and discussed.

Given the recent discussions on the Internet of Open Source vs. Open APIs, lets instead look at various dimensions of open.

Here's some of my thoughts on what makes software open.

Configurable: making changes to the basic look or feel or behavior of the software. Think of this as an Open User Interface or Open User Experience
    This may be
  • rearranging user interface elements
  • adding new skins/themes/templates
  • hiding or showing features
  • changing language strings for labels and prompts
There may be entire cottage industries that spring up around these, such as making templates/themes/skins for software packages.

Extensible: Adding functionality to the software that wasn't in the original distribution. This is usually done via the software's plug-in structure. Wordpress has a good plug-in structure and has given rise to a host of extensions. Think of this as an Open Programming Platform.

A couple of counter-intuitive examples:

1) Microsoft Office: how does it fare on the configurable front?
Ever been through all the settings to configure the toolbars and menus of an Office Application?
How about extensibility?
That's where VBA shines. How many VBA extensions are there for Office? Countless!
So even though Office is closed-source, it scores high on the openness axes of configurable and extensible.

2) Contrast this with osticket.com: an open-source helpdesk/trouble ticket system. It's a nice enough system, but along these two metrics, it's 'closed': it's not easily extended or configured.

Interoperable: the ability to work with other programs over a network: i.e. a robust API. Think of this as an Open Network Protocol or Open Network Interface. This axis of openness has been getting a lot of press lately. Open APIs have been cast as the antagonist of open source. Actually, they're just two different types of openness. Many closed-source systems from Google Apps to Mailchimp to Salesforce have good open APIs. For some subset of software, this one dimension of openness may be sufficient for success, but more often than not, increasing other dimensions of openness help ensure success.

Hackable: the ability to change core functionality. this is the big plus of opensource. This is the general meaning of Open Source. The argument goes: opensource is valuable because you can change its functionality or fix its bugs without relying on a distant, uncaring vendor.

One of the problems with this argument is that some of the most successful opensource projects are actually hacked the least. See Eclipse and Apache. Why? because their core is very, very small, like microkernels of their problem spaces. Everything is a plugin or an API. Our practice does a lot of Joomla sites, and in that realm 'hacking the core' on a single site is very much frowned upon.

Strangely enough, having open-source plugins becomes a big plus in these arenas. The plugins or extensions are generally much smaller and easier to comprehend than the core system, and much more likely to be hacked, fixed or extended than the core component.

Contributable: Here is the true strength of open source as demonstrated by the Linux project. The users and ISVs have a voice in the direction and features of the project. Think of this as an Open Community or Open Process. Truly successful, vibrant open source projects rely on their communities to contribute to them and guide them. A couple of examples: Joomla is successful because they solicit and welcome bug squad volunteers, documentation contributors, and code contributions. SugarCRM has a much less vibrant community because even though technically the source code is available under the Affero GPL, the governing body does not accept community code or input.

Thus we see the keys to making software successful: it's not really about opensource or not, i.e. hackability. It's about having enough openness in enough different dimensions of the word to create a vibrant, healthy ecosystem of users, contributors, 3rd party developers, designers, writers, etc. 

To help with our metrics, we could assign a 0-10 score for each of these dimensions, then do a bulls-eye plot to visualize the openness of the product.

On such, Microsoft Word would probably look something like this:

Whereas OSTIcket would look like:
So, given that osticket is a moribund project, this diagram might give us some clues as to how to revitalize it. We could start getting suggestions for future directions, maybe an advisory board, and put it out on github or sourceforge to encourage issue tracking and contributions. Then start reworking it to allow for skins and plugins, then an API to get remote access.

I've done a fair amount of work with Joomla, so here's how I think it stacks up (CMSs don't have strong network APIs, but some)

And the open source LMS Moodle:
I had to do some research, but it looks like there's almost 300 people who have commit privileges on the codebase, so that looks reasonable contributable to me. It's main shortcoming is in the configurable dimension. It doesn't have a very robust templating engine.

How about SugarCRM? It's dual-licensed, open source and commercial license. There are some extensions, but not many skins. Also there's no way for users to commit back to the codebase or be on the governing body. So maybe they look like this:

From the above, we can see that a successful software project needs enough of the right kinds of openness to create a critical mass of users/developers/contributors that interact with each other to create a viable ecosystem.

One measure of a software project's success is how vibrant an ecosystem has grown up around it. One indicator I look at is 2nd order effects, such as are the plugins growing plugins?

A couple of thought experiments:
My vision for an e-commerce system: Joomla/Zoo for products, UPS/USPS for shipping info, Paypal for payments, the ecommerce system itself should be an open microkernel.

A similar vision for CRM: Mailchimp for mass email, Google for docs and email, mongodb for database records, and an open source, community microkernel to tie it all together.