The Beer Driven Devs

Liam walked into a client site with a problem nobody could crack. Twelve months of effort, no progress, and a manager asking why.

Then two different people described the same problem to him — one said complicated, the other said complex — and the entire thing came apart in his hands.

Most people use those two words interchangeably. They are not interchangeable. They describe fundamentally different classes of problem, and the methods that reliably solve one will reliably fail on the other. If you’ve ever sat in a room watching a team run the same play for a year with nothing to show for it, there’s a decent chance the problem was never the plan. It was the diagnosis.

This episode is about the framework that makes that distinction, and what happens when you start pointing it at everything.

We talk about:

Matt also admits to reading up on Cynefin a fortnight ago for entirely unrelated reasons, which is either uncanny timing or evidence that we share a brain. Neither option is reassuring.

Also: ADAConf is coming up. Matt will be there volunteering, wearing the glasses and the shirt, handing out stickers. Liam will not, which he is appropriately sour about.

🏷️ Listener discount: Use “BDD15” at the checkout for a 15% discount

Matt — Aldi scotch 🥃 (the decent stuff ran out and there’s no resupply until Christmas)

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

Back in January we asked a panel whether there was a future career for software developers in the age of AI.

Eight months later, Matt thinks we have an answer. He doesn’t think anyone’s going to like it.

This is a darker episode than usual, and deliberately so — not a hot take, not a doom spiral, and not another round of reassurance. Matt starts with the part he has the most skin in: a ten-year plan to make a living from small consumer software, built entirely on the assumption that people can’t build those things themselves. That assumption died this month.

Four things landed in the same week, and the timing is the story:

None of these on its own is the bombshell. All of them inside one week is.

The question is no longer whether proprietary software survives. It’s whether universal capability stays universal, or whether the people who own the infrastructure underneath it quietly re-dig the moat.

Matt’s also honest that all of this is speculation built on a week of anecdotes — which is why we end on the historical precedents for getting this exact call wrong, including a famous warning that turns out to be a myth, and has survived eighty years of being debunked anyway.

🍻 Tonight’s Drinks

Matt — a fever and a sunburn.

🔗 Links from the episode

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

Our Prime Minister got in front of the media this week to talk about unauthorised access to a Medicare system. So naturally we opened the articles and started asking questions.

What actually happened here? Was anything really hacked, and how secure was it? How secure should it have been? And how worried should any of us be about “rogue” AI agents?

The incident also arrives at a convenient moment for an industry currently falling over itself to tell the world how terrifying its own technology is — a story that happens to serve the people already holding the technology.

We get into:

These aren’t questions two mates can solve over a beer (or not, see below), but the bigger question we can’t escape is one of liability. And while we may not have an answer to that question, the people that claim to are the ones who most seem like they should be kept out of it. And this is definitely not the end of the conversation!

Matt: Lagavulin 🥃

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

This one starts as a correction and doesn’t stay one.

Last episode, talking about auth, Matt said that after the IdentityServer licence change Microsoft “closed ranks” and stopped taking third-party dependencies in their templates. A re-listen flagged it as something worth revisiting. Then, working on something unrelated, he hit the example that settles it outright — and once you’ve seen one, they’re everywhere.

So that’s the correction. It takes about ten minutes.

The rest of the episode is what the correction opened up.

Microsoft put IdentityServer into the ASP.NET Core templates. Overnight, two blokes became responsible for the support and maintenance of millions of developers and an unknown number of commercial products.

Did anyone ask them if they wanted that?

We get into:

Then, live on the recording and for entirely unrelated reasons, Matt opens a repo and finds an announcement neither of us had seen.

That sends the back half somewhere we didn’t plan: whether an honesty system can fund open source when auditing your own dependency tree is this painful, what the streaming wars taught us about convenience beating enforcement, and one very specific thing we noticed about a file in the Aspire repo that we couldn’t explain on the night.

This is the third time we’ve revisited this topic, after one and two years for prior episodes, so we’re right on schedule — once from the community’s side, once from the maintainer’s, and once with Jimmy. And it’s still a big ball of open questions. We’re closer than we were. We’re not there.

Waters all round

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

Matt has spent the better part of a year circling a side project to build his own identity provider. Then, one afternoon this week, he realised he was solving the wrong problem, and that the solution he actually needed is one we all used to reach for without thinking.

This episode is the story of that realisation, and where it leads.

We start with a fast tour through how we got here — basic auth, forms and cookies, the shift to SPAs, OAuth 2, OIDC, JWTs and the well-known discovery document — and end up at the awkward corner .NET developers have been standing in since IdentityServer stopped being free: you own the whole app, you don’t want Entra, so what do you actually do?

That’s the jumping-off point for the bigger question: what else have we been conditioned to believe is too hard, too dangerous, or too high-risk — that we actually already know how to do?

We cover:

🍻 Tonight’s Drinks

🔗 Tonight’s Links

Thumbnail attribution: Password 123456 written on a paper von Marco Verch unter Creative Commons 2.0

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep the mics on.

Cheers! 🍻

This week Liam takes the mic — and the segue of a lifetime — to tell the story of a framework he unapologetically loves: WPF.

