Okay, But Why?

AI - Episode 12 - Forward Deployed: Turning 'We Should Use AI' Into Something Useful

Sun, 27 Sep 2026 16:48:54 +0000

We return to the original support problem and follow the complete journey: discovery, scoping, prototyping, architecture, integration, evaluation, production, adoption, and feedback. Along the way, we explain Forward Deployed Engineering and compare it with software engineering, AI/ML engineering, solutions architecture, and DevRel. The final realization: technology is not the requirement. The problem is the requirement.

AI - Episode 11 - From Demo to Production: Oh Shit, People Are Actually Using It

Sun, 27 Sep 2026 16:48:21 +0000

Real users have arrived, and so have latency, rate limits, privacy questions, and bills. We explore model choice, caching, fallbacks, logging, and operational ownership before comparing hosted APIs with local and self-hosted models. Sabrina brings the open-weight question; GPUs and quantization get plain-language explanations. The model turns out to be one dependency inside a much larger software system.

AI - Episode 10 - Evals, Hallucinations & Keeping the Robot From Ruining Tuesday

Sun, 27 Sep 2026 16:47:41 +0000

The demo worked. Unfortunately, that’s not a test strategy. We try to break Support Assistant with missing policies, conflicting documents, unavailable services, malicious instructions, and unauthorized refund requests. Learn how ordinary tests, AI evaluations, human review, monitoring, and traces work together—and why a convincing answer or impressive average score can hide a serious failure.

AI - Episode 9 - Agents: Apparently the Robot Has a Job Now

Sun, 27 Sep 2026 16:47:12 +0000

When does a chatbot with tools become an agent—and would that actually help? We compare tool assistants, predefined workflows, and systems that let a model choose what happens next. Planning, state, memory, orchestration, and multiple agents all get a turn, but so do budgets, stopping conditions, and the humble if statement. The robot’s lanyard remains under review.

AI - Episode 8 - MCP: Why Does AI Need Another Damn Protocol?

Sun, 27 Sep 2026 16:46:44 +0000

We already have APIs and tool calling. What problem is MCP trying to solve? Parisa, Jules, and Sabrina untangle hosts, clients, servers, tools, resources, and prompts as Support Assistant connects to more systems. The USB-C analogy makes an appearance—with limits—because a shared connection format doesn’t guarantee compatibility, trustworthy integrations, or permission to access everything.

AI - Episode 7 - Tools & Function Calling: Letting the Robot Do Things

Sun, 27 Sep 2026 16:46:20 +0000

Reading the shipping policy is useful. Checking a real order requires a different capability. We follow a tool call from the model’s proposed arguments through application-controlled validation, authorization, execution, and results. Then someone asks for a refund, and suddenly permissions, human approval, accessible confirmations, and avoiding duplicate transactions become very relevant.

AI - Episode 6 - RAG: Giving AI a Filing Cabinet

Sun, 27 Sep 2026 16:45:34 +0000

Brenda’s 40,000 documents are back, and this time we’re retrieving the useful ones. We explain retrieval-augmented generation, embeddings, vectors, semantic search, and chunking without turning the episode into a mathematics lecture. Learn how RAG differs from keyword search and fine-tuning—and why retrieving a passage doesn’t automatically make the resulting answer correct.

AI - Episode 5 - Putting AI in Software: Models, APIs & SDKs

Sun, 27 Sep 2026 16:45:02 +0000

How does a model become a feature in your own application? Follow a request from the browser through your server to a model provider, with APIs, SDKs, streaming, token costs, and failure handling along the way. There’s a Chef Nervous Robot callback, a firm boundary around secret API keys, and a familiar realization: wait, that’s just JavaScript.

AI - Episode 4 - Prompts, Context & Talking to the Robot

Sun, 27 Sep 2026 16:44:29 +0000

Can we replace elaborate prompt rituals with a useful brief? Sabrina joins Parisa and Jules to discuss instructions, examples, context windows, randomness, and structured output. Brenda proposes pasting all 40,000 company documents into the prompt. We explain why that’s a problem—and why better prompting doesn’t mean training, guaranteed accuracy, or enforceable security.

AI - Episode 3 - LLMs: Extremely Fancy Autocomplete?

Sun, 27 Sep 2026 16:43:55 +0000

Is a language model a digital mind or autocomplete wearing an expensive coat? We explore tokens, next-token prediction, transformers, attention, and context to understand what happens when an LLM generates an answer. Support Assistant discovers that sounding like an experienced employee is not the same as knowing the company’s actual refund policy.

AI - Episode 2 - How Does a Machine Learn Anything?

Sun, 27 Sep 2026 16:43:17 +0000

If nobody programmed every answer, where did they come from? Parisa and Jules unpack training data, models, weights, neural networks, and the difference between training and inference. Along the way, “let’s train our own AI” turns out to contain several enormous assumptions—and using AI in a web application doesn’t suddenly require writing everything in Python.

AI - Episode 1 - What the Hell Is AI, Actually?

Sun, 27 Sep 2026 16:41:26 +0000

Management says, “We should add AI.” Parisa has a follow-up: “To do what?” We untangle AI, machine learning, deep learning, generative AI, and LLMs—and introduce Support Assistant, our fictional company’s attempt to help support staff find information without opening twelve tabs. Before choosing the technology, we need an actual problem.

Containers & Infrastructure - Episode 12 - Do You Actually Need Any of This Shit?

Fri, 25 Sep 2026 17:59:11 +0000

Our little podcast app probably never needed Kubernetes. From static portfolios to large distributed systems, we compare infrastructure choices against actual requirements, costs, and maintenance responsibilities. The goal isn’t the most impressive diagram—it’s a decision you can explain and sustain.

Containers & Infrastructure - Episode 11 - Infrastructure as Code: Why Is My Server in Git?

Fri, 25 Sep 2026 17:58:38 +0000

Someone configured production six months ago. Nobody remembers exactly what they did. We explore how infrastructure as code makes those decisions reviewable and repeatable, why Terraform and OpenTofu keep state, and why Git cannot reverse time for your database.

Containers & Infrastructure - Episode 10 - The Cloud Is Someone Else's Computer*

Fri, 25 Sep 2026 17:58:10 +0000

The asterisk is doing some serious work. We explore cloud services by what they manage: compute, storage, databases, networking, containers, and more. The useful question is how much responsibility you want to keep—and what you’re paying someone else to handle.

Containers & Infrastructure - Episode 9 - Pods, Nodes & Clusters, Oh My

Fri, 25 Sep 2026 17:57:41 +0000

Kubernetes has a lot of nouns. Now they have jobs. We connect clusters, nodes, Pods, Deployments, and Services through one simple example: we want three replicas, but only two exist. What happens next—and what can still go wrong?

Containers & Infrastructure - Episode 8 - Kubernetes: Who Asked for This?!

Fri, 25 Sep 2026 17:57:12 +0000

One container is manageable. Hundreds of containers across machines that occasionally fail create a different problem. Before introducing the vocabulary, we explain why orchestration exists—and why “Docker or Kubernetes?” is usually the wrong question.

Containers & Infrastructure - Episode 7 - From Git Push to Production

Fri, 25 Sep 2026 17:56:42 +0000

