Devs Do Something

David Furlong: Frames, Frames.js and Farcaster Apr 23, 2024

Today’s episode is a special episode with David Furlong, founder of frames.js.
We discuss everything frames and farcaster. Don't miss out on it !

Participate in the Superfluid Frontier Guild program: https://www.notion.so/superfluidhq/Superfluid-Frontier-Guild-ca56b52629f446989a66fb69b158cd74
FramesJs: https://framesjs.org/
Superfluid: https://www.superfluid.finance/

The Modern Web3 Stack with Vitto Rivabella Jun 16, 2023

Today's episode features Vitto Rivabella on the modern web3 stack.

Vitto on Twitter: https://twitter.com/VittoStack
Create Web3 Dapp: https://www.alchemy.com/create-web3-dapp

A Deep Dive on Linea: A New zkEVM Jun 09, 2023

Today's episode is with Emily from the Consensys team on all things Linea - Consenys' new zkEVM.

Linea: https://linea.build/
Linea Docs: https://docs.linea.build/
On ZK Hardware: https://hackmd.io/@Cysic/BJQcpVbXn

Planet IX - Web3 Game Development Behind the Scenes Jun 02, 2023

Today's episode features Lukas & Emil of the Planet IX core team.

You can learn more about Planet IX (and play the game!) here: https://planetix.com/

Alchemy & Account Abstraction Infrastructure May 26, 2023

Today's guest is Noam Hurwitz, an engineer at Alchemy who is playing a key role in building Alchemy's new account abstraction infrastructure.

Alchemy on AA: www.alchemy.com/account-abstraction
Alchemy: https://www.alchemy.com
Alchemy University: https://university.alchemy.com
Follow Noam on Twitter: https://twitter.com/ProbablyNoam

00:00 Intro

3:51 How Noam got into crypto

6:00 Noam’s take on the current Account Abstraction discourse

8:32 AA infrastructure overview

11:32 Walking through Alchemy’s bundler architecture

13:15 MEV and user operations

15:05 The ‘intent based architecture’ and the userOp mempool

18:05 The entry point contract

22:50 Paymaster contracts

25:24 What should application developers know about AA?

29:40 What do smart contract accounts enable?

32:41 Lessons from drafting an EIP and EIP 6900

37:16 Avoiding centralization around AA infrastructure

42:46 New security issues presented by AA

45:01 Noam’s advice on building APIs & developer products

49:15 Noam’s favorite technical implementations in the industry

50:54 Advice for those early in their career

52:48 How Noam hopes the industry evolves over the next decade

Alluo Finance - How to Build a Great DeFi UX May 19, 2023

Today's episode is with Remi & Sung - core contributors at Alluo Finance. We went deep into Alluo's smart contract architecture & philosophy on building great DeFi user experiences.

Learn more about Alluo: https://linktr.ee/alluo

Build on Superfluid: https://www.superfluid.finance/wave-pool

00:00 Intro
5:11 How Remi got into the industry/Alluo's founding
8:11 How Sung got into the space
9:58 What is Alluo?
16:18 Auto Invest - streaming DCA
18:33 An overview of the Alluo contract architecture
23:59 - Bridging architecture
25:15 - Simplicity in protocol design
31:52 - How Alluo liquidity direction voting works at the smart contract level
34:58 - Boosted pools
39:57 - Using the 4626 design for the boosted pool
42:05 - stIBAlluo for money streaming
47:26 - Building out a high quality mobile experience for DeFi
56:59 - Advice for early stage DeFi teams

The Graph Deep Dive with Pranav Maheshwari May 12, 2023

Today's episode features a deep dive on The Graph with engineer Pranav Maheshwari.

Check out the Superfluid Wave Pool here: https://superfluid.finance/wavepool

Zac Williamson on Huff, Aztec, Noir, and Building with ZK Tech May 05, 2023

This week's guest is Zac Williamson, founder & CEO at Aztec.

Check out the Superfluid Wave Pool! https://www.superfluid.finance/wavepool

Aztec: https://twitter.com/aztecnetwork
Noir Docs: https://noir-lang.org/
Zac on Twitter: https://twitter.com/Zac_Aztec

00:00 Intro

3:45 How Zac got into Web3

6:45 The creation of Aztec

14:30 why did he build huff?

19:05 Weirstrudel & Optimizations in Huff

21:33 Inspirations for Huff Language designs

23:15 Why did Huff take off?

27:27 The future of the Huff community?

31:08 Mental models needed for devs that want to build privacy preserving apps

37:05 Hello world in Noir

38:50 Private functions and private contracts on Aztec

46:22 The Aztec sequencer

50:15 Noir & smart contract security

51255 What should people build on Noir?

56:52 Advice for early career devs

Solidity Fuzzing & Web3 Testing with a Trail of Bits Security Engineer Apr 27, 2023

This week's episode features an interview between Patrick Collins and a Web3 Security Engineer at Trail of Bits. They cover:
- testing methodologies
- fuzzing
- static analysis

With Trail of Bits Security Engineer, Troy!

Timestamps
3:10 - Exploring Smart Contract Testing Methodologies with Trail of Bits
5:37 - Testing Strategies for Smart Contracts
8:10 - Fuzz Testing and Invariant-Based Testing Explained
10:56 - Coverage Guided Fuzzing Explained
13:50 - The Benefits of Coverage Guided Fuzzing and the Differences between Echidna, Foundry, & Others
16:27 - Using Coverage Guided Fuzzing with Optic and Echidna
19:12 - Symbolic execution and coverage-guided fuzzing in Echidna
21:57 - Testing Philosophies: Dynamic vs. Static Testing
24:24 - Dynamic vs Static Analysis and the trade-offs of each approach
27:10 - The Importance of Efficient Testing and Using a Variety of Testing Methods
29:57 - The Role of Security Firms and Testing Philosophies
32:33 - Balancing Cost and Efficiency in Security Audits
35:15 - The Importance of Code Reuse in Building Tools and Languages
38:04 - The pitfalls of focusing on language intricacies in programming and the benefits of prioritizing language design and philosophy
40:41 - The Need for More Open Source Tools and Communication in the Ethereum Community
43:22 - Advice for becoming more security-minded in smart contract coding
45:51 - Discussion with Alpha Rush on Testing Compilers and Security Focus Journeys

Ethereum Optimizooor Culture With Rage of Size.Market Apr 20, 2023

Today's guest is the pseudonymous developer Rage of Size.Market.

Rage on Twitter: https://twitter.com/rage_pit

How to Level Up as a Web3 Engineer with Alberto Cuesta Cañada Apr 14, 2023

Building a Full Stack Skillset with Albert Hu Apr 06, 2023

Today's guest is Albert Hu - Founding Product Engineer at DeForm & former Developer Advocate at Alchemy.

Lens Protocol In Depth with Nader Dabit Mar 30, 2023

Today's episode is a technical deep dive into how Lens Protocol works under the hood.

