Differences Between "Open Source" and "Open Currency"

[Cross posted from New Currency Frontiers]

Alan’s last couple of posts have attempted to address confusion Openness and what we mean when we talk about that with respect to currencies or the new economy. Responses from various folks indicate that more clarification would be useful.

Let’s start by talking about Open Source Software.

Basically this means the source code of a software program is available and licensed in a way that would allow people to download it and adapt it for their own use, and possibly republish modifications for others use.

Open Source is a HUGE BREAKTHROUGH in terms of an Information Age gift economy. Software developers have learned that we can actually produce better software which evolves and adapts more quickly by freely sharing the product of our labor and asking others who use it and adapt it to also share their changes back to the community. This is a huge strategic advantage over closed and proprietary software applications. In the currency space, Cyclos is probably the most feature-rich and mature example of an Open Source application. It continues to evolve and grow because of the Strohalm Foundation and a supportive base of users and geeks. However, it is built in the traditional siloed computing paradigm.

Traditional Siloed Computing

The traditional approach in pretty much all computing and information technologies is to separate applications into very distinct silos. This means, we run our applications in a very controlled environment (whether the original source code is open or closed). We keep our applications secure by limiting access to our server and databases. If somebody penetrates the “castle walls” which protect our applications, they can wreak all kinds of havoc: change permissions, modify source code, delete files or records, modify data in the database, change accounts or passwords, etc.

This whole approach creates an inherent power imbalance between a very clearly defined “us” and “them.” There are those who control the server, applications and settings, and then there is everyone else (such as users of those applications). The people who can go inside the castle walls control everything, the people outside the walls don’t.

Currently all software applications, whether open source (like Cyclos) or proprietary (like Paypal, banking software, the Visa Network, ACH or GETS) operate inside this siloed approach.

Why We Need Open Computing

What we are undertaking with the Metacurrency project is no small feat, because we are talking about a whole new architecture for software applications and information technologies. And this is why we’re spending so much energy clarifying what we mean by OPEN.

What happens if you want to write a check against your bank account, but there is a discrepancy between what you believe your balance is and what the bank says? Who is the authority? Who decides whether the check clears? Who decides what fees you’ll be charged if it doesn’t? What interest rates you’ll earn or pay? What other random fees and charges may happen? What the rules are and when they change? How much you can withdraw from an ATM in a single day? Etc…

The short answer: THEY do. Your only option is to move to another bank. Another bank where you’ll be in the exact same position again. One group of people holds all the cards, makes all the rules, sets all the policies. And you have no authority to represent your own account, your balance, the rules you’ve agreed to, etc.

So, I ask you… If we are making a whole new model for currencies, do we want to repeat that pattern? Are we going to just trust that well-meaning, community-minded folks will never abuse the inherent power imbalance built into that approach to computing?

There’s a reason for the saying: “Power corrupts. Absolute power corrupts absolutely.” Currencies are extremely powerful tools. If we want to break the pattern of humanity serving currencies and instead have currencies serve us, then we must break the architectural pattern of power imbalance which gives one group ABSOLUTE POWER and withholds it from the bulk of participants. It is an inherently corruptible structure. If we build the new economy on this inherently corruptible foundation, can we expect any outcome other than corruption?

Exactly how naïve are we?

We need a whole new model of computing which allows BOTH individuals and communities to be sovereign entities and maximizes the freedom of independence of both for a truly Open Economy.

Currencies Are Like Games

We find that currencies operate very similar to games. Currencies are a shared set of agreements about value, counting and transacting with each other just like games function by a shared set of rules, scorekeeping and making plays. Players choose which games they want to play, their strategies, their own moves and they should be able to see the part of the game relevant to their play. Each player is sovereign.

The rules may evolve, but players should not be able to change them willy-nilly. The rule-changing function operates at a different layer of governance than players making plays. BOTH levels need to have their own sovereignty. College football and professional football leagues can and do make different rules. And it’s important for players, spectators and referees to know the rules the game is being played by at any time.

If you want to play football with a group of friends in the park, you all can make your own rules deciding to play touch football instead of tackle. Each community of play is also sovereign. But a player on the field never make decisions via community governance, they choose for themselves where to run, throw or block.

Should the game of currencies provide any less? Under the current system, you are playing a game of earning dollars, but for most of the players, the rules are not visible, the state of the game is not visible and they are not even an authority able to represent plays they’ve made or their current status in the game.