Pushing code means the code has traveled. It doesn’t necessarily mean anything is deployed. We trace a change through automated checks, image builds, registries, and production, then ask what happens when the green checkmark turns into a real-world problem.

Containers & Infrastructure - Episode 6 - Docker Compose: My App Has Friends

Fri, 25 Sep 2026 17:56:20 +0000

Our fictional podcast app now has a frontend, an API, and a database. Docker Compose helps describe how they fit together—and Parisa discovers that familiar tools like DDEV and Lando have been doing quite a bit of this work already.

Containers & Infrastructure - Episode 5 - Why Can't My Container See Localhost?!

Fri, 25 Sep 2026 17:55:25 +0000

The API works. The database works. Together, they refuse to speak. We follow requests across container boundaries, decode port mappings, and discover why deleting a container can become a very unpleasant lesson about persistent storage.

Containers & Infrastructure - Episode 4 - Images, Containers & Dockerfiles

Fri, 25 Sep 2026 17:55:02 +0000

A Dockerfile, an image, and a container walk into a deployment—and they are three different things. We untangle building, pulling, running, layers, and registries, with a frozen-lasagna metaphor that knows when to stop.

Containers & Infrastructure - Episode 3 - Docker: Who Asked for This?

Fri, 25 Sep 2026 17:54:30 +0000

“It works on my machine” is less reassuring when nobody else has your machine. We explore the environment problems containers help solve, how Docker fits in, and why a container is not simply a tiny virtual machine.

Containers & Infrastructure - Episode 2 - Servers, VMs & the Cloud Before Containers

Fri, 25 Sep 2026 17:53:10 +0000

Why couldn’t we just put every application on one server? From shared hosting and cPanel to virtual machines, we explore resource sharing, isolation, and the infrastructure work that existed long before anyone called it “the cloud.”

Containers & Infrastructure - Episode 1 - Where Does My App Actually Live?

Fri, 25 Sep 2026 17:52:36 +0000

Underneath every framework and hosting dashboard, something is running on a computer. Parisa and Jules unpack processes, runtimes, memory, storage, ports, and servers—and explain why sending someone a localhost link does not count as deployment.

Accessibility - Episode 6 - Your Lighthouse Score Is Not an Accessibility Audit

Thu, 17 Sep 2026 22:16:57 +0000

Lighthouse says 100. Congratulations! Are we accessible now? Parisa and Jules look at what automated accessibility testing can—and absolutely cannot—tell us. They dig into Lighthouse, axe, WAVE, browser accessibility tools, keyboard testing, screen readers, and manual checks, then put it all together into a development workflow where accessibility happens while we're building instead of during the traditional pre-launch panic.

Accessibility - Episode 5 - Your Design Is Lying to You

Thu, 17 Sep 2026 22:16:30 +0000

An interface can look completely obvious to the person who designed it and still create barriers for someone else. Parisa and Jules tackle contrast, color, zoom and reflow, motion, touch targets, labels, form errors, and cognitive load. Because “I can see what it means” turns out to be a pretty terrible accessibility testing methodology.

Accessibility - Episode 4 - ARIA: What Is This Shit Actually For?

Thu, 17 Sep 2026 22:16:02 +0000

ARIA is supposed to improve accessibility, so surely adding more ARIA makes things more accessible. Right? Absolutely not. Parisa and Jules figure out what ARIA actually communicates, when native HTML is the better answer, how roles, states, accessible names, descriptions, and live regions work, and why role="button" doesn't magically turn a div into a button.

Accessibility - Episode 3 - Throw Away Your Mouse

Thu, 17 Sep 2026 22:15:29 +0000

Your interface works perfectly—as long as everyone owns a mouse. Parisa and Jules put the mouse aside to explore keyboard navigation, focus, focus order, tabindex, skip links, dialogs, and focus management. They also discover why removing the focus outline is one of those tiny CSS decisions capable of causing a disproportionate amount of bullshit.

Accessibility - Episode 2 - HTML Was Already Doing This

Thu, 17 Sep 2026 22:15:00 +0000

Why does it matter whether you use a button or a div if they look exactly the same? Parisa and Jules dig into semantic HTML, the DOM, the accessibility tree, and all the useful information and behavior browsers already provide when we use native elements correctly. Turns out HTML has been doing a surprising amount of accessibility work for us this whole time.

Accessibility - Episode 1 - Who Is This Actually For?

Thu, 17 Sep 2026 22:14:18 +0000

Accessibility gets reduced to checklists, screen readers, and “remember your alt text” way too easily. Parisa and Jules start with the bigger question: who actually encounters accessibility barriers on the web, how different people interact with the same interface, and what WCAG and POUR are actually trying to accomplish. Accessibility isn't a special version of the web. It's about not unnecessarily requiring everyone to use the web the same way.

Modern CMS Development - Episode 10 - Drupal 10/11: What Changed, What Stayed & Should We Use a CMS?

Thu, 17 Sep 2026 20:30:01 +0000

What modern Drupal changed, what stayed fundamentally Drupal, and how to decide between Drupal, WordPress, static sites, custom applications, and headless CMSs.

Modern CMS Development - Episode 9 - APIs, Headless Drupal & Modern Drupal

Thu, 17 Sep 2026 20:29:35 +0000

JSON:API, authentication, headless frontends, decoupling tradeoffs, Recipes, Drupal CMS, Canvas, and what “modern Drupal” actually means now.

Modern CMS Development - Episode 8 - Composer, Config & Deployment: “But I Changed It in the Admin UI”

Thu, 17 Sep 2026 20:29:00 +0000

Composer, Drush, YAML configuration, environments, deployments, and the extremely important distinction between code, configuration, and content.

Modern CMS Development - Episode 7 - Modules, Hooks, Services & Symfony: Wait, Which Part Is Drupal?

Thu, 17 Sep 2026 20:28:29 +0000

Routes, controllers, plugins, services, dependency injection, Symfony, events, and the evolution from procedural hooks toward modern Drupal’s object-oriented patter

Modern CMS Development - Episode 6 - Modern Drupal Frontend: Twig, Themes & Components

Thu, 17 Sep 2026 20:28:00 +0000

Modern Drupal theming with Twig, preprocessing, libraries, behaviors, Single Directory Components, props, slots, and accessible component markup.

Modern CMS Development - Episode 5 - Views, Display Modes & Render Arrays: Who Actually Builds the Page?

Thu, 17 Sep 2026 20:27:26 +0000

How Drupal finds content, decides how to display it, renders it, and keeps all of that performant through its caching system.

Modern CMS Development - Episode 4 - Content Modeling: Why Drupal People Won't Shut Up About Structure

Thu, 17 Sep 2026 20:26:59 +0000

How to model real content using fields, references, cardinality, taxonomy, reusable structures, display modes, moderation, and multilingual requirements.

Modern CMS Development - Episode 3 - Drupal: Why Is Everything an Entity?

Thu, 17 Sep 2026 20:26:25 +0000

The Drupal mental model: entity types, bundles, entities, and fields—and why nodes, media, taxonomy terms, users, and blocks all start making more sense once that clicks.

Modern CMS Development - Episode 2 - WordPress: How Did a Blogging Tool Eat the Web?

