Esiste un modo ben noto per documentare il processo fatto prima di scrivere qualsiasi codice?

3

Che cosa voglio fare

Sono in un processo di sketch, prototipazione e brainstorming per conoscere le possibilità che il codice affronterà e che tipo di problemi potrei affrontare durante la scrittura del codice. E decidi come deve comportarsi il codice per affrontare il problema che risolve, valutando i pro ei contro dei possibili comportamenti.

Cosa so di

Nel github ho visto un sacco di codice che documenta le funzioni con una descrizione e spiega come si comporta il codice e le discussioni mirano a migliorare il comportamento del codice, ma non hanno mai visto la documentazione di ciò che ha portato a decidere lo "scopo" di un codice.

La domanda

Quindi la domanda è, dove "pubblicare" quel contenuto. Nei commenti del codice non ancora scritto? In un txt separato? Sotto una cartella specifica? Poiché le domande qui richieste non generano una discussione ma una risposta specifica, la domanda specifica è se esiste già un modo ben noto e studiato per farlo, o qualcosa di simile a ciò che sto facendo. SOLO come e dove i piani del documento, non come pianificare.

Un esempio di ciò che ho fatto

Quello che sto facendo è un gestore di memoria, proprio come quello che ha un sistema operativo per allocare i programmi in memoria mentre sono in esecuzione, o qualche volta li tiene chiusi dopo la chiusura come un tipo di cache.

Qui sto cercando di capire tutte le possibili esigenze di allocazione della memoria in cui allocare memoria ed eliminarla. Ad esempio potrebbe avere a che fare con buchi di memoria inutilizzati tra le sezioni di memoria utilizzate (se nel progetto finale sarà consentito). Comunque in questa lista non ci sono decisioni prese, solo cercando di descrivere lo scenario, per chiarire un po 'i thigs.

Data and objects in memory by behavior:
-------------------------------------
(#.Category)
  ([letter]-Condition. Implicances)
-------------------------------------
  1.Initialization:
    A-It is declared in the beginning. 4A 
    B-It is declared on the run.
  2.Persistency:
    A-It is needed for several operations.
    B-It is needed for just one operation. 3Ba
  3.Deletion:
    A-Lasts forever.
    B-Could be deleted.
      a-Will be deleted.
  4.Ammount of data:
    A-There is a fixed known ammount of data to be stored.
    B-The ammount of data to be stored is unknown while storing until finished.

L'elenco che segue è un mock-up delle decisioni prese definendo tipi di oggetti distinti con un comportamento specifico per poi assegnare un modo per trattarli.

Objects to store:
  Type A:
    Description:
      There is certainty that they will be used and never need be deleted
      enlarged or srinked.
  Type B: 
    Description:
      They are not intended to exist forever and it is not certain
      that they will be needed to be deleted.
  Type C:
    Description:
      They are known to be deleted or exist just for a short time but there
      could be other operations while this object exists.
  Auxiliary Memory:
    Description:
      There is no certainty of how many data will be needed to store.
      A space where data can be stored and used within ONE operation,
      once used must NOT be leaved there to read later, so it can be
      safely overwritten or deleted.
      Anyway the data written here can be reclaimed to be marked as an
      object to prevent being overwritten/deleted.
    
posta Juan Molina 30.08.2017 - 09:24
fonte

3 risposte

-1

Mi sembra che tu stia parlando di Documenti di decisione architettonica .

    
risposta data 31.08.2017 - 23:44
fonte
3

Quello che stai cercando è il documento di specifica dei requisiti .

Questo documento di solito ha due capitoli:

  1. le aspettative del cliente sul software da scrivere e
  2. una descrizione dell'architettura dei sistemi

Questo (due?) documento (i) deve essere collocato nello stesso SCM del codice (sì, una cartella documents è un buon posto) in un formato che gli SCM possono gestire facilmente (markdown, HTML, LaTeX) .

Il motivo è che i requisiti tendono a cambiare durante i tempi di sviluppo, specialmente in un progetto "agile" e quindi potresti voler esplorare quando un requisito modificato: prima o dopo che il codice non incontra il nuovo requisito è stato scritto.

    
risposta data 30.08.2017 - 11:31
fonte
0

Nel tuo caso d'uso di esempio, sembra che tu sia più interessato ai test di integrazione piuttosto che ai test dei requisiti. Tuttavia, il resto della tua domanda riguarda il processo di individuazione dei requisiti. Proverò a spiegare un po 'di questo processo e quali strumenti potresti essere in grado di utilizzare per espandere i requisiti per coprire completamente ciò che ci si aspetta dal sistema.

L'attuale processo di scoperta è più una questione procedurale. Come nella maggior parte delle cose nella vita, qualsiasi strumento tu scelga di utilizzare è lì per supportare il processo di sviluppo del software che stai utilizzando per creare la tua applicazione. (esempi di SDCL sono: Scrum , Kanban , Cascata e RUP ) Il processo è principalmente ciò che ne fai. Spetta a te rivisitare le specifiche e aggiornarle se necessario. Il processo scelto determinerà quale sia lo strumento migliore per il lavoro.

C'è un grosso problema nel sistemare le cose in anticipo: non consentono molta flessibilità e quindi (inutilmente?) aumentano la complessità del design, che a sua volta probabilmente aumenterà gli errori nel codice e nel design. Quanto più non sei disposto a rivedere le decisioni passate e i prodotti di tali decisioni, tanto più doloroso sarà il processo di sviluppo in termini di garanzia della qualità e spesso anche di soddisfazione del cliente e consegna puntuale. (questa è fondamentalmente la grande lezione delle metodologie agili)

Detto questo, ci sono alcuni strumenti per aiutarti a documentare i requisiti:

Un modo per documentare i requisiti è scrivere test delle specifiche. Questi test consentono agli esperti di dominio di specificare le situazioni in linguaggio naturale e quindi le persone con codice alfabetico possono allegare test a questi scenari. Specflow è un esempio di un sistema che può farlo per te in C #

Un altro modo è utilizzare standard di specifiche rigide. Un esempio di questo è IEEE 830

Né risolve l'interfaccia dell'applicazione. Se sei pronto a correggere l'interfaccia, almeno ad un livello elevato, puoi anche scrivere test unitari e collegarli alle tue esigenze nel tuo software ALM (come puoi fare con TFS)

Oltre ai requisiti, puoi anche utilizzare linguaggi meta come UML per aiutarti a prendere decisioni di progettazione e documentarli. L'onnipresente diagramma di classe è tristemente famoso per semplificare eccessivamente le cose, sì, rimane uno dei metodi più comuni di visualizzazione della struttura del codice.

Ci sono pro e contro nell'usare questo linguaggio. Porterai il design più in primo piano nel ciclo di sviluppo, rendendolo meno flessibile. D'altra parte, avrai la possibilità di lavorare di più sui concetti e avere un'idea migliore di ciò che stai facendo. Se usato correttamente, con più di un semplice diagramma di classe, UML può essere utile per stabilire una struttura approssimativa della struttura e dei processi del codice.

    
risposta data 31.08.2017 - 17:05
fonte

Leggi altre domande sui tag