Backend Banter

Today we welcome YK Sugi—engineer, educator, and the mind behind CSS Dojo—for the final episode of season two.We talk about his journey from YouTube dev tutorials to building one of Sourcegraph’s most-used AI tools, and how the role of DevRel has changed (and in some cases, disappeared). YK also breaks down how senior engineers are actually using AI, why fundamentals still matter, and how Agent Chat was born during a company hackathon.If you’re curious about AI devtools, the future of DevRel, or just want to hear how a former YouTuber accidentally shipped a flagship feature—this one's for you.Learn back-end development - https://www.boot.devListen on your favorite podcast player - https://www.backendbanter.fmYK’s X: https://x.com/ykdojoYK's LinkedIn: https://www.linkedin.com/in/ykdojo/Sourcegraph's Youtube channel: https://www.youtube.com/@Sourcegraph/featuredTimestamps:00:00 - Intro and Meeting YK03:05 - Starting Out with CSS Dojo05:36 - DevRel Burnout and Market Whiplash11:40 - Building Agent Chat at Sourcegraph13:52 - Claude, Cursor, and AI Tool Comparisons21:52 - AI Use: Juniors vs. Seniors26:22 - Designing Dev Tools That Think37:56 - Will AI Consolidate the Tooling Ecosystem?44:21 - Should Codebases Change for AI?50:52 - Advice for Learners, DevRels, and Job Seekers01:07:02 - Outro and Where to find YK's workLike & subscribe for the algo if you enjoyed the video!

Today we welcome Mitchell Hashimoto, co-founder of HashiCorp and creator of Ghostty, a new terminal emulator built in Zig. In this episode, Mitchell shares the story behind Ghostty, how his curiosity about terminals evolved into a full-fledged project, and why Zig became his language of choice.We also dive into Ghostty’s unique features, the role of libghostty, and why Mitchell believes native-feeling apps are essential for developer experience. Plus, we explore his insights on computer science education, dynamic linking, and what really matters when learning to code.If you’re into terminals, low-level programming, or just love hearing how great software gets built, this one’s for you!Learn back-end development - https://www.boot.devListen on your favorite podcast player - https://www.backendbanter.fmMitchell's X/Twitter: https://x.com/mitchellhGhostty: https://ghostty.org/Timestamps:00:00 - Intro and Meeting Mitchell01:06 - Mitchell’s Journey at HashiCorp03:13 - What is Ghostty and Why Build It?08:35 - Native Performance and Zig’s Advantage15:25 - Why Mitchell Chose Zig Over Rust31:15 - Ghostty’s Road to Package Repositories52:00 - Future Plans for Ghostty1:04:02 - Where to Find Mitchell and GhosttyLike & subscribe for the algo if you enjoyed the video!

Today we welcome Madison Kana—a self-taught dev who defied the traditional path. From dropping out and navigating a world of homeschooling to launching the Code Book Club, Madison transformed her unconventional journey into a thriving community of coders. In this episode, she shares how bypassing the typical education route fueled her passion, the real challenges of learning on your own, and the power of mentorship in building a dynamic tech career. If you’re ready to break the mold and carve your own path in software development.Learn back-end development - https://www.boot.devListen on your favorite podcast player: https://www.backendbanter.fmMadison's X: https://x.com/MadisonkannaWebsite: https://madisonkanna.com/Learn out loud: learn0utloud.comTimestamps:00:00 - Intro00:30 - Where did it all start?01:40 - Dropping out08:42 - How Madison started learning code22:00 - Team leading30:30 - Code Book Club38:50 - Learn out loud46:20 - AI talk54:18 - Book recommendations56:05 - OutroLike & subscribe for the algo if you enjoyed the video!

Today we bring Sam Aaron, the creator of Sonic Pi, a free code-based music creation and performance tool that lets you use simple code to turn your computer into a fully networked live coding music studio! It is also used to engage students in computer science and programming through music creation!In this episode, we explore the origins of Sonic Pi, its deep connection with Raspberry Pi, and how it enables live coding for music creation, starting from it's Ruby-based language features, we discuss how Sonic Pi has evolved, the challenges of maintaining it as a sustainable open-source project and if you’re curious about coding, music, or both—this one’s for you!Learn back-end development - https://www.boot.devListen on your favorite podcast player: https://www.backendbanter.fmSonic Pi - https://sonic-pi.net/Sam's Youtube Channel: https://www.youtube.com/samaaronSam's Instagram: https://www.instagram.com/samaaron/Sam's X/Twitter: https://x.com/samaaronDJ Dave: https://www.youtube.com/@dj_dave____Timestamps:00:00 - Intro01:11 - Sonic Pi Origin Story03:03 - Connection To Raspberry Pi04:23 - But What Is Sonic Pi?06:25 - Is Ruby The Primary Language Used In Sonic Pi?10:25 - A Small Sonic Pi Showcase17:53 - Collaboration through Git23:12 - How Did Sam Get Involved In All Of This?25:14 - The Feedback Loop of Sonic Pi26:56 - How Does The Live Coding Experience Work In Sonic Pi?32:01 - The Two Different Working Modes Of Sonic Pi33:42 - How Does Debugging Work In Sonic Pi38:55 - How Do The Different Components Fit Into The Architecture Of The Project51:33 - Has Sam Been Full-Time On Sonic Pi Since Its Inception?53:25 - Does Sam Want To Try Something Different?56:25 - How Is Sam Finding More Sustainable Revenue?

