.NET 11 porta con sé centinaia di ottimizzazioni, ma la domanda interessante è: quanto può diventare più veloce il nostro codice senza che noi cambiamo nulla?
In questa puntata parto dal gigantesco post annuale di Stephen Toub sulle performance di .NET 11 per capire cosa sta migliorando nel JIT e nel runtime, passando anche per Runtime Async e alcune ottimizzazioni che possono avere un impatto sulle normali applicazioni ASP.NET Core.
Il punto però non è dire che ".NET 11 è il 20% più veloce": i benchmark misurano scenari specifici e il risultato reale dipende sempre dal nostro workload.
Ma è interessante capire quanto lavoro riesca ormai a fare il runtime per ottimizzare automaticamente il codice che abbiamo già scritto. 

• https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-11/
• https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-11/runtime
• https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-11/

#dotnet #dotnet11 #performance #runtime #jit #runtimeasync #aspnetcore #csharp #softwaredevelopment #developers #programming #dotnetdeveloper #dotnetinpillole #podcast

Nella scorsa puntata ho parlato di come scegliere tra modelli AI diversi all’interno delle nostre applicazioni.
Ora GitHub porta un concetto simile dentro Copilot con Project HydraFusion: invece di scegliere un singolo modello, può orchestrare più modelli durante lo stesso task, cercando il compromesso migliore tra qualità, costo e velocità.
In questa puntata parlo di come funziona questo approccio, delle differenze rispetto al model routing che possiamo implementare noi e, soprattutto, di quanto controllo siamo disposti a lasciare al provider.

• https://github.blog/ai-and-ml/github-copilot/project-hydrafusion-frontier-quality-via-multi-model-orchestration/
  
  
• https://github.com/orgs/community/discussions/206492
  
  
• https://docs.github.com/en/copilot/concepts/agents/copilot-cli/rubber-duck
  
  
• https://docs.github.com/en/copilot/concepts/models/auto-model-selection
  
  

#GitHubCopilot #HydraFusion #ProjectHydraFusion #AI #ArtificialIntelligence #GenerativeAI #LLM #MultiModel #ModelRouting #AIOrchestration #CodingAgents #GitHub #Copilot #DotNet #CSharp #SoftwareDevelopment #Developers #SoftwareArchitecture #DeveloperTools #DotNetInPillole #Podcast

Un solo modello AI non basta più? In questa puntata parlo di routing e failover in Microsoft.Extensions.AI: come scegliere tra modelli diversi, gestire provider alternativi e capire quando queste nuove primitive servono davvero senza complicare inutilmente l’architettura.

• https://devblogs.microsoft.com/dotnet/routing-and-failover-for-microsoft-extensions-ai/
  
  
• https://learn.microsoft.com/en-us/dotnet/ai/ichatclient#chat-routing-experimental
• https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.ai.routingchatclient

#dotnet #MicrosoftExtensionsAI #ArtificialIntelligence #AI #GenerativeAI #LLM #CSharp #DotNetDevelopers #SoftwareArchitecture #Routing #Failover #AzureOpenAI #OpenAI #SemanticRouting #DotNetInPillole #podcast

In questa puntata parlo di una delle novità più interessanti di Blazor con .NET 11: la possibilità di mettere in pausa i circuit inattivi e ripristinarli quando l’utente torna sull’applicazione. Questo permette di liberare risorse lato server quando una tab rimane inutilizzata, migliorando uno degli aspetti più delicati della scalabilità di Blazor Interactive Server.
C’è però anche un altro aspetto interessante: con il server-triggered pause è il server stesso a poter chiedere la sospensione dei circuit, aprendo scenari utili per graceful shutdown, rolling deployment, instance draining e CI/CD

• https://learn.microsoft.com/en-us/aspnet/core/blazor/state-management/server
• https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-11

#dotnet #dotnet11 #blazor #blazorserver #aspnetcore #csharp #blazorwebapp #interactiveserver #signalr #circuit #scalability #webdevelopment #softwaredevelopment #developers #programming #dotnetdeveloper #gracefulshutdown #rollingdeployment #cicd #dotnetinpillole

La validazione non è sempre sincrona. Controllare che un campo sia obbligatorio o che una stringa abbia una certa lunghezza è semplice, ma cosa succede quando per validare un dato dobbiamo interrogare un database o chiamare un servizio esterno?
Con .NET 11 arriva finalmente il supporto alla validazione asincrona. In questa puntata vediamo cosa cambia, come si integra con ASP.NET Core e Blazor e soprattutto in quali casi può essere realmente utile.
Perché poter fare una validazione asincrona non significa che dobbiamo trasformare ogni regola di business in un validator.