Build with Superfluid: https://www.superfluid.finance/wavepool
Build on Lens: https://www.lens.xyz/garden

Chapters:
00:00:00 - Intro
00:02:45 - Hackathons and the Superfluid Wave Pool
00:05:35 - Understanding Lens: A Developer's Perspective
00:08:11 - Lens Infrastructure: What's Happening Under the Hood?
00:11:02 - Build a Following That Stays with You Forever
00:13:33 - The Challenges of Storing and Retrieving Data in Blockchain Applications
00:16:13 - Building the Lens API
00:21:30 - Lens Modules
00:29:31 - Social Media Monetization and the Scalability of Lens compared to Twitter
00:32:05 - Scalability and the Challenges of Building at Twitter Scale and Beyond
00:34:52 - A Modular Infrastructure for Increased Transaction Speeds
00:37:21 - Building on top of the Lens API: Required Skill Sets
00:39:46 - Progressive Decentralization
00:44:53 - Building Recommendation Algorithms with AI and Machine Learning Techniques
00:49:47 - Exciting Opportunities for Developers on Lens Platform
00:52:11 - Building with Lens and Calls to Action for Developers

How To Perform an Audit with Damn Vulnerable DeFi Creator & Patrick Collins Mar 23, 2023

00:00 Intro & Opening Conversation
7:58 Tincho's audit setup

12:35 VSCodium

14:08 Foundry v hardhat

22:00 First audit steps

25:00 Tincho's process for commenting within the code itself
30:00 Processing a codebase with lots of inheritance & moving parts: there’s a kind of art here to flowing back and forth between the big picture architecture/business logic and the low level understanding of contract

32:42 Be careful of going down adjacent rabbit holes that don’t have to do with the thing you’re auditing

36:52 When Tincho finds a bug… what does he do?

41:15 Communicating with clients

44:12 Waling through tests with Tincho

47:40 To best understand a protocol, make the codebase your own: run things locally

52:00 Intuition vs checklists

56:05 Learning by reading past reports

59:04 Reviewing fixes

1:00:18 Handling hacks & the purpose of audits

Safe, Smart Contract Wallets, & Account Abstraction with Richard Meissner Mar 16, 2023

Today’s guest is Richard Meissner, co founder & CTO at Safe. Richard is an expert on all things smart contract wallets, and we used this episode to go deep into account abstraction. In particular, we discussed the Safe contract architecture and how things like Safe modules & smart contract wallets work under the hood. The Safe team has rolled out a ton of new libraries & tech that make supporting smart contract wallets and AA a breeze, and we discussed them as well.

00:00 Intro

3:55 How Richard got into the industry

8:31 The Safe contract architecture

14:13 Safe modules

17:11 Misconceptions and account abstraction

20:45 ERC 4337 Infrastructure

23:11 How app developers can make proper use of smart contract wallets

25:45 What does the ecosystem need to do to enable better UX?

29:50 Solving the YOLO signing problem

36:37 The Safe Core Suite

42:30 Frictionless onboarding

50:08 How Richard & the Safe team approach smart contract security

56:00 Advice for early career devs

59:45 What does Richard hope our industry looks like in 10 years?

Safe Core: https://twitter.com/safe/status/1630946737220141062
Richard on Twitter: https://twitter.com/rimeissner

Devtooligan on Huff, Audits, & Following Curiosity Mar 09, 2023

Today’s guest is with Devtooligan - a pseudonymous smart contract engineer and auditor.

Devtooligan is a mainstay in the Huff community and just recently landed a job as a security engineer at Trail of Bits. In this episode we went deep into Huff & why so many Huffoors have had lots of success. We also discussed Devtooligan’s career path and his journey leveling up with smart contract security.

00:00 Intro

3:33 How devtooligan got into crypto

6:48 Working at Yield Protocol, Ethernaut, Getting into Huff,

12:30 Why learn Huff?

16:35 What has Solidity done well?

20:02 What should the Huff community work on?

23:00 Why have Huffors had success?

27:40 Getting better with smart contract security

37:55 What does Devtooligan’s audit process look like?

43:53 What can smart contract devs be better at? (Documentation)

48:31 AI tooling & auditing

51:45 Tinkering is what drives innovation

Useful Links:
-Devtooligan on Twitter: https://twitter.com/devtooligan
-Security reference, exercises, and tips: http://secure-contracts.com

-Huff main site: www.huff.sh

-Statecharts and state machines: https://stately.ai/docs/state-machines-and-statecharts

-ToB Youtube channel: https://www.youtube.com/@trailofbits

-Fuzzing workshop: https://www.youtube.com/watch?v=QofNQxW_K08&list=PLciHOL_J7Iwqdja9UH4ZzE8dP1IxtsBXI

-How to prepare for an audit: https://blog.trailofbits.com/2018/04/06/how-to-prepare-for-a-security-audit/

A Deep Dive into the Polygon zkEVM with Jordi Baylina Mar 02, 2023

Today's guest is Jordi Baylina, who leads the technical team building the Polygon zkEVM. The polygon zkEVM launches in late march, and this episode will serve as your technical introduction to how the zkEVM works.

We got deep into how Jordi & the team pulled this off - we talked through how the prover & sequencer works, stepped through a sample transaction step by step, and got into just how his team was able to pull off opcode parity w Ethereum L1 (and some of the tradeoffs with supporting full EVM compatibility).

If you’re interested in deploying atop the zkEVM or just understanding how it works from a technical point of view, I think you’ll enjoy this episode!

00:00 Intro
3:22 How Jordi got into crypto

6:33 What is Polygon’s zkEVM?

9:34 Enabling opcode parity with Etheruem on a ZK rollup

16:10 Pricing opcodes

19:33 Walking through a transaction on the zkEVM under the hood

25:38 Bottlenecks with data availability & the sequencer

30:50 Progressively decentralizing the sequencer

34:39 LX <> LY bridge design

39:48 Tradeoffs of being fully EVM compatible

49:46 Retaining parity with the EVM as the EVM introduces changes

52:23 What should people build on the zkEVM?

Learn about the Polygon zkEVM here: https://wiki.polygon.technology/docs/zkEVM/develop/
Jordi on Twitter: https://twitter.com/jbaylina

DCBuilder.eth - Zero Knowledge ML and Becoming a Web3 Developer Feb 23, 2023

Today’s guest is DC Builder - a pseudonymous dev who works as an engineer at Worldcoin and maintains DevPill.me - a guide to becoming a web3 engineer.

DC Builder has contributed quite a bit of open source content & research to the space as well. He’s written things like deep dive guides on L2s and he also created the zero knowledge machine learning community.
In this episode, we got deep into the weeds on ZK ML (a fascinating topic I knew nothing about before this convo), becoming a web3 dev, and how to decide which communities and ecosystems to invest time into.

This is a great episode for engineers looking to level up in the industry, and for anyone curious about ZK ML.

