A lot of people in the crypto research community are talking about shared building and shared sequencing. I have remaining questions about the importance of both but something I do find cool and related is this new idea of intents. Both Flashbots and Anoma are building platforms to allow users to express their intents for transaction execution in a way that looks very different than vanilla execution on the EVM.

In the EVM when you want to interact with a smart contract you sign a message that sends data to a specific function on an address that contains deployed code with step by step instructions for the requested execution. You provide the inputs, but you don’t necessarily have control over the outputs because the code you’re interacting with might be stateful, etc.

However, in an intents-centric design the user merely signs their intents with a bond and will pay the bond if their intents are met. This is cool, but it’s a very different way of thinking about the world.

Interestingly, it reminds me of a class I took in college on programing languages.

For the entire semester we focused on building a Sudoku solver in what felt like every programming language ever invented. The point of the class was to show to us noobs that there were many tradeoffs one could make as a developer and depending on the problem a given programming language could yield very different developer experience, solution performance, hard to squash bugs, etc.

I started off with C++ struggling through manual memory management. As an early programer it was in this class that I gained a fond appreciation for object oriented programming and automated garbage collection that came with higher level languages. I also remember really enjoying Racket, which is a Lisp variant. Part of the reason I liked it so much was because Paul Graham wrote a lot about Lisp.

Towards the end of the semester we moved on to logical programming and were instructed to implement the sudoku solver in prolog. Prolog is an extremely weird language, but for certain problems can be very powerful and very expressive. A program in prolog describe a series of statements about what the program should accomplish, but does not provide ordered instructions for execution. This creates a very weird syntax, but it turns out it’s particularly good for solving Sudoku.

For instance, while it took me numerous days + hundreds of lines of code to write a Sudoku solver in languages like C++, Go, Python, etc. it only required three lines of code to write a valid sudoku solver in Prolog. This literally blew my mind.

So when I first met the Anoma team and then later read the Flashbots Suave whitepaper and learned more about their vision for intents all I could think about was my prolog sudoku solver.

I have to believe there are some interesting problems in crypto that would be best suited for a programming paradigm that feels more like prolog and less like the EVM. Complex combinatorial logic such as transaction ordering for mev searchers and builders could be a good example! Though I have remaining questions around the need for shared builders and shared sequencers, I am excited to see how intents environments evolve.