.NET in pillole

1. 369 - Stiamo perdendo qualcosa di importante?

   9 de novembro de 202615 minA seguir

   Dopo oltre dieci anni di attività, DotNetCode ha annunciato la chiusura della propria community.Una notizia che mi ha fatto riflettere: quanto diamo per scontati gli eventi gratuiti e le opportunità di …

   Notas do episódio

   Dopo oltre dieci anni di attività, DotNetCode ha annunciato la chiusura della propria community.
   
   Una notizia che mi ha fatto riflettere: quanto diamo per scontati gli eventi gratuiti e le opportunità di formazione e confronto tra sviluppatori?
   
   In questa puntata condivido alcune considerazioni sul valore delle community tecniche e sulle difficoltà di mantenerle vive, anche alla luce dei vent'anni di esperienza con XE.
   
   Un grazie a tutte le persone che hanno contribuito a DotNetCode in questi anni!
   
   #DotNetInPillole #DotNet #Community #SoftwareDevelopment

2. 368 - Oltre GitHub Spec Kit: OpenSpec e BMAD a confronto

   2 de novembro de 202621 minA seguir

   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 …

   Notas do episódio

   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

3. 367 - GitHub Spec Kit: l'AI scrive codice, ma chi scrive i requisiti?

   26 de outubro de 202623 minA seguir

   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 …

   Notas do episódio

   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

4. 366 - Ho scritto un libro su .NET!

   19 de outubro de 202622 minA seguir

   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 è …

   Notas do episódio

   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

5. 365 - Memory dump in .NET: quando log e trace non bastano

   12 de outubro de 202619 minA seguir

   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 …

   Notas do episódio

   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

6. 364 - Eseguire codice generato dall'AI in sicurezza

   5 de outubro de 202619 minA seguir

   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 …

   Notas do episódio

   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

7. 363 - Non tutto deve essere una REST API

   28 de setembro de 202614 minA seguir

   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 …

   Notas do episódio

   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

8. 362 - .NET 11 è più veloce senza cambiare il nostro codice?

   21 de setembro de 202620 minA seguir

   .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 …

   Notas do episódio

   .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

9. 361 - E se fosse il provider a scegliere il modello?

   14 de setembro de 202618 minA seguir

   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 …

   Notas do episódio

   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

10. 360 - Un solo modello AI non basta più?

    7 de setembro de 202615 minA seguir

    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 …

    Notas do episódio

    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

11. 359 - Blazor Server scala meglio con .NET 11?

    31 de agosto de 202621 minA seguir

    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 …

    Notas do episódio

    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

12. 358 - Validazione asincrona in .NET 11: era ora?

    24 de agosto de 202614 minA seguir

    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 …

    Notas do episódio

    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

13. 357 - C# 15 e Union Types: finalmente servono davvero?

    17 de agosto de 202626 minA seguir

    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 …

    Notas do episódio

    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

14. 356 - Dal codice ai log: perché Aspire può cambiare i coding agent

    10 de agosto de 202615 minA seguir

    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 …

    Notas do episódio

    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

15. 355 - L’AI può davvero trasformare un mockup in codice?

    3 de agosto de 202614 minA seguir

    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 …

    Notas do episódio

    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
    
    

16. 354 - Copilot e Claude: i tool (e modi) per ridurre token, costi e contesto

    27 de julho de 202631 minA seguir

    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 …

    Notas do episódio

    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
    
    
    
    
    
    
    

17. 353 - TimescaleDB: quando PostgreSQL incontra le serie temporali

    20 de julho de 202619 minA seguir

    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 …

    Notas do episódio

    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

18. 352 - PostgreSQL e .NET: quando il database modella il dominio

    13 de julho de 202620 minA seguir

    In questa puntata parlo di PostgreSQL dal punto di vista di uno sviluppatore .NET, concentrandomi sui suoi tipi custom (che ritengo una delle sue potenzianlità): enum, domain, composite type e range.Non un …

    Notas do episódio

    In questa puntata parlo di PostgreSQL dal punto di vista di uno sviluppatore .NET, concentrandomi sui suoi tipi custom (che ritengo una delle sue potenzianlità): enum, domain, composite type e range.
    Non un confronto con SQL Server, ma uno sguardo a come PostgreSQL possa aiutare a modellare meglio il dominio (con i vari pro e contro).
    
    #PostgreSQL #DotNet #CSharp #AspNetCore #Database #SQL #SQLServer #EntityFrameworkCore #Npgsql #BackendDevelopment #podcast #dotnetinpillole