00:00 Intro
3:20 How DC builder got into crypto
7:31 Bottom up vs top down learning
9:17 From research to development
13:45 devpill.me breakdown
16:41 Advice for early web3 engineers
118:48 How to evaluate new developer ecosystems?
23:09 Leveling up as a developer
27:39 ZK
32: 28 ZK ML - a wild topic
42:29 Using ZK for *interactions* with ML models
47:44 Working at Worldcoin (ZK ML experiments and Worldcoin ID state bridge)
56:33 Moving data from Polygon to Ethereum L1
1:03:43 Learning about how the EIP/ERC process works
1:06:44 Building social capital in the industry
1:12:54 Other things that DC builder is interested in
1:15:53 What does DC Builder hope that our industry accomplishes?

Learning how to learn: https://barbaraoakley.com/books/learning-how-to-learn/
Blockchain Dev Guide: https://www.devpill.me/
Awesome ZKML: https://github.com/worldcoin/awesome-zkml
DCBuilder on Twitter: https://twitter.com/DCbuild3r

A Deep Dive on StarkNet with Henri Liuetad Feb 16, 2023

Today’s guest is Henri from StarkWare. Henri is a dev advocate who is deeply plugged into the StarkNet ecosystem and also hosts the StarkNet team’s podcast. This episode is meant to be a great introduction into building on StarkNet for existing web3 devs.

We went very deep into all things StarkNet and Cairo.

We discussed things like the StarkNet account model & runtime environment, the evolution of Cairo & Cairo 1.0, and the future of applications that might use StarkNet for privacy preserving applications (rather than using the ZK rollup for scalability alone).

We also made sure to talk through the mental models that devs coming from the EVM need to understand in order to build on starknet, and why the team built their own separate language in the first place.

Shownotes:
00:00 intro
3:15 How Henri got into crypto

6:05 What is StarkNet?

10:41 STARKS v SNARKS

15:54 Walking through a StarkNet transaction

19:05 Decentralization

19:58 StarkNet account model

23:22 Mental models EVM devs should understand to build on StarkNet

29:34 What will people build on StarkNet?

33:30 Building a privacy preserving application on StarkNet

37:12 Cairo

41:28 Evolution of Cairo and Cairo 1.0

44:52 Building secure products in Cairo

49:15 Validity rollups & data availability

56:20 What *should* people build on StarkNet?

58:58 Henri’s long term view on the industry

StarkWare Base Camp: https://twitter.com/StarkWareLtd/status/1605519238038294529
Henri: https://twitter.com/henrlihenrli
StarkNet: https://starkware.co/starknet/

DeGatchi on Reverse Engineering and MEV Feb 09, 2023

Today’s guest is DeGatchi, an anon web3 dev who has gone from teaching himself to code on the bus, to building some of the most cutting edge open source tooling in the space. In this episode, Degatchi walks us through his journey into crypto, and his work as a dev to date. We discussed his early learning process, and his journey doing things like launching a DEX, getting into MEV, and ultimately building cutting edge tooling like bytecode & calldata decoders. If you’re interested in some nuanced takes on MEV, understanding the EVM under the hood, and how you can dramatically increase your own rate of learning in the industry, this episode is for you.

Shownotes:
2:53 How DeGatchi got into crypto

7:06 Importance of working with other good engineers

8:50 Languages: learning solidity, rust

10:15 The role of MEV for the industry

13:55 Getting into MEV

15:55 MEV terminology: long tail, short tail, generalized front-running

21:11 Rust v Go for MEV

23:20 Reverse engineering

24:30 Building a call data decoder

25:40 Bytecode decoder

33:05 anon crypto dev culture

35:55 People who have helped DeGatchi (0xBuns, Huff community, Flashbots discord, “cult” on fantom, etc)

38:02 Zk interests

39:32 Yield farming automation

43:01 Other interests

44:31 What other tooling does DeGatchi want to build?

48:55 Advice for other early career devs

51:10 What does DeGatchi hope the industry looks like in 10 years?

DeGatchi on Twitter: https://twitter.com/DeGatchi
DeGatchi's Blog: https://degatchi.com/

Account Abstraction, ERC 4337, & Biconomy with sachint.eth Feb 02, 2023

Today’s guest is Sachin from Biconomy. This episode was dedicated to the details of account abstraction and new technologies that aim to improve the overall user experience in web3. In particular, we went into great detail on ERC4337 vs EIP 3074, and talked through what infrastructure is required to actually get ERC 4337 implemented.

Biconomy is working pretty aggressively on this, so we got a first hand perspective here. We also dove into some of the second order effects of ERC 4337 - such as how the user operation pool will work and whether or not this will open up new forms of front running outside of traditional MEV. If you’re a dev that wants to be on the forefront of new developments in account abstraction, then this episode is for you.

If you're looking for a hackathon this month, check out the Superfluid Wave Pool: https://superfluid.finance/wavepool

00:00 Intro
3:45 how Sachin got into crypto

13:44 ERC4337 v EIP 3074

29:58 Infrastructure for ERC 4337

45:29 Idiosyncrasies of the user operation pool with ERC 4337

47:20 Fixed gas transactions

52:10 Supporting smart contract wallets on front end with biconomy

1:03:45 How has Sachin approached improving as a dev?

1:09:30 How does Sachin see the industry evolving?

Sachin on Twitter: https://twitter.com/schin_tomar
ERC 4337: https://eips.ethereum.org/EIPS/eip-4337
Biconomy: https://www.biconomy.io/
Fixed Gas Tx: https://mirror.xyz/0xd96FA162b064553822e765545E3D48a054eC81F6/PgRtcrT3CGN7sc723-2ykpXnAqQEJCMMtiLTL47ZFMQ

Nader Dabit on UX, Developer Ecosystems, and Giving Back Jan 26, 2023

Today’s guest is Nader Dabit - the Director of Developer relations at Aave. Nader has had a very positive impact on many, many devs in web3, and in this episode, we tried to get behind the scenes on how Nader approaches creating developer content, building developer communities, and both building & maintaining APIs and developer tooling. If you work in dev real or are building a protocol or product that’s meant to be used by developers, I think you’ll get a lot out of this episode.

If you're a dev listening to this, you should out the Superfluid Wave Pool - a continuous hackathon where you can win prizes and build your portfolio of work: https://superfluid.finance/wavepool

3:55 How Nader got into web3

5:39 Following curiosity

9:04 Avoiding distractions

11:50 How Nader approaches learning a new protocol or technology

16:05 How to decide what to learn in the first place

19:03 What problems in the industry is Nader interested in solving?

23:02 Giving back via education

28:22 Preparing for a dev workshop

31:48 Advice for giving talks

34:27 Building developer communities

39:34 Leveraging bounties and contractors within your dev community

47:39 Building SDKs and APIs

50:34 UX improvements that web3 needs

52:52 What does Nader want people to build?

55:35 What’s on the Lens developer roadmap?

