Ethereum actually came back?
L2 and their scalability promise.
I want to dedicate this and the following weeks to Ethereum’s Comeback: Or, How I Learned to Stop Worrying and Love the Blockchain. No, I am not leaving the vibecoding and MCP conversation behind, the following series of posts are going to be over how to use L2 to leverage ETH with the minimum technical requirements, because yes, we want to be technical, but no, we don’t hold a Senior Matrix Binary code understanding degree.
This weekend, something happened that many of us had already given up hope on: Ethereum came roaring back like a Marvel character nobody really asked for but everyone’s suddenly pretending to love. Why did this happen? Take your pick: Bitcoin’s own rally, a surge in transaction volumes, or the institutional money pouring in through ETFs (which, let’s be honest, are just Wall Street’s way of saying, “We want in, but with training wheels”). There are a lot of reasons, but this post is not about financial analysis, because if it were, I’d have to start charging you for therapy. No, this is about how to actually use all this tech, rather than just shouting “WAGMI” into the crypto void.
Before we continue, this post is available in Spanish here.
Let’s remember: Ethereum’s big promise is “programmable money.” That’s right, money that can do tricks like a dog, but with more math and less drool. Thanks to smart contracts, if action A happens, then action B is automatically triggered and recorded on the blockchain. But to make this happen securely, you need validator nodes. Scaling this up so it doesn’t move slower than British public transport is a massive challenge. Enter Layer 2 solutions-because if there’s one thing tech loves, it’s slapping on another layer and pretending it’s a solution.
What the Hell Are Layer 2s?
Layer 2s (L2s) are basically Ethereum’s way of saying, “Let’s do all the heavy lifting off-stage and just take a bow on the main chain.” They process transactions away from Ethereum’s main chain, but keep the security. They use things like rollups and payment channels to crank up speed (up to 10,000 TPS!) and slash costs by up to 90%. That’s right: you can finally send a transaction without having to remortgage your house.
Among the L2 crowd, my personal favorite is Starknet. Why? Because it uses Zero Knowledge (ZK) rollups, which is a fancy way of saying, “I can prove I know something without telling you what it is.” Kind of like when you tell your friends you’ve seen ‘The Wire’ but can’t name a single character.
Starknet’s Value Proposition: The Holy Trinity
- Scalability: Starknet processes most transactions off Ethereum’s main chain, so things move faster and the network doesn’t get as congested as the London Tube at rush hour.
- Lower Costs: Transactions on Starknet are much cheaper, making decentralized apps (dApps) actually usable. Upcoming upgrades like Volition and EIP 4844 promise to make things even cheaper, because apparently, there’s no bottom to this rabbit hole.
- Cryptographic Security: Unlike some L2s that play fast and loose, Starknet uses zk-STARKs for mathematical validation; no third-party trust falls are required.
Oh, and Starknet uses its own programming language called Cairo. Yes, another programming language, because developers clearly didn’t have enough existential dread already.
Starknet in the Wild: What Can You Actually Do With It?
Gaming
Blockchain gaming is one of Starknet’s breakout use cases. Imagine games where:
- Transactions are fast enough that you don’t age visibly between moves.
- Transaction fees are so low, you might actually make money instead of losing it.
- Game logic runs directly on-chain, so you can’t blame lag for your defeat.
Examples? Influence (an on-chain strategy game) and Realms (an on-chain universe) are both powered by Starknet. Performance tests show games like Influence have seen transaction speeds up to 10.5x faster thanks to Cairo’s native execution. That’s right: faster than your internet provider’s customer service, which is a low bar, but still.
DeFi
Starknet lets you build DeFi protocols that are:
- Faster than Ethereum’s main chain (which, let’s face it, isn’t hard).
- Cheap enough for microtransactions, so you can finally stop pretending “gas fees” are a real excuse.
- Capable of handling complex financial logic.
Top projects: Ekubo (token launch platform), AVNU (gasless DeFi trading), and ZKX (decentralized perpetuals exchange). Yes, those names sound like rejected Star Wars droids, but they’re real.
Decentralized Social Networks
Starknet can power social platforms that:
- Support millions of users without melting down.
- Deliver real-time feeds and instant reactions, just like Web2-only, without Mark Zuckerberg lurking in the background.
- Slash gas costs so you can post and comment without consulting your accountant.
These platforms can handle posts, comments, and votes with low latency, making them competitive with their centralized, soul-crushing counterparts.
Starknet Is Still Evolving (Unlike My Cooking Skills)
Starknet keeps getting better: faster transactions, lower latency, cheaper everything. The potential for new blockchain use cases keeps expanding-unlike my patience for NFT shills.
The Starknet Developer Journey: A Guide for the Masochistically Curious
If you’re a developer looking to transition to Starknet, here’s your roadmap. Don’t worry, there are fewer existential crises than learning React (but only slightly).
Phase 1: Setting Up Your Environment
Install Cairo (the language, not the city):
- MacOS:
1. Install dependencies: `brew install gmp`
2. If you hit a wall: `CFLAGS=-I\`brew --prefix gmp\`/include LDFLAGS=-L\`brew --prefix gmp\`/lib pip install ecdsa fastecdsa sympy`
3. Create a Python 3.7 virtual environment: `python3.7 -m venv ~/cairo_venv`
4. Activate it: `source ~/cairo_venv/bin/activate`
5. Install Cairo: `pip3 install cairo-lang`
- Ubuntu:
1. Update and install everything: `sudo apt update && sudo apt upgrade && sudo apt install -y software-properties-common git curl pkg-config build-essential libssl-dev libffi-dev libgmp3-dev`
2. Install Python 3.7: `sudo add-apt-repository ppa:deadsnakes/ppa -y && sudo apt install -y python3.7 python3.7-dev python3.7-venv python3-pip`
3. Set up the virtual environment and install Cairo: `python3.7 -m venv ~/cairo_venv && source ~/cairo_venv/bin/activate && pip3 install ecdsa fastecdsa sympy cairo-lang`
Set Up Your IDE (because you deserve nice things):
- Install the official “Cairo” extension by StarkWare for VSCode.
- Try “Cairo language support for StarkNet” by Eric Lau from Open Zeppelin.
Phase 2: Blockchain & Ethereum Basics
Before you go full Starknet, know your basics:
- What is a blockchain?
- How does Ethereum work?
- What are Layer 2s, and why do we need them?
- What are rollups and zero-knowledge proofs? (No, it’s not a magic trick, but close.)
Phase 3: Learning Cairo
Cairo is a language for zero-knowledge proofs. Key things to know:
- The syntax (spoiler: it’s not Java).
- Memory management (very different from what you’re used to).
- Data types and pointers (bring snacks).
- The Cairo standard library.
Pro tip: Check out the “Walking with Starknet” tutorial series.
Phase 4: Starknet Development
Now you’re ready to:
- Write basic smart contracts.
- Deploy contracts on the Starknet testnet.
- Use dev tools like Nile or Hardhat.
- Study common design patterns.
Phase 5: Integration & Advanced Use Cases
With your Node.js or Java experience, you can:
- Build web apps that talk to Starknet contracts.
- Develop backends that communicate with the blockchain.
- Implement off-chain databases for your dApps.
Phase 6: Community Engagement (a.k.a. Networking Without the Awkward Small Talk)
- Join the Starknet Startup House in Monterrey this June. Yes, you can register. No, there won’t be free pizza, but accommodation, meals, and professional VCs and technical feedback are included for the selected teams.
- Check out the Launchpad for pre-event learning.
- Share your knowledge. Write articles, give talks, or make memes.
- Contribute to open-source Starknet projects.
Recommended Resources
- Official Starknet and Cairo documentation
- “Walking with Starknet” tutorials
There you have it: a crash course in Starknet, with less jargon and more sarcasm. Stay tuned for more posts where we’ll dive deeper into use cases and how to actually build something useful-because the blockchain isn’t going to revolutionize itself. I will deliver more tutorials if the engagement keeps growing.