Wrapping up 2022

By: Katelyn Baker, Head of Software Engineering

How does one wrap up a year, summarizing 8760 hours in hopefully fewer words in a manner compelling to readers? If anyone has any bright ideas, please let me know. However, in the absence of talent, we must rely on perseverance, so let’s give it a good old college try.

Along the way, we may learn a lesson or two!

Assessing where we arrived by remembering where we started

It turns out that you can achieve a lot in twelve months!

Because human memory, especially mine, is endearingly fallible, the first thing I did when asked to review last year was to go digging back through our internal project planning docs. As my colleague, Marcello Farina (Product Manager extraordinaire), wrote earlier this year we use a milestone-centric delivery model to plan and execute projects (including Corda 5), and looking at how many of those got ticked off over the past 12 months is a testament to just how much the Corda 5 team have undertaken.

Consider January: “Operation Chainsaw” was complete and little else. A fitting name for a Milestone as it involved the hacking apart of the monolith that was the Corda 4 codebase, rescuing what was worth preserving and starting afresh with what wasn’t. At the end of it, we essentially had a pile of bricks all over the floor.

Forging a cohesive whole in the form of the second Developer Preview delivered at CordaCon, was a labor worthy of King Eurystheus. Hopefully, the diagram above captures a portion of the scale of what was achieved, how many moving parts needed to come together, and how teams on different workstreams needed to deliver for each other to ensure success!

It goes all the way to 11

One thousand!

That’s the number of Virtual Corda 5 Nodes my colleague Dries Samyn created using a simple Python script through the new REST interface in April; it took him a whole thirty seconds!

Looking for early justification of the architectural choices we’d made (and remember, at. this point a lot of Corda 5 was still a pile o’ bits), he took it upon himself to start prodding at the edges to see just how scalable this new beast was.

Turns out very!

This simple demonstration was so powerful: in front of everyone, 1000 unique identities were onboarded in seconds. Anyone who has tried to onboard a thousand identities on an older version of Corda, including setting up a thousand nodes, will appreciate just how awesome this was to see, and so early on in the process.

If people had doubts about earlier decisions, this demo dispelled them and was a great way to end the first third of the year.

More Previews than you can shake a stick at

It wasn’t just the Developer Preview and the soon-to-be-released Beta of Corda 5 that the team shipped. Indeed, back in May 2022, we saw two significant events:

• Firstly, the Corda 5 codebases were released to the open-source community, aligning the development of that project with its older sibling.
• Secondly, the Peer to Peer team released the P2P Preview, demonstrating the power of the technology layer underpinning our software.

May was a transformative month for the C5 team. For the first time, our work was out there for the scrutiny of all. For the first time, images, binaries, and charts were shipping out of it. That was a heck of a milestone in itself, bringing together not just Engineering and Product Management, but also the QA Engineers and the build Engineers, it was a true team effort.

Cloud Native

June saw the publication where we presented the first look at Corda 5’s cloud-native deployment.

If ever there was a neglected and unloved aspect of Corda, the deployment and operation of it at scale would surely be it. Indeed, some early decisions surrounding the development of the first-generation Corda architecture would prove actively hostile to ever delivering a scalable solution that would play nice in the data center.

Addressing this shortcoming was front and center at the outset of the Corda 5 platform. Seeing the first demos of the infrastructure spinning up with a single command, capable of scaling to host many discrete DLT applications each with their own large and expandable user bases was another proof point we were on the right track and delivering the right stuff at great speed.

No town like your Home Town

To summarize why the completion of the Operation Hometown Hero Milestone and the accompanying internal demo in July was such a big deal, we need to once again look at the process by which Corda 5 came together. The major workstreams up to the end of July were:

1. Chainsaw: Hack what we had with Corda 4 apart and take stock of the remaining fleshy gobbets of code.
2. Scaffold: Build the “theater set” version of Corda 5 from the liberated Chainsaw survivors plus what was needed to deliver “Corda, if Corda doesn’t do anything”. The most complex thing that could be done was that the state machine could respond to an RPC call to echo “hello world” to the log file.
3. Hometown Hero: Take those bare bones from Scaffold and expand the capabilities of Corda so that CorDapps can be loaded, virtual nodes created and flows executed between peers (albeit within a single cluster).

Seeing Hometown Hero demoed to the whole company was, I believe, a defining moment for the team. Finally, Corda was Corda again. The satisfaction of finally seeing that pile of bricks become something cohesive, to prove we could do it (not least to ourselves) was vast.

It helps if the demo at least gently prods some buttocks. This was something that we invested time and people into polishing. Now, it may seem strange to do this with what was effectively throw-away code, but the lessons learned by building it were truly valuable and the ability to “show, not tell” the Corda 5 story finally cannot be understated. If I could impart one piece of wisdom to the next generation of architects and designers of complex software, it would be to invest in your demos: they will speak so much louder than thousands of lines of prose and win hearts and minds. They will bring people together and generate excitement, as it did for us, and it showed we were on the path to a successful 2022.

Developers Developers Developers

Steve Balmer wasn’t wrong: a platform is nothing without the people who build atop it. Corda started out by shipping milestone releases to its developer community long before the dreaded Version 1.0 was looming on the horizon. We prioritized the developer experience because we knew that was the key to getting people to try the platform, because we were developers both of and upon Corda as well, and because as a small team, it was easy to keep everyone aligned with the goals of the platform as a whole.

One of the problems with growth is that you lose that easy alignment. As that small group of developers morphed into teams with areas of focus and deadlines to hit and features to add, the focus on the holistic whole of Corda was lost a bit. When something is everyone’s problem, in reality, it is no one’s! People always assume someone else will pick up the things that get dropped.

The developer experience of Corda had become the thing we dropped.

Until August! when we created the first internal team focussed solely on making sure the experience of building applications to run on Corda is first class and ensuring developers are always a persona at the table whatever change is being considered for the platform.

Alas, their work is hard to see, since no one knows “just how bad” things would be, had they not intervened. Trust me when I say that the second developer preview was made possible by this team’s efforts. That said, this blog is a good example of them showing their work externally.

Wrapping it all in a bow

Finishing out 2022 and moving into this bright, shiny, new year, the team continues to hit milestones. They shipped the Alpha version of Corda 5 in November and the first beta releases are set to have dropped in December and continue from January, adding polish and stability on the way to 5.0.

It’s important to look back at the moments that defined our progress, to see how we documented and celebrated them, used them as evidence to the rest of the business and our external developer community that we were doing the right thing, on the right track, and had made the right choices.

When we hadn’t, when deadlines were missed and milestones changed, we had evidence to back up those changes to the schedule and plan; when we came back with solutions we had tangible demonstrations to show the benefit, in hindsight, of the choices we’d put to people. We earned trust over the course of 2022 by relentlessly focusing on hitting milestones and delivering incremental, demonstrable, progress. It’s a lesson I’ll take forward as to how to manage such disruptive change.

2022 was a heck of a year, exhausting and exhilarating. It’s been one of the true highlights of my career to date to see the Corda 5 project move from a simple proposal to a terrifying mountain of work left to do with no tangible thing to show anyone, to what it is now, a complex but well architected and modular codebase almost ready to ship.