Today's episode features Vitto Rivabella on the modern web3 stack. Vitto on Twitter: https://twitter.com/VittoStackCreate Web3 Dapp: https://www.alchemy.com/create-web3-dapp

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

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/

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-abstractionAlchemy: https://www.alchemy.comAlchemy University: https://university.alchemy.comFollow Noam on Twitter: https://twitter.com/ProbablyNoam00:00 Intro3:51 How Noam got into crypto6:00 Noam’s take on the current Account Abstraction discourse8:32 AA infrastructure overview11:32 Walking through Alchemy’s bundler architecture13:15 MEV and user operations15:05 The ‘intent based architecture’ and the userOp mempool18:05 The entry point contract22:50 Paymaster contracts25: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 690037:16 Avoiding centralization around AA infrastructure42:46 New security issues presented by AA45:01 Noam’s advice on building APIs & developer products49:15 Noam’s favorite technical implementations in the industry50:54 Advice for those early in their career52:48 How Noam hopes the industry evolves over the next decade

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/alluoBuild on Superfluid: https://www.superfluid.finance/wave-pool00:00 Intro5:11 How Remi got into the industry/Alluo's founding8:11 How Sung got into the space9:58 What is Alluo?16:18 Auto Invest - streaming DCA18:33 An overview of the Alluo contract architecture23:59 - Bridging architecture25:15 - Simplicity in protocol design31:52 - How Alluo liquidity direction voting works at the smart contract level34:58 - Boosted pools39:57 - Using the 4626 design for the boosted pool42:05 - stIBAlluo for money streaming47:26 - Building out a high quality mobile experience for DeFi56:59 - Advice for early stage DeFi teams

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

This week's guest is Zac Williamson, founder & CEO at Aztec. Check out the Superfluid Wave Pool! https://www.superfluid.finance/wavepoolAztec: https://twitter.com/aztecnetworkNoir Docs: https://noir-lang.org/Zac on Twitter: https://twitter.com/Zac_Aztec00:00 Intro3:45 How Zac got into Web36:45 The creation of Aztec14:30 why did he build huff?19:05 Weirstrudel & Optimizations in Huff21:33 Inspirations for Huff Language designs23: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 apps37:05 Hello world in Noir38:50 Private functions and private contracts on Aztec46:22 The Aztec sequencer50:15 Noir & smart contract security51255 What should people build on Noir?56:52 Advice for early career devs

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 analysisWith Trail of Bits Security Engineer, Troy!Timestamps3:10 - Exploring Smart Contract Testing Methodologies with Trail of Bits5:37 - Testing Strategies for Smart Contracts8:10 - Fuzz Testing and Invariant-Based Testing Explained10:56 - Coverage Guided Fuzzing Explained13:50 - The Benefits of Coverage Guided Fuzzing and the Differences between Echidna, Foundry, & Others16:27 - Using Coverage Guided Fuzzing with Optic and Echidna19:12 - Symbolic execution and coverage-guided fuzzing in Echidna21:57 - Testing Philosophies: Dynamic vs. Static Testing24:24 - Dynamic vs Static Analysis and the trade-offs of each approach27:10 - The Importance of Efficient Testing and Using a Variety of Testing Methods29:57 - The Role of Security Firms and Testing Philosophies32:33 - Balancing Cost and Efficiency in Security Audits35:15 - The Importance of Code Reuse in Building Tools and Languages38:04 - The pitfalls of focusing on language intricacies in programming and the benefits of prioritizing language design and philosophy40:41 - The Need for More Open Source Tools and Communication in the Ethereum Community43:22 - Advice for becoming more security-minded in smart contract coding45:51 - Discussion with Alpha Rush on Testing Compilers and Security Focus Journeys

Today's guest is the pseudonymous developer Rage of Size.Market.Rage on Twitter: https://twitter.com/rage_pit

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

Today's episode is a technical deep dive into how Lens Protocol works under the hood.Build with Superfluid: https://www.superfluid.finance/wavepoolBuild on Lens: https://www.lens.xyz/gardenChapters:00:00:00 - Intro00:02:45 - Hackathons and the Superfluid Wave Pool00:05:35 - Understanding Lens: A Developer's Perspective00:08:11 - Lens Infrastructure: What's Happening Under the Hood?00:11:02 - Build a Following That Stays with You Forever00:13:33 - The Challenges of Storing and Retrieving Data in Blockchain Applications00:16:13 - Building the Lens API00:21:30 - Lens Modules00:29:31 - Social Media Monetization and the Scalability of Lens compared to Twitter00:32:05 - Scalability and the Challenges of Building at Twitter Scale and Beyond00:34:52 - A Modular Infrastructure for Increased Transaction Speeds00:37:21 - Building on top of the Lens API: Required Skill Sets00:39:46 - Progressive Decentralization00:44:53 - Building Recommendation Algorithms with AI and Machine Learning Techniques00:49:47 - Exciting Opportunities for Developers on Lens Platform00:52:11 - Building with Lens and Calls to Action for Developers

