flow-control voorkeur?

[link0007]

Hey,
Na veel tutorials doorgewerkt te hebben, ben ik erachter gekomen dat veel programmers 'kotsen' op labels en gotos. Daarom wil ik jullie mening hierover wel eens weten: Wat is jullie voorkeur? Waarom? Welke 'flow-controllers' gebruik jij vaak? Dit is de plaats om het met de rest van de wereld te delen!
Ik persoonlijk 'kots' op geen enkel commando / manier om je doel te bereiken in een taal, en gebruik dan ook met alle liefde labels en gotos in talen als pascal. Het minste gebruik ik eigenlijk de 'for' loop, enkel omdat er veel duidelijkere manieren zijn om hetzelfde te bereiken.
But what about you?

[Verwijderd]

Ik begrijp hem niet helemaal, hoor...
Lijkt mij een beetje de omgekeerde wereld
Maar ik gebruik zelf ook vaak een 'if'. Ga je vanaf nu alles proberen op te lossen met 'if's

[link0007]

nee, vaker gebruik ik 'case <variabele> of ' in pascal maar in TI-basic en Gamemaker <en C++, al ken ik die taal nog niet zo goed> gebruik ik wel heel vaak if statements. maar dat zijn geen flow-controllers. ik heb het over loops e.d.

[Sjaaky]

Maar hoe maak jij dan for-lusjes?
Als while lus, of met labels en goto?

code:

int i = 0;

label:
  doStuff();
  i++;
if (i < 10) goto label;

Sorry maar dan prefereer ik toch:

code:

for(int i = 0; i < 10; i++)
{
  doStuff();
}

Ik vind een for een stuk duidelijker, je ziet direct wat de lus gaat doen. Het is een abstractieniveau hoger. De compiler maakt er wel machinecode met goto's van, want een cpu kent geen forlusjes.
Vroeger deed ik ook alles met goto's, maar uiteindelijk werd dat programma 1 grote brei. Alles stond ook in 1 of 2 procedure's ofzo. Geen goto's gebruiken (of alleen in uitzonderlijke gevallen) dwingt je je programma netter te structureren, wat de onderhoudbaarheid verhoogt.

[link0007]

Eigenlijk vind ik persoonlijk de label toch het duidelijkst... het enige probleem is dan het verklaren van variabelen, wat met een for() loop heel makkelijk gaat -in C++, ik meen niet in pascal-... maar als je alles goet uitschrijft kan het toch echt een stuk leesbaarder worden... Maar misschien komt dit met de jaren

[Zjosh]

Welke programmeer taal hebben we het nu over? Zelf kan ik wel wat met PIC asm, daar is DE flowcontrol functie natuurlijk DECFSZ, maar ik denk dat jij het hebt over hogere talen. Ik vind het gebruik van if's behoorlijk duidelijk op kleine stukjes. Grote stukken code kun je beter met een while loop doen.

[Infinitive]

In deze context kan een linkje naar dit artikel niet ontbreken: Goto statement considered harmful (Edsger W. Dijkstra)

[Verwijderd]

Eigenlijk vind ik persoonlijk de label toch het duidelijkst...

Hoe je dat met droge ogen kunt beweren is mij een raadsel.
Wanneer een van mijn collega's ooit zou besluiten dat 'ie ergens labels en goto's nodig heeft, heeft 'ie een probleem.
Dat hele goto-gebeuren nodigde alleen maar uit tot spaghetti-code en niet te onderhouden programma's. Hou je gewoon aan de normale for/while/case/if flow control dingen die je programmeertaal je biedt. Als je daar niet genoeg aan hebt ben je of een genie, of moet je je code nog 's goed doorkijken.

[link0007]

Oh ik heb er wel genoeg aan hoor, maar persoonlijk vind ik het gewoon veel fijner om met labels te werken. Het is toch heel makkelijk om elke nieuwe functie een eigen label te geven, en dan vanuit de hele code daar gewoon naartoe springen.
neem nou deze code:

code:

 program encrypt;

 uses crt;
 label label1;

 var
 a : char;

 begin

 clrscr;
 clrscr;
 write('fill in your text:  ');
 label1:
 begin
 read(a);
 case a of
 '~':begin textcolor (red);writeln('halted');halt;end;
 ' ':write(' ');
 '!':write('!');
 '?':write('?');
 '.':write('.');
 ',':write(',');
 '1':write('8');
 '2':write('7');
 '3':write('6');
 '4':write('5');
 '5':write('4');
 '6':write('3');
 '7':write('2');
 '8':write('1');
 '9':write('0');
 '0':write('9');
 'a','A':write('z');
 'b','B':write('y');
 'c','C':write('x');
 'd','D':write('w');
 'e','E':write('v');
 'f','F':write('u');
 'g','G':write('t');
 'h','H':write('s');
 'i','I':write('r');
 'j','J':write('q');
 'k','K':write('p');
 'l','L':write('o');
 'm','M':write('n');
 'n','N':write('m');
 'o','O':write('l');
 'p','P':write('k');
 'q','Q':write('j');
 'r','R':write('i');
 's','S':write('h');
 't','T':write('g');
 'u','U':write('f');
 'v','V':write('e');
 'w','W':write('d');
 'x','X':write('c');
 'y','Y':write('b');
 'z','Z':write('a');
 end;

 goto label1;

 end;

end.;

In dit -kleine- programma, is het -in mijn ogen- toch echt de beste optie geweest om een label te gebruiken. Ik had waarschijnlijk hetzelfde kunnen doen met een while/for loop, maar zou dat het nou echt duidelijker maken? Zo krijg je al een idee van de flow die het programma afloopt, terwijl dat met een for/while loop een stuk moeilijker te zien is.

[MicroWhale]

ik zou bovenstaand voorbeeld op onderstaande manier hebben gedaan.

Delphi:

  while a<>'~' do
  begin
    case a of
      '.' :etc...
    end;
  end;
  textcolor (red);
  writeln('halted');

met inspringen wordt je code een heel stuk leesbaarder. bovendien garandeer je op deze manier je flow. Met goto's kun je je flow niet garanderen omdat je niet zeker weet of je wel naar het goede label springt. Dat moet je met je eigen ogen checken. Bij een while ligt het vast dat hij tussen de begin en end blijft totdat aan de conditie voldaan is.

[ Voor 3% gewijzigd door MicroWhale op 24-09-2006 10:52 ]

[link0007]

Ja sorry voor het gebrek aan inspringing, ik ben een slordige programmeur (zeldzaam?) en was het een vergeten.
Maar, alhoewel het even goed werkt, snap ik niet waarom een 'while' loop het nou overzichtelijker zou maken. bij de labels had ik alleen een veel duidelijker overzicht wat er gebeurt wanneer een bepaalde letter werd gebruikt... Maar dat ligt natuurlijk aan je persoonlijke denkwijze/voorkeur, denk ik zo.

[Cuball]

Ik weet niet welke programeur je bent en waar je opleiding gevolgd hebt, maar ik kan je toch zeggen dat elke programeur toch weet dat goto statements enzo not done zijn, dat is jaren 70-80 code dat je dan schrijft!

Leer gestructureerd programeren ! En alles zal zo veel duidelijker zijn

[DroogKloot]

Je programmeert duidelijk nog niet lang genoeg en/of je programma's zijn niet complex genoeg om in te zien dat goto's niets aan overzichtelijkheid bijdragen:

C:

void functie() {
    int i = 0;
    l1:
    i++;
    if (i <= 10)  goto l2;
    if (i > 10) goto l3;
    goto l1;
    l3:
    return;
    l2:
    printf("i: %d, i squared: %d\n", i, i * i);
    goto l1;
}

Hoe veel tijd heb je nodig om te doorgronden wat hier gebeurt?

[ Voor 4% gewijzigd door DroogKloot op 24-09-2006 12:59 ]

[JKVA]

Ze hebben bij het maken van Java niet voor niks gekozen GOTO statements expliciet weg te laten. Sterker nog, bij de eerste Java compilers werd je voor prutser uitgemaakt als je het keyword goto ergens gebruikte.

Dat zal toch niet zonder reden zijn neem ik aan?

[JaQ]

JKVA schreef op zondag 24 september 2006 @ 14:34:
Dat zal toch niet zonder reden zijn neem ik aan?

Omdat iemand iets zegt hoef je het niet altijd meteen maar klakkeloos aan te nemen