Thu, 17 Sep 2026 20:25:52 +0000

How WordPress grew from blogging software into a massive CMS ecosystem of content types, taxonomies, themes, plugins, hooks, and blocks.

Modern CMS Development - Episode 1 - What the Hell Is a CMS?

Thu, 17 Sep 2026 20:25:27 +0000

Why content management systems exist, what they actually manage, and how a CMS differs from a framework, site builder, or hosting platform.

APIs - Episode 14 - Modern APIs: AI, MCP, and "Wait, Isn't This All Just APIs Again?"

Thu, 17 Sep 2026 20:24:54 +0000

Model APIs, SDKs, streaming, tool calls, MCP, and agents—and how a lot of supposedly mysterious AI infrastructure becomes much less mysterious once you see the boundaries.

APIs - Episode 13 - API Design: Don't Make Other Developers Hate You

Thu, 17 Sep 2026 20:24:24 +0000

Consistent contracts, useful errors, pagination, filtering, rate limits, idempotency, compatibility, and documentation that does not require psychic powers.

APIs - Episode 12 - REST Isn't the Only Option

Thu, 17 Sep 2026 20:23:54 +0000

GraphQL, RPC, gRPC, WebSockets, server-sent events, and streaming—and the different communication problems each approach is trying to solve.

APIs - Episode 11 - Webhooks: What If the API Calls You?

Thu, 17 Sep 2026 20:23:26 +0000

Instead of constantly asking an API whether something happened, let it call you—then deal with verification, retries, duplicates, ordering, and failure.

APIs - Episode 10 - CORS: Why Is My Browser Yelling at Me?

Thu, 17 Sep 2026 20:22:45 +0000

Origins, preflight requests, credentials, browser restrictions, and why CORS is neither authentication nor a random punishment invented for frontend developers.

APIs - Episode 9 - OAuth: Why Is "Sign In With Google" So Complicated?

Thu, 17 Sep 2026 20:22:18 +0000

What OAuth is actually doing during all those redirects, why delegated authorization exists, and how “Sign in with…” fits into the larger picture.

APIs - Episode 8 - Authentication: How Does the API Know Who the Hell I Am?

Thu, 17 Sep 2026 20:21:47 +0000

How APIs identify callers, where authentication ends and authorization begins, and how credentials, sessions, and tokens fit into the picture.

APIs - Episode 7 - Building an API

Thu, 17 Sep 2026 20:21:19 +0000

What happens on the other side of the request: routes, handlers, validation, authorization, business logic, databases, errors, and contracts.

APIs - Episode 6 - Calling an API From JavaScript

Thu, 17 Sep 2026 20:20:47 +0000

Using fetch and async/await without pretending networks are reliable, including loading, errors, cancellation, races, and retries.

APIs - Episode 5 - JSON: Why Are We Passing This Stuff Around Everywhere?

Thu, 17 Sep 2026 20:20:18 +0000

Why JSON became the web’s favorite little data envelope, how it differs from a JavaScript object, and why parsing data does not mean you can trust it.

APIs - Episode 4 - REST: Who Asked for This?

Thu, 17 Sep 2026 20:19:46 +0000

Why REST became popular, what resources and stateless requests actually mean, and why GET, POST, PUT, PATCH, and DELETE are not interchangeable vibes.

APIs - Episode 3 - HTTP: The Thing Underneath the API

Thu, 17 Sep 2026 20:19:00 +0000

Requests, responses, methods, headers, bodies, status codes, failures, and the protocol doing most of the actual work underneath web APIs.

APIs - Episode 2 - Why Did We Need Web APIs?

Thu, 17 Sep 2026 20:18:16 +0000

How we got from server-rendered forms to AJAX and shared backends, and why separating data from pages became useful.

APIs - Episode 1 - Okay, What Actually Is an API?

Thu, 17 Sep 2026 20:17:17 +0000

APIs as contracts and boundaries—not just URLs—including the APIs inside libraries, browsers, operating systems, and remote services.

Next.js - Episode 10 - Do I Actually Need This Shit?

Thu, 17 Sep 2026 20:07:08 +0000

When Next.js earns its complexity, when plain React is enough, and when the boring old web may still be exactly what your project needs.

Next.js - Episode 9 - Next.js Ate My Web Stack

Thu, 17 Sep 2026 20:05:45 +0000

How routing, rendering, server code, APIs, caching, assets, metadata, and deployment ended up under one framework-shaped roof.

Next.js - Episode 8 - Oh, So There IS a Backend

Thu, 17 Sep 2026 20:04:31 +0000

Route Handlers, HTTP endpoints, webhooks, external consumers, and when your Next.js application really does need an API boundary.

Next.js - Episode 7 - Did We Just Put the Backend in the Component?

Thu, 17 Sep 2026 20:03:16 +0000

Server-side mutations, forms, validation, authorization, and why putting backend work near your React code does not make normal security rules disappear.

Next.js - Episode 6 - Caching: Why Is My Website Lying to Me?

Thu, 17 Sep 2026 20:01:44 +0000

Why Next.js caches things, how stale data happens, and how to think about freshness, revalidation, and invalidation without losing your damn mind.

Next.js - Episode 5 - Why Am I Fetching My Own Data Over HTTP?

Thu, 17 Sep 2026 20:00:25 +0000

Where data fetching belongs in Next.js, when Server Components can talk directly to your data source, and when an HTTP request is just an unnecessary middleman.

Next.js - Episode 4 - SSR, SSG, CSR and Please Stop Inventing Acronyms

Thu, 17 Sep 2026 19:59:06 +0000

A practical tour of server rendering, static generation, client rendering, hydration, streaming, and when the HTML actually gets made.

Next.js - Episode 3 - React Runs WHERE?

Thu, 17 Sep 2026 19:57:37 +0000

Server Components, Client Components, browser boundaries, hydration, and the increasingly complicated answer to “where is this React code actually running?”

Next.js - Episode 2 - The Folder That Controls Reality

Thu, 17 Sep 2026 19:56:21 +0000

How the App Router turns folders and files into routes, pages, layouts, and dynamic URLs—and why your directory structure suddenly has opinions.

Next.js - Episode 1 - Wait, React Needs a Framework Now?

Thu, 17 Sep 2026 19:49:55 +0000

Why Next.js exists, what it adds on top of React, and how routing, rendering, data, and deployment became part of the framework conversation.

Cybersecurity - Episode 25 - So You Want to Take Security+ — Fine, Here Are the Acronyms

Wed, 16 Sep 2026 03:02:40 +0000

We turn the series’ practical understanding toward Security+ preparation: concept families, common protocols, scenario questions, labs, and coverage planning. The exam objectives provide the checklist; understanding provides a way to reason through it. Memorization has a job, but it shouldn’t be doing all the work.

Cybersecurity - Episode 24 - The Big Security Picture — Red Teams, Blue Teams & Everyone Else

Wed, 16 Sep 2026 03:01:39 +0000

Who actually does all this security work? We connect application security, detection, incident response, identity, governance, architecture, and offensive testing into a larger picture. These roles overlap, collaborate, and depend on skills from across technology. There’s considerably more to the field than “person in hoodie.”

Cybersecurity - Episode 23 - Secure Development & DevSecOps — Security Before Friday

