Respectful Software

The model for UX driven open software is broken

The ethos of free/open-source software has long been celebrated for its role in promoting user freedom and collaborative innovation, particularly in areas like application frameworks and server operating systems. However, this model, while effective in some domains, breaks down in others such as user interfaces and product development, largely due to inadequate monetary incentive. Typically, to have a user experience which is truly great and stands the test of time it takes a highly deditcated individual or small team to be ruthless about every detail, and maintain that through future versions. This is typically not something that you can get people to do for free and therefore we end up with a lot of sloppy UX in open source / free software. I think about this a lot, having been a long time Linux user at home, but recently back to MacOS because of too much UX sloppiness in most Linux distros.

I was thinking about this a lot recently and I realized that the proposal from 37 Signals Once might hold the solution. The radical proposal is: make the source code open to paying customers, but unavailable widely. This solves the monetary incentive problem, while still reaping a lot of the benefits of the source code being open to those who use it.

For lack of a better name, I'll term this kind of software "respectful software" in the rest of this article where we explore some of the implications / suggest some pitfalls to avoid. Why Respectful? well basically it comes down to that sharing the source code with your customer respects their freedom and security. This is fundamentally the argument that Richard Stallman makes for software freedom. But the critical caveat is that to be respectful it doesn't mean that the customer has the right to share the software arbitrarily -- that seems to be a clause added to the Free Software Licenses that misses the point (and its the point where UX driven software products fall down on that license).

The TiVo Incident

For those unfamiliar, there was a very long debate over the use of the Linux kernel in TiVo hardware. TiVo was using GPLv2 Licensed Linux but with modifications that they never shared back with Linus Torvalds. This frustrated Torvalds, because he basically wanted to know what modifications they had made to make any relevant improvements to the kernel for other users. This led to discussions of a v3 of the GPL license (although it turns out Torvalds was unhappy with other modifications of V3 so never signed Linux up for it).

What does that have to do with "respectful software"? Well, I suggest that if there is ever a standard licence written for such kinds of software, that a clause be included that requires changes to go back to the software's developer for exactly the reaoson that Torvalds had with TiVO. Eg. that you want to be able to know if there was an issue with the software so large that one of the customers was forced to patch it without asking for an improvment from the vendor.

A new standard license?

While there aren't really many standards in commercial licensing. I suspect that it would be beneficial to small teams shipping this kind of software to have a license similar to the GPL that they could slap on their product without having to run in circles with lawyers.

It seems to me like the GPL is a good fit but there would need to be some modifications:

1. Removal of the right to redistribute clauses.
2. Base the license on GPLv2 rather than GPLv3, to avoid complications with GPLv3's DRM clauses, given the commercial focus of this model.

Conclusion

In a changing economic landscape where software companies are increasingly driven towards short-term profitability, traditional B2B software models, often prohibitively expensive, face challenges. The "Respectful Software" model, inspired by Once's "hybrid" open-source approach, may represent the future of B2B software products. This model allows customers to access and trust the source code – becoming increasingly important in SaaS – without necessitating full public openness, thus enabling developers to invest in high-quality user experience.