19 novembre 2026

Solid 2.0: segnali asincroni, meno “primitivi magici” e un framework che prova a prevenire i bug prima di prod

La nuova major di Solid riscrive il modo in cui gestisci l’async: Promise come valori reattivi, loading state che spariscono e un tooling pensato anche per flussi con agenti.

Solid 2.0 è la prima major release in anni e punta dritta al punto debole tipico delle UI moderne: la complessità dell’asincrono. Con un modello in cui anche le Promise diventano “segnali”, Solid riduce drasticamente boilerplate, flag di caricamento e race condition. In più, elimina API nate come workaround, sposta alcune funzionalità server nel core e introduce errori strutturati (codici, fix suggeriti e istruzioni per agenti) insieme a controlli proattivi su waterfall e loop di effetti.

Negli ultimi anni ci siamo abituati a un paradosso: le UI diventano sempre più ricche, ma la base su cui poggiano (rete, servizi, dipendenze, supply chain) è sempre più fragile. In questo contesto, ciò che “non si rompe” non è un dettaglio: è un obiettivo architetturale.

Solid 2.0 arriva con una promessa concreta per chi costruisce frontend complessi: rendere l’asincrono banale quanto lo stato locale, riducendo di colpo una categoria intera di bug — loading state incoerenti, race condition, cancellazioni dimenticate, waterfall involontarie.

Un ripasso utile: Solid non “ri-renderizza” come React

Solid è spesso descritto come “React, ma senza la parte dolorosa”. Il motivo è sotto al cofano:

  • i componenti vengono eseguiti una sola volta;
  • l’aggiornamento non avviene tramite re-render dell’albero, ma tramite aggiornamenti mirati dei singoli nodi DOM che dipendono da un valore;
  • il tutto è possibile grazie ai signals, cioè primitive reattive che tracciano con precisione chi legge cosa.

Questo modello ha contribuito a rendere popolari i signals ben oltre Solid: li ritroviamo in varie forme anche in altri ecosistemi (e perfino come idea ricorrente nel mondo JavaScript).

Il vero salto di Solid 2.0: l’async diventa un valore reattivo come gli altri

In Solid 1.x c’era una separazione netta:

  • i signals erano sincroni;
  • tutto ciò che arrivava dal server richiedeva primitive dedicate, spesso da comporre con meccanismi tipo suspense, transizioni e gestione manuale di stati intermedi.

Solid 2.0 ribalta la cosa con un’idea semplice ma potentissima: una computation può restituire una Promise.

Tradotto in pratica:

  • fai fetch (o qualunque operazione async) dentro una normale computation/memo;
  • consumi il risultato in JSX come se fosse un valore qualsiasi;
  • Solid sa che quel valore non è pronto e fa “aspettare” automaticamente tutto ciò che dipende da esso.

Perché cambia davvero il gioco

Se ti è mai capitato di gestire una UI a dipendenze, sai che il problema non è “mostrare uno spinner”. Il problema è quando:

  • una scelta utente invalida richieste precedenti;
  • i risultati arrivano fuori ordine;
  • devi cancellare, debouncare o ignorare risposte obsolete;
  • le dipendenze tra chiamate generano cascati di caricamenti e stati incoerenti.

Con i signals asincroni di Solid 2.0, gran parte di questa complessità viene assorbita dal framework: loading, coordinamento e cancellazione diventano aspetti del modello reattivo, non un collage di flag (isLoading, isFetching, isStale, requestId, ecc.) sparsi per l’app.

Un caso tipico: una select che determina quali “attributi” caricare. In molti stack finisci con:

  • stati di caricamento multipli;
  • race condition che emergono solo in produzione;
  • UI che mostra dati di una selezione precedente.

In Solid 2.0 l’obiettivo è che questo si riduca a poche righe, perché la dipendenza tra valori è la dipendenza tra richieste, senza dover orchestrare manualmente.

“Delete your darlings”: meno API, meno workaround

Quando cambi il modello, molte API nate per aggirare vecchi limiti diventano rumore. Solid 2.0 fa una scelta non comune: rimuove diverse primitive (inclusa una funzione di fetch molto usata in 1.x) insieme ad altre API che esistevano principalmente per sostenere il vecchio approccio.

Questa pulizia ha un effetto positivo sul design complessivo: meno concetti speciali, più coerenza interna.

Implicazione pratica

Se hai un’app in Solid 1, la migrazione non è “zero effort”: alcune parti vanno ripensate. Ma il vantaggio è che il risultato finale tende a essere più semplice (meno wrapper, meno suspense annidate, meno stati transitori).

Server: cosa cambia (e cosa non cambia)

Un altro spostamento importante riguarda le funzionalità server.

In passato esisteva un meta-framework ufficiale che copriva una parte di queste esigenze. Con 2.0 alcune funzionalità (in particolare le server functions) confluiscono nel core di Solid, riducendo la necessità di un “contenitore” unico e prescrittivo.

La filosofia che ne esce è chiara: invece di imporre un pacchetto totale con opinioni su ogni strato, Solid mira a essere un set di building block solidi (stato + async + server), lasciando più libertà su router e integrazioni.

Errori pensati per un mondo con agenti (ma utili anche a chi scrive a mano)

Solid 2.0 introduce un approccio interessante all’esperienza di debugging:

  • quando avviene un errore, non hai solo uno stack trace;
  • ottieni un codice errore, una posizione precisa, un fix suggerito;
  • e un riferimento a un file di istruzioni (es. skill.md) che descrive in modo strutturato come risolvere il problema.

Anche se non usi agenti, questo formato è una win: rende gli errori più cercabili, riproducibili e azionabili.

Controlli proattivi: waterfall e loop prima che facciano danni

Il modello reattivo di Solid ha un superpotere: sa esattamente quale stato viene letto e cosa sta per aggiornarsi.

Su 2.0 questo tracciamento viene sfruttato anche per intercettare classi di problemi che spesso scopri tardi:

  • request waterfall involontarie (dipendenze async serializzate quando potevano essere parallele);
  • effect loop implementati male (effetti che si auto-attivano in modo patologico).

L’idea è spostare il feedback “a sinistra”: meno sorprese in produzione, più diagnosi durante lo sviluppo.

Stabilità come feature: processi di rilascio più severi

Al di là delle feature, Solid 2.0 segnala anche una maturità di processo: tante iterazioni, molte correzioni, e una soglia più alta prima di dichiarare stabile una major. Per chi sceglie un framework per prodotti reali, la disciplina di rilascio è parte integrante della tecnologia.

Sintesi: perché Solid 2.0 merita attenzione

Solid 2.0 non prova a vincere con l’ennesima sintassi o con un nuovo pattern da imparare. Vince (quando ci riesce) con una promessa più rara:

  • trattare l’asincrono come stato, non come eccezione;
  • tagliare boilerplate (loading flag, cancellazioni, orchestrazioni manuali);
  • offrire un runtime che capisce le dipendenze reali e può prevenire categorie di bug.

Se costruisci UI dove i dati cambiano spesso, si sovrappongono richieste e la complessità nasce più dall’async che dal rendering, Solid 2.0 è un candidato serio: meno “gestione del caos”, più composizione naturale di valori reattivi.