00:00 Intro & Opening Conversation7:58 Tincho's audit setup12:35 VSCodium14:08 Foundry v hardhat22:00 First audit steps25:00 Tincho's process for commenting within the code itself30: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 contract32: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 clients44:12 Waling through tests with Tincho47:40 To best understand a protocol, make the codebase your own: run things locally51:00 Time bounding your review process52:00 Intuition vs checklists56:05 Learning by reading past reports59:04 Reviewing fixes1:00:18 Handling hacks & the purpose of audits

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 Intro3:55 How Richard got into the industry8:31 The Safe contract architecture14:13 Safe modules17:11 Misconceptions and account abstraction20:45 ERC 4337 Infrastructure 23:11 How app developers can make proper use of smart contract wallets25:45 What does the ecosystem need to do to enable better UX?29:50 Solving the YOLO signing problem36:37 The Safe Core Suite42:30 Frictionless onboarding 50:08 How Richard & the Safe team approach smart contract security56:00 Advice for early career devs59:45 What does Richard hope our industry looks like in 10 years?Safe Core: https://twitter.com/safe/status/1630946737220141062Richard on Twitter: https://twitter.com/rimeissner

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 Intro3:33 How devtooligan got into crypto6: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 security37:55 What does Devtooligan’s audit process look like?43:53 What can smart contract devs be better at? (Documentation)48:31 AI tooling & auditing51:45 Tinkering is what drives innovationUseful 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/

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 Intro3:22 How Jordi got into crypto6:33 What is Polygon’s zkEVM?9:34 Enabling opcode parity with Etheruem on a ZK rollup16:10 Pricing opcodes 19:33 Walking through a transaction on the zkEVM under the hood25:38 Bottlenecks with data availability & the sequencer30:50 Progressively decentralizing the sequencer34:39 LX <> LY bridge design39:48 Tradeoffs of being fully EVM compatible49:46 Retaining parity with the EVM as the EVM introduces changes52: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

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 Intro3:20 How DC builder got into crypto7:31 Bottom up vs top down learning9:17 From research to development13:45 devpill.me breakdown16:41 Advice for early web3 engineers118:48 How to evaluate new developer ecosystems?23:09 Leveling up as a developer27:39 ZK32: 28 ZK ML - a wild topic42:29 Using ZK for *interactions* with ML models47:44 Working at Worldcoin (ZK ML experiments and Worldcoin ID state bridge)56:33 Moving data from Polygon to Ethereum L11:03:43 Learning about how the EIP/ERC process works1:06:44 Building social capital in the industry1:12:54 Other things that DC builder is interested in1: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-zkmlDCBuilder on Twitter: https://twitter.com/DCbuild3r

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 intro3:15 How Henri got into crypto6:05 What is StarkNet?10:41 STARKS v SNARKS15:54 Walking through a StarkNet transaction19:05 Decentralization19:58 StarkNet account model23:22 Mental models EVM devs should understand to build on StarkNet29:34 What will people build on StarkNet?33:30 Building a privacy preserving application on StarkNet37:12 Cairo41:28 Evolution of Cairo and Cairo 1.044:52 Building secure products in Cairo49:15 Validity rollups & data availability56:20 What *should* people build on StarkNet?58:58 Henri’s long term view on the industryStarkWare Base Camp: https://twitter.com/StarkWareLtd/status/1605519238038294529Henri: https://twitter.com/henrlihenrliStarkNet: https://starkware.co/starknet/

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 crypto7:06 Importance of working with other good engineers8:50 Languages: learning solidity, rust10:15 The role of MEV for the industry13:55 Getting into MEV15:55 MEV terminology: long tail, short tail, generalized front-running21:11 Rust v Go for MEV23:20 Reverse engineering24:30 Building a call data decoder25:40 Bytecode decoder33:05 anon crypto dev culture35:55 People who have helped DeGatchi (0xBuns, Huff community, Flashbots discord, “cult” on fantom, etc)38:02 Zk interests39:32 Yield farming automation43:01 Other interests44:31 What other tooling does DeGatchi want to build?48:55 Advice for other early career devs51:10 What does DeGatchi hope the industry looks like in 10 years?DeGatchi on Twitter: https://twitter.com/DeGatchiDeGatchi's Blog: https://degatchi.com/

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/wavepool00:00 Intro3:45 how Sachin got into crypto13:44 ERC4337 v EIP 307429:58 Infrastructure for ERC 433745:29 Idiosyncrasies of the user operation pool with ERC 433747:20 Fixed gas transactions52:10 Supporting smart contract wallets on front end with biconomy1: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_tomarERC 4337: https://eips.ethereum.org/EIPS/eip-4337Biconomy: https://www.biconomy.io/ Fixed Gas Tx: https://mirror.xyz/0xd96FA162b064553822e765545E3D48a054eC81F6/PgRtcrT3CGN7sc723-2ykpXnAqQEJCMMtiLTL47ZFMQ

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/wavepool3:55 How Nader got into web35:39 Following curiosity9:04 Avoiding distractions11:50 How Nader approaches learning a new protocol or technology16:05 How to decide what to learn in the first place19:03 What problems in the industry is Nader interested in solving?23:02 Giving back via education28:22 Preparing for a dev workshop31:48 Advice for giving talks34:27 Building developer communities39:34 Leveraging bounties and contractors within your dev community47:39 Building SDKs and APIs50:34 UX improvements that web3 needs52:52 What does Nader want people to build?55:35 What’s on the Lens developer roadmap?Nader on Twitter: https://twitter.com/dabit3Building Developer Communities Article: https://nader.substack.com/p/building-high-impact-developer-communitiesLens: https://www.lens.xyz/gardenMiguel Piedrafita on Twitter: https://twitter.com/m1guelpf

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 Background8:50 Understanding NEAR mental models for EVM devs11:51 A token transfer on NEAR under the hood 14:35 Sharding on NEAR19:33 Asynchronicity 25:32 Token contracts on NEAR26:51 NEAR account model - all accounts are contracts29:00 Account access keys32:00 Human readable names (NEAR’s ENS equivalent)36:40 Aurora, Rainbow & EVM compatibility 43:45 NEAR meta transactions48:35 Zero knowledge light clients51:35 Developer experience on NEAR56:30 Developer advice57:31 Long term vision for NEARNEAR: https://near.org/Aurora: https://aurora.dev/Bowen on Twitter: https://twitter.com/BowenWang18

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-prizesStream salaries with Superfluid: https://use.superfluid.finance/payrollShownotes:2:04 Wave Pool PUSH x Superfluid opportunity5:30 How Harsh got into crypto10:40 Founding PUSH (EPNS at the time)16:00 Decentralized internet infrastructure22:00 PUSH intro - what is PUSH?28:05 Example: using PUSH with Superfluid33:05 What are channels?35:01 Notification payloads40:05 PUSH delivery nodes48:06 Progressive decentralization51:01 The PUSH developer community55: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 cryptoLinks:Harsh on Twitter: https://twitter.com/harshrajatPUSH: https://push.org/Learn Game Theory: https://ncase.me/trust/

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/payrollBartosz 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-aRRxcQShownotes:4:27 How Bartosz got into crypto7:10 The Solana ecosystem9:11 Solana mental models & how they compare to the EVM13:21 How tokens work on Solana17:36 Code reuse and inheritance on Solana19:49 Solana & the separation of compute and state 24:56 Upgradable contracts on Solana26:23 The Solana account model28:47 Optimizing for network performance or developer adoption?33:17 Solana DevX37: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 tokens41:31 Long term view of what blockchain looks like43:35 Solana bootcampsBartosz on Twitter: https://twitter.com/baalazamon

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/payroll00:00 Intro3:50 How Luis got into crypto6:30 Teaching himself to code9:45 The founding of Gelato13:45 Managing tradeoffs between developer experience and decentralization19:20 Hardware requirements for Gelato Checkers and Gelato Executors24:22 Gelato Checker client in depth30:00 Overcoming technical challenges33:35 DevOps skills40:10 Advice for building developer APIs and tooling45:35 How to use Gelato in your own application48:50 What does Luis hope crypto looks like in 10 years?Luis on Twitter: https://twitter.com/gitpushaGelato Network: https://www.gelato.network/

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/payroll00:00 intro4:04 How Julien got involved in crypto6:29 Julien’s background in quantum physics9:12 Will all of our cryptography get broken soon by strong quantum computers?10:02 The founding of argent15:47 Account abstraction EIPs23:59 EIP 433725: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 wallets41:16 Social recovery49:34 Starknet, zkSync52:03 EIP wars59:07 Argent’s focus on security1:04:42 Julien’s long term focus - real products for real peopleArgent: https://www.argent.xyz/Julien on Twitter: https://twitter.com/jnisetEIP 4337: https://eips.ethereum.org/EIPS/eip-4337

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 Intro4:10 How did Patrick get into crypto?5:57 Chainlink & the importance of oracles7:57 First crypto projects9:07 Does Patrick still hate Javascript?10:33 Early challenges of building smart contracts11:50 How Patrick approaches videos/tutorial content18:17 Maintaining docs & videos as the tech progresses21:12 How does Patrick stay on top of endless developer questions?27:02 Bad advice or bad patterns Patrick sees in devrel32:53 The smart contract language debate35:42 How Patrick approaches smart contract security38:07 What tooling does Patrick wishes someone would build?40:42 What is Patrick excited about?Patrick on Youtube: https://www.youtube.com/c/patrickcollinsPatrick on Twitter: https://twitter.com/patrickalphacChainlink: https://chain.link/

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 Intro4:01 how beans got into crypto 6:30 working at Coinbase & early projects11:50 NFTs and smart contract security16:55 how to get started w security/more security thoughts20:33 IAmTheOptimizer26:03 MEV33:19 Designing with MEV in mind37:22 Blind Vickery Auctions44:17 What other developments is Beans excited about?48:06 How Beans gets better as a dev52:06 What does Beans want to learn next? Huff, Zk, Rust, Sway58:02 What does Beans hope that the industry looks like in 10 years?0xBeans on Twitter: https://twitter.com/0x_Beans

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/payroll00:00 Teaser2:17 Intro4:47 How foobar got into crypto7:05 Crypto math that Foobar loves10:23 How NFT devs should think about cryptoeconomics14:07 How does Foobar think about smart contract security?19:42 Delegate.cash 29:18 Delegate.cash vs other attempts at solving the same problem32:09 Immutable vs mutable smart contracts38:09 Advice for building contracts that will be used by lots of people42:08 Advice for drafting EIPs48:32 Common mistakes that Foobar sees from junior devs50:52 Bored and Dangerous54:42 What does Foobar hope our industry looks like in the next 10 yearsDelegate Cash: https://delegate.cash/Bored And Dangerous Repo: https://github.com/0xfoobar/boredanddangerousFoobar's Substack: https://0xfoobar.substack.com/Foobar on Royalties: https://0xfoobar.substack.com/p/on-royaltiesFoobar on Twitter: https://twitter.com/0xfoobar

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/payroll00:00 Intro5:14 How Nick got into crypto8: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 execution16:38 Register machine architecture21:38 Sway33:45 Scripts, predicates, & how they can improve UX39:05 Fuel’s native asset model48:00 Smart contract security with a new language51:50 What does Nick hope people build on Fuel? 56:10 What should you be prepared for when building on Fuel1: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-fuelSway: https://fuellabs.github.io/sway/v0.31.1/Nick on Twitter: https://twitter.com/IAmNickDodsonOur Episode with Cami - Head of DevX at Fuel: https://www.devsdosomething.fm/episodes/cami-ramos-garzon-developer-experience-fuel-bringing-crypto-to-latam

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/payrollIn 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: buildingSo give it a listen, and let us know what you think.Links: EVM Course: evmfromscratch.comWinter on Twitter: https://twitter.com/w1nt3r_ethTimestamps:00:00 Intro5:25 How Winter got involved in crypto7:27 Winter’s NFT projects9: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 space30:38 How would Winter approach gas optimization for a new project?34:37 Smart contract security41:14 Leveling up as a solidity developer 46:10 Winter’s new EVM course50:09 How to market your work without feeling like a shill57: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 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 Intro1:30 Who is Igor?4:12 how Igor got involved in crypto8:55 Early technical decisions with Babylon [decent soundbite here on audits]13:44 Advice on testing composable systems16: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 audits45:12 Favorite optimizations50: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_ioIgor's Devcon Talk on Contract Size Limits: https://www.youtube.com/watch?v=qzlUNSt5pnAEthernaut: https://ethernaut.openzeppelin.com/Damn Vulnerable DeFi: https://www.damnvulnerabledefi.xyz/Paradigm CTF: https://twitter.com/paradigm_ctf?lang=en