19. 351 - Microsoft.Data.SqlClient: il driver che usi ogni giorno ma non conosci

    6 de julho de 202617 minA seguir

    In questa puntata parlo di Microsoft.Data.SqlClient, il driver che molte applicazioni .NET usano ogni giorno per comunicare con SQL Server, spesso senza che ce ne rendiamo davvero conto.Vediamo perché non è …

    Notas do episódio

    In questa puntata parlo di Microsoft.Data.SqlClient, il driver che molte applicazioni .NET usano ogni giorno per comunicare con SQL Server, spesso senza che ce ne rendiamo davvero conto.
    Vediamo perché non è solo “la libreria della connection string”, ma un componente importante per sicurezza, autenticazione, performance, retry, diagnostica e nuove funzionalità come il supporto ai vector type di SQL Server 2025.
    

    • https://learn.microsoft.com/en-us/sql/connect/ado-net/microsoft-ado-net-sql-server
      
      
    • https://techcommunity.microsoft.com/blog/sqlserver/microsoft-data-sqlclient-7-0-is-here-a-leaner-more-modular-driver-for-sql-server/4503173
      
      
    • https://learn.microsoft.com/en-us/sql/connect/ado-net/sqlclient-driver-support-lifecycle
      
      
    • https://github.com/dotnet/SqlClient/discussions/3793
      
      

    
    #dotnet #csharp #sqlserver #microsoftdatasqlclient #sqlclient #ado.net #aspnetcore #efcore #dapper #azure #azuresql #database #programmazione #svilupposoftware #dotnetinpillole

20. 350 - GitHub Copilot App: dalla issue alla pull request con l’AI

    29 de junho de 202616 minA seguir

    In questa puntata parlo di GitHub Copilot App, la nuova esperienza desktop pensata per portare Copilot oltre l’IDE.Non più solo suggerimenti di codice o chat dentro l’editor, ma un modo diverso di lavorare con …

    Notas do episódio

    In questa puntata parlo di GitHub Copilot App, la nuova esperienza desktop pensata per portare Copilot oltre l’IDE.
    Non più solo suggerimenti di codice o chat dentro l’editor, ma un modo diverso di lavorare con issue, branch, pull request, review e agenti AI collegati ai repository GitHub.
    Provo a capire cosa cambia davvero per noi sviluppatori .NET, dove può essere utile e perché potrebbe rappresentare un altro passo verso lo sviluppo software sempre più “agentico”.
    

    • https://docs.github.com/en/copilot/concepts/agents/github-copilot-app
      
      
    • https://docs.github.com/en/copilot/how-tos/github-copilot-app/getting-started
      
      
    • https://docs.github.com/en/copilot/how-tos/github-copilot-app/using-automations
      
      
    • https://github.com/features/ai/github-app

    
    
    #GitHubCopilot #GitHubCopilotApp #Copilot #GitHub #AI #SviluppoSoftware #Programmazione #CodingAI #AIAgents #AgenticDevelopment #PullRequest #SoftwareDevelopment #DevTools #DotNetInPillole #Podcast

21. 349 - Continuous AI: oltre la CI/CD con GitHub

    22 de junho de 202615 minA seguir

    In questa puntata parlo di GitHub Agentic Workflows e di come possono portare l’AI dentro i processi di manutenzione del repository. Mi concentro soprattutto su due casi d’uso: mantenere la documentazione …

    Notas do episódio

    In questa puntata parlo di GitHub Agentic Workflows e di come possono portare l’AI dentro i processi di manutenzione del repository. Mi concentro soprattutto su due casi d’uso: mantenere la documentazione allineata alle modifiche del codice e individuare continuamente piccole semplificazioni da proporre tramite pull request. Una panoramica pratica su opportunità, limiti e ruolo della revisione umana.
    

    • https://github.github.com/gh-aw/
      
      
    • https://github.blog/ai-and-ml/automate-repository-tasks-with-github-agentic-workflows/
      
      
    • https://github.com/githubnext/agentics
      
      

    
    #GitHub #GitHubActions #AgenticWorkflows #GitHubCopilot #ContinuousAI #ArtificialIntelligence #AI #DotNet #DotNetDeveloper #SoftwareDevelopment #DeveloperTools #DevOps #CICD #CodeQuality #CodeReview #Refactoring #TechnicalDebt #Documentation #SoftwareArchitecture #Programmazione

