On Interoperability

OpenTransact is all about interoperability. That is why it was created. I
have been quite perplexed to be honest where this comes from.

It is not just library interoperability.

It is trusting that my application can work with many different providers.

It is allowing people to create new interesting derivative open transact
services on top of existing services.

It is also about letting me bring my transactions with me and maintain them
in a separate app.

However as I understand it the very narrow definition of Interoperability
that Manu believes we don't support is:

I want to pay someone from my PayPal account and having it show up in my
Moms Dwolla account.

http://manu.sporny.org/2011/web-payments-comparison/#interoperability

Just like when you in a bank can send money from one bank to another.

Before I start going through the issues here. I would like to ask where
PaySwarm specifically specifies how to move money from one payment provider
to another? I can not find it in the spec.

What we realize though is that there are many different ways payment
services can interoperate.

This is not as simple as defining a protocol. There are many different
issues here.

Like how do I as PayPal move money to Dwolla? That is not an API issue.

Traditionally in the US you can abstract that away to banks via the ACH
network and SWIFT internationally.

PayPal and Dwolla both use ACH to move money between peoples bank accounts.

The way money is moved in banking has traditionally been through banks
maintaining "nostro" accounts within each other.

So if I have an account with CitiBank and want to send $20 to someone in
Wells Fargo. Citi would credit Well's Fargos nostro account $20 and tell
them to send it to their customers account. Chase would charge Citibanks
nostro account $20 and move that into their customers account.

Every now and then (in the old days) you would have to physically move
money or gold to maintain good nostro account levels.

This was later modernized by having central banks deal with such movements
in a centralized ledger, so individual banks didn't have to have
connections with everyone.

In a web payment 1.0 world PayPal and Dwolla use ACH to abstract away all
of that.

In a web payment 2.0 world without ACH things are different. We want to
move money between two of possibly thousands of payment providers, we need
either a distributed graph of connected payment providers each with
"nostro" accounts with each other or a few central players.

I like the distributed graph model myself. The most important proposal in
this space is Ryan Fuggers Ripple project http://ripple-project.org/

There is actually an OpenTransact implementation of it called Rivulet here:

https://github.com/jplewicke/rivulet

These are currently all based on a central graph database. But the ideas
could definitely be implemented in a distributed way using OpenTransact.

The point of all of this is interoperability can mean a lot of things. Also
that sending money from one institution to another is not quite as simple
as it is made out.

P


-- 
http://picomoney.com - Like money, just smaller
http://stakeventures.com - My blog about startups and agile banking