Join to Learn

Join our Learning Stellar Contracts program, an 8-week series of instruction and practice with Stellar and Helios.

Efficiently learn about Cardano smart contracts and the best known practices for making great software that interacts with on-chain currency.

How it works

Each week, we'll join together with you live in US/West mornings (afternoon / evening, European time). Each session is expected to run 90 minutes, and you'll have space to continue discussions together.

Each session will come with an experiential-learning activity.

You'll get both direct and vicarous co-experiences and build intuition and understanding.

Who should join?

Are you a coder? Although you aren't required to write any code during our program, you'll have the opportunity to engage more deeply into the practical technical details. We hope to also be announcing available certifications for program graduates, as well.

UI Developers are cordially invited. You'll connect to the mental models of Cardano dApps, engaging into the ways static applications can provide compelling connection to payments infrastructure, dynamic user experiences, and rich user-to-user interactions. Learn as much as you like, and become a skilled full-stack dApp developer.

Non-developers are also most welcome. You are smart and inquisitive. You want to play an active role in our ecosystem, participate in commercial ventures together with technicians, and connect your business knowledge with Cardano know-how.

Topic Plan

We're showing high-level topic areas, together with a more detailed look into our early sessions, to help you get a strong sense of what to expect from the learning program.

Learning about Cardano Smart Contracts

Week 1: the Cardano domain model

We'll inventory the key "moving parts" of Cardano smart contracts, that apply regardless of the choice of language. We'll also point to Stellar-specific terminology that can help cement the universal concepts for you.

We'll show different ways that commercial application systems can be constructed, and ways the on-chain mechanisms work - and some cases where they don't work in ways we might intuitively guess. And we'll survey a few off-chain technologies that can help serve your product goals.

For your learn-by-doing activity, you'll choose an application domain and work on shaping some of its key interactions using the building-blocks you've learned. We'll additionally offer a range of sample applications where you can practice solutioning and get prompt feedback.

Week 2: the shape of a Stellar contract

In week 2, we'll extend the essentials of Cardano contracts and learn about the blend of off-chain and on-chain code that makes up Stellar contracts.

We'll also introduce the Helios on-chain language, preparing you for deeper learning about it in week 3.

For practice, you'll develop the concept for a bite-sized piece of contract logic for one dApp, as diagrams (Miro or pen-and-paper) and/or with Javascript. You can extend your week-1 case, or you can switch to another case we find together in our classroom collaborations.

(Want to do conceptual modeling for more cases? Be awesome and go for it!)

Week 3: The Helios on-chain language

In week 3, we'll introduce you to the essentials of the Helios on-chain language, implementing at least one example contract together.

You'll also get light exposure to the Stellar testing environment, vicarously experiencing the power of test-automation and seeing testing practices in action.

For the learn-by-doing segment, you can choose to practice reviewing our Helios Top 10 - the on-chain types that can be most essential for practical contract development. Even for non-technicians, reviewing details of the "top 10" is great for developing understanding and intuition.

Coders can go deeper by implementing a simple contract script - choosing from a case in your own project, or from a short-list we can suggest. Pair up with less-technical people to earn coop contributor credits while giving them vicarious experience.

Creating Transactions for Smart Contracts

In this segment of the course, we'll transition smoothly into an integrative perspective that includes on-chain data, constellations of collaborating smart contracts, and off-chain code important for connecting UI's meaningfully with on-chain transactions.

Week 4: Designing Stellar constellations

Gain exposure to, and practice with, small collaborating scripts that get good things done.

Week 5: Creating micro-APIs for your application

Practices and conventions for shaping software, so everyone on your team can understand how to get things done within your dApp - even if they aren't going to write any on-chain code.

You'll learn how to provide these capabilities as open APIs and create revenue-generation potential without binding other developers to your user-interfaces.

Week 6: Licensing, Auditing, Transparency, Open-Source, and creating commercial value

This week connects the dots between commercialization, open-source, certification and licensing.

We'll also recap key learnings from prior weeks, freshening the most important material and connecting it with this week's topics.

Week 7: Delegates and distributive transaction-building

Discover patterns for combining simple components in complementary ways, to create high-functioning software that you can extend further.

Advanced Topics

Having developed strong understanding of both basic and intermediate techniques, we'll dig into strategic approaches for applying the essentials, while effectively serving a variety of different goals for different situations.

We'll switch back and forth between concepts and concrete examples, to keep you grounded while developing big-picture intuition.

Week 8: Requirements Management and Testing

In addition to a recap of key learnings about delegates, we'll focus this week on practices around requirements management and testing. Building things right is no good if you aren't building the right thing. We'll get a good look at both.

Week 9: Design patterns for great delegates

With delegates, there's not just One Right Way. You'll learn about variations on the theme, how they might apply in various situations, and how to distinguish between those techniques and their fitness for your goals.

Week 10: Enabling evolutionary capacity for your contracts

Immutable or upgradable? Why not both? Practical considerations for continuity, evolution and escape-hatches.