.NET in pillole

Nella scorsa puntata ti ho parlato di GitHub Spec Kit e di come lo Spec-Driven Development possa aiutarci a chiarire i requisiti prima di iniziare a scrivere codice.
Ma GitHub Spec Kit non è l'unico strumento disponibile. Esistono anche OpenSpec e BMAD Method, che affrontano lo stesso problema con approcci differenti.
In questa puntata ti parlo di questi due strumenti, delle principali differenze rispetto a GitHub Spec Kit e di come permettono di gestire specifiche, requisiti e attività di sviluppo.

• https://github.com/Fission-AI/OpenSpec
• https://github.com/bmad-code-org/BMAD-METHOD
• https://github.com/github/spec-kit
• https://github.com/melkio/github-dev-days-2026

#OpenSpec #BMAD #GitHubSpecKit #SpecDrivenDevelopment #AI #CodingAgents #SoftwareDevelopment #DotNetInPillole #Podcast

Oggi, grazie all'AI, possiamo scrivere codice sempre più velocemente. Ma cosa succede quando i requisiti sono incompleti o poco chiari?

In questa puntata ti parlo di GitHub Spec Kit e di Spec-Driven Development, un approccio che mette le specifiche al centro dello sviluppo software, aiutandoci a lavorare meglio con i coding agent.

• https://github.com/github/spec-kit

#GitHubSpecKit #SpecDrivenDevelopment #AI #CodingAgents #DotNet #DotNetInPillole #Podcast

Oggi puntata diversa dal solito...ebbene si, ho proprio scritto un libro, il mio primo libro!
Si intitola "Imparare .NET sviluppando" e in questa puntata ti racconto perché ho deciso di scriverlo, a chi è rivolto e come ho strutturato il percorso che parte dalle basi di C# e arriva allo sviluppo di un'applicazione web con ASP.NET Core e Blazor.

Se sei interessato, lo trovi qui: https://link.amazon/B01u6CYzB

#dotnet #csharp #aspnetcore #blazor #SoftwareDevelopment #Programming #ImparareAProgrammare #DotNetBook #LibroDotNet #Developers #DotNetInPillole #Podcast #adv

In questa puntata parlo di memory dump in .NET e di quando possono diventare utili per capire problemi che log, metriche e trace da soli non riescono a spiegare.
Partiamo da casi concreti: un’applicazione che continua a consumare memoria, thread bloccati, oggetti che il Garbage Collector non libera o problemi che compaiono solamente in produzione.
Ti racconto cosa contiene realmente un dump, come raccoglierlo con gli strumenti .NET e quali informazioni possiamo ricavare analizzandolo.
Perché log e trace ci raccontano cosa è successo, ma a volte abbiamo bisogno di fotografare lo stato del processo e capire cosa c’era davvero in memoria in quel momento.

• https://devblogs.microsoft.com/dotnet/creating-a-memory-dump-in-csharp/
• https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-dump
• https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dumps
• https://learn.microsoft.com/en-us/dotnet/core/diagnostics/dotnet-gcdump

#dotnet #csharp #memorydump #dotnetdump #diagnostics #debugging #memoryleak #garbagecollector #aspnetcore #performance #observability #developers #softwaredevelopment #dotnetdeveloper #dotnetinpillole #podcast

Durante la conferenza 1nn0vAI, ho scoperto le Azure Container Apps Dynamic Sessions e mi ha colpito soprattutto un caso d’uso: eseguire in modo isolato codice generato dall’AI.

In questa puntata ti parlo di come funzionano e perché possono essere una soluzione interessante quando un LLM non deve solo generare codice, ma anche eseguirlo in sicurezza.

• https://learn.microsoft.com/en-us/azure/container-apps/sessions
• https://learn.microsoft.com/en-us/azure/container-apps/ai-integration
• https://learn.microsoft.com/en-us/azure/container-apps/sessions-custom-container

#Azure #AzureContainerApps #DynamicSessions #AI #ArtificialIntelligence #GenerativeAI #LLM #AIAgents #CodeInterpreter #Sandbox #MicrosoftAzure #Cloud #DotNet #CSharp #SoftwareDevelopment #DotNetInPillole #Podcast

In questa puntata parto da un caso concreto nato preparando una sessione su Blazor e AI: cosa succede quando un processo non può più vivere comodamente dentro una singola request?
Da Task a IAsyncEnumerable, fino a processi in background, Channel e SignalR per aggiornare la UI: il punto non è complicare l’architettura, ma scegliere il modello giusto in base al lifetime del processo.
Perché una REST API va benissimo in moltissimi casi… ma non tutto deve necessariamente vivere dentro una request HTTP fino alla fine.

#dotnet #aspnetcore #blazor #restapi #signalr #backgroundservice #channel #iasyncenumerable #softwarearchitecture #softwaredevelopment #developers #dotnetinpillole #podcast

.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