Wed, 16 Sep 2026 03:00:41 +0000

Security works better when it participates in development instead of arriving as a surprise before release. We explore requirements, reviews, automated scanning, pipeline permissions, artifact integrity, and maintenance. The goal is useful feedback throughout the lifecycle, without turning every developer’s day into an obstacle course.

Cybersecurity - Episode 22 - Business Continuity & Disaster Recovery — The Building Is Gone, Now What?

Wed, 16 Sep 2026 02:59:44 +0000

Having a backup and being able to recover are different achievements. We explore business continuity, disaster recovery, recovery targets, failover, and restoration testing. The question isn’t just whether the data survived—it’s how the organization keeps working while the systems it relies on are unavailable.

Cybersecurity - Episode 21 - Risk, Governance, Privacy & Compliance — Congratulations, Security Has Paperwork

Wed, 16 Sep 2026 02:58:50 +0000

Policies and risk registers sound far removed from writing code—until somebody has to decide what data to keep or which risk to accept. We connect governance, privacy, compliance, and third-party risk to practical choices. Documentation earns its place when it makes responsibilities and decisions clear.

Cybersecurity - Episode 20 - Incident Response & Digital Forensics — Production Is on Fire, Don’t Touch Anything

Wed, 16 Sep 2026 02:57:50 +0000

Something bad is happening, and panic is not an incident-response plan. We walk through preparation, analysis, containment, recovery, and lessons learned, alongside evidence preservation and forensic basics. The challenge is to stop the harm without destroying the information needed to understand what happened.

Cybersecurity - Episode 19 - Security Operations — Who Watches the Logs?

Wed, 16 Sep 2026 02:56:57 +0000

Collecting logs is easy compared with recognizing what matters in them. We explore security operations, SIEMs, detection tools, threat intelligence, baselines, and alert fatigue. A useful alert needs evidence and a response—not merely the ability to wake somebody up at an unreasonable hour.

Cybersecurity - Episode 18 - Secure Architecture & Cloud Security — Whose Computer Is This Anyway?

Wed, 16 Sep 2026 02:56:00 +0000

Moving to the cloud changes responsibilities; it doesn’t remove them. We explore shared responsibility, service models, cloud permissions, network controls, hardening, and resilience. Managed infrastructure can take work off your plate, but somebody still has to decide who gets access and whether that storage should be public.

Cybersecurity - Episode 17 - Vulnerabilities, CVEs & Pentesting — How Broken Is It?

Wed, 16 Sep 2026 02:55:10 +0000

A scanner found something. Now what? We distinguish vulnerability identifiers, severity scores, exploitation evidence, scanning, and penetration testing, then follow prioritization and remediation. The useful question isn’t simply how frightening a finding sounds—it’s what it means for this system and what should happen next.

Cybersecurity - Episode 16 - Dependencies, Supply Chains & Secrets — npm Has Entered the Threat Model

Wed, 16 Sep 2026 02:54:14 +0000

Your application depends on code you didn’t write, tools you didn’t build, and credentials you really shouldn’t commit. We examine dependency risks, lockfiles, vulnerability scanning, build pipelines, and software provenance. Plus: why deleting a leaked secret from the latest version doesn’t make it secret again.

Cybersecurity - Episode 15 - OWASP & Threat Modeling — Please Imagine the Worst

Wed, 16 Sep 2026 02:53:19 +0000

Security lists can help us remember familiar failures, but our application still needs its own questions. We explore OWASP, assets, trust boundaries, data flows, STRIDE, and abuse cases. Threat modeling means examining how a design could be misused while there’s still time to change it.

Cybersecurity - Episode 14 - Sessions, Cookies, Tokens & API Security

Wed, 16 Sep 2026 02:52:14 +0000

How does an application remember a login without handing out unlimited access forever? We explore session security, cookie flags, bearer tokens, JWTs, API keys, expiry, and revocation. The format of a credential matters less than how it’s issued, stored, checked, and eventually made useless.

Cybersecurity - Episode 13 - CSRF, CORS & Same-Origin Policy — Why Is the Browser Yelling at Me?

Wed, 16 Sep 2026 02:51:17 +0000

CORS errors, cookies, preflight requests, CSRF tokens: several different security mechanisms are getting blamed for each other’s jobs. We separate the same-origin policy, CORS, and cross-site request forgery, then follow what browsers send and what JavaScript can read. Turning the warning off is not the same as fixing the boundary.

Cybersecurity - Episode 12 - Injection — Stop Concatenating Untrusted Shit

Wed, 16 Sep 2026 02:50:17 +0000

When data becomes part of an instruction, the program may start following somebody else’s instructions. We explore SQL, command, template, and other injection problems, including why parameterized queries are a structural defense. Input validation helps, but it isn’t a substitute for keeping data and commands separate.

Cybersecurity - Episode 11 - XSS — You Put WHAT in My DOM?

Wed, 16 Sep 2026 02:49:16 +0000

Cross-site scripting happens when untrusted content gets to behave like trusted code. We explore stored, reflected, and DOM-based XSS, then examine output contexts, escaping, sanitization, CSP, and dangerous browser APIs. Framework protections help, but they can’t save us from every escape hatch we deliberately open.

Cybersecurity - Episode 10 - How Attacks Actually Happen — From Recon to “Oh Shit”

Wed, 16 Sep 2026 02:48:12 +0000

Real attacks often chain several ordinary weaknesses together. We follow reconnaissance, initial access, privilege escalation, lateral movement, and exfiltration, then explore how defenders can interrupt that sequence. Attack frameworks become useful when they help explain behavior—not when they become another wall of acronyms.

Cybersecurity - Episode 9 - Malware, Ransomware & Other Assholes

Wed, 16 Sep 2026 02:47:15 +0000

Malware is a broad category of bad behavior, not one specific kind of scary file. We distinguish viruses, worms, trojans, ransomware, spyware, and other threats, then connect persistence, detection, and recovery. Backups help, but recovering from an attack takes more than finding a folder marked “backup.”

Cybersecurity - Episode 8 - Social Engineering & Credential Attacks — Hacking the Squishy Humans

Wed, 16 Sep 2026 02:46:07 +0000

Attackers don’t always need a software vulnerability. Sometimes they need urgency, apparent authority, and a believable request. We explore phishing, pretexting, help-desk attacks, MFA fatigue, and credential theft—and why useful defenses should support people instead of blaming them for being human.

Cybersecurity - Episode 7 - HTTPS, TLS, Certificates & PKI — Who Says This Is Really the Website?

Wed, 16 Sep 2026 02:44:50 +0000

The browser shows a secure connection. What did it actually verify? We follow TLS, certificates, certificate authorities, and the trust chain, then examine expiry, revocation, and private keys. HTTPS protects the connection, but it doesn’t certify that the application—or the person running it—is behaving well.

Cybersecurity - Episode 6 - Cryptography Without the Wizard Robes

Wed, 16 Sep 2026 02:43:12 +0000

Encryption, hashing, and digital signatures solve different problems, despite frequently sharing the same intimidating conversation. We unpack keys, password hashing, authenticity, randomness, and key management without turning the episode into a maths ambush. The algorithm matters, but so does where you left the secret.

