Ethereum Protocol Fellowship: 4-Week Highlights
Introduction
It's been nearly four weeks since I joined the Ethereum Protocol Fellowship (EPF). The last two weeks have been particularly intense as I've been catching up with the available resources.
Why I Joined the Fellowship
My primary motivation for joining the Fellowship was to deepen my understanding of the Ethereum Protocol and to learn what it takes to become a core Protocol Engineer. The EPF has provided numerous resources, including the EPF Wiki and the EPF Wiki YouTube channel, which have been instrumental in my learning journey.
Study Highlights
Over the past two weeks, I've delved into various topics such as the Ethereum Roadmap, the history of Ethereum from pre-merge to post-merge, and the current and future state of the protocol. I've also studied consensus and execution clients and their specifications.
Consensus Layer vs. Execution Layer:
Consensus Layer: Ensures the security of the blockchain and consensus among network participants. It handles block proposal, validation, and finalization.
Execution Layer: Carries out transactions, performs computations, and updates the blockchain state.
I also explored different client services like Reth, Geth, Lighthouse, Besu, Prysm, and Nimbus. Notably, I found that these clients use languages like Go, Rust, Nim, Java, and C++—none of which use Solidity.
Additional Learnings
I've also studied cryptographic concepts relevant to the Ethereum Protocol, such as Merkle and Verkle trees, which dictate data structuring, hashing, and storage.
Another significant area of research was the ePBS (Enshrined Proposal Builder Separation), aimed at separating block builders from block proposers to enhance block production efficiency and reduce issues related to Maximal Extractable Value (MEV).
I also learned about how to an Ethereum node and how to interact with various clients like the lighthouse Consensus client and the Geth Execution client with Holesky and Emephry testnet more on this in another blog/tutorial.
Learning Go and Rust
Realizing the need to understand Go and Rust to contribute to client projects, I undertook an intensive seven-day study: three days for Go and four days for Rust.
Highlights from Learning Go:
Go is similar to Kotlin and Solidity in some ways. It's a statically typed, beginner-friendly language.
It uses structs instead of classes and capitalizes functions to make them public.
Unfamiliar concepts included pointers and references, which are crucial for encapsulation.
Complex topics like goroutines, channels, and Mutexes were challenging but became clearer over time.
Highlights from Learning Rust:
Rust is notoriously difficult for beginners but excels in performance, security, and computational accuracy.
Inspired by Reth’s performance, I dived into Rust and found it more rigid than Go, requiring semicolons similar to Java.
Rust uses modules (mod) and public (pub) keywords instead of classes and public/private identifiers.
Key concepts include error handling with Panic, custom errors, traits (similar to interfaces), and ownership.
Reflections and Advice
Joining the Fellowship has taught me the importance of understanding the Ethereum Protocol itself, beyond just the EVM-compatible layers, rollups, and sidechains. Here are some tips for future fellows:
Study the Ethereum white/yellow paper and the protocol roadmap to stay informed about upcoming changes.
Follow and contribute to Ethereum Improvement Proposals (EIPs).
Understand that Solidity is essential for smart contract development, but the protocol side requires knowledge of languages like Go and Rust.
Current Progress and Future Goals
The fellowship is progressing well, and we're now selecting projects to focus on for the remainder of the program. The next four months will be even more intense as we start making significant contributions to the protocol. Despite feeling like the least knowledgeable at times, I am committed to improving daily and have already started contributing to the EPF Study Guide Wiki.
Other Activities
Cartesi Experiment Week: Built a Tipping DApp, learning about Cartesi Rollup’s asset handling and routing.
CartDev CLI Tool: Working on this tool to streamline the project setup and development process, helping onboard more developers into the Cartesi ecosystem.
I'm excited about the journey ahead and look forward to making meaningful contributions to the Ethereum Protocol.