Lane chats with Chris Ferdinandi—creator of Go Make Things and ADHD for the Win—a frontend dev, educator, and all-around expert in making JavaScript (and learning) simpler. Chris has built a career helping devs cut through the noise, level up their skills, and embrace ADHD-friendly ways to stay focused and productive. We dive into his journey from discovering his own ADHD to reshaping how people learn to code. We talk about why so many devs have ADHD, how gamification can actually help (when done right), and how today’s tech is messing with our attention spans. Plus, we get into the psychology of learning and what actually works when it comes to staying engaged and motivated. Learn back-end development - https://www.boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm ADHD ftw! : https://adhdftw.com/backend-banter/ Go Make Things: https://gomakethings.com/ https://bsky.app/profile/cferdinandi.bsky.social https://mastodon.social/@cferdinandi 00:00 - Intro 01:58 - Why so many devs have ADHD 03:21 - Quick explanation of ADHD 07:10 - Is ADHD actually more common now? 17:41 - ADHD, dopamine, and why we can’t put our phones down 20:50 - Trying meds for ADHD – what’s it like? 22:34 - How ADHDftw got started 24:21 - Why finishing big projects is so damn hard 25:54 - Best content styles for ADHD brains 28:40 - Gamification: What works and what’s just hype? 34:16 - Which gamer type fits ADHD folks best? 39:27 - Is TikTok basically junk food for your brain? 41:45 - Must-read books on focus and getting stuff done 43:43 - Where to find Chris and his content 46:26 - Is ADHD a gift or a curse? 59:30 - Brutally honest feedback for Boot.dev 01:18:58 - Outro Like & subscribe for the algo if you enjoyed the video!

This week on Backend Banter, we’re joined by Ryan Fleury, a talented game developer currently working with Epic Games on their Rad Debugger project. Ryan shares his journey from building games to creating powerful developer tools, offering insights into arenas, memory management, and the fascinating world of programming from the ground up. In this episode, we dive deep into memory management, exploring the differences between stack, heap, and arenas, and how they shape modern development. We discuss the trade-offs of various allocation strategies, the magic of pointer stability, and how arenas simplify managing lifetimes in both games and other applications. Along the way, Ryan shares his approach to developing tools, insights into game development workflows, and practical tips for clean and efficient programming. Learn back-end development: https://www.boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm Ryan's Socials: Rad Debugger: https://github.com/EpicGamesExt/raddebugger Website: https://www.rfleury.com/ X/Twitter: https://x.com/ryanjfleury Timestamps: 00:00 - Intro 00:54 - Ryan Fleury's Path to Game Development 02:49 - From Engines to Debugging Tools 06:51 - Arenas Explained: Memory Management Basics 16:51 - Arenas vs. Garbage Collectors 27:40 - Real-World Applications of Arenas 31:39 - Why Pointer Stability Matters 42:57 - Dynamic Allocation Made Simple 48:48 - How Arenas Streamline Development 01:01:38 - Debugging Tools and the Rad Debugger 01:09:43 - Where to find Ryan