It’s part personal history, part technology retrospective, and part quiet argument that the ideas WPF introduced never really went away. They just changed frameworks.

We start in 2005, with a beautiful Mac network monitoring tool, a very ugly WinForms companion app, and the tantalising promise of something Microsoft was calling Avalon. From there we walk forward through the moments that shaped modern .NET UI development.

Along the way we get into:

There’s a soft landing at the end about Xamarin’s journey into MAUI, Liam’s very first MAUI UI July post; which was — of course — partially about WPF.

If you’ve ever bound a property, wrangled a DataTemplate, or felt a small flicker of joy the first time a Style did exactly what you wanted — this one’s for you.

No drinks tonight — just Liam’s notes, Matt’s memory, and a healthy dose of nostalgia.

Any Likes 👍, Shares 📣, Subscriptions 🔔 and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

Matt stumbled across a famous John Carmack email from 2007 — the one where he asks his team to start thinking about inlining their functions — and couldn’t stop thinking about it. So this week we sat down to pull it apart.

On the surface it reads like a hot take on code style: stop breaking everything into small functions, inline the logic, use big comment blocks instead. Easy to dismiss, easy to misread. Matt read it, formed a confident take, went back and re-read it, and discovered his first take was wrong. That gap, between what the email seems to say and what it’s actually getting at, is where the whole conversation lives.

Because the real message isn’t “inline everything.” It’s think about it. And once you take that seriously, one short email starts asking uncomfortable questions about state, consistency, and why we trust the advice we trust. What does it mean to write code with no surprises? When is running code you don’t need the safer choice? And why does a technique that’s obviously right for a game’s core loop feel obviously wrong for the software the two of us actually build?

That last question turns out to be the point. Carmack isn’t handing down a rule; he’s showing his working for a specific set of constraints, and trusting his readers to notice their own constraints are different. Which is exactly the part our industry is worst at: we take “here’s how I do it” and turn it into “here’s how it’s done,” pattern by pattern, until blind adherence becomes its own anti-pattern.

And then there’s the human sting in the tail. Carmack signs off the whole thing with a single word — “Discussion?” — inviting his team to push back. It’s a lovely gesture. It’s also, we suspect, a little naive about what happens when someone that senior “invites discussion.” Sometimes the most powerful person in the room can’t make a suggestion at all, no matter how they phrase it.

No grand thesis, no neat landing. Just two mates thinking out loud about a genuinely great piece of writing; which, fittingly, is all Carmack was ever asking for. We barely scratched the surface, and we’d genuinely love to hear what it stirs up for you.

🍻 Tonight’s Drinks

Liam – Neither beer nor scotch this week (the garage beckoned, the scotch cupboard was bare). Just a driven dev.

🔗 Links from the episode

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

This one starts with Matt eating his words from It’s time to let JavaScript go, but the admission is just the door in. What’s on the other side is a longer, harder look at security fatalism: why the entire software world runs on code nobody can fully check, why even careful people keep running install scripts they haven’t read, and why that behaviour is rational rather than reckless. Shai-Hulud, a supply-chain worm we’ve seen before, now spreading beyond JavaScript into other ecosystems in what Matt calls a zoonotic spillover, gives it all a nasty topicality, but the real question underneath is about trust, and where you can honestly draw the line.

We get into:

No neat bow, and no silver bullet; just an honest map of how we got here and where the fuzzy line might sit.

Matt – A pint of Clone and Wood (his own homebrew — he felt he’d earned it)

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

First things first: an apology. After three-plus years and 73 episodes without missing a drop, we finally missed one. Turns out even the Beer Driven Devs need a break sometimes.

Refreshed and back at the mics, Matt goes full tech historian this week. While researching a long-form essay for his blog, he went down a rabbit hole on the history of CPUs and GPUs, and came back with a story that runs from the Amiga’s dedicated graphics chips all the way to today’s AI-fuelled GPU gold rush.

We cover:

The through-line of the whole story: constraints drive innovation, and the current kings can be dethroned. They always have been before.

🍻 Tonight’s Drinks:

🔗 Tonight’s Links:

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻

Matt’s back from /NEW Conference in Newcastle and has a lot to unpack. Liam missed out this year, so this episode is a whistle-stop debrief of the highlights: talks, panels, stickers, and a few recurring themes that kept surfacing across the two days.

The conference theme was Human in the Loop, and while Matt deliberately stuck to the non-AI track, AI still found its way into nearly every conversation. Not because it was forced, but because the same questions kept coming up: who’s in control, who’s being listened to, and why do we keep ignoring the lessons we already know?

We cover:

A lot of ideas circled the same centre: the problems aren’t new, only the substrate has changed. And if we’d been doing what we said we were doing all along, most of the hard parts wouldn’t be hard at all.

No beers tonight, Liam’s still recovering from a recent night out at Sunday Road Brewing, and Matt’s running on conference afterglow and not much else.

Any Likes 👍, Shares 📣, Subscriptions 🔔, and Love ❤️ go a long way to helping us keep doing this for fun.

Cheers! 🍻