Motivazione intuitiva per la programmazione alfabetizzata?

Question

Quindi, ho usato il scarabocchio/lp modulo per scrivere il mio primo programma letterato utilizzando plt-scheme:

#lang scribble/lp
(require scribble/lp)

<<lp_scheme.ss>>

@chunk[<squarefunction>
        (define (f x)
         (* x x))]

Niente di utile lì, ovviamente.Ora mi chiedo perché non dovrei usare semplici commenti, invece di costrutti di programmazione alfabetizzati.Qualsiasi opinione è benvenuta.Sarebbe davvero fantastico se qualcuno che probabilmente ha avuto più esposizione/esp.con esso per fornire una spiegazione più intuitiva delle differenze tra codice ben documentato e codice scritto utilizzando costrutti di programmazione Literate.

Answer 1

(Presumo che tu stia utilizzando la definizione di programmazione alfabetizzata di Donald Knuth.)

La differenza fondamentale è una delle sequenza.

Nello scrivere una domanda regolare, ci sono restrizioni sull'ordine in cui esprimi le cose.

Illustrare:

• Tutto il codice per una particolare classe deve essere espresso in un unico posto
  (o in un numero molto limitato di posti, ad es.classi parziali C#)
• Tutto il codice per un metodo deve essere fornito in una volta sola, nell'ordine corretto di esecuzione
• Le dipendenze devono essere dichiarate prima delle cose da esse dipendenti
  (variabili dichiarate prima dell'uso nella maggior parte dei linguaggi;procedure/funzioni dichiarate prima dell'uso in Pascal;assembly di librerie compilati prima di altri in .NET)

Con programmazione alfabetizzata sei libero da questa restrizione e libero di esprimere i tuoi concetti nell'ordine che ha senso per te da utilizzare quando spieghi il programma a un altro sviluppatore.

Ciò ha un'altra conseguenza: in alcune forme, puoi esprimere un concetto una volta (ad esempio, "Tutte le proprietà attiveranno l'evento PropertyChanged quando modificato") e avere questo intrecciata durante la tua applicazione in una miriade di altri posti.

Per programmi molto semplici, un programma competente e uno ben commentato potrebbero sembrare uguali, ma man mano che la complessità del sistema aumenta, i due inizieranno ad apparire molto diversi.

Answer 2

motivazione principale, come per me, è che ogni fogli carta uso programmatore / notebook all'architettura 'design', sviluppare idee, ci scrive schemi, diagrammi, provare un po 'di matematica e così via. Dopo aver terminato il programma, tutti questi notebook / fogli di carta sono persi, in modo sostenibilità del programma sta scendendo. Ho scritto di questo in WiKi della mia LP strumento NanoLP: http://code.google .com / p / nano-lp / wiki / AboutLP .

Secondo la motivazione, non così esplicitamente, è bug minori. Ma questo non è cosa 'teorica', è l'esperienza infatti (per me) - quando si è 'pensiero' sulla carta, disegnare diagrammi, schemi di algoritmi - il vostro programma avrà bug minori. LP è tale 'documento', nient'altro.

Ci sono molti sviluppatori, che non attira qualcosa, commenti anche (!), Scrivono programma solo ... Terribile!

E LP vi aiuta a creare una buona documentazione (non in modo formale - descrizione sulle funzioni, è args, e quello che ritorna, e che questo è bene conosciuto con la firma di funzione, quindi perché è necessaria tale documentazione ??), ma aiuta a scrivere la documentazione rEALE REAL semantica, con le immagini, con la descrizione delle azioni reali ...

Molte motivazioni :) e sicuro a volte è meglio utilizzare solo LP inversa (Doxygen, per esempio), a volte -. Vera LP, dipende da molti fattori

Answer 3

Programmazione istruita si basa su tre semplici istruzioni:

1. I programmatori devono scrivere codice, che il computer può capire
2. I programmatori devono scrivere la documentazione, che la gente può capire
3. Se queste sono documenti separati è inevitabile che essi saranno out-of-sync

In effetti, nella mia esperienza, # 2 di solito ottiene poca attenzione. Ho perso il conto di quante volte QA mi ha detto "il dottore dice questo, ma il codice lo fa, è il codice corretto o è il doc out-of-date?" Non mi aspetto che il mio posto di lavoro è fuori dal comune, in questo senso. Inoltre, in uno dei miei primi progetti, stavo cercando di mantenere la documentazione up-to-date come il back-e-indietro con le parti interessate hanno determinato nuove esigenze. Questo è stato sufficiente in termini di tempo che mi è stato detto, per la gestione, per fermare scherzi con i documenti e solo ottenere il funzionamento del progetto. Siamo passati a processi di documentazione meno noiosi, da allora (grazie a Dio!).

Abbiamo Code Review strumenti dove, quando facciamo una modifica al codice, più persone possono vedere i cambiamenti, chiaramente delineati, e commenti possono essere fatti, fare domande, spiegando roba, offrendo miglioramenti. Se il codice è stato scritto con le tecniche di programmazione letterata, gran parte di questa domanda / risposta sarebbe superfluo perché la spiegazione sarebbe incluso.

Gran parte della mentalità di programmazione moderna è che il codice dovrebbe essere la propria documentazione. Molti esperti sostengono che, se vi trovate a dover spiegare il codice nei commenti, probabilmente si dovrebbe riformattare il codice (cambiare i nomi / funzione variabile, ecc) in modo tale che i commenti sono inutili. Trovo che questo sia grande, in teoria, meno pratico nella realtà. Voglio dire, quando sto usando librerie create / gestiti da qualcun altro, la loro scelta del metodo / nomi delle funzioni non è sempre intuitivo da me. Ad esempio:

Set<String> statesWeCareABout = new HashSet<String>(Arrays.asList(new String[] { "one", "two", "three" }));
Set<String> statesWeFound = <some function>;
statesWeFound.retainAll(statesWeCareAbout);

Se non si ha familiarità con l'insieme <> o HashSet <>, non si può sapere che .retainAll () significa dammi l'intersezione dei due, con il risultato nel Set modificata <>.

Infine, Literate Programming di solito permette di rompere le cose in modo che si può spiegare questo pezzo di codice in isolamento, poi in linea in questo altro pezzo di codice. Questo è più in linea con il funzionamento di comprensione umana. Mi spieghi come funziona, poi costruire su quella comprensione per spiegare il quadro più ampio. I computer non mi importa; è possibile scrivere una singola funzione con 1.000 linee di codice e non ha alcun problema comprendere il tutto. Dio vi aiuterà, se si, come sviluppatore, deve mantenere tale.

E che, in realtà, è il ragionamento dietro Literate Programming. Codice dovrà essere mantenuto, se è in fase di bug risolti o funzionalità che viene aggiunto. E se non può essere compresa da qualcun altro, più tardi, in modo efficiente, sarà sostituito. Non c'è modo per tanto "solo scrivere" codice in questo mondo. Programmazione Literate rende più facile da leggere e comprendere, che lo rende più probabilità di essere conservato e utilizzato, a lungo termine.

E abbiamo davvero tempo per continuare a re-inventare la ruota?