Il ''' Il Literate programming''' è un [[paradigma di programmazione]] introdotto da [[Donald Knuth]] in cui un [[Programma (informatica)|programma per computer]] viene fornito come una spiegazione della sua logica in un linguaggio naturale, come l'inglese, intervallata da [[Snippet|frammenti]] di [[Macro (informatica)|macro]] e [[codice sorgente]] tradizionale, da cui può essere generato codice sorgente [[Compilatore|compilabile]]. <ref name="TCJ_LP" >{{note label|TCJ_LP||v}}{{note label|TCJ_LP||w}}{{note label|TCJ_LP||x}}{{note label|TCJ_LP||y}}{{note label|TCJ_LP||z}}{{Cita pubblicazione|autore=Knuth|nome=Donald E.|linkautore=Donald Knuth|anno=1984|titolo=Literate Programming|rivista=[[The Computer Journal]]|editore=[[British Computer Society]]|volume=27|numero=2|pp=97–111|accesso=January 4, 2009|doi=10.1093/ comjnl/27.2.97|url=http://www.literateprogramming.com/knuthweb.pdf}}</ref> ▼
[[File:Literate_Programming_book_cover.jpg|miniatura| ''Literate Programming'' di [[Donald Knuth]] è il libro con cui ha inizialmente diffuso i concetti primari del literate programming]]
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 [[Programmatore informatico|programmatori]] di sviluppare programmi nell'ordine richiesto dalla logica e dal flusso dei loro pensieri. <ref> "{{Cita|Knuth}}{{Citazione|I had the feeling that top-down and bottom-up were opposing methodologies: one more suitable for program exposition and the other more suitable for program creation. But after gaining experience with WEB, I have come to realize that there is no need to choose once and for all between top-down and bottom-up, because a program is best thought of as a web instead of a tree. A hierarchical structure is present, but the most important thing about a program is its structural relationships. A complex piece of software consists of simple parts and simple relations between those parts; the programmer's task is to state those parts and those relationships, in whatever order is best for human comprehension not in some rigidly determined order like top-down or bottom-up ." — [[Donald Knuth|Donald E. Knuth]], Literate Programming{{ref label|TCJ_LP|1|v}}</ref> 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|il codice sorgente]] tradizionale. ▼▲'''Il Literate programming''' è un [[paradigma di programmazione]] introdotto da [[Donald Knuth]] in cui un [[Programma (informatica)|programma per computer]] viene fornito come una spiegazione della sua logica in un linguaggio naturale, come l'inglese, intervallata da [[Snippet|frammenti]] di [[Macro (informatica)|macro]] e [[codice sorgente]] tradizionale, da cui può essere generato codice sorgente [[Compilatore|compilabile]]. <ref name="TCJ_LP">{{note label|TCJ_LP||v}}{{note label|TCJ_LP||w}}{{note label|TCJ_LP||x}}{{note label|TCJ_LP||y}}{{note label|TCJ_LP||z}}{{Cita pubblicazione|autore=Knuth|nome=Donald E.|linkautore=Donald Knuth|anno=1984|titolo=Literate Programming|rivista=[[The Computer Journal]]|editore=[[British Computer Society]]|volume=27|numero=2|pp=97–111|accesso=January 4, 2009|doi=10.1093/comjnl/27.2.97|url=http://www.literateprogramming.com/knuthweb.pdf}}</ref>
Gli strumenti per il literate programming (LP) vengono utilizzati per ottenere due rappresentazioni da un [[file sorgente ]] literate: uno adatto per ulteriori compilazioni o [[File eseguibile|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". <ref name="ObliqueScottReference"> IfSe onesi remembersricorda thatch thela firstprima versionversione ofdello thestrumento toolera was calledchiamata WEB, thel'interessante amusingriferimento literaryletterario referencenascosto hidden byda Knuth in thesequesti namesnomi becomesdiventa obviousovvio: "{{Citazione|Oh, what a tangled web we weave when first we practise to deceive " – |autore=[[Sir Walter Scott]], in Canto VI, Stanza 17 ofdi ''[[Marmion ( poempoema)|Marmion]]'' (1808) , anun epicpoema poemepico about thesulla [[ Battlebattaglia ofdi Flodden Field]] indel 1513. }} –La thecitazione actualreale citationapparve appearedcome asun'epigrafe anall'interno epigraphdi inun aarticolo Maypubblicato 1986nel articlemaggio bydel 1986 da Jon Bentley ande Donald Knuth in oneuna ofcolonna the classicaldi ''Programming Pearls '', columnspresente in ''Communications of the ACM '', vol . 29 , numn. 5 on, p.365 .</ref> 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. ▼▲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 [[Programmatore informatico|programmatori]] di sviluppare programmi nell'ordine richiesto dalla logica e dal flusso dei loro pensieri. <ref>"I had the feeling that top-down and bottom-up were opposing methodologies: one more suitable for program exposition and the other more suitable for program creation. But after gaining experience with WEB, I have come to realize that there is no need to choose once and for all between top-down and bottom-up, because a program is best thought of as a web instead of a tree. A hierarchical structure is present, but the most important thing about a program is its structural relationships. A complex piece of software consists of simple parts and simple relations between those parts; the programmer's task is to state those parts and those relationships, in whatever order is best for human comprehension not in some rigidly determined order like top-down or bottom-up." — [[Donald Knuth|Donald E. Knuth]], Literate Programming{{ref label|TCJ_LP|1|v}}</ref> 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 [[Codice sorgente|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 [[File eseguibile|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". <ref name="ObliqueScottReference">If one remembers that the first version of the tool was called WEB, the amusing literary reference hidden by Knuth in these names becomes obvious: "Oh, what a tangled web we weave when first we practise to deceive" – [[Sir Walter Scott]], in Canto VI, Stanza 17 of ''[[Marmion (poem)|Marmion]]'' (1808) an epic poem about the [[Battle of Flodden]] in 1513. – the actual citation appeared as an epigraph in a May 1986 article by Jon Bentley and Donald Knuth in one of the classical Programming Pearls columns in Communications of the ACM, vol 29 num 5 on p.365</ref> 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 ==
LaIl programmazioneliterate letterariaprogramming fu introdottaintrodotto 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 la l'[[Università di Stanford|Stanford University]] come parte della ricerca sugli [[Algoritmo|algoritmi]] e sulla [[tipografia]] digitale. Questa implementazione fu chiamata " [[WEB (linguaggio)|WEB]] " da Knuth poiché credeva che fosse una delle poche parole inglesi di tre lettere che non erano già state applicate al computer. <ref>{{Cita web|url=http://www.literateprogramming.com/knuthweb.pdf|titolo=Literate Programming|cognome=|nome=|sito=archive.computerhistory.org|data=|accesso=3 giugno 2019-06-03|urlarchivio=|dataarchivio=|urlmortolingua=en}}</ref> Tuttavia, assomigliaricorda correttamenteeffettivamente allala natura complicata del software delicatamente assemblato da materiali semplici. <ref name="TCJ_LP">{{note label|TCJ_LP||v}}{{note label|TCJ_LP||w}}{{note label|TCJ_LP||x}}{{note label|TCJ_LP||y}}{{note label|TCJ_LP||z}}{{Cita pubblicazione|autore=Knuth|nome=Donald E.|linkautore=Donald Knuth|anno=1984|titolo=Literate Programming|rivista=[[The Computer Journal]]|editore=[[British Computer Society]]|volume=27|numero=2|pp=97–111|accesso=January 4, 2009|doi=10.1093/comjnl/27.2.97|url=http://www.literateprogramming.com/knuthweb.pdf}}</ref>
== 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 [[Algoritmo|algoritmi]] in [[pseudocodice]] tipicamente utilizzati nell'insegnamento dell'[[Informatica|dell'informatica]] . Queste frasi esplicative arbitrarie diventano precisi nuovi operatori, creati al volo dal programmatore, formando un ''meta-linguaggiometalinguaggio'' in cima al linguaggio di programmazione sottostante.
Un [[preprocessore]] viene utilizzato per sostituire gerarchie arbitrarie, o piuttosto "reti" di macro "interconnesse, <ref>{{Cita|Knuth}}{{Citazione|"WEB's macros are allowed to have at most one parameter. Again, I did this in the interests of simplicity, because I noticed that most applications of multiple parameters could in fact be reduced to the one-parameter case. For example, suppose that you want to define something like... In other words, the name of one macro can usefully be a parameter to another macro. This particular trick makes it possible to..."|[[Donald Knuth|Donald E. Knuth]]|Literate Programming{{ref label|TCJ_LP|1|w}}}}</ref> 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 [[Linguaggio di programmazione|linguaggi di programmazione]] tradizionali o di interrompere il flusso del pensiero.
=== Vantaggi ===
Secondo Knuth, il literate programming <ref name="Knuth">{{Cita web|url=https://www.informit.com/articles/article.aspx?p=1193856|titolo=Interview with Donald Knuth|cognome=Knuth|nome=Donald E.|wkautore=Donald Knuth|data=April25 25,aprile 2008|citazione=Yet to me, literate programming is certainly the most important thing that came out of the [[TeX]] project. Not only has it enabled me to write and maintain programs faster and more reliably than ever before, and been one of my greatest sources of joy since the 1980s-it has actually been indispensable at times. Some of my major programs, such as the MMIX meta-simulator, could not have been written with any other methodology that I've ever heard of. The complexity was simply too daunting for my limited brain to handle; without literate programming, the whole enterprise would have flopped miserably. ... Literate programming is what you need to rise above the ordinary level of achievement.|accesso=January 4, gennaio 2009}}</ref> <ref>{{Cita|Knuth}}. {{Citazione|"Another surprising thing that I learned while using WEB was that traditional programming languages had been causing me to write inferior programs, although I hadn't realized what I was doing. My original idea was that WEB would be merely a tool for documentation, but I actually found that my WEB programs were better than the programs I had been writing in other languages."|[[Donald Knuth|Donald E. Knuth]]|Literate Programming{{ref label|TCJ_LP|1|x}}}}</ref> 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. <ref>{{Cita|Knuth}}. {{Citazione|"Thus the WEB language allows a person to express programs in a ''"stream of consciousness" order''. TANGLE is able to scramble everything up into the arrangement that a PASCAL compiler demands. This feature of WEB is perhaps its greatest asset; it makes a WEB-written program much more readable than the same program written purely in PASCAL, even if the latter program is well commented. And the fact that there's no need to be hung up on the question of top-down versus bottom-up, since a programmer can now ''view a large program as a web, to be explored in a '''psychologically correct order''' is perhaps the greatest lesson'' I have learned from my recent experiences."|[[Donald Knuth|Donald E. Knuth]]|Literate Programming{{ref label|TCJ_LP|1|y}}}}</ref> 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à meta-linguistichemetalinguistiche 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. <ref name="Knuth" />
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. <ref>{{Cita web|url=http://archive.computerhistory.org/resources/text/Oral_History/Knuth_Don_1/Knuth_Don.oral_history.2007.102658053_all.pdf|titolo="Oral History of Donald Knuth"- an Interview with Ed Feigenbaum|cognome=|nome=|sito=archive.computerhistory.org|data=|accesso=7 dicembre 2018-12-07|urlarchivio=|dataarchivio=|urlmortolingua=en}}</ref>
=== Contrasto con il classico processo di generazione della documentazione ===
Molto spesso si fraintendechiama ilerroneamente literate programming<ref name="MJD2000">{{Cita web|url=https://www.perl.com/pub/tchrist/litprog.html/|titolo=POD> isil notprocesso Literatedi Programming|cognome=Dominus|nome=Mark-Jason|wkautore=Markestrazione Jason Dominus|sito=Perl.com|data=March 20, 2000|urlarchivio=https://web.archive.org/web/20090102151452/http://www.perl.com/pub/a/tchrist/litprog.html|dataarchivio=January 2, 2009|urlmorto=no}}</ref> per riferirsi solo alladella 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 (linguaggio di programmazione)|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. <ref name="MJD2000">{{Cita web|url=https://www.perl.com/pub/tchrist/litprog.html/|titolo=POD is not Literate Programming|cognome=Dominus|nome=Mark-Jason|wkautoreautore=Mark Jason Dominus|sito=Perl.com|data=March20 20,marzo 2000|urlarchivio=https://web.archive.org/web/20090102151452/http://www.perl.com/pub/a/tchrist/litprog.html|dataarchivio=January 2, gennaio 2009|urlmorto=no}}</ref> <ref>{{Cita|Knuth}}. {{Citazione|"I chose the name WEB partly because it was one of the few three-letter words of English that hadn't already been applied to computers. But as time went on, I've become extremely pleased with the name, because I think that a complex piece of software is, indeed, best regarded as a web that has been delicately pieced together from simple materials. We understand a complicated system by understanding its simple parts, and by understanding the simple relations between those parts and their immediate neighbors. If we express a program as a web of ideas, we can emphasize its structural properties in a natural and satisfying way."|[[Donald Knuth|Donald E. Knuth]]|Literate Programming{{ref label|TCJ_LP|1|z}}}}</ref>
=== Critica ===
Nel 1986, [[Jon Bentley]] chiese a Knuth di dimostrare il concetto di literate programming scrivendo un programma in WEB. Knuth tirò fuoriprodusse un lungo elencolistato 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 richiederichiedeva solo sei righe di script shell riutilizzando standard utilities [[Unix]] standard. McIlroy ha concluso dicendo: <ref>{{Cita pubblicazione|autore=Jon Bentley|linkautore=Jon Bentley (computer scientist)|anno=1986|titolo=Programming pearls|volume=29|pp=471-483|url=https://www.cs.tufts.edu/~nr/cs257/archive/don-knuth/pearls-2.pdf|autore2=D. E. Knuth|autore3=M. D. McIlroy|wkautore3lingua=Douglas McIlroyen}}</ref>
{{Citazione|Knuth ci ha mostrato come programmare intellegibilmente, ma non saggiamente. Apprezzo la disciplina. Non apprezzo il risultato. Ha creato una sorta di intricato uovo Faberge di qualità industriale, magnificamente lavorato, rifinito oltre ogni ordinario desiderio, un autentico pezzo da museo.}}
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. <ref>{{Cita web|url=https://www.princeton.edu/~hos/mike/transcripts/mcilroy.htm|titolo=Interview with M. D. McIlroy|cognome=Michael S. Mahoney|wkautore=Michael Sean Mahoney|data=18 August 1989}}</ref> 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. <ref>{{Cita pubblicazione|autore=Christopher J. Van Wyk|data=July 1987|titolo=Literate programming|volume=30|numero=7|pp=593-599|url=https://www.cs.upc.edu/~eipec/pdf/p583-van_wyk.pdf|autore2=David R. Hanson|autore3=John Gilbert|wkautore2=David Hanson (computer scientist)}}</ref> ▼
▲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. <ref>{{Cita web|url=https://www.princeton.edu/~hos/mike/transcripts/mcilroy.htm|titolo=Interview with M. D. McIlroy| cognome=Michael S. Mahoney|wkautoreautore=Michael Sean Mahoney|data=18 Augustagosto 1989 |lingua=en}}</ref> 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. <ref>{{Cita pubblicazione|autore=Christopher J. Van Wyk|data= Julyluglio 1987|titolo=Literate programming|volume=30|numero=7|pp=593-599|url=https://www.cs.upc.edu/~eipec/pdf/p583-van_wyk.pdf|autore2=David R. Hanson|autore3=John Gilbert| wkautore2lingua= Daviden|accesso=30 Hansonluglio (computer2019|dataarchivio=16 scientist)luglio 2023|urlarchivio=https://web.archive.org/web/20230716224057/https://www.cs.upc.edu/~eipec/pdf/p583-van_wyk.pdf|urlmorto=sì}}</ref>
== 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 <code>[[Wc (Unix)|wc]]</code> [[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 . <ref name="noweb-wc">{{Cita web|url=https://www.cs.tufts.edu/~nr/noweb/examples/wc.html|titolo=An Example of noweb|cognome=Ramsey|nome=Norman|data=May 13, 2008|accesso=January 4, 2009}}</ref> Questo esempio fornisce una buona illustrazione degli elementi di base del literate programming.
=== Creazione di macro ===
Il frammento seguente del literate program <code>wc</code> <ref name="noweb-wc">{{Cita web|url=https://www.cs.tufts.edu/~nr/noweb/examples/wc.html|titolo=An Example of noweb|cognome=Ramsey|nome=Norman|data=May 13, 2008|accesso=January 4, 2009}}</ref> 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 (" <code><<...>></code> ") che indicano le macro, il simbolo " <code>@</code> " che indica la fine della sezione di codice in un file noweb. Il simbolo " <code><<*>></code> " 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 " <code><<name of the chunk>>=</code> ", con il segno uguale), quindi un file di un literate program può contenere diversi file con codice sorgente.
<sourcesyntaxhighlight lang="c">
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/
#include <stdio.h>
@
</syntaxhighlight>
</source>
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 " <code>if</code> ", " <code>while</code> " o " <code>case</code> ". Ciò è illustrato dal seguente frammento del literate program <code>wc</code> . <ref name="noweb-wc">{{Cita web|url=https://www.cs.tufts.edu/~nr/noweb/examples/wc.html|titolo=An Example of noweb|cognome=Ramsey|nome=Norman|data=May 13, 2008|accesso=January 4, 2009}}</ref>
<sourcesyntaxhighlight lang="c">
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
}
@
</syntaxhighlight>
</source>
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. <ref name="TCJ_LP">{{note label|TCJ_LP||v}}{{note label|TCJ_LP||w}}{{note label|TCJ_LP||x}}{{note label|TCJ_LP||y}}{{note label|TCJ_LP||z}}{{Cita pubblicazione|autore=Knuth|nome=Donald E.|linkautore=Donald Knuth|anno=1984|titolo=Literate Programming|rivista=[[The Computer Journal]]|editore=[[British Computer Society]]|volume=27|numero=2|pp=97–111|accesso=January 4, 2009|doi=10.1093/comjnl/27.2.97|url=http://www.literateprogramming.com/knuthweb.pdf}}.</ref>
=== Ordine della logica umana, non quello del compilatore ===
In un literate program noweb oltre all'ordine libero della loro esposizione, i blocchi dietro le macro, una volta introdotti con " <code><<...>>=</code> ", possono essere sviluppati successivamente in qualsiasi posto nel file semplicemente scrivendo " <code><<name of the chunk>>=</code> "e aggiungendo più contenuto ad esso, come illustra il seguente frammento (" più" viene aggiunto dal formatter del documento per la leggibilità e non è nel codice). <ref name="noweb-wc">{{Cita web|url=https://www.cs.tufts.edu/~nr/noweb/examples/wc.html|titolo=An Example of noweb|cognomeautore=Norman Ramsey|nomelingua=Normanen|data=May 13, maggio 2008|accesso=January 4, gennaio 2009}}</ref>
<sourcesyntaxhighlight lang="text"> The grand totals must be initialized to zero at the beginning of the program.
If we made these variables local to main, we would have to do this initialization
explicitly; however, C globals are automatically zeroed. (Or rather,``statically
/* total number of words, lines, chars */
@
</syntaxhighlight>
</source>
=== Registrazione del processo di ragionamento ===
La documentazione per un literate program viene prodotta come parte della stesura del programma. Invece dei commenti forniti come note a margine del codice sorgente, un literate program contiene la spiegazione dei concetti su ciascun livello, con concetti di livello inferiore rinviati al loro posto appropriato, cosa che consente una migliore comunicazione del pensiero. I frammenti di <code>wc</code> sopra mostrano come si intrecciano la spiegazione del programma e del suo codice sorgente. Tale esposizione di idee crea un flusso del pensiero, come un'opera letteraria. Knuth ha scritto un "romanzo" che spiega il codice del gioco di [[Avventura testuale|narrativa interattiva]] [[Colossal Cave Adventure]] . <ref>TheIl gamegioco, alsonoto knownanche ascome ''ADVENT'', wasera originallystato writteninizialmente byscritto da Crowther in aboutcirca 700 lineslinee ofdi FORTRANcodice codeFORTRANcode; Knuth recastlo itrimaneeggiò intonel thelinguaggio WEB idiom. It isÈ availabledisponibile atsu [http://www.literateprogramming.com/cweb_download.html literateprogramming.com] oro onsul [https://cs.stanford.edu/~knuth/programs.html sito di Knuth's website] ({{Webarchive|url=https://web.archive.org/web/20080820091137/http://sunburn.stanford.edu/~knuth/programs.html|datedata=2008-08-20}}).</ref>
== Strumenti ==
Il primo ambiente di literate programming pubblicato fu [[WEB (linguaggio)|WEB]], introdotto da Knuth nel 1981 per il suo sistema di composizione tipografica [[TeX]] ; utilizza [[Pascal (linguaggio di programmazione)|Pascal]] come linguaggio di programmazione sottostante e TeX per la composizione della documentazione. Il codice sorgente TeX commentato completo è stato pubblicato in ''TeX: The Program'' di Knuth, volume B dell'opera in 5 volumi ''Computers and Typesetting''. Knuth aveva usato privatamente un sistema di literate programming chiamato DOC già dal 1979. Si ispirava alle idee di Pierre-Arnoul de Marneffe . <ref>{{Cita pubblicazione|autore=de Marneffe|nome=Pierre Arnoul|linkautore=Pierre-Arnoul de Marneffe|data=Decemberdicembre 1973|titolo=Holon Programming – Report PMAR 73-23|editore=[[UniversityUniversité ofde Liège|University de Liège]],- Service d'Informatique}}</ref> Il CWEB gratuito, scritto da Knuth e Silvio Levy, è WEB adattato per [[C (linguaggio)|C]] e [[C++|C ++]], funziona sulla maggior parte dei sistemi operativi e può produrre documentazione TeX e [[Portable Document Format|PDF]] .
Esistono varie altre implementazioni del concetto di programmazione letterata (alcune non hanno macro e quindi violano il principio dell'ordine della logica umana come punto prioritario):
* [[Axiom (software)|Axiom]], che si è evoluto da scratchpad, un sistema di calcolo algebrico per computer sviluppato da [[IBM]]. Ora è sviluppato da Tim Daly, uno degli sviluppatori di scratchpad, Axiom è totalmente scritto come literate program.
* noweb è indipendente dal linguaggio di programmazione del codice sorgente. È noto per la sua semplicità, data la necessità di utilizzare solo due convenzioni di markup del testo e due invocazioni di strumenti e consente la [[formattazione del testo]] in HTML anziché passare attraverso il sistema TeX.
* ''Literate'' è un "moderno sistema di literate programming". Come noweb, funziona con qualsiasi linguaggio di programmazione, ma produce HTML con evidenziazione della sintassi e cerca di conservare tutti i vantaggi di CWEB, incluso l'output formattato come CWEB. Altri notevoli vantaggi rispetto agli strumenti precedenti includono l'essere basato su Markdown e la generazione di codice "aggrovigliato" ben formattato.<ref>{{Cita web|autore=Zachary Yedidia|data=24 luglio 2019|titolo=A literate programming tool for any language|lingua=en|accesso=30 luglio 2019|sito=GitHub|url=https://github.com/zyedidia/Literate . }}</ref>
* FunnelWeb è un altro strumento LP in grado di produrre output HTML. Ha un markup più complicato (con "@" che sfugge a qualsiasi comando FunnelWeb), ma ha molte opzioni flessibili. Come noweb, è indipendente dal linguaggio di programmazione del codice sorgente.<ref>{{Cita web|url=http://www.ross.net/funnelweb/|urlmorto=sì|urlarchivio=https://web.archive.org/web/20190604103010/http://www.ross.net/funnelweb/|sito=FunnelWeb|titolo=The FunnelWeb Literate Programming Tool|lingua=en}}</ref>
* Nuweb può tradurre una singola fonte LP in un numero qualsiasi di file di codice in qualsiasi combinazione di linguaggi insieme alla documentazione in [[LaTeX]] . Lo fa in una sola invocazione; non ha comandi di trama e groviglio separati. Non ha l'estensibilità di noweb, ma può usare il pacchetto listings di LaTeX per fornire una stampa ben formattata ed il pacchetto hyperref per fornire collegamenti ipertestuali nell'output PDF. Dispone inoltre di ampie funzionalità di indicizzazione e riferimenti incrociati, inclusi riferimenti incrociati dal codice generato alla documentazione, sia come commenti generati automaticamente sia come stringhe che il codice può utilizzare per segnalare/fare rapporto del proprio comportamento. Vimes è un type-checker per la [[notazione Z]] che mostra l'uso di nuweb in un'applicazione pratica. Circa 15.000 righe di sorgenti nuweb sono tradotte in quasi 15.000 righe di codice C / C ++ e oltre 460 pagine di documentazione.<ref>{{Cita web|url=http://nuweb.sourceforge.net/|titolo=The nuweb system for Literate Programming|sito=nuweb.sourceforge.net|lingua=en|accesso=30 luglio 2019}}</ref>
* [https://github.com/slott56/py-web-tool pyWeb] è uno strumento di literate programming che ha la sintassi per le macro simili a CWEB, ma utilizza [[ReStructuredText]] invece di [[TeX]] per il markup e rispetta l'indentazione, cosa che lo rende utilizzabile per linguaggi come [[Python]], sebbene sia possibile utilizzarlo per qualsiasi linguaggio di programmazione.
* Molly è uno strumento LP scritto in [[Perl]], che mira a modernizzare e ridimensionare il literate programming per mezzo di "HTML pieghevole (folding)" e "viste virtuali" sul codice. Utilizza il markup "noweb" per i file di origine literate.<ref>{{Cita web|data=13 febbraio 2019|titolo=A literate programming "weaver" which can run as CGI to produce folding HTML-formatted documentation and runs with "noweb" tools of Norman Ramsey: unixtechie/Literate-Molly|sito=GitHub|lingua=en|accesso=30 luglio 2019|url=https://github.com/unixtechie/Literate-Molly . }}</ref>
* Codnar è uno strumento di literate programming inverso disponibile come [[RubyGems|Ruby Gem]] . Invece di estrarre il codice sorgente leggibile dal compilatore dalle fonti di documentazione, la documentazione literate viene estratta dai normali file di codice sorgente leggibili dalla macchina. Questo consente a questi file di codice sorgente di essere modificati e mantenuti come al solito. L'approccio è simile a quello utilizzato dai più diffusi strumenti di documentazione [[Application programming interface|API]], come [[Javadoc|JavaDoc]] . Tali strumenti, tuttavia, generano documentazione di riferimento [[Application programming interface|API]], mentre Codnar genera una narrazione lineare che descrive il codice, simile a quella creata dai classici strumenti LP. Codnar può coesistere con gli strumenti di documentazione API, consentendo sia un manuale di riferimento che una narrazione lineare generabili dallo stesso set di file di codice sorgente.<ref>{{Cita web|autore=Oren Ben-Kiki|data=21 giugno 2019|sito=GitHub|titolo=Code Narrator: an inverse literate programming tool. - orenbenkiki/codnar|lingua=en|accesso=30 luglio 2019|url=https://github.com/orenbenkiki/codnar }}</ref>
* L' editor di testo Leo è un outlining editor che supporta opzionalmente i markup noweb e CWEB L'autore di Leo mescola due approcci diversi: in primo luogo, Leo è un outlining editor, cosa che aiuta nella gestione di testi di grandi dimensioni; in secondo luogo, Leo incorpora alcune delle idee del literate programming, che nella sua forma pura (cioè il modo in cui viene utilizzato dallo strumento Web di Knuth o strumenti come "noweb") è possibile solo con un certo grado di inventiva e l'uso dell'editor in un modo non esattamente previsto dal suo autore (in nodi @root modificati). Tuttavia, questa e altre estensioni (nodi @file) rendono la programmazione della struttura e la gestione del testo efficaci e facilmente gestibili ed in qualche modo simili al literate programming. <ref>{{Cita web|url=http://leoeditor.com/|titolo=Leo's Home Page|cognome=Ream|nomeautore=Edward K. Ream|lingua=en|data=September 2, settembre 2008|accesso=April 3, aprile 2015|dataarchivio=16 luglio 2023|urlarchivio=https://web.archive.org/web/20230716224054/http://leoeditor.com/|urlmorto=sì}}</ref>
* Il [[Haskell (linguaggio)|linguaggio di]] programmazione [[Haskell (linguaggio)|Haskell]] ha il supporto nativo per un semi-literate programming. Il compilatore/interprete supporta due estensioni di file: <code>.hs</code> e <code>.lhs</code> ; quest'ultimo sta per literate Haskell.
: I literate script possono essere testo sorgente LaTeX completo, e allo stesso tempo possono essere compilati, senza modifiche, perché l'interprete compila il testo solo in un ambiente di codice, ad esempio
: <sourcesyntaxhighlight lang="lhs">
% here text describing the function:
\begin{code}
\end{code}
here more text
</syntaxhighlight>
</source>
: Il codice può anche essere marcato nello stile Richard Bird, iniziando ogni riga con un simbolo maggiore di e uno spazio, precedendo e terminando il pezzo di codice con linee vuote.
* Il pacchetto di <code>listings</code> LaTeX fornisce un ambiente <code>lstlisting</code> che può essere utilizzato per abbellire il codice sorgente. Può essere utilizzato per definire un ambiente <code>code</code> da utilizzare all'interno di Haskell per stampare i simboli in modo simile a:
: <sourcesyntaxhighlight lang="lhs">
\newenvironment{code}{\lstlistings[language=Haskell]}{\endlstlistings}
(g `comp` f) x = g(f x)
\end{code}
</syntaxhighlight>
</source>
:può essere configurato per ottenere qualcosa comesimile a questo:
::<math>
\begin{align}
\end{align}
</math>
: Sebbene il pacchetto non fornisca i mezzi per organizzare blocchi di codice, è possibile dividere il codice sorgente LaTeX in diversi file. VediVedere il [http://mirrors.ctan.org/macros/latex/contrib/listings/listings.pdf manuale di listings] per una panoramica.
* Il sistema di programmazione letterata Web 68 utilizzava Algol 68 come linguaggio di programmazione sottostante, sebbene non ci fosse nulla nel pre-processore "tang" che forzasse ad utilizzare quel linguaggio. <ref>{{Cita web|url=http://www.poenikatu.co.uk/html/Web68man.html|titolo=Web 68: Literate programming with Algol 68|cognomeautore=Sian Mountbatten|accesso=1º Januarygennaio 2013|lingua=en|urlarchivio=https://web.archive.org/web/20130120154432/http://www.poenikatu.co.uk/html/Web68man.html|dataarchivio=20 gennaio 2013|urlmorto=sì}}</ref>
* [[Emacs]] org-mode per il literate programming tramite Babel, <ref>{{Cita web|url=https://orgmode.org/worg/org-contrib/babel/intro.html|titolo=Babel: Introduction|sito=orgmode.org|lingua=en|accesso=30 luglio 2019}}</ref> che consente di incorporare blocchi di codice sorgente da più linguaggi di programmazione <ref>{{Cita web|url=https://orgmode.org/worg/org-contrib/babel/languages.html#langs|titolo=Babel Languages|lingua=en|accesso=30 luglio 2019}}</ref> in un unico documento di testo. I blocchi di codice possono condividere dati tra loro, visualizzare immagini in linea o essere parsati in puro codice sorgente utilizzando la sintassi di riferimento noweb . <ref>{{Cita web|url=https://orgmode.org/worg/org-contrib/babel/intro.html#literate-programming|titolo=Babel: Introduction - Literate Programming|sito=orgmode.org|lingua=en|accesso=30 luglio 2019}}</ref>
* [[CoffeeScript]] supporta una modalità "literate", che consente di compilare programmi da un documento di origine scritto in [[Markdown]] con blocchi di codice indentati. <ref>{{Cita web|url=https://coffeescript.org/#literate|titolo=Literate CoffeeScript|cognomeautore=Jeremy Ashkenas|accesso=13 Novembernovembre 2014|lingua=en}}</ref>
* I [[Mathematica|I notebook Wolfram]] sono un metodo di programmazione literate indipendente dalla piattaforma che combina testo e grafica con codice live. <ref>[{{Cita libro|url=https://books.google.com/books?id=JTYPKxug49IC&pg=PA157&lpg=PA157&dq=%22Stephen+Wolfram%22+%22Literate+programming%22&source=bl&ots=C7RhOB4uR5&sig=_i5FMOR-d_BVsiwk7BD-C2Hye-8&hl=en&sa=X&ved=0CB0Q6AEwAGoVChMIhomzxbqGyQIVBcRjCh02pge6#v=onepage&q=%22Stephen%20Wolfram%22%20%22Literate%20programming%22&f=false |titolo=Milestones in Computer Science and Information Technology] by |autore=Edwin D. Reilly, |p. =157.}}</ref> <ref>{{Cita web|url=https://www.wolfram.com/notebooks/|titolo=Wolfram Notebooks|cognome=|nome=|sito=www.wolfram.com|datalingua=en|accesso=28 novembre 2018-11-28}}</ref>
* [[Swift (linguaggio di programmazione)]], creato da [[Apple|Apple Inc.,]], può essere modificato in [https://developer.apple.com/library/prerelease/ios/recipes/Playground_Help/Chapters/AboutPlaygrounds.html Playgrounds] che fornisce un ambiente di programmazione interattivo che valuta ogni istruzione e visualizza i risultati in tempo reale durante la modifica del codice. I playgrounds consentono inoltre all'utente di aggiungere del [[Linguaggio di markup|linguaggio Markup]] insieme al codice che fornisce intestazioni, formattazione in linea ed immagini. <ref>{{Cita web|url=https://developer.apple.com/library/ios/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html#//apple_ref/doc/uid/TP40016497-CH2-SW1|titolo=Markup Formatting Reference: Markup Overview|sito=developer.apple.com|lingua=en|accesso=2015-11-15 novembre 2015}}</ref>
* Jupyter Notebook, precedentemente IPython Notebook, funziona nel formato dei notebooks, che combina intestazioni, testo (incluso LaTeX), grafici, ecc. con il codice scritto.
* [[Julia (linguaggio di programmazione)]] supporta la modalità di sviluppo iJulia che è stata ispirata da iPython.
* Agda (linguaggio di programmazione) supporta una forma limitata di literate programming pronta all'uso . <ref>{{Cita web|url=http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.LiterateAgda|titolo=Literate Agda|cognome=|nome=|sito=Agda Wiki|datalingua=en|accesso=2017-03-26 marzo 2017}}</ref>
* [http://witheve.com I programmi nel linguaggio di programmazione Eve] sono principalmente in prosa .<ref>{{Cita web|url=http://docs.witheve.com/handbook/literate-programming/|lingua=en|titolo=Eve and Literate ProgammingProgramming|sito=Eve Handbook|accesso=25 maggio 2017|urlarchivio=https://web.archive.org/web/20170524092539/http://docs.witheve.com/handbook/literate-05-25programming/|dataarchivio=24 maggio 2017|urlmorto=sì}}</ref> . Eve combina varianti di [[Datalog]] e [[Markdown]] con un ambiente di sviluppo grafico live.
* Simile ai quaderni Jupyter, i quaderni [https://bookdown.org/yihui/rmarkdown/notebook.html R] sono un metodo di literate programming che consente l'interazione diretta con [[R (software)|R]] (anche il supporto per Python, SQL e Bash sono esplicitamente menzionati) generando un documento riproducibile con output di qualità da pubblicazione.
* Il meccanismo di personalizzazione della [[Text Encoding Initiative]] che consente il vincolo, la modifica o l'estensione dello schema [[Text Encoding Initiative|TEI]] consente agli utenti di mescolare la documentazione in prosa con frammenti delle specifiche dello schema nel loro formato [[Text Encoding Initiative|One Document Does-it-all]] . Da questa documentazione in prosa, è possibile generare schemi e processi di elaborazione del modello e il paradigma del literate programming di Knuth viene citato come fonte d'ispirazione per questo metodologia di lavoro. <ref>{{Cita web|url=http://www.tei-c.org/release/doc/tei-p5-doc/en/html/USE.html#IMGD|titolo=TEI Guidelines|cognome=|nome=|sito=TEI Consortium|datalingua=en|accesso=23 agosto 2018|urlarchivio=https://web.archive.org/web/20180822123639/http://www.tei-08c.org/release/doc/tei-23p5-doc/en/html/USE.html#IMGD|dataarchivio=22 agosto 2018|urlmorto=sì}}</ref>
== FontiNote ==
<references />
{{Reflist|40em}}
== Bibliografia ==
* {{Cita pubblicazione|autore=Donald E. Knuth|anno=1984|titolo=Literate Programming|rivista=The Computer Journal|editore=British Computer Society|volume=27|numero=2|pp=97-111|accesso=4 gennaio 2009|doi=10.1093/comjnl/27.2.97|url=http://www.literateprogramming.com/knuthweb.pdf|cid=Knuth}}
{{refbegin}}
* {{citecita news |firstautore=Wayne |last=Sewell |title titolo= Weaving a Program: Literate Programming in WEB |publisherurl=https://archive.org/details/weavingprogramli0000sewe|pubblicazione=Van Nostrand Reinhold |yearanno=1989 |isbn=0-442-31946-0 }}
* {{cite bookcita libro|firstautore=Donald E. |last=Knuth |author-link=Donald Knuth |titletitolo=Literate Programming |publisheranno=1992|editore=[[Stanford University]] - Center for the Study of Language and Information |___location=California |year=1992 |isbn=978-0-937073-80-3 }}
* {{cite bookcita libro|firstautore=Eitan M. |last=Guari |title titolo= TeX & LaTeX: Drawing and Literate Programming |publishereditore=McGraw Hill |yearanno=1994 |isbn=0-07-911616-7 }} (includesinclude software)
* {{citecita web |firstautore=Kurt |last=Nørmark |url = http://www.cs.aau.dk/~normark/litpro/issues-and-problems.html |title titolo= Literate Programming – Issues and Problems |publishereditore=[[UniversityUniversità ofdi Aalborg]] |datedata=August 13, 1998agosto 1998|lingua=en}}
* {{cite newscita pubblicazione|firstautore=Eric |last=Schulte |url = https://www.jstatsoft.org/article/view/v046i03/v46i03.pdf |title titolo= A Multi-Language Computing Environment for Literate Programming and Reproducible Research |publisherrivista=Journal of Statistical Software |datedata=Januarygennaio 2012 |volume=46 |issuenumero=3 |lingua=en}}
{{refend}}
{{Portale|informatica}}
[[Categoria:Paradigmi di programmazione]]
<br />
| 