Ik programmeer zelf weinig meer, maar goto is iets waar ik na pascal mee ben gestopt. Ik heb er echter wel de basisprincipes van gestructureerd programmeren door geleerd (en dat is iets wat een hoop "jonge" programmeurs nog moeten leren, onafhankelijk van welke taal ze bezigen). Als je goed gaat kijken naar een procedureel programma, dan wordt namelijk regelmatig het zelfde principe toegepast. Wat je dan ziet is iets als:

code:

function doe_iets() {
  print('iets');
}

function do_iets_anders() {
  print('iets anders');
}

for ( i < 10; i++ )
do
  if mod($i) = 0 
  then
    doe_iets;
  else
    doe_iets_anders;
  fi
done

Is deze pseudo-code dan opeens ook "fout" of "vies"? Of maakt het aanroepen van een functie de code opeens wel goed, alleen maar omdat er geen goto staat?

[Verwijderd]

JaQ schreef op zondag 24 september 2006 @ 15:44:
[...]


Is deze pseudo-code dan opeens ook "fout" of "vies"? Of maakt het aanroepen van een functie de code opeens wel goed, alleen maar omdat er geen goto staat?

Deze pseudo code vind ik inderdaad een stuk beter, omdat een functie-aanroep altijd terugkeert naar het punt waar deze aangeroepen is. GOTO's hebben die eigenschap niet, waardoor je veel meer spaghetti code krijgt.

[M55]

Je zou eens in de linux kernel moeten gaan kijken, daar wordt goto statements nog veel gebruikt hoor

[Alarmnummer]

link0007 schreef op zondag 24 september 2006 @ 11:18:
Ja sorry voor het gebrek aan inspringing, ik ben een slordige programmeur (zeldzaam?) en was het een vergeten.
Maar, alhoewel het even goed werkt, snap ik niet waarom een 'while' loop het nou overzichtelijker zou maken. bij de labels had ik alleen een veel duidelijker overzicht wat er gebeurt wanneer een bepaalde letter werd gebruikt... Maar dat ligt natuurlijk aan je persoonlijke denkwijze/voorkeur, denk ik zo.

Ik wou eigelijk niet op dit topic reageren, maar besloten om het toch te doen.

Goto's zijn gewoon redelijk bad omdat:
1) de flow vaak erg lastig is om in te zien
2) niemand het nog gebruikt (dus voor die mensen is het nog lastiger)

Meestal kan je meer dan goed genoeg redden met de bestaande constructies zoals switch-case/ifthenelse/for/while/dowhile.

En verder zijn issue op dit niveau meestal niet de dingen waar een programmeur zich nog om moet druk maken. Als je wat professioneler bezig bent dan zit de complexiteit vaak op een heel ander niveau. En je probeerd dan ook zo veel mogelijk "wow.. wat ben ik slim als ik dit stukje complexe code werkend kan krijgen" te vermijden.

Je kunt een aantal dingen doen:
1) je kop in het zandsteken en gewoon doorgaan met je huidige manier van aanpak. Misschien zul je in de toekomst het licht zien (ik heb vroeger ook veel de goto's gebruikt.. vroeger.. 15 jaar geleden oid)
2) ons advies aannemen en de goto gewoon niet meer gebruiken.

Sommige mensen (zoals ik ook) die moeten dingen gewoon zelf ervaren. Probeer eens code van een oud stukje code van je er bij te pakken; probeer eens te kijken of je het nog in een oogopslag kunt zien. Als jij niet meteen kunt begrijpen wat jij eerder hebt gemaakt, dan heb je daar al een goed argument gevonden om de goto te dumpen.

[ Voor 3% gewijzigd door Alarmnummer op 24-09-2006 18:59 ]

[whoami]

10 goto moet je gewoon niet gebruiken
20 goto 10

Verder zie ik dat dit topic geen lang leven beschoren is in SE&A. Ik bedoel maar, je gebruikt de statements in functie waarvan je ze nodig hebt (en een goto heb je helemaal niet nodig), dus waarom zou je dan een 'voorkeurs' statement hebben ?

[whoami]

Verder zie ik dat dit topic geen lang leven beschoren is in SE&A.

Hmm, ik ben helderziend.