Corda turns 3

Corda turns 3

Last week it was Corda’s third birthday, if we go by the date of the first git commits. Seems like a good excuse to write a rambling blog post!

I was reminded of this by watching newly posted interviews we did with flagship Corda users at CordaCon. It’s still a little bit surreal (but really nice) to watch people talk about using Corda to improve huge industries like global trade and insurance. Feels like hardly any time at all that the only apps were unit tests.

Here are a few things currently on my mind.

SGX

One thing that comes through in the videos is the importance of privacy controls. We haven’t talked about privacy much in 2018, mostly because this has been a quiet year feature wise. The focus has been on consolidation and maturing the platform. Better faster stronger, but not very different.

Still, lots has been going on behind the scenes. If you’re curious where SGX went, go take a look at Andras’ “hello world” enclave PR that generates random numbers in a Java enclave. It supports deterministic builds with remote attestation so you can audit what the remote CPU is doing. You can’t download and play with it yet because it’s not ready to go — we’re on track to have a proper, documented developer preview of Oblivium ready by EOY as promised, albeit not encrypting the Corda ledger yet (‘Oblivium’ is our codename for the JVM-in-SGX project). But feel free to comment on the sample code as the API is still taking shape.

Community

I’ve started open source projects several times in the past and the great joy is always the users and contributors. I’ve been really happy to see contributions grow from small tweaks to full blown design efforts like what Fuzz, Mark, Richard and the rest of the Cordite team are doing, and of course Corda 3.3 had a ton of people’s code contributions in it which was fantastic. The TAC committee has proven a worthy successor to the original Architecture Working Group. The grounding it provides is invaluable.

Over time I plan for Corda OS to become more and more a community led effort, a bit like how Java developed, with a structured way for the community to not just contribute improvements but actively control the platform’s architectural direction. Open sourcing the code was the first step, the TAC is a second, the Corda Foundation we’re setting up is a third and decisive way to decentralize control away from R3, and eventually I suspect not just the main zone but also the code and protocol will be governed in a similar way.

This is all hand-wavy and in the future — it’s not been discussed much to be honest and we’re not planning on making any sudden moves here. It’ll be a gradual process that happens at its own pace, perhaps over a period of many years.

Specification

A key part of that process is turning Corda into a rigorously specified protocol, independent of the reference implementation. This is a ton of work which doesn’t deliver any direct value in the immediate term. So we’re spreading it out over time. As the protocol becomes ever more precisely documented it will evolve into a separate artifact that can have its own community and development process. Alternative non-R3 implementations may appear.

In the past couple of days I’ve been working on a C++ deserialization engine for our protocol, partly to help out a project that wants to verify transaction contents on an iPhone, and partly to force me to write some protocol documentation. The first PR is here. It’s still very far from being a spec, but because our protocol is AMQP+extra bits and AMQP is already an open and well specified protocol, it’s sufficient to describe the basics. More advanced things like how exactly calendared dates appear on the wire, the flow session protocol and so on will appear over time.

Please do contribute! The protocol is usually a direct mapping of documented classes in the API so it’s not hard to figure out.

Next year

The fourth year of Corda development is now starting. I think a better time to talk about what’s coming will be at the start of 2019, as by then we should have Corda 4 out the door and will be looking forward.

We’ve spent a year focused almost entirely on production-readiness topics like performance, usability, deployability, upgradability, BFT notaries, security etc. Corda 4 adds a few new things around tokens and app upgrades, but the experien
ce of writing a cordapp is pretty much the same as at the start of the year. We’ll keep up the production focus in 2019 but not to the same singular extent — we’ll be doing some more work on new features for app developers too.

I’ll ask for input again at the start of the Corda 5 cycle because it’s very open to feedback, but here are some initial APIs we’re thinking of upgrading:

• Flow framework. In particular being able to do blocking send/receives on arbitrary message queues, which is a part of our plan for human interaction from apps.
• If there is interest and adoption, support for more languages like JavaScript, C++, C# … probably using a mix of Graal and conventional code generation. We might start looking for contributors to ‘own’ optimizing the experience in these other languages, rather than the Corda team taking it all on.
• Java 11 and all the new functionality that unlocks, like losing the hateful @Suspendable annotations (which means, flows in Scala, yay!).
• Integration and activation of the big tech chunks we developed in 2018 like Oblivium and the DJVM.
• Data distribution groups?
• Data model stuff? Making it easier to use encumbrances, multi-sig threshold keys and so on?

Things like MAXIMUS, BFT notaries and the enterprise roadmap (which don’t affect app developers directly) aren’t listed here — those have been committed to already, so community feedback on the direction is less useful. I’m only talking about the API and protocol today.

As always, it’s a real pleasure working with such an esteemed group of professionals. So where do you want to go? What shall we do together in our fourth year?

Cheers!