Source: https://hackmd.io/@abdelhamid/stark-at-home-why-cairo-1

In a recent Stark @ Home Episode named Why Cairo 1.0 ?, the creators of Cairo programming language came together to discuss their vision for the future of Layer 2 scaling solutions. The episode featured a thorough conversation between:

Throughout the discussion, the panelists covered various aspects of StarkNet, Cairo, Sierra, and the ongoing improvements and optimizations of these technologies.

5 quotes from the Stark @ Home Episode - Why Cairo 1.0?

- Vitalik: "Level one is Cairo assembly, the base language that gets proven. Sierra adds safety and Cairo 1.0 adds Expressivity."

- Eli: "Making the proof ZK is relatively easy. Designing for a general purpose computation that is meaningful and composable is much harder."

- Lior: "With Cairo, you don't need to be a ZK expert to start writing programs."

- Shahar: "Sierra is an intermediate representation that allows us to make sure that the Cairo programs are consistently provable, addressing issues like reverted transactions, unsatisfiable AIRs, and DOS attacks."

- Ori: "Typed Starknet adds type safety, enabling better resource management & efficiency."

This post summarizes the main points of the webinar.

StarkNet: A Layer 2 Scaling Solution

StarkNet is a Layer 2 scaling solution designed to improve transaction throughput on Ethereum. The platform employs zk-STARKS, an advanced zero-knowledge proof technology, to enhance scalability and maintain strong security guarantees. The webinar offered a detailed introduction to Cairo and Sierra, two programming languages specifically developed for StarkNet.

Cairo: A High-Level Language for StarkNet

Cairo is a high-level programming language designed to make it easier for developers to write contracts and applications for StarkNet. It features a memory model and syntax that closely resemble conventional programming languages. During the webinar, the panelists discussed ongoing improvements and optimizations to Cairo, including:

Sierra: An intermediate representation bringing Safety

Sierra is designed to enhance the safety of the language, allowing the construction of Cairo programs that are consistently provable.

The addition of an extra layer between user-written Cairo 1.0 code and the proven Casm code is necessary due to the limitations of Cairo and the need to address issues like reverted transactions, unsatisfiable AIRs, and DOS attacks. Sequencers in L2 systems must be compensated for their work, even if a transaction fails. If they can’t charge for such transactions, it becomes an obvious DOS attack.

A possible solution is to include these transactions in a block, like Ethereum. However, this is difficult in a validity rollup with Cairo 0, as there’s no separation between user code and proven code, allowing users to write unprovable code. Sierra, the added layer, ensures all transactions are eventually provable, addressing these concerns.

Some of the future plans for Sierra include:

Performance Improvements and Scaling

The panelists discussed various strategies for enhancing transaction processing speed and scaling StarkNet. These included:

In addition to these strategies, the speakers mentioned plans to transition from a Python-based implementation to a Rust-based implementation for better performance.

Future Directions for StarkNet

Some exciting future directions for StarkNet include:

Typed StarkNet

Typed StarkNet would involve adding type safety to contracts and state within the StarkNet ecosystem. This would enable better resource management and more efficient transaction processing.

Extensibility of Cairo and Sierra

The panelists emphasized that Cairo and Sierra’s extensible design offers the potential for adaptation and expansion into non-blockchain ecosystems. Sierra provides increased flexibility for future enhancements, such as employing a small field to accelerate arithmetic operations.

Q&A Highlights

The webinar concluded with a Q&A session, during which the panelists answered several interesting questions from the audience. Some of the main topics covered included:

Conclusion

The episode offered a fascinating glimpse into the world of StarkNet and Cairo programming language. As the panelists continue to refine and optimize these technologies, developers can look forward to new features, improvements, and opportunities for innovation.

For those interested in learning more about Cairo, Sierra, and StarkNet, the panelists recommended exploring resources such as starklings, an interactive tutorial based on Rustlings. By exploring these tools and tutorials, developers can gain a deeper understanding of the potential of StarkNet and its associated technologies.

Call out StarkNet Beta Testers!

Reddio is building developer tools for StarkNet to help you accelerate the process to develop StarkNet applications. We are inviting all of StarkNet developers to join our beta testing group, try out brand-new features and tell us what you think.

https://share.hsforms.com/1E88oQkqMSJifUV1CqR_WrQd30xn