Un modo alternativo per rimanere aggiornati sul mondo .NET e tutto ciò che ci gira attorno: dai nuovi rilasci, ad articoli e post che troveremo particolarmente interessanti. Non mancheranno sicuramente le community ed i loro eventi. Ed un pizzico di architetture e problematiche di tutti i giorni.
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/206492https://docs.github.com/en/copilot/concepts/agents/copilot-cli/rubber-duckhttps://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-experimentalhttps://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/CDhttps://learn.microsoft.com/en-us/aspnet/core/blazor/state-management/serverhttps://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/overviewhttps://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-11https://learn.microsoft.com/en-us/aspnet/core/fundamentals/validation?view=aspnetcore-11.0https://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-15https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/unionhttps://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/headroomhttps://github.com/juliusbrussee/cavemanhttps://github.com/Graphify-Labs/graphifyhttps://github.com/oraios/serenahttps://github.com/upstash/context7https://github.com/yamadashy/repomixhttps://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/timescaledbhttps://timescaledb.org/https://www.tigerdata.com/#TimescaleDB #PostgreSQL #InfluxDB #TimeSeries #Database #DotNet #CSharp #Npgsql #Dapper #EntityFrameworkCore #IoT #Telemetry #SoftwareDevelopment #DotNetInPillole #podcast
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
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-serverhttps://techcommunity.microsoft.com/blog/sqlserver/microsoft-data-sqlclient-7-0-is-here-a-leaner-more-modular-driver-for-sql-server/4503173https://learn.microsoft.com/en-us/sql/connect/ado-net/sqlclient-driver-support-lifecyclehttps://github.com/dotnet/SqlClient/discussions/3793#dotnet #csharp #sqlserver #microsoftdatasqlclient #sqlclient #ado.net #aspnetcore #efcore #dapper #azure #azuresql #database #programmazione #svilupposoftware #dotnetinpillole
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-apphttps://docs.github.com/en/copilot/how-tos/github-copilot-app/getting-startedhttps://docs.github.com/en/copilot/how-tos/github-copilot-app/using-automationshttps://github.com/features/ai/github-app#GitHubCopilot #GitHubCopilotApp #Copilot #GitHub #AI #SviluppoSoftware #Programmazione #CodingAI #AIAgents #AgenticDevelopment #PullRequest #SoftwareDevelopment #DevTools #DotNetInPillole #Podcast
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
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/pageshttps://github.com/collections/static-site-generatorshttps://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
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/markitdownhttps://github.com/docling-project/doclinghttps://github.com/upstash/context7#dotnet #csharp #intelligenzaartificiale #AI #MarkItDown #Docling #Context7 #MCP #ModelContextProtocol #GitHubCopilot #ClaudeAI #LLM #AIAgents #RAG #Markdown #DocumentProcessing #DeveloperTools #SoftwareDevelopment #Programmazione #DotNetInPillole
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
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
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.mdhttps://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview2/aspnetcore.mdhttps://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview3/aspnetcore.mdhttps://github.com/dotnet/core/blob/main/release-notes/11.0/preview/preview4/aspnetcore.mdhttps://github.com/dotnet/aspnetcore/issues/64787#dotnet #dotnet11 #aspnetcore #blazor #opentelemetry #openapi #minimalapi #webassembly #csharp
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-testinghttps://www.nuget.org/packages/dotnet-stryker#dotnet #csharp #testing #unittesting #mutationtesting #strykerdotnet #softwarequality #cleancode #podcast #dotnetinpillole
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/rebushttps://rebus.fm/what-is-rebus/https://github.com/MassTransit/MassTransithttps://masstransit.io/#dotnet #csharp #rebus #messaging #servicebus #rabbitmq #azureservicebus #microservices #softwarearchitecture #distributedsystems #backenddevelopment #podcast #dotnetinpillole
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-0https://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
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-kernelhttps://devblogs.microsoft.com/dotnet/introducing-microsoft-extensions-ai-preview/https://learn.microsoft.com/en-us/dotnet/ai/microsoft-extensions-aihttps://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
In questa puntata parto da una novità di Visual Studio, Bookmark Studio, ma la uso come scusa per parlare di un problema molto più grande: orientarsi nel codice. Perché oggi non è più difficile scrivere codice, anche grazie all'AI. Il vero problema è riuscire a seguirlo, capirlo e non perdersi dentro codebase sempre più grandi e complesse. Ti racconto come affrontare questo problema in modo pratico, passando da strumenti come Solution Filter, bookmark evoluti e debugging più intelligente.https://devblogs.microsoft.com/visualstudio/bookmark-studio-evolving-bookmarks-in-visual-studio/https://learn.microsoft.com/en-us/visualstudio/ide/setting-bookmarks-in-codehttps://learn.microsoft.com/en-us/visualstudio/ide/filtered-solutions#dotnet #csharp #visualstudio #softwaredevelopment #programmazione #debugging #clean code #developerlife #coding #webdevelopment #copilot #ai #devtips #productivity #devtools #podcast #dotnetinpillole
In questa puntata parlo di retry automatici, una di quelle cose che usiamo tutti senza pensarci troppo. Il problema è che i retry non sono sempre una soluzione: in molti casi possono amplificare i problemi, creare effetti collaterali e mettere in crisi interi sistemi. Vediamo quando hanno davvero senso, quando evitarli e soprattutto come usarli nel modo corretto.#dotnet #csharp #softwarearchitecture #backend #resilience #polly #microservices #programmazione
In questa puntata parlo di un problema che tutti abbiamo incontrato almeno una volta: le cron expression. Potenti, sì… ma spesso illeggibili e facili da sbagliare. Ti parlo di NaturalCron, una libreria che permette di definire schedulazioni in modo più chiaro e dichiarativo, migliorando la leggibilità del codice senza cambiare gli strumenti che già utilizzi. Non è una rivoluzione, ma è uno di quei piccoli miglioramenti che possono fare davvero la differenza nella qualità del nostro codice.https://github.com/hugoj0s3/NaturalCronhttps://github.com/bradymholt/cron-expression-descriptor#dotnet #csharp #nuget #naturalcron #cron #softwaredevelopment #backend #developerlife #coding #programmazione #dotnetdeveloper #cleanCode #architecture #techpodcast #dotnetinpillole #podcast
In questa puntata parlo di AngleSharp, una libreria .NET moderna che permette di parsare HTML e lavorare con il DOM in modo molto simile a quanto avviene nei browser. Vedremo come funziona, in quali scenari può essere utile e perché può essere una valida alternativa a HtmlAgilityPack quando dobbiamo analizzare o manipolare markup HTML nelle nostre applicazioni .NET.https://github.com/AngleSharp/AngleSharphttps://anglesharp.github.io/#dotnet #csharp #anglesharp #htmlparsing #webscraping #htmlagilitypack #dotnetdeveloper #programming #softwaredevelopment #backenddevelopment #webdevelopment #dotnetinpillole #podcast
In questa puntata parlo di SignalR oggi e cerco di rispondere a una domanda molto pratica: quando ha davvero senso usarlo?SignalR è una tecnologia potente e ancora molto attuale nell'ecosistema ASP.NET Core, ma introdurre il realtime significa anche introdurre complessità. Vediamo quindi quali problemi risolve davvero, quando è la scelta giusta e quando invece una soluzione più semplice può essere sufficiente.#dotnet #csharp #signalr #aspnetcore #websocket #realtime #softwarearchitecture #backenddevelopment #programmazione #dotnetinpillole #podcast
In questa puntata parto da un post che mi ha fatto riflettere molto: con l'AI che genera codice a velocità altissima, il nostro modello di controllo è ancora valido? Possiamo davvero continuare a fare code review riga per riga quando una PR tocca decine di file? Condivido alcune considerazioni su come cambia il ruolo dello sviluppatore .NET e perché oggi più che mai servono guardrail architetturali, contratti chiari e test orientati al comportamento. Non è una puntata sui tool di AI, ma su come progettare sistemi che possano reggere la loro velocità.https://blazorconf.it/#dotnet #softwarearchitecture #ai #codequality #codereview #cleanarchitecture #contracttesting #devleadership #aspnetcore #modernbackend #podcast #dotnetinpillole
In questa puntata parlo di contract testing per API .NET e di come evitare quei breaking change che scopriamo solo dopo il deploy. Ti racconto in modo pratico cos'è un contract test, quando usarlo rispetto a integration ed E2E, e confronto due approcci concreti: Pact (Consumer-Driven Contracts) e test basati su OpenAPI.https://github.com/pact-foundation/pact-nethttps://pact.io/https://devblogs.microsoft.com/ise/pact-contract-testing-because-not-everything-needs-full-integration-tests/https://pactflow.io/blog/what-is-contract-testing/#dotnet #dotnetdeveloper #webapi #restapi #contracttesting #pact #pactnet #openapi #swagger #microservices #csharp #softwarearchitecture #ci #cicd #devops #backenddeveloper #podcast #dotnetinpillole
In questa puntata ti parlo di Audit.NET, una libreria potente e flessibile per implementare un auditing serio nelle applicazioni .NET. Vediamo insieme quali problemi risolve, come si integra con ASP.NET Core ed Entity Framework Core e quando ha davvero senso introdurla in un progetto enterprise.https://github.com/thepirat000/Audit.NEThttps://www.nuget.org/packages/Audit.NET#dotnet #csharp #auditnet #aspnetcore #efcore #backenddevelopment #softwarearchitecture #cleanarchitecture #logging #enterprisedevelopment #webapi #dapper #programmazione #developeritalia #podcast #dotnetinpillole
In questa puntata ti parlo di Mailpit, un server SMTP fittizio moderno pensato per lo sviluppo e il testing delle email. Ti racconto cosa ha di più rispetto ad altri strumenti simili, come funziona e in che modo può migliorare il tuo workflow tra sviluppo locale, container e test automatizzati. https://mailpit.axllent.org/https://aspire.dev/integrations/devtools/mailpit/https://github.com/rnwood/smtp4devPer la Blazor Conf:https://sessionize.com/blazorconf2026/https://www.eventbrite.com/e/registrazione-blazor-conf-2026-1982296322663#Mailpit #smtp4dev #EmailTesting #DevTools #BackendDev #Fullstack #CI_CD #DevWorkflow #TestingAutomatizzato #SviluppoSoftware #dotnetinpillole #podcast
Scopri le nuove File-Based Apps introdotte in .NET 10: applicazioni C# scritte in un singolo file, senza .csproj, ideali per script, prototipi e CLI tool. Vediamo vantaggi, casi d'uso, criticità ed esempi reali.https://github.com/DamianEdwards/runfilehttps://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/file-based-programshttps://learn.microsoft.com/en-us/dotnet/core/sdk/file-based-apps#dotnet10 #csharp #filebasedapps #dotnet #developers #coding #scripting #cli #programmazione #dotnetinpillole #podcast
Le Minimal API sono davvero il futuro di .NET? In questa puntata esploriamo vantaggi e limiti di questo approccio rispetto ai controller tradizionali, per capire quando ha senso adottarle e quando no. Una riflessione utile per orientarsi nel 2026.#dotnet #MinimalAPI #ASPNETCore #WebAPI #dotnetdeveloper #BackendDevelopment #APIdesign #CleanCode #SoftwareArchitecture #DevPodcast #dotnetinpillole #podcast
Scopri come funziona Tailwind CSS, il framework utility-first che sta rivoluzionando il modo di scrivere interfacce web. In questa puntata analizziamo vantaggi, casi d'uso, esempi pratici e mettiamo Tailwind a confronto con Bootstrap per capire quando conviene scegliere l'uno o l'altro.https://tailwindcss.com/https://timdeschryver.dev/blog/integrating-tailwind-css-in-blazorhttps://marketplace.visualstudio.com/items?itemName=TheronWang.TailwindCSSIntellisenseaBlazor Conf 2026https://sessionize.com/blazorconf2026/https://blazorconf.it/#TailwindCSS #Bootstrap5 #FrontendDevelopment #CSSFramework #WebDesign #UtilityFirstCSS #DevPodcast #UIUXDesign #WebDevelopment #TailwindVsBootstrap #dotnetinpillole #podcast
L'AI ci rende più produttivi che mai, ma a che prezzo?Partendo dal caso Tailwind CSS, parlo di come l'intelligenza artificiale stia cambiando il rapporto con l'open-source e perché la sostenibilità dei progetti oggi è un problema più reale che mai.#opensource #ai #softwaredevelopment #programmazione #developers #dotnetinpillole #podcasttech #podcast
In questa puntata parlo di una parte del nostro lavoro di cui si discute poco: i compromessi.Scrivere software non significa solo scegliere librerie o framework, ma trovare ogni giorno il giusto equilibrio tra qualità del codice, tempi di consegna, architettura, test e persone. La soluzione “perfetta” quasi mai esiste, e spesso dobbiamo scegliere quella meno sbagliata per il contesto in cui stiamo lavorando.Una puntata più riflessiva, basata sull'esperienza, per ricordarci che crescere come sviluppatori significa anche accettare consapevolmente i compromessi giusti.#dotnet #softwaredevelopment #codinglife #dotnetinpillole #podcast
In questa puntata di .NET in pillole parlo delle differenze tra Console Application e .NET Worker Service.Vediamo come cambia il lifecycle dell'applicazione, la gestione dei task in background, dello shutdown e dei servizi come logging, configurazione e dependency injection.Una puntata pratica per capire quando usare una console e quando invece scegliere un Worker Service, evitando soluzioni sbagliate nei progetti backend.#dotnet #csharp #aspnetcore #dotnetinpillole #backend #podcast
In questa puntata di .NET in pillole parlo di applicazioni CLI in .NET e di come gestire in modo corretto e pulito gli argomenti da riga di comando.Parto da CommandLineParser, una libreria semplice e molto diretta, ideale quando serve solo fare parsing senza complicarsi la vita, per poi passare a Spectre.Console.Cli, un framework più completo che permette di costruire CLI moderne, strutturate e pronte a crescere nel tempo.https://github.com/commandlineparser/commandlinehttps://spectreconsole.net/cli/getting-started#dotnet #cli #CommandLineParser #SpectreConsoleCli #podcast #dotnetinpillole
In questa puntata parliamo di System.CommandLine, la libreria ufficiale .NET per creare CLI moderne, robuste e tipizzate. Vediamo come evitare il parsing manuale di args, gestire comandi, opzioni e validazione, e costruire tool professionali in pochi minuti.https://github.com/dotnet/command-line-apihttps://learn.microsoft.com/en-us/dotnet/standard/commandline/https://github.com/massimobonanni/KubePizza#dotnet #cli #CommandLine #podcast #dotnetinpillole
E non poteva mancare una puntata dedicata alle novità di Blazor arrivate con .NET 10, dalle modifiche nel template delle Blazor Web App, al PersistentState, passando per validazione e autenticazione.https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-10.0https://github.com/dotnet/aspnetcore/issues/64228https://github.com/dotnet/aspnetcore/issues/63842#dotnet #blazor #aspnet #dotnet10 #podcast #dotnetinpillole
n questa puntata esploriamo le principali novità introdotte in ASP.NET Core 10 (escludendo Blazor) dalle ottimizzazioni di Kestrel alla validazione nelle Minimal API, dal nuovo supporto agli SSE fino ai miglioramenti di OpenAPI, sicurezza e performance. Un aggiornamento ricco di funzionalità pratiche che semplificano lo sviluppo di API moderne, più veloci e più sicure.https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-10.0https://learn.microsoft.com/en-us/aspnet/core/security/authentication/passkeys/blazorhttps://learn.microsoft.com/en-us/aspnet/core/migration/90-to-100#dotnet #aspnet #dotnet10 #podcast #dotnetinpillole
In questa puntata esploriamo le novità più interessanti di C# 14 introdotte con .NET 10: dalla nuova keyword field agli extension members, passando per l'assegnazione null-condizionale e i miglioramenti a Span e agli operatori. Una panoramica pratica per capire cosa cambia davvero nel codice di tutti i giorni.https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14https://youtu.be/xy-HzFp0pbA?si=q95uRbn9D7kIDl6v#dotnet #csharp14 #podcast #dotnetinpillole
Scopri la mia funzionalità preferita in .NET 10: i miglioramenti nella validazione, con la possibilità di validare proprietà con oggetti complessi e collezioni! Meno codice, più controllo sui dati e una developer experience decisamente migliorata.https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-10.0?view=aspnetcore-9.0https://learn.microsoft.com/en-us/aspnet/core/blazor/forms/validation?view=aspnetcore-10.0https://github.com/dotnet/aspnetcore/issues/46349#dotnet #net10 #validation #podcast #dotnetinpillole
Humanizer è una piccola libreria .NET con un grande impatto: converte stringhe, date, numeri e enum in formati leggibili, localizzati e user-friendly, con pochissimo codice.https://github.com/Humanizr/Humanizerhttps://github.com/Humanizr/Humanizer/blob/main/docs/quick-start.mdhttps://youtu.be/S3BEfCzYPRU?si=BrZhOkbTnbevo2Yp#dotnet #humanizer #nuget #podcast #dotnetinpillole
Copilot non è più solo un suggeritore di codice: con i nuovi Copilot Agents e la funzionalità di Planning in Visual Studio, diventa un vero compagno di squadra.In questa puntata parliamo di come gli agenti personalizzati — come il nuovo C# Expert — permettano di avere un Copilot che conosce le best practice del linguaggio e segue le regole del tuo team, mentre la modalità di Planning introduce un approccio strutturato ai task complessi, passo dopo passo. Scopri come queste novità possono migliorare qualità, coerenza e produttività nel tuo lavoro quotidiano di sviluppatore .NET.https://github.com/github/awesome-copilot/blob/main/agents/CSharpExpert.agent.mdhttps://devblogs.microsoft.com/dotnet/introducing-custom-agents-for-dotnet-developers-csharp-expert-winforms-expert/https://devblogs.microsoft.com/visualstudio/introducing-planning-in-visual-studio-public-preview/https://docs.github.com/en/copilot/concepts/agents/coding-agent/about-custom-agents#dotnet #copilot #github #ai #customagents #podcast #dotnetinpillole
In questa puntata ti parlo della vulnerabilità CVE-2025-55315, quella che Microsoft ha classificato con un punteggio di gravità 9.9 e che molti considerano la più critica mai scoperta in ASP.NET Core.Capiremo insieme cos'è l'HTTP Request Smuggling, come funziona questo tipo di attacco e perché può compromettere anche applicazioni perfettamente scritte.Vedremo quali versioni di .NET sono vulnerabili, come verificare se il tuo server è a rischio e quali patch o mitigazioni puoi applicare subito. Anche se non scrivi codice “sbagliato”, a volte basta un header HTTP fuori posto per spalancare la porta a un attaccante.https://www.cve.org/CVERecord?id=CVE-2025-55315https://github.com/dotnet/aspnetcore/issues/64033https://msrc.microsoft.com/update-guide/vulnerability/CVE-2025-55315https://github.com/sirredbeard/CVE-2025-55315-repro#dotnet #security #aspnetcore #kestrel #podcast #dotnetinpillole
In questa puntata esploriamo RazorConsole, una libreria sperimentale che porta il modello Blazor nel terminale. Scopri come costruire interfacce console interattive in .NET usando componenti Razor, tra rendering testuale, input dinamico e Hot Reload. https://github.com/LittleLittleCloud/RazorConsole#dotnet #blazor #aspnet #RazorConsole #SpectreConsole #podcast #dotnetinpillole
In questa puntata ti parlo di come sia possibile creare interfacce utente riusabili e interattive che si adattano automaticamente a Teams, Outlook o alle tue app web, partendo da un semplice file JSON. Un modo elegante e pratico per scrivere una porzione di UI una volta sola e mostrarla ovunque.https://adaptivecards.io/https://learn.microsoft.com/en-us/adaptive-cards/https://github.com/microsoft/AdaptiveCardshttps://adaptivecards.microsoft.com/designer#dotnet #adaptivecards #teams #podcast #dotnetinpillole
In questa puntata ti parlo dei server MCP in Visual Studio 2022, una novità che rende GitHub Copilot ancora più potente: dalla documentazione ufficiale sempre a portata di mano, alla gestione di GitHub e Azure DevOps, fino alla generazione automatica di test per le tue app ASP.NET e Blazor.https://learn.microsoft.com/en-us/visualstudio/ide/mcp-servers?view=vs-2022https://github.com/modelcontextprotocol/servershttps://techcommunity.microsoft.com/blog/azuredevcommunityblog/use-copilot-and-mcp-to-query-microsoft-learn-docs/4455835https://devblogs.microsoft.com/visualstudio/mcp-prompts-resources-sampling/https://github.com/microsoft/playwright-mcp#visualstudio #copilot #mcp #github #azuredevops #dotnetinpillole #podcast
In questa puntata ti parlo di come utilizzare i file di prompt e di instructions in Visual Studio per personalizzare GitHub Copilot, rendendolo più aderente alle regole del tuo progetto e più utile nelle attività ripetitive, con esempi pratici in C# e Blazor.https://github.com/github/awesome-copilothttps://devblogs.microsoft.com/dotnet/prompt-files-and-instructions-files-explained/https://code.visualstudio.com/docs/copilot/customization/custom-instructions#copilot #visualstudio #github #podcast #dotnetinpillole
In questa puntata ti parlo di come strumenti come GitHub Copilot e ChatGPT stiano cambiando il modo in cui studenti e programmatori alle prime armi imparano a scrivere codice. Vediamo insieme vantaggi, rischi e consigli pratici per usare l'AI come alleato formativo senza cadere nella trappola della dipendenza o della comprensione superficiale.https://arxiv.org/html/2506.10051v1https://youtu.be/gieL0bxyTUU?si=MX-vqyiLFh2JmpO9#copilot #ChatGpt #development #podcast #dotnetinpillole
© 2020-2026 Ivy Podcast Discovery LLC