Nader on Twitter: https://twitter.com/dabit3
Building Developer Communities Article: https://nader.substack.com/p/building-high-impact-developer-communities
Lens: https://www.lens.xyz/garden
Miguel Piedrafitaon Twitter: https://twitter.com/m1guelpf

A Technical Introduction to NEAR Protocol with Bowen Wang Jan 19, 2023

Today’s guest is Bowen Wang, the Head of Protocol Development at Near. This episode will serve as a technical introduction to NEAR from the point of view of an EVM developer. Bowen and I discussed a lot of the inner workings of NEAR: we went into sharding, asynchronicity on NEAR, javascript smart contracts, and NEAR’s analogues to account abstraction. We also discussed how Aurora works, which is an EVM scaling solution built on top of NEAR. If you’re interested in expanding your domain knowledge to other L1s and learning how a great engineer thinks about building a developer career, I think you’ll like this episode.

3:20 Bowen’s Background

8:50 Understanding NEAR mental models for EVM devs

11:51 A token transfer on NEAR under the hood

14:35 Sharding on NEAR

19:33 Asynchronicity

25:32 Token contracts on NEAR

26:51 NEAR account model - all accounts are contracts

29:00 Account access keys

32:00 Human readable names (NEAR’s ENS equivalent)

36:40 Aurora, Rainbow & EVM compatibility

43:45 NEAR meta transactions

48:35 Zero knowledge light clients

51:35 Developer experience on NEAR

56:30 Developer advice

57:31 Long term vision for NEAR

NEAR: https://near.org/
Aurora: https://aurora.dev/
Bowen on Twitter: https://twitter.com/BowenWang18

Harsh Rajat - A Deep Dive Into PUSH Protocol and Web3 Communications Jan 12, 2023

Push protocol is building a decentralized communication and notification layer for web3, and in this episode, we deep dive the protocol on a technical level. We talk through things like the push smart contracts, PUSH ‘channels’, what exactly the notification itself is under the hood, and more. We also asked Harsh some more general questions about being an engineer in the space, and he gave some very good advice for engineers looking to be founders.

Learn more about the Superfluid Wave Pool and the January PUSH Protocol prize here: https://docs.superfluid.finance/superfluid/resources/superfluid-wave-pool#current-prizes

Stream salaries with Superfluid: https://use.superfluid.finance/payroll

Shownotes:
2:04 Wave Pool PUSH x Superfluid opportunity

5:30 How Harsh got into crypto

10:40 Founding PUSH (EPNS at the time)

16:00 Decentralized internet infrastructure

22:00 PUSH intro - what is PUSH?

28:05 Example: using PUSH with Superfluid

33:05 What are channels?

35:01 Notification payloads

40:05 PUSH delivery nodes

48:06 Progressive decentralization

51:01 The PUSH developer community

55:55 How has Harsh approached getting better as a dev and founder?

1:00:01 What bad advice should devs avoid?

1:04:03 What should devs build on PUSH?

1:06:31 What does Harsh hope the industry looks like in 10 years?

1:10:08 Game theory applied to building in crypto

Links:
Harsh on Twitter: https://twitter.com/harshrajat
PUSH: https://push.org/
Learn Game Theory: https://ncase.me/trust/

Introduction to Solana For Ethereum Developers with Bartosz Lipinski Jan 05, 2023

Today we’ll be looking beyond the EVM to do a technical deep dive on the Solana ecosystem.

Stream Salaries With Superfluid: https://use.superfluid.finance/payroll

Bartosz is the head of product engineering at Solana. He’ll tell you more about his journey into crypto in the episode, but Bartosz is someone with deep expertise in building software for the world of traditional finance. Before getting into crypto, he built trading systems for years at Citadel and worked as a senior engineer at JP Morgan.

You can consider this episode as a crash course on building on Solana for engineers who have a familiarity with the EVM. We walk through the Solana execution environment, how token contracts work on Solana, and some of the different mental models you’ll need to wrap your mind around to build Solana programs.

We also walk through how Bartosz thinks about building developer communities, and what he’s excited about in the Solana ecosystem.
Whether or not you plan to build on Solana, Bartosz is an excellent engineer and someone we can all learn from.

Solana Chicago Bootcamp in Jan '23: https://twitter.com/baalazamon/status/1605022057129218048?s=20&t=oVOeco1X11gSo2i-aRRxcQ

Shownotes:
4:27 How Bartosz got into crypto
7:10 The Solana ecosystem
9:11 Solana mental models & how they compare to the EVM
13:21 How tokens work on Solana
17:36 Code reuse and inheritance on Solana
19:49 Solana & the separation of compute and state
24:56 Upgradable contracts on Solana
26:23 The Solana account model
28:47 Optimizing for network performance or developer adoption?
33:17 Solana DevX
37:00 Favorite design patterns (Solana NFT composability)
38:03 Requests for tooling for the Solana ecosystem (block explorers)
38:51 Exciting new Solana developments - zkps and tokens
41:31 Long term view of what blockchain looks like
43:35 Solana bootcamps

Bartosz on Twitter: https://twitter.com/baalazamon

Luis (@gitpusha) on Gelato, Smart Contract Automation, & Off Chain Infrastructure Dec 29, 2022

Today’s guest is Luis (aka gitpusha), co founder of Gelato network. Luis has a fascinating story. He taught himself to code about 5 years ago and jumped into crypto before finding his way into smart contract automation & ultimately the founding of Gelato Network - a protocol for decentralized smart contract automation. In this episode, we deep dive Gelato’s network architecture, how the Gelato team approaches building developer APIs and tooling, and the specifics of professionally running off chain infrastructure.

Stream Salaries With Superfluid: https://use.superfluid.finance/payroll

00:00 Intro

3:50 How Luis got into crypto

6:30 Teaching himself to code

9:45 The founding of Gelato

13:45 Managing tradeoffs between developer experience and decentralization

19:20 Hardware requirements for Gelato Checkers and Gelato Executors

24:22 Gelato Checker client in depth

30:00 Overcoming technical challenges

33:35 DevOps skills

40:10 Advice for building developer APIs and tooling

45:35 How to use Gelato in your own application

48:50 What does Luis hope crypto looks like in 10 years?

Luis on Twitter: https://twitter.com/gitpusha
Gelato Network: https://www.gelato.network/

Julien Niset - Argent and Account Abstraction Dec 22, 2022

Today’s guest is Julien Niset, co-founder of Argent. Argent is a non custodial smart contract wallet that aims to improve UX across the entirety of web3. Julien has also become an expert & thought leader on account abstraction. In this episode, we deep dive account abstraction, how Argent works under the hood, and what app developers need to understand about all of this to build the next generation of web3 products.