22. 348 - GitHub Pages: l’hosting gratuito che molti sviluppatori ignorano

    15 de junho de 202615 minA seguir

    In questa puntata parlo di GitHub Pages, uno strumento che secondo me tanti sviluppatori conoscono di nome, ma che spesso sottovalutano.Non è solo “un posto dove mettere due paginette HTML”, ma può diventare …

    Notas do episódio

    In questa puntata parlo di GitHub Pages, uno strumento che secondo me tanti sviluppatori conoscono di nome, ma che spesso sottovalutano.
    Non è solo “un posto dove mettere due paginette HTML”, ma può diventare molto utile per pubblicare documentazione tecnica, landing page di progetto, demo, siti statici e anche applicazioni Blazor WebAssembly.
    Ragiono su quando ha senso usarlo, quando invece non è la scelta giusta, quali sono i suoi limiti e come si integra con GitHub Actions e con gli static site generator.
    Una puntata pratica per ricordarci che non tutto deve finire su un App Service, dentro un container o dietro un backend: a volte un sito statico è esattamente quello che ci serve.
    

    • https://docs.github.com/en/pages
    • https://github.com/collections/static-site-generators
    • https://github.blog/developer-skills/github/github-for-beginners-getting-started-with-github-pages/

    
    #dotnet #github #githubpages #blazor #blazorwebassembly #webdevelopment #aspnetcore #csharp #githubactions #staticsite #staticsitegenerator #developer #programmazione #sviluppatori #dotnetinpillole

23. 347 - Prima del prompt: documenti, markdown e contesto per l’AI

    8 de junho de 202613 minA seguir

    In questa puntata parto da MarkItDown, un tool che sta ricevendo parecchia attenzione perché permette di trasformare documenti e file in Markdown, rendendoli più facili da usare con l’AI. Da qui allargo il …

    Notas do episódio

    In questa puntata parto da MarkItDown, un tool che sta ricevendo parecchia attenzione perché permette di trasformare documenti e file in Markdown, rendendoli più facili da usare con l’AI.
    Da qui allargo il discorso a Docling, al suo server MCP e a Context7, per parlare di un tema che secondo me diventerà sempre più importante: non basta avere un buon modello AI, serve anche dargli il contesto giusto.
    Una puntata su documenti, agenti, MCP e strumenti che possono aiutarci a lavorare meglio con Copilot, Claude e gli assistenti AI che usiamo ogni giorno.
    

    • https://github.com/microsoft/markitdown
    • https://github.com/docling-project/docling
    • https://github.com/upstash/context7

    
    #dotnet #csharp #intelligenzaartificiale #AI #MarkItDown #Docling #Context7 #MCP #ModelContextProtocol #GitHubCopilot #ClaudeAI #LLM #AIAgents #RAG #Markdown #DocumentProcessing #DeveloperTools #SoftwareDevelopment #Programmazione #DotNetInPillole

24. 346 - Usare Aspire per sviluppare meglio

    1 de junho de 202619 minA seguir

    In questa puntata parlo di Aspire con un taglio molto pratico: non come tecnologia di deploy o orchestrazione finale, ma come strumento per semplificare lo sviluppo quotidiano.Ti racconto di come Aspire può …

    Notas do episódio

    In questa puntata parlo di Aspire con un taglio molto pratico: non come tecnologia di deploy o orchestrazione finale, ma come strumento per semplificare lo sviluppo quotidiano.
    Ti racconto di come Aspire può aiutarmi a far partire in locale applicazioni composte da più servizi, database, cache, code e frontend, usando l’AppHost, la dashboard, il service discovery e una configurazione più coerente. L’obiettivo è farti capire quanto può essere utile per lavorare meglio, osservare cosa succede nell’applicazione e ridurre l’attrito nello sviluppo, senza essere obbligati a usarlo anche in produzione.
    

    • https://learn.microsoft.com/dotnet/aspire/
    • https://aspire.dev/it/

    #dotnet #aspire #aspiredev #csharp #csharpdeveloper #softwaredevelopment #programmazione #sviluppoweb #backenddevelopment #microservices #cloudnative #docker #observability #opentelemetry #visualstudio #podcast #dotnetinpillole