Cybersecurity - Episode 5 - Authorization & IAM — Are You Allowed to Do That?

Wed, 16 Sep 2026 02:42:12 +0000

Logging in doesn’t entitle you to everybody else’s data. We explore permissions, roles, attributes, service accounts, and identity lifecycles, including the surprisingly destructive act of changing an ID in a URL. Access control means checking this person, this action, and this resource—not merely confirming a session exists.

Cybersecurity - Episode 4 - Authentication — Prove You're You

Wed, 16 Sep 2026 02:40:42 +0000

Passwords, MFA, passkeys, biometrics: what evidence should convince a system that you’re really you? We examine authentication factors, credential attacks, password storage, SSO, and account recovery. Strong authentication also has to work for real people—including when they lose a device or need an accessible way in.

Cybersecurity - Episode 3 - Firewalls, Segmentation, VPNs & Zero Trust

Wed, 16 Sep 2026 02:39:27 +0000

“We have a firewall” is the beginning of a conversation, not the end. We explore traffic filtering, segmentation, VPNs, proxies, and Zero Trust through the access decisions they support. An encrypted tunnel doesn’t automatically make its users trustworthy, and being inside the network shouldn’t grant unlimited roaming privileges.

Cybersecurity - Episode 2 - Networking, But Now Everyone Is Suspicious

Wed, 16 Sep 2026 02:37:24 +0000

IP addresses, ports, DNS, routing: familiar networking concepts look different when we ask who can reach what. We follow how systems communicate, what common protocols do, and where attackers find opportunities. The goal is to understand the traffic—not memorize a list of numbers and hope for the best.

Cybersecurity - Episode 1 - What Are We Actually Protecting?

Wed, 16 Sep 2026 02:35:55 +0000

Before the acronyms arrive, what is cybersecurity trying to accomplish? We connect confidentiality, integrity, availability, threats, vulnerabilities, and risk to everyday development decisions. Security isn’t a promise that nothing bad will happen. It’s understanding what matters, what could go wrong, and how to reduce the damage.

JavaScript Testing - Episode 10 - One Hundred Percent of What? — Coverage and the Limits of Tests

Mon, 14 Sep 2026 15:11:33 +0000

One hundred percent coverage sounds reassuring. It doesn’t mean every important behavior was checked. We unpack coverage metrics, mutation testing, property-based testing, and the limits of automated confidence. A test suite can execute every line and still share the application’s misunderstanding of what it was supposed to do.

JavaScript Testing - Episode 9 - Unit, Integration, End-to-End — Which Wires Are Connected?

Mon, 14 Sep 2026 15:09:57 +0000

The pieces work separately. Do they work together? We follow one application promise through unit, integration, API, and browser tests, looking at which dependencies are real and what each scope can prove. The best test plan balances confidence, diagnostic clarity, maintenance, and the cost of running it.

JavaScript Testing - Episode 8 - Async Tests — The Test Finished Before the Bug Arrived

Mon, 14 Sep 2026 15:08:32 +0000

A green test means very little if it stopped before the interesting part happened. We work through promises, rejected requests, loading states, races, fake timers, and condition-based waiting. The recurring question: what tells this test that the behavior it cares about has actually finished?

JavaScript Testing - Episode 7 - React Testing — Stop Interrogating the Furniture

Mon, 14 Sep 2026 15:06:49 +0000

Did the component behave correctly, or did we merely confirm its internal furniture arrangement? We explore React tests through rendering, interaction, and observable results, including props, effects, providers, network boundaries, and snapshots. A useful test should survive a refactor that leaves the user’s experience unchanged.

JavaScript Testing - Episode 6 - Testing the DOM Without a Browser — Mostly

Mon, 14 Sep 2026 15:05:53 +0000

A simulated DOM can tell us plenty about an interface, but it doesn’t actually draw the page. We test a widget through roles, labels, keyboard interactions, and visible feedback, then examine where real-browser checks still matter. Finding a button and proving people can use it are related questions, not identical ones.

JavaScript Testing - Episode 5 - Mocks, Stubs, Spies, and Other Lies We Tell Our Code

Mon, 14 Sep 2026 15:04:25 +0000

Testing shouldn’t require emailing real customers or charging actual credit cards. We explore test doubles, dependency boundaries, and the differences between supplying an answer and observing a call. A replacement can make a test safer and clearer—or so accommodating that reality never gets a vote.

JavaScript Testing - Episode 4 - Jest, Vitest, and Who Actually Runs This Stuff?

Mon, 14 Sep 2026 15:03:14 +0000

The test file exists. What finds it, runs it, and decides whether it failed? We separate runners, assertions, environments, transforms, and watch mode while exploring Jest, Vitest, and Node’s testing support. Configuration starts making more sense when every moving part has an identifiable job.

JavaScript Testing - Episode 3 - Arrange, Act, Assert — The Testing Sandwich

Mon, 14 Sep 2026 15:01:33 +0000

A test should make its question easy to see. We use Arrange, Act, Assert to separate the situation, the action, and the expected result, then tackle fixtures, hooks, names, and parameterized cases. Three comments aren’t enough if the test still passes for the wrong reason.

JavaScript Testing - Episode 2 - Unit Tests — How Tiny Is Tiny?

Mon, 14 Sep 2026 04:12:02 +0000

Is a unit a function, a file, or whatever fits comfortably in your brain? We test small behavioral promises through inputs, outputs, errors, and mutation. Along the way, we examine useful assertions, edge cases, and why a collection of passing unit tests doesn’t prove the whole application works.

JavaScript Testing - Episode 1 - Why Are We Testing Code That Already Works?

Mon, 14 Sep 2026 04:10:13 +0000

“I clicked it and it worked” is evidence. It’s just evidence with a short memory. We explore what automated tests preserve, how regressions happen, and what a passing test actually proves. Before choosing a testing framework, we need a useful question and a reason to trust the answer.

Web Architecture - Episode 14 - Build an Architecture in Your Head — Reasons Before Rectangles

Mon, 14 Sep 2026 02:41:09 +0000

Time to design a system without beginning with a shopping list of technologies. We take Nervous Robot Pizza Delivery from requirements through data ownership, failure paths, accessibility, growth, and recovery. The series wraps with a practical way to explain not just what you’d build, but why.

Web Architecture - Episode 13 - SSR, CSR, SSG, and Hydration — When Does the HTML Happen?

Mon, 14 Sep 2026 02:40:18 +0000

Where is the page built, when is it built, and when does it become interactive? We connect server rendering, client rendering, static generation, hydration, and streaming through concrete page journeys. The acronyms become much less mysterious once we follow the HTML instead of ranking frameworks.

Web Architecture - Episode 12 - Scaling — More Pizza, Not Automatically More Services

Mon, 14 Sep 2026 02:39:25 +0000

The pizza site went viral. Does that mean we need microservices now? We explore bottlenecks, vertical and horizontal scaling, queues, database pressure, load testing, and graceful degradation. Scaling starts with measuring what’s struggling, then adding capacity where it will actually help.

Web Architecture - Episode 11 - Caching and CDNs — Yesterday's Pizza, Today's Problem

Mon, 14 Sep 2026 02:38:35 +0000