Today, we bring you the final episode of the first season of Backend Banter! It’s a wrap up for now. With 69 episodes behind us, we want to tell you the story of Boot Dev and how far we’ve come from our beginnings, and for that, we bring Allan Lires, the first official employee and the second person to work on our platform! We’re going to cover our entire timeline, achievements, hardships, how Lane and Allan were able to go all-in on building Boot Dev and our visions and plans for the future. Learn back-end development - https://boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm Allan's X/Twitter: https://x.com/AllanLires Boot.Dev Discord: https://discord.com/invite/EEkFwbv Timestamps: 00:00 Intro 00:01 Last episode of Season 1 of Backend Banter 01:45 Boot.dev Story and what this episode will be about 02:26 How and when Allan was hired to work at Boot.dev 05:33 Timeline on Boot.dev 08:53 Guessing game 10:34 The Rebranding Process 12:43 Going Full-time 14:56 What was the curriculum in the beginning? 18:38 What was the original vision for Boot.dev 19:17 Being honest about how long it'll take you to learn to code 22:48 Setting expectations for difficulty 29:55 On learning the fundamentals 34:42 The Long Term vision of Boot.dev 41:30 Old gamification features and why we changed them 50:26 The Track is Never Complete 55:01 We cover a lot of the basics that traditional colleges don't cover 01:00:06 Why do we want to remove JavaScript from the learning course 01:06:12 Million Lessons Completed in a single month 01:08:28 You got to be comfortable being uncomfortable 01:13:25 Where to find Allan

In today’s episode, we bring back Aaron Francis. If you haven’t watched our previous episode with him, he is a software developer, fellow content creator and co-founder of Try Hard Studios. In the past he’s been an accountant at a Big 4 but now he focuses on Laravel, web development and all things business and video. This episode will step away from the usual tech focused content and we’ll talk a bit more about the business side of things, how you have to balance entertainment and education when creating courses, Aaron’s High Performance SQLite course, building a personal brand through the discomfort of centering it around yourself, how good presentation matters and how proactiveness puts you miles ahead of the majority, so stay tuned! Learn back-end development - https://www.boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm Aaron's X/Twitter: https://x.com/aarondfrancis Aaron's Website: https://aaronfrancis.com/ High Performance SQLite: https://highperformancesqlite.com/ Screencasting: https://screencasting.com/ Mostly Technical Podcast: https://mostlytechnical.com/ Timestamps: 00:00 Intro 01:32 Podcast listening going up when having a kid 02:25 Podcast about earning the first million 08:54 You have to choose the entertainment vs education levels 10:37 You have to shape your material to the platforms 16:40 Long hour videos vs 2 minute ones 20:16 Are the videos in the High Performance SQLite in linear order? 24:19 Figuring out the metrics 28:06 Building courses on other domains 31:46 Building brands is difficult 35:55 quick disclaimer 36:30 Personal brand vs company 37:57 Is this sellable? 40:23 Do you need an audience? 44:26 The strategy is simple but it is also hard to execute 49:31 The presentation matters a LOT 51:54 On being proactive 57:00 Where to find Aaron

In today’s episode, we welcome Matt Pocock, an educator, content creator and engineer who used to be a voice coach. Now, he teaches Typescript on his YouTube channel and is building Total Typescript, the most comprehensive TypeScript course available out there. We talk about his transition from a completely unrelated field into tech, the importance of great communication, TypeScript’s future, AI tooling and job hunts! A lot more else is covered in this video, so get cozy and tune in into this gem of an episode! Learn back-end development - https://boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm Matt's X/Twitter: https://x.com/mattpocockuk Total Typescript: https://www.totaltypescript.com/ Timestamps: 00:00 Intro 01:15 What did Matt do before becoming a dev? 03:15 Career Transitions from a non-math background 04:02 What makes a good programmer? 06:46 Math knowledge > great communication? 08:55 On writing elaborate PR's 09:58 OCaml my Typescript 11:00 What is Typescript's Future? 14:21 Python type hinting and JSDoc 20:36 null vs undefined 25:02 interfaces vs type aliases 32:35 Does Matt have any rules of thumb when working with types? 37:14 How do you build nice encapsulated components with no external dependencies? 43:43 AI tooling integration 46:15 Will there be fewer jobs? 52:00 How often do you use classes? 54:29 Where to find Matt

In today’s episode, we bring Spiro Floropoulos, a senior developer and architect with over 20 years of experience. This episode is an unusual one, as Spiro recently got laid off due to a bizarre chain of events that involved HTMX, overworking, and technical debt. But we’ll learn from this story, as we want to shed some light on how situations that Spiro described could be avoided, namely how the tech industry is obsessing over developer experience and why that’s detrimental, why abstractions should be teaching you the technology as opposed to just doing the work for you, why you should be able to train your junior devs and much more! Learn back-end development - https://boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm Spiro's X/Twitter: https://x.com/spirodonfl Spiro's Website: https://spirofloropoulos.com/ Timestamps: 00:00 Intro 00:35 Why are we having this conversation 01:33 How was HTMX involved in this? 03:38 Spiro's background 05:58 Why are we focusing so much on developer experience? 13:38 The Tech Industry as a whole is headed down the wrong path 16:17 Abstractions teaching you about the underlying technology rather than hiding it 18:47 What are the long-term consequences of unresolved technical debt? 26:46 There's things you can't blame frameworks for 28:27 We have to slow down 30:46 What happened after the introduction of HTMX into the project? 40:26 Hiring juniors is great, but you should have the resources to train them 47:00 The Technical Debt 50:32 The more complex the feature became, the bigger the struggle with HTMX 53:42 The reasons why Spiro was let go 57:10 Instead of Agile we should treat our programmers like adults 57:31 HTMX was instant and testing ability was better 01:01:21 Is Spiro looking for work? 01:02:00 Where to find Spiro