Stream payroll with Superfluid: https://use.superfluid.finance/payrollToday’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: @0xyorkeHyperlane docs: https://docs.hyperlane.xyz/hyperlane-docs

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/payrollTimestamps:2:02 Intro4:44 How Cami got involved in crypto9:52 The welcoming nature of web311:11 A brief introduction to Fuel12:31 Fuel's focus on developer experience with Sway & a vertically integrated toolchain16:29 Writing libraries in Sway17:36 How Cami prepares for developer focused workshops & talks19:32 What can engineers do to become better at teaching & documentation?21:35 Crypto & Latin America23:38 Advice for engineers in LatAm who want to get involved in Web326:37 Where does Cami hope our industry accomplishes throughout the next decade?Cami on Twitter: https://twitter.com/camiinthisthangFuel Docs: https://fuellabs.github.io/fuel-docs/master/

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/payroll4:00 How Odysseas got involved in crypto10:00 The Sovereign Stack14:30 What is urbit?20:20 Radicle and decentralization around git24:50 What do devs need to build into the sovereign stack?27:20 Staying decentralized at the hardware level30:40 Devcon and what we should be building37:06 Avoiding getting distracted as a new solidity developer (decent SB)44:10 Cross chain messaging48:20 Advice on making open source contributions51:30 High quality patterns in the Foundry codebase54:00 Odysseas favorite design pattern: a bash script to print a txt file of your contract’s storage layout58:15 the importance of focus, and why Odysseas doesn’t focus on gas golfing1:00:00 Where Odysseas hopes the industry goes within the next 10 yearsOdysseas on Twitter: https://twitter.com/odysseas_ethOdysseas' Blog: https://odyslam.com/Github: https://github.com/OdysLam/

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 Linkshttps://huff.sh/ https://github.com/pentagonxyz/huffmate https://github.com/huff-languageWriting a SNARK verifier in Huff:https://github.com/whitenois3/huff-snark-verifierTimestamps:00:00 Intro5:00 getting involved with huff & going low level8:05 Huff overview10:12 Writing a SNARK verifier in Huff13:07 Good Huff use cases16: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 yourself22:01 Huff as an educational tool for understanding the low level26:28 Optimizations and interesting design patterns30:33 New EIPs for the EVM execution environment34:16 Long term vision for Huff, and new feature ideas41:10 Huff’s place in MEV43:35 CTFs48:52 Outside of Huff, what is Vex interested in?52:30 Vex’s long term outlook on the industry

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.fiDawson's OSS Contributions: https://earni.fi/ossBun.js: https://bun.sh/WASM: https://webassembly.org/YC Startup School: https://www.startupschool.org/Indie Hackers: https://www.indiehackers.com/0:00 Intro3:17 How Dawson got involved in the space9:01 Dawson’s first real crypto project: putting election data on chain11: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 contributions33: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 applications52: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 ends58:41 Why safe, high quality DeFi is important for the world

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/defenderEthereum For Web Developers: https://link.springer.com/book/10.100...Santiago on Twitter: https://twitter.com/smpalladinoTimestamps:00:00 Intro2:26 How Santiago got involved in crypto5:58 Getting started in web3 when coming from a traditional software development background8:34 What tooling does Santiago wish existed?10:39 Open Zeppelin Defender13: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 evolves22:24 The role of off chain infra in the next iteration of dapps26:05 Decentralized backend infrastructure30:24 The Defender architecture & some of Santiago’s favorite design patterns used in its development35:43 How Santiago approaches API development41:05 Why multi-chain governance & account abstractions NEED to get solved 46:28 The LatAm crypto ecosystem52:19 Santiago’s long term vision for the industry

