Skip to content
Sign in
Artwork for SWE – Software Engineering for the Rest of Us
Technology

SWE – Software Engineering for the Rest of Us

Arian Zargaran

SWE: Software engineering, explained like you're smart but brand new. Two hosts, one big idea a day, zero jargon left unexplained. If you've ever nodded along in a tech conversation you didn't understand, this is your show.

Play
Open in
  • 13 episodes
  • daily
  • Avg 6 min
  • English

Episodes 13

NewestOldestLongest
All13Unplayed13In progress0Played0
  • Yesterday · 8 min

    Episode 12: The Waiter Who Serves a Million Tables at Once

    Mia and Leo explain APIs through a restaurant menu: endpoints, requests, parameters, API keys, and responses, with real examples from weather apps, Google login, and online payments. Why do apps order from each other's kitchens instead of cooking everything themselves?

  • Wednesday · 7 min

    Episode 11: The Dining Room and the Kitchen Behind Every App

    Mia and Leo explain frontend vs backend through a restaurant: the dining room you see and touch, the kitchen doing the hidden work, and the A P I waiter running between them. What happens behind the swinging door when you tap order? Plus a teaser for tomorrow's deep dive on A P Is.

  • Tuesday · 7 min

    Episode 10: What Really Happens in the Second Before a Website Appears

    Mia and Leo trace the journey from typing a URL to seeing a page — DNS address lookup, HTTP requests, servers, HTML, CSS, JavaScript, and status codes like 404 — through an ordering-a-package analogy. What four-step delivery happens every time a website loads?

  • Monday · 7 min

    Episode 9: The Tape Fix That Costs You Later

    Mia and Leo explain technical debt: why software teams knowingly take shortcuts (like taping a leaky pipe before guests arrive), how refactoring pays it back, and why big apps slow down as the interest piles up. Can you name the difference between deliberate and careless debt after one listen?

  • Sunday · 5 min

    Episode 8: Pilots Never Skip the Checklist. Neither Should Code

    Mia and Leo explain automated testing through the pilot's pre-flight checklist: unit, integration, and end-to-end tests, why every code change gets a full safety check before it ships, and what even the best tests can't catch. What happens when teams skip the checklist to ship faster?

  • Saturday · 6 min

    Episode 7: The Teaspoon That Cost 300 Million Dollars

    Not all bugs are created equal. Mia and Leo break down the three kinds of bugs — syntax errors, runtime errors, and the silent, deadly logic error — and explain why computers amplify one tiny mistake into a catastrophe. Featuring the true story of the 1999 Mars Climate Orbiter, lost because two teams mixed up metric and imperial units. Next time your app crashes right after an update, you will know exactly what kind of bug bit it.

  • October 9 · 6 min

    Episode 6: Never Rewrite the Original While the Kitchen Is Serving

    Mia and Leo explain Git branches, pull requests, code review, merges, and merge conflicts through a restaurant kitchen's master recipe book — how engineers experiment safely and fold changes in without breaking the real thing. Why does a merge conflict mean the system is working?

  • October 8 · 6 min

    Episode 5: Save Points for Code

    Mia and Leo explain Git through a photo album for your code: commits as labeled snapshots, diffs as side-by-side comparisons, reverting as time travel to a working version, and why every project needs version control instead of folders named final-final. What's the difference between Git and GitHub, and where does the photo album analogy break? Plus a teaser for branches and pull requests.

  • October 7 · 6 min

    Episode 4: The Translator Who Reads the Whole Book First

    Mia and Leo explain compilers vs. interpreters: how source code becomes machine code, why compiled programs like phone apps run fast while interpreted languages like Python and JavaScript stay flexible, plus Java bytecode and just-in-time compilation. Which translator is quietly working inside your favorite app right now?

  • October 6 · 5 min

    Episode 3: The Recipe Your Computer Can't Read

    Mia and Leo crack open source code: the human-readable recipe behind every app and website, why engineers write recipes instead of ones and zeros, and how translators turn those recipes into machine code your phone can run. Plus a peek at tomorrow's deep dive into compilers versus interpreters. What does the code behind your favorite app actually look like?

  • October 5 · 8 min

    Episode 2: Why Talking to a Rubber Duck Fixes Your Code

    Mia and Leo unpack the debugging mindset: the rubber duck technique, reproducing bugs, reading error messages, divide-and-conquer with binary search, logging breadcrumbs, and breakpoints that freeze time. The developer's guide to finding bugs — plus why debugging is a life skill, not just a coding skill.

  • October 5 · 6 min

    Episode 1: What a Software Engineer Actually Does

    Mia and Leo kick off SWE with the plain-English basics: debugging, Git, A P Is, databases, testing, and deployment. The eighty percent of software engineering beyond writing code.

Showing 1–13 of 13 episodes