Here's a fresh collection of links and quick takes from my recent reading, and this one has a nice mix worth your time. The big highlight for me is seeing both Syncfusion and Infragistics bring their component libraries to Blazor under the MIT license, but there's also plenty on serverless Azure, Docker sandboxes, and the practical realities of going AI-first at work.
From Cloud-First to AI-First: Productivity-Maxxing or Token-Maxxing? (Dewan Ahmed) - Using AI globally and safely at work requires governance and some agreement on roles and permissions... Just like a migration. This post summarizes sessions that help with planning and that approach
Bonjour, hi! I've been building an app for a little while, and I finally recorded a video that shows how to actually play with it. Here it is.
First, the game
I didn't invent the game. 2D6 Dungeon was created by Toby Lancaster, and it's a dice-and-paper dungeon crawler. You roll dice and use that randomness to create rooms, discover what's in them, fight creatures and gain experience (XP).
You play with two books: one holds the rules, and the other is full of tables you roll on. There are also expansions. Everything is available in print and as PDF, which is what I used when I was live coding so viewers could follow along.
A companion, not a digital version
This app is not a digital version of the game. It's a companion app. I wanted to be able to play on the couch, in bed, or in the car (assuming you're not the driver), all places where throwing dice and drawing on a piece of paper isn't very convenient. Playing stays very manual on purpose, which is why it's called the 2D6 Dungeon companion App and not the 2D6 Dungeon game.
How it's built
This isn't a one-shot AI-generated app. I've been crafting it for a long time, in my spare time and during my live streams. It's written in C# with Blazor and Fluent UI, stores everything in MySQL, and runs in containers orchestrated with .NET Aspire. You can run it locally (Docker works if you don't want to install anything) or deploy it to Azure Container Apps.
The code is open source and available on GitHub. If you just want to give it a try, there's also a hosted version. It runs on a very tiny server and I clean up the existing games roughly every week, so please don't use it for a game you want to keep. It's only there so people can try it.
What's in the video
Rolling dice with pen, paper and books is a bit different from using an interface, so the video plays through the start of a game in the app. I create an adventurer, roll the dungeon entrance, open doors with the room wizard, look up results in the tables, adjust a room on the map, and fight a couple of creatures, then save and reload the adventure.
Feedback welcome
A big reason I made this video is to get feedback. If something weird happens, if it doesn't match the rule book, or if you can't get it running, open an issue on GitHub (screenshots help a lot) or find me on Discord. I'd especially like to hear from people playing on a tablet, since that's what it was designed for. And of course, you'll need the books to play: the game is available from DR Games, and Toby often streams himself playing it with dice and paper.
Another week, another batch of links that caught my attention, and this one covers a lot of ground. From AI agents on Kubernetes and a security incident that should make every developer pause, to the authentication changes coming in .NET 11 and a sharp argument that slow software is a design problem rather than a language problem. Here's what I found worth sharing.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Welcome back for another round of Reading Notes, the weekly list of links I wish I had found sooner. This edition leans into .NET performance with CBOR and NativeAOT, includes what you need to know before touching Xcode 27 in your MAUI apps, and answers the question everybody keeps asking about the Copilot SDK. Skim the headings and jump straight to whatever catches your eye.
This week’s Reading Notes covers key updates ranging from new Blazor AI components that handle agent UIs to Docker announcements you definitely shouldn’t have missed at the recent WeAreDevelopers event. I also recommend checking out resources on why SDK integrations like Squad now support HydraFusion and how MCP servers might help restore our speed with Aspire infrastructure work today.
Programming
Build Agentic UI with the new Blazor AI components (Daniel Roth) - A second set of AI-packed components for Blazor. Just like the first time, it looks very useful, assuming they match the scenario in your applications
Console and worker apps | Aspire - I used to spend my days around Azure resources and IaC files, but much less recently. This MCP server is, I believe, what will help me get back to my speed
This week we have a collection of tools and articles that genuinely improve how we build software and manage our daily workflows. From automating pre-push checks to refining SQL formatting, these notes share practical wins for the modern .NET developer. Give them a read through before your next commit or sprint starts.
A faster, lighter C# Dev Kit - .NET Blog (Drew Noakes) - Understand better all the goodness in this upcoming new release of our beloved VS Code extension, C# Dev Kit
Volunteers Don't Quit. They Fade. (Henk Boelman) - Communities are so important; would it be in person or online. We really need to learn how to be better at keeping a healthy balance
I have a confession to make. For years, every time I had to write or edit a SQL INSERT statement, I did the same little dance: put my cursor on a value, count the commas, scroll back up to the column list, count again, and hope I landed on the right spot. Then I'd change the value... and still not be 100% sure it was the right column.
With three or four columns, fine. But give me a table with fifteen columns and a few rows of data, and I'm suddenly back in school, counting on my fingers.
So I built Rainbow SQL, my very first VS Code extension. 🎉
The idea: just give me matching colors
The idea was simple. If every column had its own color, and every value used the same color as its column, I wouldn't need to count anything anymore. I could just see it.
Here's what that looks like:
health_points is blue, so the blue value is the health points. That's it. No more counting commas.
It works whether your statement is on one long line, or nicely formatted across multiple lines with many rows:
Every id gets the same color, every code gets the same color, and so on, all the way down.
"But which column is this, exactly?"
Colors are great, but sometimes you want to be sure. So I added a little hover popup. Put your mouse over any value and Rainbow SQL tells you the column number, the column name, the table, and which row you're in.
And if you're more of a keyboard person (like me most of the time), the active column also shows up in the status bar while you move your cursor through the statement.
A small bonus: catching mismatches
While building it, I kept running into a second classic mistake: one value too many, or one value missing. You know, the kind of error that only shows up when you run the script... and of course it's on row 47.
Let me be clear: Rainbow SQL is not a SQL validator, and it doesn't try to be one. But when the number of values in a row doesn't match the number of declared columns, it highlights that row in red so you can spot it right away.
Row 2 is missing a value, row 3 has an extra one. Both jump out immediately.
The rest of the goodies
Here's a quick tour of everything that's in there:
Matching column and value colors to follow each column through one or more VALUES rows.
Single-row and multi-row statements, on one line or across many.
Column details on hover: column number, name, table, and row position.
Active column in the status bar while you move through a statement.
Mismatch detection for rows with too many or too few values.
Theme-aware colors, with separate palettes for light and dark themes. And yes, you can customize them.
SQL-aware parsing that handles quoted values, comments, nested expressions, and the usual identifier quoting styles.
It activates for SQL, PostgreSQL, MySQL, PL/SQL, T-SQL, and SQLite files. And if you ever want a break from the rainbow, run Rainbow SQL: Toggle Rainbow SQL Highlighting from the Command Palette.
Give it a try (and tell me what you think!)
Rainbow SQL is free and available now on the Visual Studio Marketplace:
Or install it directly from VS Code: open the Extensions view (Ctrl+Shift+X), search for Rainbow SQL, and click Install.
If it saves you a few minutes of comma counting, I'd really appreciate it if you left a review on the Marketplace. It's my first extension, so every rating and comment means a lot, and it helps other people find it too.
Found a bug or have an idea? The code is on GitHub at fboucher/vscode-rainbow-sql, and issues are very welcome.
This week’s highlights bring together some practical programming improvements, thoughtful reflections on the craft of coding, and a few interesting ways to work with AI. From open-source Blazor controls and smarter CSS optimization to Claude Code routing, Docker Sandboxes, and better secrets management, there’s plenty here to explore and put to use.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
This week's reading notes cover a nice mix of AI, programming, and databases, with a few pieces that stuck with me longer than I expected. On the AI side there's a new kind of model, a book about Nvidia and Jensen Huang that I thoroughly enjoyed, and an experiment where coding agents chose Azure SQL. On the .NET side, Stephen Toub is back with his annual performance post, and I finally found the Swagger vs. Scalar comparison I'd been looking for.
A summer of AI optimization (Daniel Lemire) - Every medal has two sides; this is the story of the bright one.
Programming
Docker at WeAreDevelopers: Partner & Customer Sessions (Leon Jones, Eli Aleyner) - WeAreDevelopers event occurred 23-25sept and there were many interesting sessions .Will some of them be available online? Or maybe I need to remember for next year.
I enjoyed learning about Nvidia's backstory and the entire semiconductor/chip industry. Jensen Huang is clearly a smart man with a keen sense for business.
When I stepped into a role with many APIs to ramp up on, I needed a faster way to explore endpoints, chain calls, and inspect responses without bouncing between tools.
The VS Code extension REST Client (humao.rest-client) helped me do exactly that. It lets you send REST and GraphQL requests directly from .http files in VS Code.
In this post, I will share the workflow I use to learn APIs quickly: keep requests close to code and notes, reuse values across calls, and avoid unnecessary copy-paste.
To start, create a .http file and add your requests there. Separate requests with ###; that separator is what makes the Send Request link appear above each request block.
Yes, you can use AI or tools like Postman and Insomnia to generate requests. But when your goal is to learn an API, it helps to keep everything close to your code and notes. I already had VS Code open all day, so I decided to keep my full API learning workflow there.
In my case, every API call is secured and requires an access token, so generating one is step zero.
I could paste one token at the top of the file, but that approach breaks quickly: tokens expire, and pasted values can accidentally be committed or pushed.
That is why I keep credentials in a local .env file (for example: CLIENT_ID, CLIENT_SECRET, and TENANT_ID) that is listed in .gitignore.
Then I created my first request to generate an access token from those values:
POST https://login.microsoftonline.com:443/{{$dotenv TENANT_ID}}/oauth2/v2.0/token
Content-Type: application/x-www-form-urlencoded
client_id={{$dotenv CLIENT_ID}}&scope={{$dotenv CREDS_SCOPES}}&client_secret={{$dotenv CLIENT_SECRET}}&grant_type=client_credentials
Quick breakdown: each {{$dotenv ...}} expression reads a value from your .env file, so you keep secrets out of your .http file and out of source control.
{{$dotenv TENANT_ID}} -> TENANT_ID
{{$dotenv CLIENT_ID}} -> CLIENT_ID
{{$dotenv CLIENT_SECRET}} -> CLIENT_SECRET
To execute the call, click the Send Request link above the request. The response opens in a new tab, and you can inspect the access token in the body.
Then you can use that token in the next request:
GET https://ecostruxure-building-platform-api-uat.se.app/api/Sites
Authorization: Bearer {{ACCESS_TOKEN}}
X-Api-Version: {{apiVersion}}
To avoid copy-pasting values, the better approach is to name requests and reference their responses as variables:
Notice the @name createToken labels that request. After it runs, you can access fields from its response body. The response content is JSON and looks like this:
For example, to retrieve the access_token value, we can use the expression createToken.response.body.$.access_token. When assigned to a variable, it looks like this:
Then you can use {{ACCESS_TOKEN}} in all your requests, like this one that retrieves all buildings:
### ==============================
#### Retrieve my sites
# @name getBuildings
GET https://ecostruxure-building-platform-api-uat.se.app/api/Buildings
Authorization: Bearer {{ACCESS_TOKEN}}
X-Api-Version: {{apiVersion}}
If you come back later and the token has expired, just run the token request again, and the variable {{ACCESS_TOKEN}} will automatically update for all subsequent requests. No copy-pasting required.
Extracting a value from a list response
What if a response returns multiple items and you need one specific ID?
For example, the previous query returns multiple buildings, but I was interested in the building named "Virtual Building FB". The response looks like this:
To get the value of the id property for one building with a specific name, we can filter with JSONPath:
@buildingId={{getBuildings.response.body.$[?(@.name=='Virtual Building FB')].id}}
This uses the previous request response (getBuildings) and extracts the matching id.
ℹ️ NOTE: If this is your first time seeing JSONPath, read it like this:
$ means "start from the root of the response body."
[?()] applies a filter.
@.name=='Virtual Building FB' keeps only objects where name matches.
.id returns the id field from the matched object.
Then use {{buildingId}} in the next request:
### ==============================
### Retrieve all floors within a specific building
# @name getFloors
GET https://ecostruxure-building-platform-api-uat.se.app/api/Buildings/{{buildingId}}/Floors
Authorization: Bearer {{ACCESS_TOKEN}}
X-Api-Version: {{apiVersion}}
GraphQL is powerful here because you can request related data in one call instead of chaining multiple REST endpoints.
In short: if you are learning a new API, REST Client helps you move faster with less context switching. Keep your requests in a .http file, reuse values with @name + {{...}}, and iterate directly in VS Code.
Lately, this workflow has been even more useful as my day-to-day work includes broader platform discussions and faster discovery cycles.
If useful, I can share a follow-up .http starter template that you can adapt to your own APIs.
Show Me
You prefer watching a video? I got you here a video I did sharing the how I use REST Client extension.
This week's collection highlights practical advice for managing Azure Service Bus and making more cost-effective choices when selecting AI models. I have also gathered some useful perspectives on layered security for authentication and the nuanced debate surrounding SQL foreign key constraints.
Getting started with GitHub Copilot Spaces - I confess, I'm one of those who didn't realize (or know) that space was included in my GitHub Copilot subscription. Interesting feature!
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
This week’s collection explores the practical side of AI, focusing on governance in multi-model environments and the security advantages of robust sandboxing. I’ve also included some foundational perspectives on and organizational goals, along with a look into the history of one of my favorite tools, VS Code.
AI
James Shore: Are You Getting Your Money’s Worth from AI? (James Shore) - Interesting first post of a series. This one focuses on what we should or shouldn't measure to see and understand the performance of our teams using AI.
6 Benefits of Sandbox Environments (Kevin Wittek, Srini Sekaran) - I really like how this post explains the security issues, how Docker sandboxes address the weaknesses, and how its sandboxes differ from others.
That book has been on my to-read list for a very long time. As someone who worked at Microsoft using many OKRs, I was comfortable with the topic. Nevertheless, it was interesting to learn how other people use it in many different contexts.
I’ve put together a few articles that caught my attention this week, ranging from .NET updates and Azure migration paths to the nuances of AI evaluation workflows. These pieces offer practical insights into the tools and design choices we encounter in our daily work.
Building Reproducible AI Evaluation Workflows with Docker Sandboxes (Karan Verma) - Wow! Very interesting open-source project that tries to help with the question: before comparing benchmark scores or choosing a judge model, can someone else reliably run the same workflow under comparable conditions? Definitely worth the read.
What is YOLO Mode? - Yolo mode is the most productive way to use AI. It is better for developer habits and the brain, but it also comes with some risks. This nice post provides clarity on the topic.
Programming
The best dark mode toggle is probably none (Lea Verou) - You could think that this little theme toggle is a simple thing, but you would be wrong. Interesting post that explains all the thoughts behind that design.
This week’s collection covers everything from streamlined Azure deployment techniques to the practical realities of local versus cloud AI models. I have also gathered several helpful resources for .NET developers and some thoughts on maintaining sharp mental habits in an increasingly automated world.
No, local models will not win (sean goedecke) - I agree that local models won't replace cloud ones, but disagree and think local models usage will grow. Not only for niche operations but also for simple tasks.
Why the GitHub Copilot app became my daily driver (AJ Bajada) - When the app came out, I was pulled to it that much. Now that I have multiple accounts, and often run multiple sessions... This post shares features I did know GH app had...I have to give it a try
How to keep thinking (Sam Basu) - Brain push-ups have always been important. But with the bad habits that AI "forces" us to use, it's more than ever.
This week’s collection highlights several key advancements in Azure performance, the nuances of orchestrating multiple AI agents, and critical updates to NuGet security. These pieces offer practical insights for anyone looking to streamline their development workflow while maintaining a more secure infrastructure.
Cloud
Azure Service Bus: Count your filters (Daniel Marbach) - Great deep post about performance. The architecture and number of filters can and will greatly affect the performance.
This week’s notes focus heavily on the practicalities of building reliable AI agents, specifically looking at how we manage their memory and governance. I have also included a few notable wins in Azure storage performance and some honest reflections on where our industry is heading next.
AI
AI Governance: Runtime Enforcement, Not Runtime Advice (Karan Verma) - I'm impressed by our journey of using AI. Not long ago, we barely trusted it, and now it's running independently, and we think more about limiting what it can do. Nice second post o to a series.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
I’ve gathered a few insightful pieces this week exploring smarter ways to manage AI costs, practical hardware setups, and the foundational logic behind better programming. Each link offers a different perspective on how we can refine our workflows and think more intentionally about the tools we use every day.
Set up OpenClaw on your Raspberry Pi (Lucy Hattersley) - Tease about a very interesting post (available in the Raspberry Pi Official Magazine) more to come
The Power Of “Why?” (codemanship) - A great post that reminds us that asking the right question helps us understand the real need and build better solutions.
This week's highlights bring together insights on evolving API security, the realities of integrating AI into your workflow, and tools that can help streamline the testing process. I selected these pieces for their practical advice on simplifying everyday development tasks while building more robust and resilient infrastructure.
Programming
Web Application & API Protection: An Overview (John Brawner) - I knew many security tools existed, and obviously I use some. But I learned a lot in this post. WAAP emerged because WAF alone was not enough to address APIs, bots, DDoS, and modern cloud traffic patterns in a single runtime protection model.
AI is ready. Your APIs probably aren't (Matt Gray) - Postman has always been an interesting tool. I've been using something else for a while but am thinking about exploring it again!
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
This week's collection highlights several practical upgrades for your workflow, ranging from cleaner C# patterns to more secure ways to manage AI agents. I’ve also included a few podcast episodes and articles that offer some much-needed perspective on productivity and community life.
AI
Why AI Agents Need Isolation with Docker SBX (Karan Verma) - Power comes with responsibilities. It's well known (at least for Spider-Man fans), but more seriously, AI users have a simple way to stay safe. And now, with "the kits", it looks like it's even easier.
Using AI to Build a Blazor App 1: Start With the Problem (Jon Hilton ) - It's so true that AI doesn't always do or act the way we expect. In this case, I wonder if a different model would have been better. In my experience, GPT is better at doing things compared to brainstorming.
New: Versioned CLI and SDK Docs (Cam Soper) - That's a nice feature that more should implement! You pick your API version, and the documentation follows.
Goodbye, forever, probably. (Salma) - Sad news for the communities, but at the same time, it's because of those same communities. This post shares a very sad portrait of the online world that affects many people.
This week’s collection features a mix of critical .NET lifecycle updates and practical strategies for optimizing your database interactions. These selected articles offer helpful insights into everything from edge computing deployments to the evolving landscape of AI in modern workflows.
AI
AI Raised the Bar (And Now We're All Tired) (Golnaz) - It's so true! So much can be done quickly today. An interesting question is: how do we avoid burning out resources and tokens? How, as human we stay smart? After all, life is a marathon, not a sprint!
EF Core vs Dapper in .NET: When to Use Each (Nick Cosentino) - Great post for developers or architects planning a future project. Both tools are great, so the decision factor depends on the context.
