next-generation programming language, currently in development

Twitter . GitHub . RSS

The trouble with adoption of standards


credit: XKCD

Standards are a good idea. Getting people to agree ahead of time on an arbitrary convention makes it easier for systems to communicate. So why aren’t they adopted? Here’s the basic problem:

Now here are some solutions. I’ll use a running example: a standard for user accounts and logins.

Let’s take a step back and rethink things a bit. Why is there an explicit integration step? It’s because the standard is specified in a form which differs from the computable form in which we do our real work. Even worse, if a software system is proprietary, only the people with internal access to that proprietary system can do the work of converting from whatever computable form they use internally to whatever the form is that’s dictated by the standard.

Compare this to the experience of working with ordinary typed values in your programming language of choice. The language and its type system provides a common platform for exchanging data and functions between different ‘software systems’ (pieces of code). Standards are ‘just’ shared libraries that multiple projects use, and adoption of these libraries doesn’t face the same collective action problem as ‘real’ standards do because we are implicitly using some of the above ‘solutions’. Even in cases where multiple libraries are developed for representing the same thing, in the same niche, the ecosystem tends to converge due to network effects. Importantly, when the code is open source, people other that the original authors can convert values to standardized form—it’s just a regular function converting from one type or another!

The solution being adopted by Unison is exactly of this flavor. Unison is a common, open platform. Standard extensions to it can arise and be integrated with trivially by anyone else on the web. The key is that we’re extending what can be talked about in the language and type system—in Unison, we have first-class, typed values that can refer to large distributed systems, and so the ability of the language and type system to act as ‘quasistandards’ is expanded accordingly.

comments powered by Disqus