25. 345 - 20 anni di community, persone e tecnologia

    25 de maio de 202621 minA seguir

    Con il XE OneDay di venerdì 22 maggio abbiamo festeggiato i 20 anni di "XE - Development User Group" e lo abbiamo fatto con un evento dove abbiamo parlato di architettura del sofware.In questa puntata ti voglio …

    Notas do episódio

    Con il XE OneDay di venerdì 22 maggio abbiamo festeggiato i 20 anni di "XE - Development User Group" e lo abbiamo fatto con un evento dove abbiamo parlato di architettura del sofware.
    In questa puntata ti voglio parlare di questi 20 anni e di quello che ci sta dietro un evento come questo.
    

    • https://www.xedotnet.org/
    • https://www.xedotnet.org/eventi/oneday2026/

    
    #xe #xedotnet #community #xeoneday #friends #development #usergroup

26. 344 - ASP.NET Core e Blazor in .NET 11: cosa c’è già nelle prime preview

    18 de maio de 202617 minA seguir

    La scorsa settimana è stata rilasciata la preview 4 di .NET 11. In questa puntata vediamo cosa è stato rilasciato in queste 4 prime preview per quanto riguarda ASP.NET Core e …

    Notas do episódio

    La scorsa settimana è stata rilasciata la preview 4 di .NET 11. In questa puntata vediamo cosa è stato rilasciato in queste 4 prime preview per quanto riguarda ASP.NET Core e Blazor.
    

    • https://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview1/aspnetcore.md
    • https://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview2/aspnetcore.md
    • https://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview3/aspnetcore.md
    • https://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview4/aspnetcore.md
    • https://github.com/dotnet/aspnetcore/issues/64787

    
    #dotnet #dotnet11 #aspnetcore #blazor #opentelemetry #openapi #minimalapi #webassembly #csharp

27. 343 - Mutation Testing: chi testa i test?

    11 de maio de 202615 minA seguir

    In questa puntata parlo di Mutation Testing: una tecnica che ci aiuta a capire se i nostri test automatici stanno davvero proteggendo il codice o se stanno semplicemente passando.Partendo dai limiti della code …

    Notas do episódio

    In questa puntata parlo di Mutation Testing: una tecnica che ci aiuta a capire se i nostri test automatici stanno davvero proteggendo il codice o se stanno semplicemente passando.
    Partendo dai limiti della code coverage, vediamo come strumenti come Stryker.NET possano introdurre piccoli errori controllati nel codice per verificare se i test riescono a intercettarli.
    Una puntata pensata per sviluppatori .NET che vogliono migliorare la qualità dei propri test, senza fermarsi solo alla percentuale di copertura.
    

    • https://stryker-mutator.io/docs/stryker-net/introduction/
      
      
    • https://learn.microsoft.com/en-us/dotnet/core/testing/mutation-testing
      
      
    • https://www.nuget.org/packages/dotnet-stryker
      
      

    
    #dotnet #csharp #testing #unittesting #mutationtesting #strykerdotnet #softwarequality #cleancode #podcast #dotnetinpillole
    
    

