# Why Cairo 1.0 ? ![](https://i.imgur.com/f4zxJsY.jpg) In a recent [Stark @ Home Episode named Why Cairo 1.0 ?](https://www.crowdcast.io/e/1t3gmodi), 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. 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](https://github.com/shramee/starklings-cairo1), 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.