EELS: The Future of Execution Layer Specifications by Peter Davies | Devcon Bogotá

Summary

The speaker discusses the evolution and challenges of specifying the execution layer in Ethereum, emphasizing the need for an up-to-date, readable, and executable specification. They introduce 'EELs' (Execution Environment Layers), a code-first approach that aims to improve clarity, testing, and collaboration between researchers and developers. The talk explores the development process, the benefits of EELs for parallel work, and the potential impact on Ethereum's governance and EIP process, inviting community involvement and feedback.

Takeaways

• 📘 The speaker discusses the importance of the execution layer in blockchain technology, focusing on the state transition function and its validation process.
• 🔍 The yellow paper is mentioned as a historical document that outlines the validity conditions but is criticized for being outdated and not part of the standards process.
• 📝 EIPs (Ethereum Improvement Proposals) are identified as sources of change proposals but are noted to lack a holistic view of the system's evolution.
• 🔧 The test suite is described as a valuable resource but is criticized for being unorganized and not specifying behavior comprehensively.
• 👨‍💻 The speaker advocates for a 'code-first' approach to specifications, using Python to create readable, executable, and testable code that can serve as a common language for developers.
• 🔄 The concept of 'hard forks in isolation' is introduced to simplify readability and understanding, despite the code duplication it may cause.
• 🛠️ The development process is described, highlighting the need for a common framework that allows researchers and implementers to communicate effectively.
• 🔗 The executable specification (EELs) is positioned as a tool that can streamline the development process, enabling researchers to prototype ideas and implementers to build robust systems.
• 📈 The potential of EELs to automate testing and even run miniature testnets is mentioned, emphasizing the benefits of having an executable specification for pre-emptive testing.
• 🤝 The speaker calls for community involvement, inviting others to implement their favorite EIPs using EELs and provide feedback to improve the process.
• 🔧 The need for refactoring and freezing the EELs code is discussed to facilitate a stable base for others to build upon and contribute to the Ethereum ecosystem.

Q & A

What is the primary focus of the execution layer specifications discussed in the script?

The primary focus of the execution layer specifications is the state transition function, which determines if a block is valid to be added to the state and what the new state would be after the addition.

Why is the Yellow Paper considered outdated in the context of this discussion?

The Yellow Paper is considered outdated because it reflects the Berlin version of Ethereum and has not been updated to include changes from later versions such as London.

What are the limitations of using EIPs (Ethereum Improvement Proposals) as a source of information for the execution layer?

EIPs are individual change proposals that do not provide a comprehensive view of the system. They only show isolated changes without explaining the relationships between them.

How does the test suite help in understanding the execution layer?

The test suite is full of tests that demonstrate various behaviors of the system. However, it is not well-organized and does not specify the system's behavior in a clear, readable manner.

What is the main issue with relying on client source code to understand the execution layer?

Relying on client source code is problematic because it is complex, not designed for readability, and does not serve as a clear specification of how the execution layer works.

What is the 'code-first' approach to specifications mentioned in the script?

The 'code-first' approach to specifications involves starting with Python code that is clear, readable, and executable. This code serves as the basis for the specifications, allowing for testing and validation before being formalized.

Why is readability important in the Python code used for execution layer specifications?

Readability is crucial because it allows anyone with programming knowledge to understand the specifications without needing specialized mathematical skills. It also enables executable testing of the specifications.

How does the 'code-first' approach benefit the development process for the Ethereum Virtual Machine (EVM)?

The 'code-first' approach provides a common language and framework for researchers and implementers, allowing them to work in parallel on different aspects of the EVM development process. It also enables executable tests and prototypes before full implementation.

What is the significance of having executable specifications in the development process?

Executable specifications are significant because they can be tested, allowing developers to validate changes and ensure compatibility with existing systems before full-scale implementation.

How does the script's approach to handling hard forks (e.g., Frontier, Homestead) benefit the reader?

The approach isolates each hard fork into independent implementations, making it easier for readers to understand each fork in isolation without having to consider how it relates to other forks.

What is the current status of the execution layer specifications project mentioned in the script?

The project has implemented all the hard forks, and the merge is still a work in progress. The team is working on refactoring and freezing the code to allow others to build on top of it.

How can the community help with the execution layer specifications project?

The community can help by implementing their favorite EIPs using the execution layer specifications, providing feedback, and contributing to the open process of refining and expanding the specifications.

What is the potential impact of executable specifications on the EIP process for Ethereum?

Executable specifications could potentially change the EIP process by providing a more streamlined and efficient way to propose, test, and implement changes to the execution layer of Ethereum.