Il Literate programming è un paradigma di programmazione introdotto da Donald Knuth in cui un programma per computer viene fornito come una spiegazione della sua logica in un linguaggio naturale, come l'inglese, intervallata da frammenti di macro e codice sorgente tradizionale, da cui può essere generato codice sorgente compilabile.

Il paradigma del literate programming, come concepito da Knuth, rappresenta un allontanamento dalla scrittura di programmi per computer nel modo e nell'ordine imposti dal computer, e consente invece ai programmatori di sviluppare programmi nell'ordine richiesto dalla logica e dal flusso dei loro pensieri. I literate programs sono scritti come un'esposizione ininterrotta della logica in un linguaggio umano ordinario, proprio come il testo di un saggio, in cui sono incluse le macro per nascondere le astrazioni e il codice sorgente tradizionale.

Gli strumenti per il literate programming (LP) vengono utilizzati per ottenere due rappresentazioni da un file sorgente literate: uno adatto per ulteriori compilazioni o esecuzioni da un computer, il codice "aggrovigliato" o "tangled" e un altro per la visualizzazione come documentazione formattata, che si dice sia "intessuta" o "woven".Se si ricorda ch la prima versione dello strumento era chiamata WEB, l'interessante riferimento letterario nascosto da Knuth in questi nomi diventa ovvio: La citazione reale apparve come un'epigrafe all'interno di un articolo pubblicato nel maggio del 1986 da Jon Bentley e Donald Knuth in una colonna di Programming Pearls, presente in Communications of the ACM, vol. 29, n. 5, p.365. Mentre la prima generazione di strumenti di literate programming era specifica per un certo linguaggio di programmazione, i successivi sono indipendenti ed esistono al di sopra di questi.

Storia e filosofia Il literate programming fu introdotto per la prima volta da Knuth nel 1984. L'intenzione principale dietro questo approccio era di trattare un programma come letteratura comprensibile agli esseri umani. Questo approccio è stato implementato presso l'Università di Stanford come parte della ricerca sugli algoritmi e sulla tipografia digitale. Questa implementazione fu chiamata " WEB " da Knuth poiché credeva che fosse una delle poche parole inglesi di tre lettere che non erano già state applicate al computer. Tuttavia, ricorda effettivamente la natura complicata del software delicatamente assemblato da materiali semplici.

Concetto Il literate programming consiste nello scrivere la logica del programma in un linguaggio umano con frammenti di codice e macro inclusi (separati da un markup primitivo). Le macro in un file sorgente literate sono semplicemente frasi simili a titoli o esplicative in un linguaggio umano, che descrivono le astrazioni umane create risolvendo il problema di programmazione, e nascondendo blocchi di codice o macro di livello inferiore. Queste macro sono simili agli algoritmi in pseudocodice tipicamente utilizzati nell'insegnamento dell'informatica. Queste frasi esplicative arbitrarie diventano precisi nuovi operatori, creati al volo dal programmatore, formando un metalinguaggio in cima al linguaggio di programmazione sottostante.

Un preprocessore viene utilizzato per sostituire gerarchie arbitrarie, o piuttosto "reti" di macro "interconnesse, per produrre il codice sorgente compilabile con un comando ("tangle" o "groviglio") e la documentazione con un altro ("weave" o "trama"). Il preprocessore offre anche la possibilità di generare il contenuto delle macro e di aggiungere le macro già create in qualsiasi posizione nel testo del file sorgente del programma, eliminando così la necessità di tenere presente le restrizioni imposte dai linguaggi di programmazione tradizionali o di interrompere il flusso del pensiero.

Vantaggi Secondo Knuth, il literate programming. fornisce programmi di qualità superiore, poiché obbliga i programmatori a dichiarare esplicitamente i pensieri alla base del programma, rendendo più ovvie le decisioni di progettazione scarsamente ponderate. Knuth afferma anche che il literate programming fornisce un sistema di documentazione di prim'ordine, che non è un componente aggiuntivo, ma è "cresciuto" naturalmente nel processo di esposizione dei propri pensieri durante la creazione di un programma.. La documentazione risultante consente all'autore di riavviare i propri processi di pensiero in qualsiasi momento successivo, e consente ad altri programmatori di comprendere più facilmente la costruzione del programma. Ciò differisce dalla documentazione tradizionale, in cui a un programmatore viene presentato un codice sorgente che segue un ordine imposto dal compilatore e da cui deve decifrare il processo di pensiero dietro il programma dal codice e dai commenti associati. Le capacità metalinguistiche del literate programming si sostiene anche che facilitino il ragionamento, offrendo una "visione a volo d'uccello" del codice e aumentando il numero di concetti che la mente può conservare ed elaborare con successo. L'applicabilità del concetto alla programmazione su larga scala, quella dei programmi di livello commerciale, è dimostrata da una edizione del codice TeX come literate program.

Knuth afferma inoltre che il Literate Programming può portare ad un facile porting di un dato software su più ambienti, e cita persino l'implementazione di TeX come esempio.

Contrasto con il classico processo di generazione della documentazione Molto spesso si chiama erroneamente literate programming il processo di estrazione della documentazione formattata prodotta da un file comune con codice sorgente e commenti - che è propriamente chiamata generazione di documentazione - o ai commenti copiosamente inclusi nel codice. Questo è il contrario del literate programming: il codice ben documentato o la documentazione estratta dal codice segue la struttura del codice, con la documentazione incorporata nel codice; mentre nel literate programming, il codice è incorporato nella documentazione, con il codice che segue la struttura della documentazione.

