Cosa sono le macchine a stati e quando sono utili?

Question

Accepted Answer

Una **macchina a stati** modella un sistema come un insieme finito di **stati** più le **transizioni** consentite tra di essi. Invece di gestire flag booleani indipendenti, definisci esattamente quali stati esistono e quali transizioni sono legali — rendendo gli stati impossibili non rappresentabili.

## Il problema: boolean soup

```js
// ❌ multiple booleans → 2^n combinations, many of them invalid
const [isLoading, setLoading] = useState(false);
const [isError, setError] = useState(false);
const [isSuccess, setSuccess] = useState(false);
// { isLoading: true, isError: true, isSuccess: true } — nonsense, but POSSIBLE
```

Con flag indipendenti, nulla impedisce combinazioni contraddittorie, e devi mantenerle manualmente coerenti ad ogni transizione — una calamita per i bug.

## Il modello della macchina a stati

```text
States:      idle → loading → success
                       ↓
                     error → (retry) → loading

Only defined transitions are allowed; you can't be in two states at once.
```

```js
const machine = {
  idle:    { FETCH: "loading" },
  loading: { SUCCESS: "success", ERROR: "error" },
  success: { FETCH: "loading" },
  error:   { RETRY: "loading" },
};
function transition(current, event) {
  return machine[current][event] ?? current; // only legal transitions happen
}
```

Una singola variabile `state` contiene lo stato attuale; un `event` attiva una transizione *definita*. Le transizioni illegali (ad esempio SUCCESS mentre inattivo) semplicemente non possono accadere — gli stati impossibili sono scomparsi per progettazione.

## Strumenti nel mondo reale: XState

```js
// libraries like XState formalize this with guards, actions, nested/parallel states
const toggleMachine = createMachine({
  initial: "inactive",
  states: {
    inactive: { on: { TOGGLE: "active" } },
    active:   { on: { TOGGLE: "inactive" } },
  },
});
```

## Quando le macchine a stati aiutano

```text
✓ Complex flows with many states: checkout, multi-step forms/wizards, media players
✓ Authentication flows (logged out → logging in → logged in → refreshing)
✓ Anything where invalid state combinations cause bugs
✗ Overkill for simple toggles or trivial state
```

## Perché è importante

Le macchine a stati portano rigore alla logica stateful complessa rendendo gli **stati non validi impossibili** e le transizioni **esplicite** — sostituendo fragili combinazioni di booleani con un modello chiaro ed esaustivo.

Sono particolarmente preziose per i flussi intricati (wizard, pagamenti, autenticazione, media) dove boolean soup porta a bug sottili e difficili da riprodurre.

Ancora informalmente (un enum `status`) l'idea migliora lo stato asincrono; formalmente (XState) fornisce logica visualizzabile, testabile e robusta.

Sapere quando usarle è un segno di progettazione di stati matura.