Keeping a copy can make a website faster. Keeping the wrong copy can show someone yesterday’s menu—or another customer’s order. We unpack browser caches, CDNs, freshness, validation, cache keys, and invalidation. The useful question isn’t just “Can we cache this?” It’s “Under what conditions?”

Web Architecture - Episode 10 - Microservices — Congratulations, Your Function Call Has Weather

Mon, 14 Sep 2026 02:37:41 +0000

Separate services can give teams independence, but the network introduces new ways for dinner to go wrong. We examine service boundaries, data ownership, messages, retries, compensation, and observability. Microservices solve particular problems—and bring operational responsibilities that don’t fit neatly inside the architecture diagram.

Web Architecture - Episode 9 - Monoliths — One Application, Several Responsibilities

Mon, 14 Sep 2026 02:36:47 +0000

A monolith isn’t automatically a tangled disaster. We explore how one deployable application can still have clear modules, deliberate data ownership, and useful boundaries. When does keeping things together simplify development, and what evidence would justify splitting a responsibility into a separate service?

Web Architecture - Episode 8 - Databases and Application State — Where Does the Truth Live?

Mon, 14 Sep 2026 02:35:56 +0000

An order stored in a variable is having a dangerously temporary existence. We explore persistence, transactions, concurrency, indexes, migrations, and recovery—and why a database does more than save things. Two customers want the last dough ball. Somewhere, the system needs a trustworthy answer.

Web Architecture - Episode 7 - Authentication, Sessions, Cookies, and Tokens — Do You Know Me?

Mon, 14 Sep 2026 02:34:31 +0000

Recognizing someone and allowing them to do something are different jobs. We follow sessions, cookies, tokens, login redirects, and expiry, then examine CSRF and access to individual orders. “I’m logged in” is useful information. It is not permission to inspect everybody else’s pizza.

Web Architecture - Episode 6 - APIs — A Boundary With a Job Description

Mon, 14 Sep 2026 02:33:37 +0000

An API is more than a URL that returns JSON. We explore contracts, methods, validation, errors, pagination, compatibility, and retries through a pizza-ordering system. What does one part of the application promise another, and how do we keep a retry from accidentally ordering dinner twice?

Web Architecture - Episode 5 - How We Got SPAs — The Page Refuses to Leave

Mon, 14 Sep 2026 02:32:27 +0000

Why reload an entire page when only one part needs to change? We explore the problems single-page applications solve—and the browser responsibilities they take over. Routing, loading states, accessibility, stale requests, and the Back button all enter the conversation. Smooth navigation comes with work attached.

Web Architecture - Episode 4 - Static Sites, Server Rendering, and the Allegedly Dead Web

Mon, 14 Sep 2026 02:31:35 +0000

Static doesn’t mean lifeless, and server-rendered doesn’t mean obsolete. We compare preparing HTML ahead of time with building it for each request, then follow forms, sessions, and progressive enhancement. What can the browser already do, and when does adding JavaScript actually improve the experience?

Web Architecture - Episode 3 - The Request/Response Cycle — I Pressed Enter, Now What?

Mon, 14 Sep 2026 02:30:40 +0000

A URL goes in, a page comes out, and an unreasonable amount happens in between. We follow DNS, connections, HTTP requests, headers, responses, and redirects, then investigate slow requests and missing answers. That loading spinner has a story—and sometimes the story includes an order that already went through.

Web Architecture - Episode 2 - Client vs Server — Whose Computer Is This?

Mon, 14 Sep 2026 02:29:54 +0000

The browser says the pizza costs twelve cents. Should the server believe it? We explore what belongs on the client, what belongs on the server, and why the boundary matters for security, performance, and user experience. Running JavaScript on both sides doesn’t make them the same place.

Web Architecture - Episode 1 - What Even Is Web Architecture?

Mon, 14 Sep 2026 02:28:23 +0000

Architecture diagrams have boxes, arrows, and occasionally weather. But what are they explaining? Using Nervous Robot Pizza Delivery, we follow an order through a system and explore responsibilities, boundaries, failure, and tradeoffs. The architecture starts with what people need to do, not which framework looks impressive.

Modern JavaScript - Episode 7 - Okay, But How Do People Write JavaScript Now?

Mon, 14 Sep 2026 02:25:16 +0000

Do we really need to replace every loop with a chain of array methods? We compare map, filter, find, reduce, modern loops, and object helpers through the work they actually perform. The goal is readable transformations—not proving you know the most fashionable punctuation.

Modern JavaScript - Episode 6 - Import This, Export That

Mon, 14 Sep 2026 02:24:34 +0000

Before modules, sharing JavaScript often involved globals and hoping your script tags were in the right order. We explore imports, exports, module scope, CommonJS, and dynamic imports—and explain why browsers, Node, and build tools don’t always agree about how a module should be loaded.

Modern JavaScript - Episode 5 - JavaScript Finally Learned How to Wait

Mon, 14 Sep 2026 02:23:52 +0000

How does JavaScript wait for something without freezing everything else? We connect callbacks, promises, and async/await, explain the event loop without requiring a PhD, and examine errors, parallel requests, and forgotten promises. Making asynchronous code look straightforward doesn’t make timing disappear.

Modern JavaScript - Episode 4 - Wait, That's Just JavaScript

Mon, 14 Sep 2026 02:23:13 +0000

Destructuring, spread, rest, template literals, optional chaining: modern JavaScript can look like somebody spilled punctuation into your editor. We work through what these features actually do, which problems they simplify, and when “clever” syntax makes perfectly reasonable code harder to understand.

Modern JavaScript - Episode 3 - Why Does Everything Have an Arrow Now?

Mon, 14 Sep 2026 02:22:30 +0000

Arrow functions aren’t just regular functions with less punctuation. We explore callbacks, implicit returns, and the surprisingly important difference in how arrows handle this. Plus: when a traditional function is exactly what you want, and why returning an object occasionally requires punctuation restitution.

Modern JavaScript - Episode 2 - var Has Left the Building

Mon, 14 Sep 2026 02:21:29 +0000

What did var do wrong, and why do we now have let and const? We untangle scope, hoisting, reassignment, and mutation, including why a constant object can still change. Grandpa Var gets a fair hearing, but the loop bugs remain on the record.

Modern JavaScript - Episode 1 - Wait, JavaScript Changed?

Mon, 14 Sep 2026 02:07:50 +0000

JavaScript apparently changed clothes while Parisa wasn’t looking. We unpack ES6, ECMAScript, browser support, and transpilers—and separate actual JavaScript features from TypeScript, React, and tooling. Why did the language change, and which problems were those changes supposed to solve?

React/Frameworks - Episode 8 - Do You Actually Need a Framework?

Mon, 07 Sep 2026 00:58:40 +0000

After an entire series about frameworks, we finally ask the dangerous question: should you use one at all? The crew works through real project shapes—from a simple business site to an interactive scheduling dashboard—and looks at progressive enhancement, browser-native capabilities, performance, accessibility, security, team fit, existing codebases, and maintenance costs. The answer is “it depends,” but nobody gets to say that until we explain exactly what it depends on.

React/Frameworks - Episode 7 - React Frameworks — Why Is Next.js Standing Behind React?

