It’s common to talk about software “ecosystems” without stopping to think too hard about the metaphor. But the metaphor fits well — just like a living ecosystem, a healthy software ecosystem depends on creating the right preconditions and then reliably maintaining a supportive environment.

And like the plants and animals in a natural environment, software that “lives” inside an ecosystem needs a minimum level of stability to survive. Most of the economic and social value in a software system comes from long-lived applications — applications that people can rely upon. If your ecosystem is under constant upheaval, you get mass extinctions and you don’t get the steady, long-term growth and investment required.

Decentralization implies many different teams solving many different problems in their own ways on top of a common infrastructure. You can’t attract those hundreds and then thousands of teams overnight — it requires the accumulation of trust and technical stability.

Cardstack engineers in the studio. Watch the video.

While some cryptocurrency projects and funders are aligned with this kind of long-term investment mindset, many others are simply gamblers chasing short-term gains. This is both a poor investment thesis and self-defeating if your goal is to actually change the way the world works.

Cardstack emphasizes stable growth, because our goal is a broadly-accessible ecosystem that empowers everyone — not just deep-pocketed tech companies who can afford to absorb software churn and have a high appetite for technical risk.

So how does a healthy software ecosystem grow? We can think of roughly three stages — each depending on a different group of people:

Core Contributors

In the early stages of any ambitious software project, upheaval is expected. The small, core group of contributors who are turning the ideas into reality need to iterate quickly and lay out the broad architectural patterns. For that reason, it’s important to not prematurely try to grow a big ecosystem in the earliest stage.

There are two failure modes if you grow too early: either you maintain your pace of innovation and burn through the goodwill of all the people whose apps you’re constantly breaking (if you’ve ever tried to ship a user-facing desktop app on Linux you have probably felt the effects of this). Or you lock in your architectural patterns too early and end up stuck in a local maximum that makes future improvements extremely difficult (the amount of cruft in the Win32 API is legendary, and some of Microsoft’s expensive and high-profile failures are directly related to compatibility concerns).

From the Cardstack whitepaper.

No software is ever “done” and you shouldn’t wait to ship to real users until things are perfect, because they will never be. But there are tried and true ways to build long-lived architectures. The web platform itself has succeeded largely by following those patterns. Our architectural plans for Cardstack are directly inspired by that kind of evolvable system.

But of course it’s critical to escape this early stage as quickly as possible, because the whole point is to grow an ecosystem, and you need to bring in the next, wider audience of participants: the early adopters.

Early Adopters

When is a project ready for the early adopters? It’s a continuum based on the level of expertise and risk-tolerance of each potential user. There is no hard boundary. But several things you should look for include:

One or more complete, runnable examples. Quoting the original Agile Manifesto, “running code” is worth more than abstract documentation, and this is particularly true for an early-adopter stage project.

Quoting the original Agile Manifesto, “running code” is worth more than abstract documentation, and this is particularly true for an early-adopter stage project. The beginnings of guides and API documentation. At this stage, you should expect blog-post-level tutorials and docs, not comprehensive coverage.

At this stage, you should expect blog-post-level tutorials and docs, not comprehensive coverage. An open and friendly core group of participants. These people can answer the inevitable questions that will arise. Because bugs and questions will arise.

For Cardstack, this is the stage you should be watching for. Our core contributors are working directly on checking off the “complete runnable examples” bullet point right now. As that ships, you’ll see the “beginnings of guides and API docs” immediately following. And we already have an “open and friendly core group” — we work in the open on GitHub and you can sit in on our discussions in the Cardstack Community Slack.

By virtue of their expertise, early adopters are the source of most of the ecosystem’s growth of new features. They are the plugin authors and tool makers. They bring their individual experiences from different verticals into the ecosystem to make sure there’s a solution for each problem.

Early adopters are generally tolerant of instability. But to ensure that their contributions continue to accumulate, it’s important even at this stage to ensure broad compatibility. You want your growing set of plugins and features to keep growing — not to experience waves of mass extinctions, or bifurcations between “old style” and “new style”.

From the Cardstack whitepaper.

One of the exciting things about Cardstack is that early adopters who author broadly useful open source features have a path toward a new sustainable open source business model. The token mechanism creates an open, portable way to host Cardstack applications, and along with that generates a royalty stream to the authors of the open source packages that are heavily used in valuable applications.

Another promising feature of Cardstack at this stage of development is that it becomes a great option for other crypto and decentralized open source projects to use as a starting point for organizing their own communities, since it’s built to facilitate low-effort integrations between radically different data sources (including both decentralized ledgers and traditional cloud services).

Mainstream Developers

Moving beyond the early adopter stage is a function of time and continuing broad community investment. You need time before more conservative organizations will adopt. And you need a lot of ongoing investment to bring the level of polish up to what is needed for a mainstream product.

The investment can become self-sustaining as the early adopters build successful projects in the ecosystem and continue to scratch their own itches and fix bugs. Opportunities arise to produce high-quality training materials, books, and courses. And of course the underlying software quality needs to reach a level where the typical adopter will have a just works experience most of the time.

Mainstream developers want themes, extensions, and everything to run smoothly off-the-shelf—think WordPress. And that’s no small feat. It’s easy to forget how big a gap in time and money there is between “it works well enough for me” to “it works for everyone almost all the time”.

From the Cardstack whitepaper.

Cardstack has a high probability of reaching this broad adoption phase because our market and technology risks are both quite low. We’re relying on trends that already exist: more shared code leading to higher quality and lower cost, skill-intensive IT management problems getting replaced by free software, containerization and portability of applications, the rise of the web as a true application runtime, etc.

Our mission is to take all that growing capability and bring it to the broadest set of people, in a sustainable way. Crypto projects can change the world, but only if we stop chasing short-term excitement — and understand that the biggest impacts will accrue over time.