28. 342 - Messaging in .NET senza complicarsi troppo la vita

    4 de maio de 202625 minA seguir

    In questa puntata parlo di Rebus, una libreria .NET che ci aiuta a fare un passo importante nell’architettura delle nostre applicazioni: passare da un sistema basato solo su chiamate dirette e sincrone a un …

    Notas do episódio

    In questa puntata parlo di Rebus, una libreria .NET che ci aiuta a fare un passo importante nell’architettura delle nostre applicazioni: passare da un sistema basato solo su chiamate dirette e sincrone a un modello basato su messaggi.
    Quando un’applicazione cresce, non sempre ha senso fare tutto subito, dentro la stessa richiesta HTTP. Alcune operazioni possono essere messe in coda, elaborate in background o affidate ad altri componenti del sistema.
    Rebus permette di introdurre questo approccio in modo pragmatico, aiutandoci a rendere le applicazioni più disaccoppiate, resilienti e più semplici da evolvere nel tempo.
    Una puntata dedicata a chi vuole iniziare a ragionare meno in termini di “chiamate tra servizi” e più in termini di “eventi, comandi e messaggi”.
    

    • https://github.com/rebus-org/rebus
    • https://rebus.fm/what-is-rebus/
    • https://github.com/MassTransit/MassTransit
    • https://masstransit.io/

    #dotnet #csharp #rebus #messaging #servicebus #rabbitmq #azureservicebus #microservices #softwarearchitecture #distributedsystems #backenddevelopment #podcast #dotnetinpillole

29. 341 - Microsoft Agent Framework: il nuovo modo di creare AI Agent in .NET

    27 de abril de 202619 minA seguir

    In questa puntata torno sul tema degli AI Agent in .NET partendo da una considerazione: nella scora puntata avevo parlato di Semantic Kernel e mi ero perso la notizia che ad inizio mese Microsoft ha rilasciato …

    Notas do episódio

    In questa puntata torno sul tema degli AI Agent in .NET partendo da una considerazione: nella scora puntata avevo parlato di Semantic Kernel e mi ero perso la notizia che ad inizio mese Microsoft ha rilasciato ufficialmente Microsoft Agent Framework 1.0.
    Parliamo quindi di cosa cambia davvero, perché Agent Framework può essere visto come l’evoluzione naturale di Semantic Kernel e AutoGen, e quali sono le differenze più importanti per chi sviluppa applicazioni AI con .NET.
    Vediamo il nuovo modello basato su agenti, sessioni, tool e workflow, il confronto con Semantic Kernel e soprattutto cosa significa tutto questo per chi ha già progetti o esperimenti basati sul vecchio approccio.
    

    • https://learn.microsoft.com/en-us/agent-framework/overview/
    • https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0
    • https://learn.microsoft.com/en-us/agent-framework/migration-guide/from-semantic-kernel/
    • https://devblogs.microsoft.com/agent-framework/migrate-your-semantic-kernel-and-autogen-projects-to-microsoft-agent-framework-release-candidate/

    
    
    #dotnet #csharp #aspnetcore #microsoftagentframework #agentframework #semantickernel #aiagents #artificialintelligence #generativeai #microsoftai #azureai #microsoftfoundry #dotnetdeveloper #softwaredevelopment #programmazione #sviluppatori #coding #developer #techpodcast #dotnetinpillole

30. 340 - Semantic Kernel: perché chiamare un modello non basta più

    20 de abril de 202623 minA seguir

    In questa puntata parlo di Semantic Kernel con un taglio pratico: quando serve davvero in un'applicazione .NET, dove puo' aiutare e dove invece rischia di essere solo complessita' in piu'. Il punto non e' solo …

    Notas do episódio

    In questa puntata parlo di Semantic Kernel con un taglio pratico: quando serve davvero in un'applicazione .NET, dove puo' aiutare e dove invece rischia di essere solo complessita' in piu'. Il punto non e' solo chiamare un modello, ma integrare AI, tool e contesto senza perdere controllo e architettura.
    

    • https://learn.microsoft.com/en-us/semantic-kernel/overview/
    • https://github.com/microsoft/semantic-kernel
    • https://devblogs.microsoft.com/dotnet/introducing-microsoft-extensions-ai-preview/
    • https://learn.microsoft.com/en-us/dotnet/ai/microsoft-extensions-ai
    • https://learn.microsoft.com/it-it/azure/foundry-local/get-started

    
    #dotnet #podcast #dotnetinpillole #semantickernel #ai #generativeai #llm #openai #azureopenai #microsoft #microsoftextensionsai #microsoftfoundrylocal #softwarearchitecture #developer #programming #coding

Aqui estão os 40 episódios mais recentes de 369. Os mais antigos estão no feed do podcast.