Nel 2010 Carmen Reinhart e Kenneth Rogoff pubblicarono un articolo che divenne uno dei più influenti della crisi finanziaria. La tesi: superata una soglia di debito pubblico intorno al 90% del PIL, la crescita media crolla. Fu citato nei dibattiti parlamentari e nelle motivazioni di politiche di austerità in mezza Europa.
Nel 2013 uno studente di dottorato dell’Università del Massachusetts, Thomas Herndon, chiese il foglio di calcolo originale per replicare l’analisi come esercizio di corso. Tra gli errori che trovò, insieme a scelte discutibili di ponderazione, ce n’era uno banale: una formula di media che selezionava un intervallo di celle che escludeva cinque paesi. Corretti i problemi, il crollo scompariva.
Non era un errore di programmazione. Era un errore di trascinamento del mouse.
Il no-code non è nuovo
La promessa di far programmare chi non è programmatore ha almeno sessant’anni, e ogni generazione ha creduto di essere la prima.
Il COBOL, nel 1959, fu presentato come un linguaggio abbastanza vicino all’inglese da permettere ai dirigenti di leggere e scrivere programmi. Negli anni Ottanta i cosiddetti linguaggi di quarta generazione dovevano rendere superflua la programmazione tradizionale. Poi arrivarono gli strumenti CASE, poi lo sviluppo rapido di applicazioni, poi le piattaforme low-code, e ora il no-code.
Nel 1978 Edsger Dijkstra scrisse una nota breve e cattiva sull’idea di programmare in linguaggio naturale. Il suo argomento non era snobismo: era che la difficoltà della programmazione non sta nella sintassi ma nella precisione richiesta, e che un linguaggio ambiguo non elimina il bisogno di precisione, lo nasconde finché non è troppo tardi.
Nel 1987 Fred Brooks formalizzò la stessa idea nel saggio più citato dell’ingegneria del software. Distingue tra complessità accidentale (quella degli strumenti, delle sintassi, dell’infrastruttura) e complessità essenziale, che è la difficoltà di specificare esattamente cosa deve succedere in tutti i casi possibili. Gli strumenti attaccano la prima. La seconda resta dov’è.
Il no-code è, in questa lettura, un ottimo attacco alla complessità accidentale. Il che è molto, e non è tutto.
L’esperimento naturale più grande: il foglio di calcolo
Il vero precedente del no-code non è una piattaforma di automazione. È Excel, che è il linguaggio di programmazione più usato al mondo e non viene quasi mai chiamato così.
Nel 2005 Christopher Scaffidi, Mary Shaw e Brad Myers hanno provato a contare, partendo dai dati del censimento del lavoro statunitense, quante persone programmano senza essere programmatori. La stima proiettata al 2012 era di oltre 55 milioni di persone che usavano fogli di calcolo e database al lavoro, contro meno di 3 milioni di programmatori professionisti. Un rapporto di venti a uno.
E qui arriva il dato che dovrebbe far riflettere chiunque stia per automatizzare un processo aziendale con uno strumento visuale. Raymond Panko ha raccolto per anni gli audit indipendenti su fogli di calcolo reali usati in produzione da aziende vere. Il risultato aggregato: errori trovati in circa l’88% dei fogli esaminati, con tassi di errore per cella nell’ordine dell’1-5%.
Non sono fogli fatti da dilettanti. Sono i fogli su cui si prendono decisioni.
I casi celebri sono la punta dell’iceberg: oltre a Reinhart e Rogoff, il rapporto interno di JPMorgan sulle perdite del 2012 documenta che un modello di rischio usava un foglio di calcolo in cui i valori venivano copiati e incollati a mano tra celle, e in cui una divisione era stata sostituita da una somma.
Il no-code non elimina la programmazione. La sposta su persone che non hanno versionamento, test, revisione tra pari e nessun momento in cui a qualcuno venga chiesto di controllare.
Dove funziona davvero
Detto tutto questo, il no-code funziona, e vale la pena essere precisi su dove.
| Caratteristica del compito | No-code | Codice |
|---|---|---|
| Regola semplice e stabile (“quando arriva X, fai Y”) | Ottimo | Eccessivo |
| Pochi casi particolari | Ottimo | Eccessivo |
| Molte eccezioni e condizioni annidate | Diventa illeggibile | Meglio |
| Serve tracciare chi ha cambiato cosa | Debole | Meglio |
| Volume alto e conseguenze economiche dirette | Rischioso | Meglio |
La regola pratica che ne deriva è semplice: il no-code eccelle quando la complessità essenziale del problema è bassa. Quando è alta non la fa sparire, la rende solo più difficile da vedere, perché un diagramma di venti blocchi collegati non si può leggere come si legge un testo.
Prima di automatizzare: quattro controlli
- Misura prima di automatizzare. Per una settimana annota quante volte fai ogni operazione ripetitiva e quanto dura. Automatizzare qualcosa che fai due volte al mese è un passatempo, non un guadagno.
- Automatizza un processo che hai già scritto. Se non sai descrivere a parole tutti i casi, incluse le eccezioni, lo strumento non li gestirà per te.
- Progetta l’errore, non solo il successo. Cosa succede se il campo è vuoto, se il servizio è irraggiungibile, se il dato arriva due volte? È qui che il 90% delle automazioni casalinghe fallisce in silenzio.
- Metti una notifica su ogni fallimento. Un’automazione che si rompe senza avvisare è peggio dell’operazione manuale che ha sostituito, perché nessuno se ne accorge per mesi.
- Scrivi cosa fa, dove e chi l’ha fatta. Un documento di dieci righe. È la differenza tra uno strumento aziendale e un debito che esplode quando cambi lavoro.
- Non ci mettere dentro dati che non devono uscire dall’azienda. Le piattaforme di automazione passano i dati attraverso servizi terzi: va verificato con chi si occupa di sicurezza, prima.
- Impara comunque un po’ di logica di programmazione. Condizioni, cicli, variabili. Sono gli stessi concetti sotto qualunque interfaccia visuale, e averli chiari è ciò che distingue un’automazione robusta da una fragile: vedi come imparare a programmare.
Cosa ne penso: il no-code è venduto con la promessa sbagliata
Penso che il no-code sia una delle cose più utili successe al lavoro d’ufficio negli ultimi dieci anni, e che venga venduto con la promessa sbagliata. La promessa giusta non è “non devi più pensare come un programmatore”. È “puoi pensare come un programmatore senza dover imparare anche l’infrastruttura”, che è già molto.
Trovo anche che il dato dell’88% di Panko meriti più attenzione di quanta ne riceva, perché descrive esattamente il futuro delle automazioni no-code aziendali tra qualche anno: migliaia di flussi costruiti da persone diverse, mai documentati, mai revisionati, che nessuno osa spegnere perché nessuno sa più cosa succede se lo fa.
Una previsione mia, senza numeri a sostegno: la competenza che conterà non sarà saper usare una piattaforma di automazione, ma saper riconoscere quando un processo è troppo pieno di eccezioni per essere automatizzato da chiunque.
Domande frequenti
Il no-code sostituirà i programmatori? Non è successo con il COBOL, con i linguaggi di quarta generazione né con gli strumenti CASE. L’argomento di Brooks spiega perché: gli strumenti riducono la complessità accidentale, non quella essenziale.
Quali strumenti conviene imparare? Meno importante di quanto sembri. Il concetto di innesco, condizione e azione è comune a tutti; imparato su uno, si trasferisce. Meglio uno usato bene che cinque provati.
Da dove comincio? Dall’operazione più noiosa e più frequente che fai, non dalla più complicata. La prima automazione serve a capire lo strumento, non a risolvere il problema grosso.
È rischioso per i dati aziendali? Può esserlo, perché i dati transitano da servizi esterni. Va verificato prima con chi in azienda si occupa di sicurezza informatica, non dopo.
Excel conta come no-code? È il no-code originale e più diffuso, ed è anche quello di cui abbiamo più dati sugli errori. Le basi sono in funzioni essenziali di Excel.
Fonti
- Herndon, T., Ash, M., & Pollin, R. (2014). Does High Public Debt Consistently Stifle Economic Growth? A Critique of Reinhart and Rogoff. Cambridge Journal of Economics, 38(2), 257-279. L’intervallo di celle incompleto.
- Panko, R. R. (1998). What We Know About Spreadsheet Errors. Journal of End User Computing, 10(2), 15-21. Gli audit sul campo e la quota di fogli con errori.
- Panko, R. R., & Halverson, R. P. (1996). Spreadsheets on Trial: A Survey of Research on Spreadsheet Risks. HICSS-29.
- Scaffidi, C., Shaw, M., & Myers, B. (2005). Estimating the Numbers of End Users and End User Programmers. IEEE VL/HCC. La stima dei 55 milioni.
- Brooks, F. P. (1987). No Silver Bullet: Essence and Accidents of Software Engineering. IEEE Computer, 20(4), 10-19. Complessità essenziale e accidentale.
- Dijkstra, E. W. (1978). On the Foolishness of “Natural Language Programming”. EWD667.
- Ko, A. J., et al. (2011). The State of the Art in End-User Software Engineering. ACM Computing Surveys, 43(3), 1-44.
- Nardi, B. A. (1993). A Small Matter of Programming: Perspectives on End User Computing. MIT Press. Nessun indirizzo pubblico stabile disponibile per il testo integrale. Perché i fogli di calcolo hanno avuto successo dove altri strumenti hanno fallito.
- JPMorgan Chase (2013). Report of the Management Task Force Regarding 2012 CIO Losses. La descrizione del modello basato su copia-incolla manuale tra celle.
- Powell, S. G., Baker, K. R., & Lawson, B. (2008). A Critical Review of the Literature on Spreadsheet Errors. Decision Support Systems, 46(1), 128-138.
Questo articolo è stato scritto seguendo il processo descritto in come scriviamo. Se trovi un dato riportato male, scrivimi: lo correggo e lo segnalo in fondo all’articolo.