Today we bring Thomas Ballinger, a developer at Convex, an open-source backend for application builders. We will be discussing mainly databases, and why at Convex they use Rust and Typescript. We'll also talk about systems scalability, infrastructure and go over different practices regarding abstractions Learn back-end development - https://www.boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm Convex: https://www.convex.dev/ Thomas' X/Twitter: https://x.com/ballingt Thomas' Website: https://ballingt.com/ Timestamps: 00:00 Intro 00:33 Thomas' background 02:29 Convex - what it is and why should you use it? 03:16 What are query planners? 06:32 SQL is a very high level language 07:43 The primary differentiator of Convex 10:49 Who are Convex's biggest competitors? 14:20 How do you build the infrastructure 17:11 What type of database is Convex? 19:18 Why is Convex written in Rust? 23:35 Cheap abstractions 25:47 Productivity suffering from compile times 29:47 The different approaches for a backend developer to build scalable systems 32:28 Backend for Frontend 37:21 You want to be close to your data 42:13 Are there plans to support other languages at Convex? 47:06 Does the schema update the autocompletion in the editor 48:31 Naming and behavior of the queries with Convex 51:06 Why sqlc is great 52:28 Why TypeScript is a great "shortcut" for Convex 59:34 Where to find Thomas

In today's episode, we bring back James Q Quick. Last time we talked about his best tips to land your first ever job as a developer. Today we talk about James' new startup and how he manages all his new tech adventures with being a parent and also provides some helpful insight as to why having an audience and personal connections in the industry is beneficial - but not strictly necessary to succeed. We also talk about AWS, abstraction and the current (healing) state of layoffs, so don't lose hope if you're demotivated in your job search. Learn back-end development - https://www.boot.dev Listen on your favorite podcast player: https://www.backendbanter.fm Deals for Devs: https://www.dealsfordevs.com/ James' Website: https://www.jamesqquick.com/ James' Twitter: https://x.com/jamesqquick James' Youtube: https://www.youtube.com/@JamesQQuick Timestamps: 00:00 Intro 00:55 On being a parent 04:28 Idiocracy 05:47 Deals for Devs 10:09 Comparison with Dixie Direct 12:22 How do you quantify the really high quality deals 15:57 The challenge with a two-sided marketplace 22:28 Doing stuff manually is actually pretty good 25:38 Having a personal connection helps A LOT 29:12 Zeta 34:05 The Web is being modeled on AWS 36:38 You shouldn't be learning one JavaScript framework 38:30 Know how to answer a question if you don't know the technology 41:43 When you learn to code, how much layers of abstraction you should go? 43:45 Should passion be required for a job in tech? 49:02 The state of layoffs 52:29 The ease of finding a job after a layoff when you're highly talented 55:58 Do you need an audience to find a job easily? 58:40 Developers of the world - Interviews in person 01:02:12 Where to find James

In today's episode, we welcome Ken Wheeler, a dope programmer, who creates cool projects and just gives them away for free, helping thousands of developers worldwide, a based beatmaker and just in general a cool person. In this episode, we talk about AI, React, OCaml, why stressing over specific frameworks is not worth it, advice for new developers, HTMX, SPA's and a LOT of other stuff, so stay tuned! Ken's X/Twitter: https://x.com/ken_wheeler Timestamps: 00:00 Introduction 00:25 Do you hate AI? 02:10 How diffusion works 17:47 First impressions with writing Go 18:29 Where's the line between Backend Development and DevOps 24:11 Does anyone version their REST? 24:57 urql 25:38 Offloading the data work to the other side 29:55 Wordpress is 80% of the websites 31:15 HTMX 33:12 Single Page Apps 34:02 Is React still your go-to 36:38 Is it hard to switch from React to Vue? 39:37 Picking a first language to learn 40:43 OCaml 43:12 HEX and raw Binary Data 44:42 Bluetooth powered crossbow 52:20 What got Ken into doing talks 58:45 Where to find Ken