Imagine trying to play chess where the rules change without your knowledge or consent, you can’t see the state of the board, you don’t know what plays your opponent is making, you aren’t even authorized to represent the plays that you yourself have made, and you’re not allowed to quit the stupid game. Does that even sound fun?

Our Approach to Open Computing

We identify three core components for an open, distributed, and decentralized approach to computing and currency architectures:

1. Open Transport: A protocol which can be used for participants to directly interact with each other and for any currency to interact with any other currency.
2. Open Rules: A means of representing the rules so players know what game they’re playing, what plays are valid to make, how those plays are handled and how any game/currency interacts with other games/currencies.
3. Open Data: A tamper-proof way of distributing data so there is no centralized point of failure nor power imbalance between the participants and the management/governance of a currency.

Digging Deeper into Open Data

Alan has mostly spoken about items 1 & 2 (using the metaphor of HTTP and HTML). This metaphor falls a bit short because, generally speaking, web pages don’t alter the state of other web pages, but connected games or currencies do. As mentioned, this certainly includes the ability to have universal IDs, but that is fairly negligible part of the problem we’re addressing (so we don’t even mention it in our list). We can use something like OpenID for now, but in the long run we need a completely un-enclosable namespace with no central or top authority. [But that is a conversation we’ll reserve for another time.]

I believe that the most groundbreaking part of the model has to do with item 3 - Open Data. Instead of managing data integrity and security through exclusion and obfuscation, we need an inclusive architecture THAT BUILDS INTEGRITY AND SECURITY INTO THE STRUCTURE OF THE DATA ITSELF. (Sorry for shouting, but I want to underscore that last point.) That is the only way to transcend the technological power imbalance between admins and users which is inherent in siloed computing architectures. [See previous post about Open Data]

The mechanisms for doing this involve new technologies that have never been assembled in this manner before. It means having a distributed, segmentable data engine which can store chains of linked, digitally-signed transactions. You can sort of think of this as using the digital signature validation that GIT uses for source code repositories, but for a distributed database application. It would also be helpful to the means to run signed instances of distributed applications and embed them in this distributed data engine. This enables you to validate any play (via its digital signatures and copies from various players, governance bodies or 3rd party notaries/auditors) and to see the state of play for any player. However, this does not necessarily mean complete transparency of all data. You can encrypt secret data into the transactions, or couple private entries in your own private data store to transactions via their transaction id as a foreign key. This is just like how in some games, you receive cards that are face-down, for that player’s eyes only. Other players can see that they’ve received a card (that a transaction was made), but cannot see the content of that card. If the governance of a currency gets bogged down in bad politics, makes bad decisions about rules, or even gets shut down, the players can pick right up where they left off with their own tamper-proof account statuses by selecting an old rules version (or forking with a new version) and deciding to continue the play. In this kind of true peered architecture, there’s no way to force a game to shut down as long as there are players that want to keep playing it.

Twollars as a Open System

Twollars gives us a glimpse of this power. You can define a new currency and anybody can use it via a public transaction medium (Twitter). Everybody can keep their own records (or record ALL transactions in the currency), transactions are transparent in the twitterstream, and if the twollars tools went away, you could keep using twitter on your own and track the transactions yourself.

Twollars have an open transport, and completely transparent transactions, Unfortunately, they still rely on centralized Twitter servers, the method for defining rules is rudimentary and not transparent to users, the data is not distributed, there is no accommodation for privacy (cards face-down), you have to compete for names in a limited twitter-account-namespace, and the currencies don’t interact with each other. Even so, it’s a beautiful step toward an open transaction architecture. Through it, you can begin to imagine new types of currencies and easy ways of transacting which don’t involve too much effort for the start-up team or currency participants.

Final Conclusions about Open Currencies

Open Source Software in siloed architectures still creates closed games with a clear division of us/them between system managers and players. Openness is NOT the same as Transparency. Privacy can still be accommodated as appropriate to the rules of the game being played. New platforms and data structures are required to for truly Open Currencies, and we’re busily building them.

I hope this helps with the outstanding questions. :)

P.S. Not to confuse matters, but we are also releasing all of the Metacurrency tools and platforms as Open Source Software. We also believe that is still an important part of Openness.