Julien is also an ex-quantum physicist, so we got to ask him some fun cryptography questions as well (:

If you’re interested in improving UX for your users or just understanding the current state of account abstraction is at and what it’s all about, this episode is for you.

Stream salaries with Superfluid: https://use.superfluid.finance/payroll

00:00 intro

4:04 How Julien got involved in crypto

6:29 Julien’s background in quantum physics

9:12 Will all of our cryptography get broken soon by strong quantum computers?

10:02 The founding of argent

15:47 Account abstraction EIPs

23:59 EIP 4337

25:13 A fee market for user operations

27:33 Benefits unlocked by account abstraction (multicall, session keys)

33:06 What should app devs know about integrating smart contract wallets?

40:04 Good workflows Julien has seen that have been enabled by smart contract wallets

41:16 Social recovery

49:34 Starknet, zkSync

52:03 EIP wars

59:07 Argent’s focus on security

1:04:42 Julien’s long term focus - real products for real people

Argent: https://www.argent.xyz/
Julien on Twitter: https://twitter.com/jniset
EIP 4337: https://eips.ethereum.org/EIPS/eip-4337

Patrick Collins - Developer Advocacy, New Tooling, & Chainlink Dec 15, 2022

Today’s guest is Patrick Collins. You may know Patrick from his YouTube channel or his work at Chainlink, where he serves as a Lead Developer Advocate.

Patrick is one of the industry’s best educators and devrel pros. His latest 32 hour, full stack web3 development course was viewed over 1.3M times, and lives on as one of the best resources for people who want to go from zero to hero as a web3 dev. In this episode, we talk through how Patrick thinks about developer education, developer tooling, and building communities. We also touched on what he’s most excited about in the space & the Chainlink pipeline.

00:00 Intro

4:10 How did Patrick get into crypto?

5:57 Chainlink & the importance of oracles

7:57 First crypto projects

9:07 Does Patrick still hate Javascript?

10:33 Early challenges of building smart contracts

11:50 How Patrick approaches videos/tutorial content

18:17 Maintaining docs & videos as the tech progresses

21:12 How does Patrick stay on top of endless developer questions?

27:02 Bad advice or bad patterns Patrick sees in devrel

32:53 The smart contract language debate

35:42 How Patrick approaches smart contract security

38:07 What tooling does Patrick wishes someone would build?

40:42 What is Patrick excited about?

Patrick on Youtube: https://www.youtube.com/c/patrickcollins
Patrick on Twitter: https://twitter.com/patrickalphac
Chainlink: https://chain.link/

0xBeans - IAmTheOptimizer, MEV, & Smart Contract Security Dec 08, 2022

Today’s guest is with 0xBeans - a smart contract engineer who worked at Coinbase in the early days and now does work across the space as a solidity engineer.

Beans is the creator of the IAmTheOptimizer challenge, which took off earlier this year and saw the industry’s most high profile devs taking a crack at it.

In this episode, we discuss gas optimization, MEV, and building secure smart contracts. Beans is definitely a crypto native, and if you are too, I think you’ll like this episode.

00:00 Intro
4:01 how beans got into crypto
6:30 working at Coinbase & early projects
11:50 NFTs and smart contract security
16:55 how to get started w security/more security thoughts
20:33 IAmTheOptimizer
26:03 MEV
33:19 Designing with MEV in mind
37:22 Blind Vickery Auctions
44:17 What other developments is Beans excited about?
48:06 How Beans gets better as a dev
52:06 What does Beans want to learn next? Huff, Zk, Rust, Sway
58:02 What does Beans hope that the industry looks like in 10 years?

0xBeans on Twitter: https://twitter.com/0x_Beans

0xFoobar on Delegate.cash and Building Immutable Smart Contracts Dec 01, 2022

Today’s guest is Foobar - a Dev, writer, and auditor who is also a DeFi & NFT founder.

You may know Foobar from Twitter, where he is a grade A memepoaster and prolific commentator on all things crypto.

He’s also the creator of Delegate.cash - an immutable primitive to safely claim airdrops for vaulted NFTs.

In this episode, we deep dive several of Foobar’s projects, including Delegate.cash and a repo he calls ‘Bored and Dangerous.’ We also asked Foobar about how he personally levels up as an engineer, and how he approaches things like smart contract security, making tradeoffs between immutability & mutability, and drafting EIPs.

If you’re crypto native who wants to learn how a thriving anon dev approaches their craft, this episode is for you.

Stream salaries with Superfluid: https://use.superfluid.finance/payroll

00:00 Teaser

2:17 Intro

4:47 How foobar got into crypto

7:05 Crypto math that Foobar loves

10:23 How NFT devs should think about cryptoeconomics

14:07 How does Foobar think about smart contract security?

19:42 Delegate.cash

29:18 Delegate.cash vs other attempts at solving the same problem

32:09 Immutable vs mutable smart contracts

38:09 Advice for building contracts that will be used by lots of people

42:08 Advice for drafting EIPs

48:32 Common mistakes that Foobar sees from junior devs

50:52 Bored and Dangerous

54:42 What does Foobar hope our industry looks like in the next 10 years

Delegate Cash: https://delegate.cash/
Bored And Dangerous Repo: https://github.com/0xfoobar/boredanddangerous
Foobar's Substack: https://0xfoobar.substack.com/
Foobar on Royalties: https://0xfoobar.substack.com/p/on-royalties
Foobar on Twitter: https://twitter.com/0xfoobar

Nick Dodson - Sway & the Fuel VM Nov 25, 2022

Today’s episode is with Nick Dodson, co-founder of Fuel Labs and one of the minds behind the Sway language. We deep dive the FuelVM, Sway, and how Nick approaches his work as an engineer.

Stream salaries with Superfluid: https://use.superfluid.finance/payroll

00:00 Intro

5:14 How Nick got into crypto

8:36 Why build Fuel?

11:51 Where does Fuel fit in the web3 developer ecosystem, and how does it relate to Ethereum?

14:26 Parallel transaction execution

16:38 Register machine architecture

21:38 Sway

33:45 Scripts, predicates, & how they can improve UX

39:05 Fuel’s native asset model

48:00 Smart contract security with a new language

51:50 What does Nick hope people build on Fuel?

56:10 What should you be prepared for when building on Fuel

1:00:47 How has Nick leveled up as an engineer?

1:04:12 What bad advice should young engineers NOT follow?

1:06:15 What does nick hope our industry looks like?

Fuel Docs: https://fuellabs.github.io/fuel-docs/master/
EIPs implemented in Fuel that are still open for the EVM: https://fuellabs.github.io/fuel-docs/master/vs-evm.html#eips-implemented-in-fuel
Sway: https://fuellabs.github.io/sway/v0.31.1/
Nick on Twitter: https://twitter.com/IAmNickDodson
Our Episode with Cami - Head of DevX at Fuel: https://www.devsdosomething.fm/episodes/cami-ramos-garzon-developer-experience-fuel-bringing-crypto-to-latam

@w1nt3r on NFT Development, His EVM Course, and Winning as an Honest Builder in Web3 Nov 17, 2022

Winter has been prolific on Twitter & in his web3 journey. He’s worked on projects for the Nouns and Loot communities, and produced really interesting projects of his own including ERC1155U, Runes of Ethereum, & Hot Chain SVG.

Stream salaries with Superfluid: https://use.superfluid.finance/payroll

In this episode, we talk about the benefits of building in public, gas optimization, innovating in NFTs, and how to succeed as an honest builder in web3.

Winter is *legit*, and if you’re looking for a podcast episode that takes you away from the mania that’s happened throughout the last week in crypto, this episode will do that for you. Winter will bring you back to what matters: building

So give it a listen, and let us know what you think.

Links:
EVM Course: evmfromscratch.com
Winter on Twitter: https://twitter.com/w1nt3r_eth

Timestamps:
00:00 Intro
5:25 How Winter got involved in crypto

7:27 Winter’s NFT projects

9:57 Coming to crypto from big tech (Meta)

11:47 Deep diving the EVM

15:50 Where to get started with gas golfing - EVM.code, remix, and Winter

17:12 Solidity in the browser?!

23:43 Fighting centralization in the NFT space

30:38 How would Winter approach gas optimization for a new project?

34:37 Smart contract security

41:14 Leveling up as a solidity developer

46:10 Winter’s new EVM course

50:09 How to market your work without feeling like a shill

57:14 Favorite design patterns & optimization (ERC1155U)

1:01:07 What do people in web2 think about crypto?

1:05:23 What do crypto natives misunderstand about tech cycles?

1:08:30 What does Winter hope the industry achieves over the next 10 years?

Igor Yalovoy - Founding a DeFi Protocol, Unlimited Contract Sizes, & Solidity Best Practices Nov 10, 2022

Igor has a really interesting story. Babylon was a DeFi protocol that ended up shutting down after the Rari capital exploit, but the team gave the project a high integrity effort and it sounds like they learned many things during the journey.
Igor walks us through what it was like launching a new DeFi protocol during the bull market, and also talks us through the lessons he took away from the experience.
We cover subjects like testing smart contracts, preparing for audits, optimizations he’s product of, solutions to the sometimes oppressive contract size limit in solidity, & how he personally levels up as a solidity dev.
This ep is a treasure trove of information for DeFi founders and technical folks.

0:00 Intro
1:30 Who is Igor?
4:12 how Igor got involved in crypto
8:55 Early technical decisions with Babylon [decent soundbite here on audits]
13:44 Advice on testing composable systems
16:05 Advice for people about to launch a defi protocol [cost of solidity soundbite at 15:10 or so..probably winning soundbite]
19:45 Tooling Igor wishes people built for the space [soundbite on what to build] [gives a shoutout to defender around 20 min]
27:33 The perils of the solidity contract size limit (and potential solutions)
37:22 How to approach gas optimizations [decent soundbite there on how to handle this] [39 min a good one]
41:12 Preparing for audits
45:12 Favorite optimizations
50:48 How has Igor approached leveling up as a solidity dev? [really good soundbite here as well]
53:30 What do you hope the crypto DevX looks like in the next 5-10 years?

Igor on Twitter: https://twitter.com/ylv_io
Igor's Devcon Talk on Contract Size Limits: https://www.youtube.com/watch?v=qzlUNSt5pnA
Ethernaut: https://ethernaut.openzeppelin.com/
Damn Vulnerable DeFi: https://www.damnvulnerabledefi.xyz/
Paradigm CTF: https://twitter.com/paradigm_ctf?lang=en

Yorke Rhodes on Hyperlane, Cross Chain Tech, and Solidity Nov 03, 2022

Stream payroll with Superfluid: https://use.superfluid.finance/payroll

Today’s guest is Yorke Rhodes - founding engineer at Hyperlane, a protocol which serves as a platform for building cross chain applications.

Yorke is very knowledgable about building smart contracts. He was previously at Celo and has spent his career going deep on solidity before joining Hyperlane (which was previously known as Abacus), as a founding engineer.

In this episode, Yorke and I talk through the details of Hyperlane’s system for sending and receiving messages cross chain, and talk through cross chain tech more generally. We also talk through things like how Hyperlane thinks through developer experience & building APIs, and Yorke’s thoughts on smart contract security. Finally, we wrap up by asking Yorke what his favorite design patterns and optimizations are - something we always love asking.

If you’re a solidity developer with an interest in cross chain technology, this episode is for you.

Yorke on Twitter: @0xyorke
Hyperlane docs: https://docs.hyperlane.xyz/hyperlane-docs

Cami Ramos Garzon - Developer Experience, Fuel, & Bringing Crypto to LatAm Oct 27, 2022

Today we have Cami Ramos Garzon - aka Camiinthisthang on twitter. Cami is a Colombian-American engineer who began her career as a software engineer at Paypal before ultimately getting involved in web3. She’s a natural communicator who quickly found a fit in developer relations for some of the industry’s largest and fastest moving protocols like the Graph. Today, she works as a DevRel at Fuel Labs, where she’s helping to build out a high quality developer experience for engineers who want to build applications on top of the FuelVM. In addition to this, she’s prolific on twitter and before Devcon had a post go viral on why crypto needs to focus on Latin America if it wants to reach its full potential.

This episode was recorded live during Devcon week.

Stream salaries with Superfluid: https://use.superfluid.finance/payroll

Timestamps:
2:02 Intro
4:44 How Cami got involved in crypto
9:52 The welcoming nature of web3
11:11 A brief introduction to Fuel
12:31 Fuel's focus on developer experience with Sway & a vertically integrated toolchain
16:29 Writing libraries in Sway
17:36 How Cami prepares for developer focused workshops & talks
19:32 What can engineers do to become better at teaching & documentation?
21:35 Crypto & Latin America
23:38 Advice for engineers in LatAm who want to get involved in Web3
26:37 Where does Cami hope our industry accomplishes throughout the next decade?

Cami on Twitter: https://twitter.com/camiinthisthang
Fuel Docs: https://fuellabs.github.io/fuel-docs/master/

Odysseas.eth: Cross Chain Tech, Good Design Patterns, and the Sovereign Stack Oct 20, 2022

Today’s guest is Odysseas.eth, an engineer at Nomad who has provided a lot of value to the space as an engineer and open source contributor to various projects such as Foundry. Odysseas has a passion for decentralization, and in this episode, we discuss the technical details of what he calls the Sovereign Stack - a suite of tools he feels are important for crypto natives seeking to live decentralized lives.

We also dive deep on cross chain messaging, favorite design patterns in the Foundry codebase and Odysseas’ own work (which include a really cool script for tracing contract storage I thought was awesome), and the importance of focus for engineers working in the space. This is a wide ranging conversation that decentralization maxis and protocol engineers alike will enjoy.

This episode of DDS is brought to you by Superfluid. You can learn more about streaming payroll at https://superfluid.finance/payroll

4:00 How Odysseas got involved in crypto
10:00 The Sovereign Stack

14:30 What is urbit?

20:20 Radicle and decentralization around git

24:50 What do devs need to build into the sovereign stack?

27:20 Staying decentralized at the hardware level

30:40 Devcon and what we should be building

37:06 Avoiding getting distracted as a new solidity developer (decent SB)

44:10 Cross chain messaging

48:20 Advice on making open source contributions

51:30 High quality patterns in the Foundry codebase

54:00 Odysseas favorite design pattern: a bash script to print a txt file of your contract’s storage layout

58:15 the importance of focus, and why Odysseas doesn’t focus on gas golfing

1:00:00 Where Odysseas hopes the industry goes within the next 10 years

Odysseas on Twitter: https://twitter.com/odysseas_eth
Odysseas' Blog: https://odyslam.com/
Github: https://github.com/OdysLam/

@Vex_0x: Huff, Low Level Languages, & the EVM Oct 13, 2022

Today’s guest is Vex, a software engineer, smart contract developer, and major contributor to Huff - a low level assembly language for the Ethereum Virtual machine.

Vex knows a ton about the EVM at the low level, and we go deep into why Huff is a great language to learn for building incredibly gas efficient contracts. Huff is also being used more and more as an educational tool, as it allows you to build programs that are, as Josh says, equivalent to ‘bare metal ethereum.’

If you’re interested in low level smart contract languages, and developing a deeper understanding of how the EVM works, you’ll love this episode.

Huff Links
https://huff.sh/
https://github.com/pentagonxyz/huffmate
https://github.com/huff-language
Writing a SNARK verifier in Huff:
https://github.com/whitenois3/huff-snark-verifier

Timestamps:
00:00 Intro
5:00 getting involved with huff & going low level

8:05 Huff overview

10:12 Writing a SNARK verifier in Huff

13:07 Good Huff use cases

16:20 Is the need to use low level assembly a failure of the higher level language?

19:05 Huff vs Yul - in Huff, you have to manage the stack yourself

22:01 Huff as an educational tool for understanding the low level

26:28 Optimizations and interesting design patterns

30:33 New EIPs for the EVM execution environment

34:16 Long term vision for Huff, and new feature ideas

41:10 Huff’s place in MEV

43:35 CTFs

48:52 Outside of Huff, what is Vex interested in?

52:30 Vex’s long term outlook on the industry

Daws.eth : Dapp Development, OSS Tooling, & Becoming an Indie Hacker Oct 06, 2022

Dawson is the founder of Earnifi, a platform which helps you stay on top of airdrops in web3. He is a serial hacker and has contributed to/created many open source projects to improve his own life & the lives of dapp developers.

In this episode, we talk in detail about building high performance decentralized applications, and step through Dawson's journey becoming an indie hacker. If you're a full stack dev that wants to take a highly performant app to market - this episode is for you.

Links Discussed in the Episode:
Earnifi: https://earni.fi
Dawson's OSS Contributions: https://earni.fi/oss
Bun.js: https://bun.sh/
WASM: https://webassembly.org/
YC Startup School: https://www.startupschool.org/
Indie Hackers: https://www.indiehackers.com/

0:00 Intro
3:17 How Dawson got involved in the space
9:01 Dawson’s first real crypto project: putting election data on chain
11:55 Earnifi’s early beginnings
16:13 What full stack web2 devs should know before building a web3 application
21:18 Re-writing ethers for optimal performance
24:18 "Typescript is mandatory at this point"
26:57 Dawson’s open source contributions
33:50 Approaching entrepreneurship as a developer
39:20 You just won a hackathon, and are considering building a business around your idea. What should you do next?
43:34 Creating space to pursue your own projects as a developer
47:53 Why now is the time to build privacy-preserving applications
52:31 What would Dawson work on if he had 6 months of free time?
55:12 WASM, Bun.js, and the future of web3 front ends
58:41 Why safe, high quality DeFi is important for the world

Santiago Palladino: OZ Defender, the Role of Off Chain Infra, & How Crypto Is Leveling the Playing Field Sep 29, 2022

Today, we have Santiago Palladino, a lead developer at OpenZeppelin who has helped drive the development of OpenZeppelin’s Defender product. He’s also provided value as an educator for the space, and wrote a book on Ethereum for web developers in 2019.

In this episode, we discuss Open Zeppelin’s defender product, and it’s underlying design. We also dive into the role of devops & off chain infrastructure & the future of web3 development, and explore Santiago’s thoughts on the growth of the South American & Latin American crypto ecosystem.

Santiago has a deep understanding of building products at the intersection of web2 & web3, and if you’re interested in understanding how to build products that straddle both tech stacks - this episode is for you.

OZ Defender: https://www.openzeppelin.com/defender
Ethereum For Web Developers: https://link.springer.com/book/10.100...
Santiago on Twitter: https://twitter.com/smpalladino

Timestamps:
00:00 Intro
2:26 How Santiago got involved in crypto
5:58 Getting started in web3 when coming from a traditional software development background
8:34 What tooling does Santiago wish existed?
10:39 Open Zeppelin Defender
13:58 So I’ve just deployed a smart contract to main net. What should I be thinking about next?
17:15 How to manage security & decentralization as your project evolves
22:24 The role of off chain infra in the next iteration of dapps
26:05 Decentralized backend infrastructure
30:24 The Defender architecture & some of Santiago’s favorite design patterns used in its development
35:43 How Santiago approaches API development
41:05 Why multi-chain governance & account abstractions NEED to get solved
46:28 The LatAm crypto ecosystem
52:19 Santiago’s long term vision for the industry

Sam MacPherson of MakerDAO Engineering: Managing Engineering Tradeoffs, Good Design Patterns, and Multi-Chain Maker Sep 22, 2022

00:00 intro
3:09 How Sam got involved in crypto
5:16 Multi chain maker
9:36 Maker Teleport
12:37 Stepping through a specific tx lifecycle with Maker Teleport, and how that compares to other message passing bridges in the space
16:22 UX considerations of different cross chain message passing designs
19:19 RWA on Maker
21:46 Technical considerations of bringing real world assets on chain
23:51 Learning how to manage *risk* as a developer
28:28 What does the development process look like at Maker?
32:15 What does the Maker Engineering team prioritize when considering tradeoffs?
34:37 Sam’s advice for thinking about smart contract security
37:46 Tradeoffs with upgradable contracts
42:15 How to approach naming conventions in highly visible contracts
44:37 Good design patterns Sam wishes were used more often
49:34 Sam’s interest in MEV
52:22 Sam’s long term hopes for crypto

Links:
https://makerdao.com/
https://twitter.com/SebVentures
https://twitter.com/hexonaut

@big_tech_sux on Vyper, Compilers, and the Future of Smart Contract Programming Languages Sep 15, 2022

In this episode, we talk with a vyper contributor and compiler expert who pseudonymously goes by @big_tech_sux on Twitter.

Bts knows a lot about programming languages, and we go deep into vyper in this episode. We discuss things like vyper's evolution, standardized intermediate representations for web3 compilers, and titanoboa - a new contribution to the vyper development toolchain which is dramatically improving UX.

BTS on twitter: https://twitter.com/big_tech_sux
Vyper: https://vyper.readthedocs.io/en/stable/
Titanoboa: https://github.com/vyperlang/titanoboa

Show Notes:
00:00 Intro
2:15 How BTS got into the space
4:13 Vyper's evolution
7:24 Standardized intermediate representations for EVM languages
15:47 How will the web3 language space evolve?
20:10 Vyper’s design decisions over time
37:01 Titanoboa & its features
50:31 Why the name Big Tech Sux?
52:02 BTS' long term vision for the space

Nicolás Venturo: Solidity, Engineering at Balancer Labs, & the Dangers of Gas Golfing Sep 08, 2022

Today's guest is Nicolás Venturo, a blockchain engineer at Balancer Labs and former engineer at Open Zeppelin - where he contributed to one of the first audits of the solidity compiler.

Nicolás is very well versed on the ins & outs of solidity, smart contract development, and best practiced for security. Prior to getting involved in crypto, he was an embedded systems engineer, and has spent most of his career thinking through low level systems.

In this episode, we discuss Nicolás' thoughts on how solidity has evolved over the years, Balancer's engineering process, Nicolás' favorite design patterns, and the dangers of gas golfing.

Shownotes:
00:00 How Nicolas got into the space
4:20 Parallels between solidity development & building embedded systems
12:21 Nicolas’ thoughts on assembly languages like Yul & Huff
19:21 Standard Libraries?
27:55 Nicolas’ favorite design patterns, and why *readability* matters!
41:33 The dangers of gas golfing
46:00 Balancer’s custom error’s library: revert strings without hitting byte code size limits
54:27 How Balancer makes use of batching in their codebase
1:00:40 How the Balancer engineering team approaches development cycles
1:08:31 If Nicolás couldn’t work on Balancer for 6 months, what would he work on?
1:15:24 What does Nicolás think the long term destiny of crypto will be

Links
Nicolás on Twitter: https://twitter.com/mrnventuro
Balancer: https://balancer.fi/
Balancer's custom errors library: https://github.com/balancer-labs/balancer-v2-monorepo/blob/weighted-deployment/contracts/lib/helpers/BalancerErrors.sol
Open Zeppelin defender: https://www.openzeppelin.com/defender
Nicolás at ETHLATAM: https://www.youtube.com/watch?v=1Y5IDfJQGVk
Nicolás in a recent talk on smart contract security: https://www.youtube.com/watch?v=-Zzr87YB6TQ

Chris Maree: Engineering at UMA Protocol, Cross Chain Tech, and Optimistic Oracle Design Sep 01, 2022

Today’s guest is Chris Maree, a senior engineer at UMA protocol. Chris got into crypto several years ago and is a wealth of knowledge on solidity development, DeFi, & cryptoeconomics. In this episode, we go deep on engineering at UMA, and got to ask Chris a ton of questions about smart contract design patterns. We discuss the cryptoeconomics of UMA’s optimistic oracle, the low level design of UMA’s Across bridge, gas optimization, security, and Chris’ long term vision for the space.

If you’re an engineer interested in smart contract development & DeFi, we think you’re going to love this one.

Timestamps
00:00 Intro
3:10 How Chris got involved in crypto

6:50 UMA’s optimistic oracle

11:39 Examples of long tail data usage in web3

13:45 Walking through technical examples of how the optimistic oracle works

23:00 The use of ‘ancillary data' to turn the optimistic oracle into a ‘Turing complete’ oracle

27:31 Behind the scenes on the Optimistic Oracle design

31:53 What is Across: bridging as a lending problem vs bridging as a swapping problem

34:00 The Across Hub & Spoke Model For Liquidity

38:00 Can you pass call data across chains with Across?

39:30 The use of ‘bundles’ in Across

49:20 Favorite UMA design patterns

52:03 UMA engineering design practices

58:04 Chris’ approach to security and engaging auditors

1:00:06 Trends Chris is excited about (Cross chain MEV, NFT derivatives)

1:02:50 Chris’ long term vision for the future of crypto

Links: https://docs.umaproject.org/
Chris on Github: https://github.com/chrismaree

Austin Griffith: Dev Tooling, Scaffold-ETH, and Leveling Up as a Web3 Dev Aug 25, 2022

Today, we have Austin Griffith, dev tooling & dev education extraordinaire. He’s the creator of countless high value dev tools, including ETH.Build, Scaffold-ETH, and Speed Run Ethereum. In this episode, we discuss Austin’s process for building developer tooling, new developments that Austin is excited about at the application layer, and how to level up as a solidity developer.

00:23 How Austin got into Ethereum

2:23 Austin walks through the first dapps he ever built: games

4:28 Austin’s entry into dev tooling

8:15 ETH.Build

13:40 Scaffold-ETH

21:47 Speed Run Ethereum

27:45 Taking a PM approach to building dev tooling

30:36 Austin shouts out other great devrel resources

33:02 Becoming an elite web3 developer

40:40 The state of existing dev tooling

47:49 New developments in the application layer that Austin is excited about

49:30 Nifty Ink - using meta transactions to improve UX

56:03 Austin’s vision for web3 in 10 years: public keys will be as ubiquitous as an email address

Links:
Scaffold ETH: https://docs.scaffoldeth.io/scaffold-eth/
Speed Run Ethereum: https://speedrunethereum.com/
Austin on Twitter: https://twitter.com/austingriffith
Ethereum Resources: https://ethereum.org/en/developers/

Rahul Sethuram: Optimistic Bridges, Cross Chain Communication, & Engineering at Connext Aug 17, 2022

On the Devs Do Something podcast, we bring you technical discussions with some of the best and brightest engineers in all of web3. Today, we have Rahul Sethuram - CTO & cofounder of Connext.

Connext is building the first fully trust-minimized Crosschain Communication protocol to make blockchains composable.

Rahul has been in the space for the better part of 5 years - he started his career at tesla and worked in various startups business before getting into crypto. In this episode, you’ll hear more about his journey through the proverbial idea maze as he iterated his way into building Connext, and you’ll also get an inside look into the technical side of building cross chain infrastructure.

In this episode, we hit on a ton of fascinating technical topics: you’ll hear us walk through optimistic bridge design, Connext’s engineering & design process (including how they navigated multiple re-writes), Rahul’s favorite non-EVM tech in the space, & we’ll even walk through the full lifecycle of a cross chain operation on Connext.

If you’re a web3 engineer or work alongside engineers, we think you’ll get a lot of value from this one.

00:00 Intro

3:13 How Rahul got into Web3

6:18 Connext origin story

9:00 The interoperability trilemma

10:29 Optimistic bridges

14:40 Walking through the lifecycle of a cross chain transaction using Connext

22:42 Cross chain callbacks and “asynchronous” solidity

27:14 Design patterns that Rahul is proud of (including a cool custom errors implementation)

29:46 Behind the scenes insight on how Connext iterated from their initial state channels implementation to their current model

34:49 How Connext handles development cycles

36:10 The Connext approach to managing security and protocol maintenance