Mon, 07 Sep 2026 00:57:54 +0000

React is a library that people call a framework, and now there are frameworks built around it. Excellent. Parisa, Jules, and Sabrina untangle the nesting dolls by exploring client and server rendering, hydration, React Server Components, Next.js and the App Router, "use client", server functions, caching, streaming, hosting, and what architectural complexity you're actually buying when you add a React framework.

React/Frameworks - Episode 6 - Vue and Angular — React Is Not the Only Answer

Mon, 07 Sep 2026 00:57:08 +0000

No framework cage match required. React, Vue, and Angular tackle many of the same UI problems but make very different decisions about how much structure and tooling they provide. The crew compares their component models, Vue's progressive approach, Angular's broader platform and dependency injection, ecosystems, accessibility, security, migration, and team considerations—without pretending one framework universally wins.

React/Frameworks - Episode 5 - The React Ecosystem — Why Do I Need Seventeen Other Things?

Mon, 07 Sep 2026 00:56:19 +0000

You learned React. Congratulations! Now please select a router, build tool, data-fetching strategy, form solution, state-management approach, styling system, testing tools, and possibly a small emotional-support animal. Parisa, Jules, and Sabrina map out the ecosystem around React, why the core library deliberately doesn't solve everything, and how to choose tools based on actual project requirements instead of stack astrology.

React/Frameworks - Episode 4 - Hooks and useEffect — Stop Synchronizing Nothing

Mon, 07 Sep 2026 00:55:32 +0000

Hooks are not magical React incantations, and useEffect is not the junk drawer where code goes when you don't know where else to put it. This episode explains what Hooks actually are, why effects exist, dependency arrays, cleanup, race conditions, refs, memoization, context, and custom Hooks—with a particular focus on recognizing when you don't need an effect at all.

React/Frameworks - Episode 3 - State — Why Didn’t My Variable Update the Screen?

Mon, 07 Sep 2026 00:54:49 +0000

You changed the variable. The screen did not care. Welcome to state. Parisa and Jules build the mental model behind React rendering: state updates, render snapshots, render versus commit, controlled inputs, lifting state up, immutable updates, stale closures, and how to decide what actually deserves to be state instead of storing every value you can get your hands on.

React/Frameworks - Episode 2 - Components, Props, and JSX — Whose HTML Is This?

Mon, 07 Sep 2026 00:54:04 +0000

React puts markup in JavaScript, invents components, and starts passing things called props around. Rude. This episode explains what JSX actually becomes, how React components work, why props are read-only inputs, component trees, children, lists and keys, and why mixing markup with behavior isn't necessarily the separation-of-concerns disaster it first appears to be.

React/Frameworks - Episode 1 - Who Asked for This? Why the Fuck Did We Need React?

Mon, 07 Sep 2026 00:52:45 +0000

Before React, websites were not helpless piles of rocks waiting to be rescued. So what changed? Parisa and Jules trace the path from server-rendered pages and jQuery to increasingly stateful browser applications, then unpack declarative UI, components, and the idea of UI as a function of state. Along the way: what React actually does, what it absolutely does not do, and why its model became useful enough to justify all this.

Modern CSS - Episode 14 - So… Do We Even Need a CSS Framework?

Mon, 07 Sep 2026 00:51:54 +0000

After fourteen episodes of discovering how much CSS can do by itself, it's time for the obvious question: do we still need frameworks? Parisa and Jules compare plain CSS, Bootstrap-style component systems, utility-first approaches, CSS Modules, CSS-in-JS, Sass, and PostCSS—not to crown a universal winner, but to build a practical way to decide whether a project's problems actually justify another dependency.

Modern CSS - Episode 13 - Animation Without Making Everyone Sick

Mon, 07 Sep 2026 00:50:52 +0000

Motion can communicate state and relationships—or it can make your interface physically unpleasant to use. This episode looks at transitions, keyframes, transforms, opacity, prefers-reduced-motion, View Transitions, scroll-driven animations, and when CSS versus JavaScript should control motion, with accessibility treated as part of the animation decision rather than an afterthought.

Modern CSS - Episode 12 - Modern Color — CSS Learned Math and Developed Opinions About Purple

Mon, 07 Sep 2026 00:50:07 +0000

Hex and RGB aren't the whole color story anymore. Parisa and Jules venture into modern CSS color with OKLCH, wider color gamuts, color-mix(), relative colors, gradient color spaces, alpha, gamut mapping, fallbacks, and design tokens—while making one thing very clear: fancy color math does not excuse you from actually testing contrast.

Modern CSS - Episode 11 - Logical Properties — CSS That Stops Assuming Everyone Reads Like You

Mon, 07 Sep 2026 00:49:24 +0000

margin-left seems harmless until “left” isn't actually the direction your interface needs. This episode explores CSS logical properties, inline and block directions, logical sizing and positioning, writing modes, bidirectional layouts, icons, and how flow-relative CSS can remove assumptions about language and reading direction from your layouts.

Modern CSS - Episode 10 - Tailwind — Why Are There 900 Classes in My HTML?

Mon, 07 Sep 2026 00:48:41 +0000

Utility-first CSS can be a genuine culture shock when you're used to semantic class names and separate stylesheets. Parisa, Jules, and Sabrina unpack what Tailwind actually is, why developers like it, how variants and its modern CSS-first approach work, where all those classes come from, and the real tradeoffs around composition, maintainability, accessibility, and dynamic class generation.

Modern CSS - Episode 9 - PostCSS — Wait, This Isn't Another Sass, Right?

Mon, 07 Sep 2026 00:47:55 +0000

PostCSS keeps appearing in modern build systems, often without anyone formally introducing it. This episode explains PostCSS as a CSS-processing pipeline, how plugins like Autoprefixer fit in, why Node is involved, how browser targets affect generated CSS, and why PostCSS isn't automatically a preprocessor or a magical “future CSS” translator.

Modern CSS - Episode 8 - Sass in 2026 — Are We Still Doing This?

Mon, 07 Sep 2026 00:47:15 +0000

Native CSS has variables, nesting, color functions, and increasingly powerful layout tools, so... do we still need Sass? Instead of holding a funeral for a perfectly functional preprocessor, Parisa and Jules examine what Sass actually does, which of its old jobs CSS has absorbed, what build-time features remain genuinely useful, and how to decide whether Sass is still earning its place in a project.

Modern CSS - Episode 7 - The Cascade Strikes Back — Specificity, Layers, Scope and Nesting

Mon, 07 Sep 2026 00:46:38 +0000

The cascade gets blamed for a lot of CSS misery, but the problem is often that nobody explained what the damn thing is deciding. Parisa and Jules unpack specificity and !important, then explore cascade layers, native CSS nesting, and @scope—different tools for controlling precedence, structure, and boundaries without building an even more elaborate specificity war.

Modern CSS - Episode 6 - Selectors Got Weirdly Powerful — :has(), :is(), :where() and Friends

Mon, 07 Sep 2026 00:45:53 +0000

CSS selectors have acquired some serious new tricks. This episode digs into :is(), :where(), :has(), modern :not(), forgiving selector lists, specificity, and the long-awaited ability to select elements based on what they contain—all while resisting the temptation to turn clever selectors into an unreadable crime scene.

