Hoe vaak gebruikt u pseudocode in de echte wereld?

Ik gebruik pseudocode als u niet op een computer en alleen papier en pen. Het heeft niet veel zin te maken over de syntaxis voor code die niet zal compileren (kan papier niet compileren) te maken.

Meestal gebruiken voor nutting te zijn echt complexe code, of wanneer het verklaren van code om ofwel andere ontwikkelaars of niet ontwikkelaars die het systeem te begrijpen.

Ik stroom ook diagrammen of het type UML-diagrammen wanneer het proberen te doen boven ook ...

Ik gebruik het in het algemeen bij het ontwikkelen van meerdere of andere verklaringen die zijn genest wat verwarrend kan zijn.

Op deze manier hoef ik niet terug te gaan en te documenteren sinds zijn al gedaan.

Vrij zelden, hoewel ik documenteren vaak een methode voor het schrijven van het lichaam van het.

Echter, als ik het helpen van een andere ontwikkelaar met hoe je een probleem aan te pakken, zal ik schrijven vaak een e-mail met een pseudocode oplossing.

Ik gebruik het bijna altijd tegenwoordig bij het maken van een niet-triviaal routines. Ik schep de pseudo-code als commentaar, en verder uit te breiden totdat ik op het punt dat ik kan schrijven de gelijkwaardige code eronder te krijgen. Ik vond dit een aanzienlijk versnelt de ontwikkeling, vermindert de "gewoon schrijven code" syndroom dat vereist vaak herschrijft voor dingen die oorspronkelijk niet werden beschouwd als het dwingt je om na te denken over het hele proces voor het schrijven van de werkelijke code, en dient als een goede basis voor code documentatie nadat het is geschreven.

Ik gebruik geen pseudo-code op alle. Ik ben meer comfortabel met de syntaxis van C-stijl taal dan ik ben met Pseudocode.

Wat ik wel doe heel vaak voor design doeleinden is in wezen een functionele decompositie stijl van codering.

public void doBigJob( params )
{
    doTask1( params);
    doTask2( params);
    doTask3( params);
}
private void doTask1( params)
{
    doSubTask1_1(params);
    ...
}

Die, in een ideale wereld, zou uiteindelijk om te zetten in werkende code als methodes meer en meer triviaal geworden. Echter, in het echte leven, is er een deurklink van een stuk van refactoring en herdenken van het ontwerp.

We vinden dit werkt goed genoeg, want zelden hebben we tegenkomen een algoritme dat zowel: ongelooflijk complex en moeilijk te coderen en niet beter opgelost met behulp van UML of andere modeling techniek.

Als ik uit te werken iets complex, ik gebruik het veel, maar ik gebruik het als commentaar. Bijvoorbeeld, zal ik stomp de procedure uit, en zet in elke stap Ik denk dat ik moet doen. Als ik schrijf dan de code, zal ik de reacties achter te laten: het zegt wat ik probeerde te doen.

procedure GetTextFromValidIndex (input int indexValue, output string textValue)
// initialize
// check to see if indexValue is within the acceptable range
//    get min, max from db
//    if indexValuenot between min and max
//       then return with an error
// find corresponding text in db based on indexValue
// return textValue
   return "Not Written";
end procedure;

Ik heb nog nooit, zelfs niet een keer, die nodig zijn om de pseudocode van een programma te schrijven voor het schrijven ervan.

Echter, af en ik heb gehad om pseudocode schrijven na het schrijven van code, die meestal gebeurt er als ik ben op zoek naar de high-level implementatie van een programma te beschrijven om iemand op snelheid te komen met de nieuwe code in een korte tijd. En met "high-level implementatie", bedoel ik één lijn van pseudocode beschrijft 50 of zo lijnen van C #, bijvoorbeeld:

Core dumpt een bos van XML-bestanden naar een map en loopt de process.exe
  uitvoerbaar met een paar commandline parameters.

De process.exe leest elk bestand
    Elk bestand wordt gelezen regel voor regel
    Unieke woorden worden getrokken uit het bestand opgeslagen in een database
    Bestand wordt verwijderd wanneer de voltooide verwerking