Questo malinteso ha portato alcuni a sostenere che gli strumenti di estrazione dei commenti, che i sistemi Perl Plain Old Documentation o Java Javadoc, siano "strumenti per il literate programming". Tuttavia, poiché questi strumenti non implementano la "rete di concetti astratti" che si nasconde dietro il sistema di macro in linguaggio naturale, o forniscono la capacità di cambiare l'ordine del codice sorgente da una sequenza imposta dalla macchina in una comoda per la mente umana, non possono essere correttamente chiamati strumenti di literate programming nel senso inteso da Knuth..

Critica Nel 1986, Jon Bentley chiese a Knuth di dimostrare il concetto di literate programming scrivendo un programma in WEB. Knuth produsse un lungo listato monolitico di 8 pagine che fu pubblicato insieme a una critica di Douglas McIlroy di Bell Labs. McIlroy ha elogiato la complessità della soluzione Knuth, e la sua scelta di una struttura di dati (hash trie di Frank M. Liang), ma ha notato che una più pratica, molto più veloce da implementare, debuggare e modificare soluzione del problema richiedeva solo sei righe di script shell riutilizzando utilities Unix standard. McIlroy ha concluso dicendo:

McIlroy ha successivamente ammesso che la sua critica era ingiusta, dal momento che ha criticato il programma di Knuth su basi ingegneristiche, mentre lo scopo di Knuth era solo quello di dimostrare la tecnica del literate programming. Nel 1987, Communications of the ACM ha pubblicato un articolo di follow-up che illustrava il literate programming con un programma C che combinava l'approccio artistico di Knuth con l'approccio ingegneristico di McIlroy, con una critica di John Gilbert.

Flusso di lavoro L'implementazione del literate programming prevede due passaggi:

Tessitura o Weaving: Generazione di un documento completo a proposito del programma e sulla sua manutenzione. Aggrovigliamento o Tangling: Generazione del codice macchina eseguibile

La tessitura e l'aggrovigliamento vengono eseguiti sulla stessa fonte in modo che siano coerenti tra loro.

Esempio Un classico esempio di literate programming è l'implementazione literate del programma standard di conteggio parole wc Unix. Knuth ha presentato una versione CWEB di questo esempio nel capitolo 12 del suo libro Literate Programming. Lo stesso esempio è stato successivamente riscritto per lo strumento di programmazione letterato noweb. Questo esempio fornisce una buona illustrazione degli elementi di base del literate programming.

Creazione di macro Il frammento seguente del literate program wc mostra come frasi descrittive arbitrarie in un linguaggio naturale vengono utilizzate per creare macro, che fungono da nuovi "operatori" nel linguaggio di programmazione literate e nascondono blocchi di codice o altre macro. La notazione di markup è composta da parentesi quadre (" <<...>> ") che indicano le macro, il simbolo " @ " che indica la fine della sezione di codice in un file noweb. Il simbolo " <<*>> " sta per "radice", nodo più in alto dal quale lo strumento di programmazione alfabetico inizierà a espandere la rete di macro. In realtà, scrivere il codice sorgente espanso può essere fatto da qualsiasi sezione o sottosezione (cioè un pezzo di codice designato come " <<name of the chunk>>= ", con il segno uguale), quindi un file di un literate program può contenere diversi file con codice sorgente. The purpose of wc is to count lines, words, and/or characters in a list of files. The number of lines in a file is ......../more explanations/

Here, then, is an overview of the file wc.c that is defined by the noweb program wc.nw: <<*>>= <<Header files to include>> <<Definitions>> <<Global variables>> <<Functions>> <<The main program>> @

We must include the standard I/O definitions, since we want to send formatted output to stdout and stderr. <<Header files to include>>= #include <stdio.h> @ Il dipanarsi dei blocchi può essere eseguito in qualsiasi posizione nel file di testo del programma letterato, non necessariamente nell'ordine in cui sono sequenziati nel blocco racchiudente, ma come richiesto dalla logica riflessa nel testo esplicativo che avvolge l'intero programma.

Programma come Web: le macro non sono solo nomi di sezioni Le macro non corrispondono ai "nomi di sezione" nella documentazione standard. Le macro nel literate programming possono nascondere dietro di sé qualsiasi blocco di codice ed essere utilizzate all'interno di qualsiasi operatore di linguaggio macchina di basso livello, spesso all'interno di operatori logici come " if ", " while " o " case ". Ciò è illustrato dal seguente frammento del literate program wc.

The present chunk, which does the counting, was actually one of the simplest to write. We look at each character and change state if it begins or ends a word.

<<Scan file>>= while (1) { <<Fill buffer if it is empty; break at end of file>> c = *ptr++; if (c > ' ' && c < 0177) { /* visible ASCII codes */ if (!in_word) { word_count++; in_word = 1;

continue;

if (c == '\n') line_count++; else if (c != ' ' && c != '\t') continue; in_word = 0; /* c is newline, space, or tab */

@

In effetti, le macro possono rappresentare qualsiasi frammento arbitrario di codice o altre macro e sono quindi più generali di una frammentazione top-down o bottom-up o di una sorta di sottosezionamento. Knuth dice che quando ha realizzato questo, ha iniziato a pensare a un programma come a una rete di varie parti..

Ordine della logica umana, non quello del compilatore