Modern CSS - Episode 5 - Container Queries — The Component Finally Knows Where It Lives

Mon, 07 Sep 2026 00:45:13 +0000

Media queries know about the viewport, but reusable components don't always give a shit how wide the viewport is—they care about the space they're actually given. Parisa and Jules explain container queries, query containers, container units, size and style queries, progressive enhancement, and why this feature changes how we can think about truly reusable components.

Modern CSS - Episode 4 - Responsive CSS Without Seventeen Breakpoints

Mon, 07 Sep 2026 00:44:25 +0000

Responsive design doesn't have to mean collecting device breakpoints like Pokémon. This episode explores intrinsic layouts, min(), max(), clamp(), Grid's auto-fit and auto-fill, modern viewport units, content-driven breakpoints, and how letting the browser negotiate available space can eliminate a surprising amount of media-query micromanagement.

Modern CSS - Episode 3 - Flexbox and Grid — We Can Stop Abusing Floats Now

Mon, 07 Sep 2026 00:42:41 +0000

For years, web developers made layouts with a CSS feature designed to let text wrap around pictures. It was weird, but we survived. Parisa and Jules revisit the float years before digging into what Flexbox and Grid were actually designed to solve, how their layout models differ, and why choosing between them is less about picking a winner and more about understanding the relationship you're trying to describe.

Modern CSS - Episode 2 - CSS Variables — Oh, So Sass Variables Aren't the Same Thing

Mon, 07 Sep 2026 00:41:52 +0000

They both have “variables” in the name, but Sass variables and CSS custom properties fundamentally live in different worlds. This episode explores build time versus runtime, the cascade, inheritance, scope, fallbacks, computed values, and how custom properties can become a surprisingly powerful API for components.

Modern CSS - Episode 1 - What Happened to CSS?

Mon, 07 Sep 2026 00:40:29 +0000

CSS changed—a lot. If you learned it during the era of floats, clearfixes, browser hacks, and preprocessors, modern CSS can feel like somebody quietly replaced half the language while you weren't looking. Parisa and Jules trace how we got from old-school CSS to Grid, custom properties, container queries, and other native features, while sorting out browser support, progressive enhancement, and why there was never actually a “CSS4.”

Node/NPM - Episode 4 - What Actually Happens When You Run npm run dev?

Mon, 07 Sep 2026 00:37:05 +0000

Everyone knows npm run dev starts the project. That is not the same thing as knowing what the hell it actually does. Parisa and Jules trace the command from the terminal through npm, package.json, local binaries, Node, and Vite to show how a modern development server actually starts—and where the shell, package manager, runtime, and tooling each fit into the process.

Node/NPM - Episode 3 - package.json, node_modules & Dependency Hell

Mon, 07 Sep 2026 00:36:02 +0000

Why can you delete node_modules and magically bring it back? Parisa and Jules unpack the relationship between package.json, package-lock.json, and node_modules, including direct versus transitive dependencies, version ranges, lockfiles, reproducible installs, dependency trees, and how a perfectly reasonable package system occasionally turns into dependency hell.

Node/NPM - Episode 2 - npm — Composer, But Make It JavaScript

Mon, 07 Sep 2026 00:34:55 +0000

You type npm install, your terminal loses its mind, and suddenly thousands of files appear. What actually happened? This episode explains what npm is, why package managers exist, how dependencies and package registries work, and why modern JavaScript projects stopped downloading random ZIP files and copying libraries into folders by hand.

Node/NPM - Episode 1 - Node.js — Who Let JavaScript Out of the Browser?

Mon, 07 Sep 2026 00:33:28 +0000

JavaScript used to live in the browser. Then Node showed up and suddenly JavaScript could run servers, command-line tools, build systems, and half the modern web-development ecosystem. Parisa and Jules break down what a JavaScript runtime actually is, why Node exists, what it gives JavaScript outside the browser, and why installing Node somehow became step one of making a website.

Typescript - Episode 9 — Put It in a Real Project

Mon, 07 Sep 2026 00:29:38 +0000

Knowing TypeScript syntax is one thing. Deciding whether and how to use it in an actual codebase is another. Parisa and Jules cover gradual adoption, JavaScript and TypeScript living together, third-party type declarations, untrusted network data, a quick look at TSX, migration strategy, and the situations where TypeScript genuinely pays rent.

Typescript - Episode 8 — Who Invited the Compiler?

Mon, 07 Sep 2026 00:28:44 +0000

TypeScript is more than type annotations — there is also an actual toolchain involved. This episode sorts out tsc, tsconfig.json, strict mode, targets, modules, emitting JavaScript, source maps, type dependencies, and the difference between the type checker, compiler, transpiler, bundler, and runtime.

Typescript - Episode 7 — The Escape Hatches Department

Mon, 07 Sep 2026 00:27:52 +0000

What happens when you really want TypeScript to stop asking questions? Parisa and Jules tour any, unknown, type assertions, the non-null assertion, and never, including when these tools are genuinely useful and when they are just creative ways to disable the smoke detector.

Typescript - Episode 6 — The Reusable Type Machine

Mon, 07 Sep 2026 00:26:56 +0000

Generics can look like algebra wandered into your JavaScript, but the idea is simpler than the angle brackets suggest. This episode explains type parameters, generic functions, constraints, generic types, built-in generics, and how generics preserve relationships between values without throwing away useful type information.

Typescript - Episode 5 — Functions Have Boundaries

Mon, 07 Sep 2026 00:26:02 +0000

Functions are where values enter, leave, and occasionally return later with consequences. Parisa and Jules look at parameter types, return types, optional and default parameters, rest parameters, callbacks, function types, void, methods, this, and why function boundaries are one of the places TypeScript can earn its keep.

Typescript - Episode 4 — Please Describe Your Object

Mon, 07 Sep 2026 00:25:09 +0000

How does TypeScript decide whether an object has the right shape? This episode covers structural typing, object literal checks, optional and readonly properties, type aliases, interfaces, arrays, tuples, and the important difference between describing data well and simply making the compiler stop complaining.

Typescript - Episode 3 — It Can Be a String or a Number. Now What?

Mon, 07 Sep 2026 00:24:00 +0000

Sometimes a value really can be more than one thing. Parisa and Jules explore union types, narrowing, control-flow analysis, null, undefined, optional values, literal types, discriminated unions, and why TypeScript needs proof before it lets you treat a value as something more specific.

Typescript - Episode 2 — JavaScript Already Has Types, So What the Hell?

Mon, 07 Sep 2026 00:22:31 +0000

JavaScript already has strings, numbers, booleans, objects, undefined, null, and more — so what does TypeScript mean when it talks about types? This episode separates runtime types from static types, digs into inference, arrays, function boundaries, and explains what TypeScript is actually adding to JavaScript.

Typescript - Episode 1 — JavaScript With a Complicated Little Hat

Mon, 07 Sep 2026 00:06:22 +0000

TypeScript looks a lot like JavaScript wearing extra paperwork, so what problem is it actually solving? Parisa and Jules break down what TypeScript is, why developers wanted it, how static checking differs from runtime behavior, what type inference does, and where TypeScript can help without pretending it magically prevents every bug.