00:00 intro3:09 How Sam got involved in crypto5:16 Multi chain maker9:36 Maker Teleport12:37 Stepping through a specific tx lifecycle with Maker Teleport, and how that compares to other message passing bridges in the space16:22 UX considerations of different cross chain message passing designs19:19 RWA on Maker21:46 Technical considerations of bringing real world assets on chain23:51 Learning how to manage *risk* as a developer28: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 security37:46 Tradeoffs with upgradable contracts42:15 How to approach naming conventions in highly visible contracts44:37 Good design patterns Sam wishes were used more often49:34 Sam’s interest in MEV52:22 Sam’s long term hopes for cryptoLinks:https://makerdao.com/https://twitter.com/SebVentureshttps://twitter.com/hexonaut

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_suxVyper: https://vyper.readthedocs.io/en/stable/Titanoboa: https://github.com/vyperlang/titanoboaShow Notes:00:00 Intro2:15 How BTS got into the space4:13 Vyper's evolution7:24 Standardized intermediate representations for EVM languages15:47 How will the web3 language space evolve?20:10 Vyper’s design decisions over time37:01 Titanoboa & its features 50:31 Why the name Big Tech Sux?52:02 BTS' long term vision for the space

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 space4:20 Parallels between solidity development & building embedded systems12:21 Nicolas’ thoughts on assembly languages like Yul & Huff19:21 Standard Libraries?27:55 Nicolas’ favorite design patterns, and why *readability* matters!41:33 The dangers of gas golfing46:00 Balancer’s custom error’s library: revert strings without hitting byte code size limits54:27 How Balancer makes use of batching in their codebase1:00:40 How the Balancer engineering team approaches development cycles1: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 beLinksNicolás on Twitter: https://twitter.com/mrnventuroBalancer: https://balancer.fi/Balancer's custom errors library: https://github.com/balancer-labs/balancer-v2-monorepo/blob/weighted-deployment/contracts/lib/helpers/BalancerErrors.solOpen Zeppelin defender: https://www.openzeppelin.com/defenderNicolás at ETHLATAM: https://www.youtube.com/watch?v=1Y5IDfJQGVkNicolás in a recent talk on smart contract security: https://www.youtube.com/watch?v=-Zzr87YB6TQ

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.Timestamps00:00 Intro3:10 How Chris got involved in crypto6:50 UMA’s optimistic oracle11:39 Examples of long tail data usage in web313:45 Walking through technical examples of how the optimistic oracle works23:00 The use of ‘ancillary data' to turn the optimistic oracle into a ‘Turing complete’ oracle27:31 Behind the scenes on the Optimistic Oracle design31:53 What is Across: bridging as a lending problem vs bridging as a swapping problem34:00 The Across Hub & Spoke Model For Liquidity38:00 Can you pass call data across chains with Across?39:30 The use of ‘bundles’ in Across49:20 Favorite UMA design patterns52:03 UMA engineering design practices 58:04 Chris’ approach to security and engaging auditors1:00:06 Trends Chris is excited about (Cross chain MEV, NFT derivatives)1:02:50 Chris’ long term vision for the future of cryptoLinks: https://docs.umaproject.org/Chris on Github: https://github.com/chrismaree

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 Ethereum2:23 Austin walks through the first dapps he ever built: games4:28 Austin’s entry into dev tooling8:15 ETH.Build13:40 Scaffold-ETH21:47 Speed Run Ethereum27:45 Taking a PM approach to building dev tooling30:36 Austin shouts out other great devrel resources33:02 Becoming an elite web3 developer40:40 The state of existing dev tooling47:49 New developments in the application layer that Austin is excited about49:30 Nifty Ink - using meta transactions to improve UX56:03 Austin’s vision for web3 in 10 years: public keys will be as ubiquitous as an email addressLinks:Scaffold ETH: https://docs.scaffoldeth.io/scaffold-eth/Speed Run Ethereum: https://speedrunethereum.com/Austin on Twitter: https://twitter.com/austingriffithEthereum Resources: https://ethereum.org/en/developers/

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 Intro3:13 How Rahul got into Web36:18 Connext origin story9:00 The interoperability trilemma10:29 Optimistic bridges14:40 Walking through the lifecycle of a cross chain transaction using Connext22:42 Cross chain callbacks and “asynchronous” solidity27: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 model34:49 How Connext handles development cycles36:10 The Connext approach to managing security and protocol maintenance39:12 Upgradable contracts vs full immutability40:43 Beyond the EVM45:28 Issues with validity proofs in cross chain infrastructure 48:53 Web3 tech that Rahul is excited about50:41 Cross chain MEV and arbitrage opportunities52:43 Rahul’s long term vision for the industryLinksConnext: https://www.connext.network/Rahul: https://twitter.com/rhlsthrmThe Interoperability Trilemma: https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17Optimistic Bridges: https://blog.connext.network/optimistic-bridges-fb800dc7b0e0Problems with Validity Proofs When Used in Bridging: https://blog.connext.network/validity-proofs-are-not-effective-for-bridging-blockchains-85b5e3b22a35