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:
- Vitalik Buterin, the co-founder of Ethereum
- Eli Ben-Sasson, ZK-STARK Co-Inventor and Co-Founder of StarkWare
- Lior Goldberg, StarkWare engineer and co creator of Cairo
- Shahar Papini, StarkWare engineer co creator of Cairo
- Ori Ziv, StarkWare co creator of Sierra
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:
- Enhancements to the language for convenience and usability
- Efforts to improve the efficiency of compiling Cairo to Sierra
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:
- Adding library functions or extensions to improve functionality
- Developing a Sierra-to-Casm compiler written in Sierra itself
Performance Improvements and Scaling
The panelists discussed various strategies for enhancing transaction processing speed and scaling StarkNet. These included:
- Improving the performance of the sequencers
- Implementing a fee market, similar to Ethereum
- Exploring parallelization of transactions
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:
- The reasons behind the development of Cairo and Sierra as new languages
- The potential for Cairo to be used as a standalone language, independent of StarkNet
- The possibility of implementing “unsafe Cairo” with added hints for optimization
- The prospect of employing Cairo on Ethereum L1 in the future
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.
All Comments