• https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-11/overview
• https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-11
• https://learn.microsoft.com/en-us/aspnet/core/fundamentals/validation?view=aspnetcore-11.0
• https://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview6/libraries.md

#dotnet #dotnet11 #aspnetcore #blazor #validation #asyncvalidation #minimalapi #csharp #webdevelopment #softwaredevelopment #developers #backend #programming #dotnetdeveloper #dotnetinpillole

In C# abbiamo sempre avuto diversi modi per rappresentare un valore che può assumere forme differenti: gerarchie di classi, record, enum, Result pattern o librerie dedicate.

Con C# 15 arrivano le Union Types, ma la domanda è: ci servivano davvero?

In questa puntata parto da alcuni casi concreti per capire cosa semplificano, come si integrano con pattern matching e ASP.NET Core e, soprattutto, quando possono migliorare davvero leggibilità e manutenzione del codice… e quando invece rischiano solamente di complicarlo.

• https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-15
• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/union
• https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/unions

#dotnet #csharp #csharp15 #dotnet11 #uniontypes #discriminatedunions #aspnetcore #minimalapi #softwaredevelopment #programming #developers #dotnetdeveloper #coding #softwarearchitecture #dotnetinpillole

In questa puntata parlo di Aspire da un punto di vista diverso dal solito: non solo come orchestratore locale, ma come ambiente operativo per i coding agent. Vediamo come un agente può usare Aspire per avviare l’applicazione, controllare lo stato delle risorse, leggere log e trace, verificare health ed endpoint e capire se una modifica funziona davvero nel sistema completo.

• https://aspire.dev/reference/cli/commands/aspire-agent-init/
• https://github.com/microsoft/aspire-skills/
• https://aspire.dev/

#dotnet #aspire #aspiredev #codingagents #githubcopilot #claudecode #ai #aspnetcore #blazor #csharp #softwaredevelopment #developertools #observability #opentelemetry #devops #podcast #dotnetinpillole

In questa puntata parlo di come usare AI, Figma e MCP per trasformare un mockup in una vera interfaccia funzionante. Partiamo dal design, passiamo alla generazione del codice con Copilot o Claude Code e arriviamo fino alla verifica nel browser con Playwright e Chrome DevTools. L’obiettivo non è solo generare una UI, ma creare un vero ciclo di implementazione, controllo e correzione.

#dotnet #blazor #githubcopilot #claudecode #figma #mcp #playwright #chromedevtools #ai #artificialintelligence #codingagent #frontend #webdevelopment #aspnetcore #developer #podcast #dotnetinpillole

Con l’arrivo della tariffazione basata sui token, usare bene gli agenti AI diventa ancora più importante. In questa puntata parlo di Headroom, Caveman, Graphify, Serena, Context7 e Repomix: strumenti che aiutano Copilot e Claude a leggere meno contenuto inutile, trovare più velocemente le informazioni corrette e produrre risposte più sintetiche, riducendo consumi e sprechi.

• https://github.com/headroomlabs-ai/headroom
• https://github.com/juliusbrussee/caveman
• https://github.com/Graphify-Labs/graphify
• https://github.com/oraios/serena
• https://github.com/upstash/context7
• https://github.com/yamadashy/repomix
• https://github.com/github/spec-kit

#GitHubCopilot #ClaudeCode #CodingAgent #IntelligenzaArtificiale #AITools #DeveloperTools #MCP #Headroom #Caveman #Graphify #Serena #Context7 #Repomix #DotNet #Programmazione #podcast #dotnetinpillole

Dopo aver parlato di PostgreSQL, continuo il viaggio con TimescaleDB, l’estensione pensata per gestire serie temporali, metriche e telemetria. Vediamo come funziona, perché può essere interessante in un progetto .NET e quali sono le principali differenze rispetto a InfluxDB.

• https://github.com/timescale/timescaledb
• https://timescaledb.org/
• https://www.tigerdata.com/

#TimescaleDB #PostgreSQL #InfluxDB #TimeSeries #Database #DotNet #CSharp #Npgsql #Dapper #EntityFrameworkCore #IoT #Telemetry #SoftwareDevelopment #DotNetInPillole #podcast