[alg] slechtste prog voorbeelden.

[Glimi]

paulgielens schreef op 30 maart 2003 @ 22:12:
(...)
Ik zou willen dat iedere programmeur deze boeken doodgebladerd in de kast heeft staan:

- GOF
- Distributed Systems, Concepts and Design
- Patterns of the Enterprise Architect

Vergeet
- Refactoring van Fowler niet

Verder blijf ik nog altijd een grote pleurishekel hebben aan mensen die te pas en onpas een datastructuur blijven gebruiken welke de hele applicatie kan laten crashen door een segfault

[EfBe]

Zie ik hier mensen die pulp van die omhooggevallen Fowler aanprijzen? Tsssk! Boeken van iemand die predict ad hoc aan datamodellen te knoeien zonder het datamodel (in een abstracte vorm) te wijzigen alvorens met je handen aan tabellen en velden te zitten behoren niet in iemands kast, maar in de prullenbak.
(tevens een goed voorbeeld voor deze thread: kijk voor de grap eens hoe die Fowler dat aanprijst op zn website... een echte super-softwaredeveloper!)

[ Voor 20% gewijzigd door EfBe op 31-03-2003 09:02 ]

[Scare360]

offtopic:
EfBe: is dat niet iets of wat kort door de bocht? Zijn PotEA boek is anders van hoge kwaliteit.

[mbravenboer]

EfBe: omhooggevallen Fowler

Dan is Fowler in ieder geval een marketing genie: hij heeft wel een van de meest geciteerde en besproken boeken van de laatste jaren geschreven . Bovendien worden zijn boeken gebruikt in menig academische opleiding. In ieder geval wordt zijn systematische indeling van refactorings zeer breed gebruikt en gewaardeerd. Kennelijk is er toch iets mis met de wereld of met jouw beoordeling .

[LuCarD]

Vrijdag tegen gekomen

Visual Basic:

while not rs.eof
' some comment
' some more comment
' some commented code
'
rs.movenext
wend

[Anoniem: 49136]

Ik moest een keer helpen een VB tentamen na te kijken. De studenten moesten ergens checken of iets een hoofdletter of kleine letter was.
Dan krijg je bijvoorbeeld:

code:

Dim teller As Integer, teller2 As Integer
Dim teller3 As Integer

For teller = 97 To 122
  If Asc(x) = teller Then
    ...
  End If
Next teller

For teller2 = 65 To 90
  If Asc(x) = teller2 Then
    ...
  End If
Next teller2

For teller3 = 0 To 255
  If Asc(x) <= 64 Or Asc(x) >= 123 Then
    ...
  ElseIf Asc(x) >= 91 And Asc(x) <= 96 Then
    ...
  End If
Next teller3

Briljant, nietwaar?
Merk ook op dat in die laatste loop teller3 NIET gebruikt wordt! De If-statement wordt gewoon 256 keer uitgevoerd!

[EfBe]

mbravenboer schreef op 31 March 2003 @ 11:01:
[...]
Dan is Fowler in ieder geval een marketing genie: hij heeft wel een van de meest geciteerde en besproken boeken van de laatste jaren geschreven . Bovendien worden zijn boeken gebruikt in menig academische opleiding. In ieder geval wordt zijn systematische indeling van refactorings zeer breed gebruikt en gewaardeerd. Kennelijk is er toch iets mis met de wereld of met jouw beoordeling .

Op het gebied van eXtreme Programming zal hij ongetwijfeld een guru zijn. Op het gebied van software design vind ik hem toch echt een prutser. Dat stel ik met name zo scherp omdat juist veel mensen denken dat de man veel van software design af weet en DUS denken dat hij gelijk heeft. Als je kijkt hoe hij ad-hoc gepruts aan databases aanprijst als DE manier om databases te beheren en te gebruiken in software... dat is Knoeien met hoofdletter K en zit op het niveau van veel ad-hoc gepriegel zoals we die hier in deze thread terugvinden .

M.a.w.: Fowler moet meer nadenken waar hij zn denkbeelden toepast. In niches waar eXtreme Programming wellicht een voordeel is, zijn zn ideeen toepasbaar, maar voor de rest slaat hij de plank gigantisch mis. Maar jij mag gerust op zn Fowlers aan databasemodellen rommelen hoor alleen voor je het weet eindigen de softwaresprongen die je dan moet maken om het na een tijdje weer up and running te krijgen in threads zoals deze

[Scare360]

offtopic:
EfBe: Kun jij dat artikel eens boven water halen m.b.t. database gepruts? Ik denk namelijk dat de context waarin de zaak geschreven is er_toe_doet.

Heb jij PotEA al eens doorgenomen? zo ja wat vindt je daar dan inhoudelijk van?

[EfBe]

offtopic:
zie .sig Nee de context is vrij helder en een gewone toepassing van een database zoals jij en ik kennen. Dat is juist het punt. Hij predict evolutionairy database modelling. DE fout in database-engineering

[whoami]

offtopic:
Ik heb 1 boek van Fowler (Patterns for Enterprise Application Architecture). Dat vind ik wel een goed boek. Dat EfBe niet eens is met die evolutionaire database modelling kan ik begrijpen; ik vind dat zelf ook maar iets vies.
Echter mag je je bij de beoordeling van die man niet blindstaren op dat punt (en dat ander punt aka dat hij een aanhanger van XP is).

[BdR]

volgende kwam ik tegen op mn werk, een 'klein' programmaatje om records uit

database weg te schrijven naar custom export bestandje, soort tekst

bestand. Vrij simpel zou je zeggen.. helaas stuitte ik op ong. het volgende

code:

function wegschrijventype1String(inhoud,naam:string):boolean;
function wegschrijventype2String(inhoud,naam:string):boolean;
function wegschrijventype3String(inhoud,naam:string):boolean;
..etc.. voor 20 bestandstypes

var
  bestandsnaam1,
  bestandsnaam2,
  bestandsnaam3,
  ..etc..voor 20 bestandstypes
  : String;

  s,
  s2,
  s3
  ..etc..voor 20 bestandstypes
  string;

  aantalbestanden
  aantalbestanden2,
  aantalbestanden3,
  ..etc..voor 20 bestandstypes
  : integer;

function wegschrijventype1String(inhoud,naam:string):boolean;
begin
  lap code om bestand te openen
  lap code om weg te schrijven
  lap code om bestand te sluiten
end;

function wegschrijventype2String(inhoud,naam:string):boolean;
begin
  lap code om bestand te openen
  lap code om weg te schrijven
  lap code om bestand te sluiten
end;

function wegschrijventype3String(inhoud,naam:string):boolean;
begin
  lap code om bestand te openen
  lap code om weg te schrijven
  lap code om bestand te sluiten
end;

..etc..voor 20 bestandstypes

begin

  if soort='type1' then
  begin
    aantalbestanden:=aantalbestanden+1

    repeat
      s := query.fieldbyname('blaatid').asstring+';';
      s := s + ''+query.fieldbyname('naamofzo').asstring';';
      s := s+''+query.fieldbyname('etc').asstring';';
      etc..
      query.Next;
    until query.EOF;
    wegschrijventype1String(s,bestandsnaam1);
  end else

  if soort='type2' then
  begin
    aantalbestanden2:=aantalbestanden2+1

    repeat
      s2 := query.fieldbyname('blaatid').asstring;
      s2 := s2 + query.fieldbyname('naamofzo').asstring;
      s2 := s2 + query.fieldbyname('etc').asstring;
      etc..
      query.Next;
    until query.EOF;
    wegschrijventype2String(s2,bestandsnaam2);
  end else

  if soort='type3' then
  begin
    aantalbestanden3:=aantalbestanden3+1

    repeat
      s3 := query.fieldbyname('blaatid').asstring;
      s3 := s3 + query.fieldbyname('naamofzo').asstring;
      s3 := s3 + query.fieldbyname('etc').asstring;
      etc..
      query.Next;
    until query.EOF;
    wegschrijventype3String(s3,bestandsnaam3);
  end;

  ..etc..

end;

er waren stuk of 20 bestandstypes, dus had collega ook steeds 20 variabelen en 20 functies die allemaal ongeveer hetzelfde doen aangemaakt

daarbij was het geheel ook nog zeer slordig opgemaakt qua spaties, comma's en inspringen, af en toe totaal nutteloze lege strings toevoegen (dus dit idee: string1:=string2+''+string3) en nog veel meer van die dingen

al met al een lekkere onderhoudsklus..

[EfBe]

whoami schreef op 31 March 2003 @ 16:33:

offtopic:
Echter mag je je bij de beoordeling van die man niet blindstaren op dat punt (en dat ander punt aka dat hij een aanhanger van XP is).

offtopic:
nou, iemand die niet doorheeft dat wat hij doet met die databases wel erg beun de haas is, zie ik niet 1 2 3 op andere momenten in soortgelijke situaties wel ineens overal rekening mee houden. Het is inherent aan XP natuurlijk, en vanuit DIE pov snap ik het wel, maar dat praat het nog niet goed

[whoami]

Nu ik dat topic van ACM nog eens doornam, schoot er me net nog iets te binnen.
Het heeft niet echt met 'code' te maken, eerder met database design.

Ik heb ooit eens een applicatie moeten aanpassen/uitbreiden waarvan het datamodel wel echt bagger was.
Sommige tabellen hadden geen PK, bepaalde numerieke gegevens werden in een alfanumeriek veld bijgehouden, tussen sommige tabellen werd er geen referentiele integriteit afgedwongen, data die gedupliceerd werd, de naam van een persoon die als PK gebruikt werd, etc.....
Lekker aanpaswerk hoor.....

[Anoniem: 66593]

Ik kreeg laatst een php scriptje van iemand die zei dat hij de var $i niet goed eruit haalde, kwam hierop neer:

PHP:

if ($i == $i) {
   $i = $i;
}
if ($i != $i) {
   $i = $i;
}

*uche*

[Anoniem: 66593]

Anoniem: 9962 schreef op 30 March 2003 @ 11:46:
iemand vroeg me ooit waarom zijn script vast liep... toen ik zijn code zag wist ik het antwoord gelijk

PHP:

for ($x = 0; $x < 100; $x++)
{
      for ($x = 0; $x < 100; $x++)
     {
          // do iets :P
     }
}

dit kan gewoon hoor...

duurt alleen lang om de for-loopjes te doen.
hij moet het alleen 100^100 keer doen

[Gerco]

whoami schreef op 31 March 2003 @ 16:47:
[horrorverhaal over datamodel]

Heb jij soms bij een niet nader te noemen, Papendrechts bedrijf gezeten?

[Tux]

Anoniem: 66593 schreef op 31 maart 2003 @ 17:00:
[...]


dit kan gewoon hoor...

duurt alleen lang om de for-loopjes te doen.
hij moet het alleen 100^100 keer doen

100 * 100 toch

100 + 100 + 100 en niet 100 * 100 * 100 toch?

[EfBe]

whoami schreef op 31 March 2003 @ 16:47:
Ik heb ooit eens een applicatie moeten aanpassen/uitbreiden waarvan het datamodel wel echt bagger was.
Sommige tabellen hadden geen PK, bepaalde numerieke gegevens werden in een alfanumeriek veld bijgehouden, tussen sommige tabellen werd er geen referentiele integriteit afgedwongen, data die gedupliceerd werd, de naam van een persoon die als PK gebruikt werd, etc.....
Lekker aanpaswerk hoor.....

Ik zit daar nu middenin . SectorID wordt in 3 tabellen met 3 verschillende namen bijgehouden: BG_Sector, SE_Sectorkode en TY_SectorID. BedrijfsID is numeriek maar in de database niet, daar is het alphanumeriek... Geen relaties, sommige tabellen zijn uitgenormaliseerd, anderen niet... waarom lukt het die knoeierts toch elke keer weer die toetseborden te bereiken waar ze schade kunnen berokkenen

[robbert]

Anoniem: 66593 schreef op 31 maart 2003 @ 17:00:
[...]


dit kan gewoon hoor...

duurt alleen lang om de for-loopjes te doen.
hij moet het alleen 100^100 keer doen

volgens mij doet die het maar honderd keer, aangezien als de binnenste lus klaar is dan is $x=100 dus dan is ook de buitenste lus klaar

[whoami]

EfBe schreef op 31 maart 2003 @ 17:30:
Ik zit daar nu middenin . SectorID wordt in 3 tabellen met 3 verschillende namen bijgehouden: BG_Sector, SE_Sectorkode en TY_SectorID. BedrijfsID is numeriek maar in de database niet, daar is het alphanumeriek... Geen relaties, sommige tabellen zijn uitgenormaliseerd, anderen niet... waarom lukt het die knoeierts toch elke keer weer die toetseborden te bereiken waar ze schade kunnen berokkenen

Sterker zelfs, hoe raken die knoeierds aan werk als ontwikkelaar?

Gerco schreef op 31 maart 2003 @ 17:03:
[...]

Heb jij soms bij een niet nader te noemen, Papendrechts bedrijf gezeten?

Huh? Papendrecht?
Nee hoor, 't was in Belgie.

[ Voor 19% gewijzigd door whoami op 31-03-2003 17:34 ]

[OnTracK]

robbertkrebbers schreef op 31 March 2003 @ 17:31:
[...]

volgens mij doet die het maar honderd keer, aangezien als de binnenste lus klaar is dan is $x=100 dus dan is ook de buitenste lus klaar

Hij moest dan waarschijnlijk ook net iets anders, namelijk dat een van de $x, $y wordt. dan doet ie er wel 100 * 100 over

[Gerco]

whoami schreef op 31 maart 2003 @ 17:33:
Huh? Papendrecht?
Nee hoor, 't was in Belgie.

Mja, ik zou je ons "datamodel" wel willen laten zien, maar dat wil ik liever niet publiek maken. Laat ik het er maar op houden dat de "ontwerpers" daarvan zich regelmatig schuldig maken aan de uitleg "Dat is historisch zo gegroeid".

Er is 9 van de 10 keer niet genormaliseerd, die 10e keer is het verkeerd gedaan. Er zijn geen forgeign keys aangegeven, de database ondersteunt ze niet, maar ze zijn zelfs niet gedocumenteerd, we hebben bijna 1000 tabellen met gemiddeld zo'n 30 velden per stuk waarin geen enkele vorm van naamgevingsconventie of structuur in te ontdekken is en ga zo maar door...

[Just_a_Gamer]

whoami schreef op 31 maart 2003 @ 16:47:
Nu ik dat topic van ACM nog eens doornam, schoot er me net nog iets te binnen.
Het heeft niet echt met 'code' te maken, eerder met database design.

Ik heb ooit eens een applicatie moeten aanpassen/uitbreiden waarvan het datamodel wel echt bagger was.
Sommige tabellen hadden geen PK, bepaalde numerieke gegevens werden in een alfanumeriek veld bijgehouden, tussen sommige tabellen werd er geen referentiele integriteit afgedwongen, data die gedupliceerd werd, de naam van een persoon die als PK gebruikt werd, etc.....
Lekker aanpaswerk hoor.....

Ach dat soort dingen gebeuren. Het is een dikke hel voor een database analyst die het weer helemaal weer mag gaan fixen en de programmeur die het programma weer compatible maken. Het zal wel zeker een database zijn die al heel lang bestaat toen de primary keys en foreign keys en checks blabla nog niet echt gebruikt werden. En zijn vervolgens verder aan het uitbouwen en komen tot het huidige "klote" database Dit is dus ook gebeurt met onze cijfer administratie systeem.

[Anoniem: 25556]

Dit is dus ook gebeurt met onze cijfer administratie systeem.

Je bedoelt toch niet K5?

[whoami]

Just_a_Gamer schreef op 31 March 2003 @ 18:24:
[...]


Ach dat soort dingen gebeuren. Het is een dikke hel voor een database analyst die het weer helemaal weer mag gaan fixen en de programmeur die het programma weer compatible maken. Het zal wel zeker een database zijn die al heel lang bestaat toen de primary keys en foreign keys en checks blabla nog niet echt gebruikt werden.

In mijn geval niet......
De persoon die zich met dat programma bezighield was er een maand of 2 voor dat ik het 'geërft' kreeg mee begonnen. :x
Die gast had ook gewoon Informatica gestudeerd aan een hogeschool (gelukkig niet dezelfde als ik ). Als je zo'n dingen ziet krab je je toch wel eens achter de oren en denk je toch wel eens na over het aantal prutsers in de IT hoor...

[Just_a_Gamer]

Anoniem: 25556 schreef op 31 maart 2003 @ 20:17:
[...]


Je bedoelt toch niet K5?

Voor de geinteresseerden ik heb het over FIS. Het enige echte administratie systeem van HAN Je wordt echt naar van wat voor vieze oplossingen er worden bedacht voor dat systeem

[Anoniem: 42544]

Anoniem: 66593 schreef op 31 March 2003 @ 17:00:
[...]


dit kan gewoon hoor...

duurt alleen lang om de for-loopjes te doen.
hij moet het alleen 100^100 keer doen

Huh? Ik denk dat hij enkel de tweede loop 100 keer loopt en voor de rest niets. Namelijk:
- De eerste loop begint, x wordt 1
- Dan wordt de tweede loop uitgevoerd, x wordt eerst 0 en na de loop blijft deze op 99 staan.
- Er komt dus een return naar de tweede loop met x = 99, dus de eerste loop breekt meteen

[JeroenTheStig]

...en volgens mij is de titelbalk van GoT het gevolg van een stuk debiel programmeerwerkje

edit:
plaatje ff weggedonderd, iedereen kan het wel zien

[ Voor 52% gewijzigd door JeroenTheStig op 01-04-2003 15:05 ]

[EXX]

lirpA 1 reew si teH

[ Voor 12% gewijzigd door EXX op 01-04-2003 11:47 ]

[Just_a_Gamer]

BoKToR schreef op 01 April 2003 @ 11:43:
...en volgens mij is dit het gevolg van een stukje fout programmeerwerkje

[afbeelding]
http://www.winkhem.com/jeroen/ToG.jpg

ps: check de titelbalk

1 April!!!!

[ACM]

boktor, die code zit er redelijk bewust in

[Anoniem: 13874]

[nohtml]

Anoniem: 42544 schreef op 01 April 2003 @ 11:06:
[...]


Huh? Ik denk dat hij enkel de tweede loop 100 keer loopt en voor de rest niets. Namelijk:
- De eerste loop begint, x wordt 1

x wordt nul zul je bedoelen. Het is een POST-increment

- Dan wordt de tweede loop uitgevoerd, x wordt eerst 0 en na de loop blijft deze op 99 staan.

Als je de binnen-loop verlaat is x gelijk aan 100

- Er komt dus een return naar de tweede loop met x = 99, dus de eerste loop breekt meteen

99 is nog altijd kleiner dan 100 hoor
Maar aangezien x na de binnenste loop al 100 is zal de buitenste loop inderdaad niet nogmaals doorlopen worden, omdat daar de waarde van x zelfs al 101 zal zijn in de eerst volgende keer dat de conditie van de buitenste loop gecontroleerd wordt

[ Voor 4% gewijzigd door Anoniem: 13874 op 01-04-2003 12:49 ]

[JeroenTheStig]

ACM schreef op 01 april 2003 @ 12:13:
boktor, die code zit er redelijk bewust in

ja, ik kwam d'r net ook pas achter dat het 1 april was

[ Voor 4% gewijzigd door JeroenTheStig op 01-04-2003 15:06 ]

[NaliXL]

Varienaja schreef op 29 maart 2003 @ 12:52:
De grootste klapper kwam ik een paar weken geleden tegen in de code van iemand anders:

code:

maak een of andere lijst
//we hebben nu het hoogste item in de lijst nodig
//daarvoor sorteren we eerst de lijst
lijst:=quicksort(lijst);
//we nemen nu het hoogste elemene
result:=lijst[lijst.count-1]

Niet echt efficiënt :-)

Die begrijp ik niet helemaal. Ik ben dan misschien wel een slechte programmeur, maar hier staat toch in feite :
1. sorteer lijst
2. Return het hoogste element uit de lijst
Wat het beoogde resultaat was? Ik zie ook geen manier om dit in minder stappen te doen, geloof ik. Wat had dan de efficiëntere versie geweest?

[Atari Paul]

Een aantal jaren geleden daagde mijn projectleider mij uit om een routine te schrijven om de amerikaanse weeknummering om te zetten in een europese.
Hij stelde wel als eis dat dit als one-liner werd gedaan.

En ja, dan krijg je de volgende code in Progress....:p

code:

assign {&week} = if(if entry(weekday(date(1,1,year({&date}))),"7,1,2,3,4,5,6") <= "4" then 
                    truncate(({&date} - date(1,1,year({&date})) + int(entry(weekday(date(1,1,year({&date}))),"7,1,2,3,4,5,6")) - 1) / 7,0) + 1
               else truncate(({&date} - date(1,1,year({&date})) + int(entry(weekday(date(1,1,year({&date}))),"7,1,2,3,4,5,6")) - 1) / 7,0))
               > 0 then (if entry(weekday(date(1,1,year({&date}))),"7,1,2,3,4,5,6") <= "4" then 
                    truncate(({&date} - date(1,1,year({&date})) + int(entry(weekday(date(1,1,year({&date}))),"7,1,2,3,4,5,6")) - 1) / 7,0) + 1
               else truncate(({&date} - date(1,1,year({&date})) + int(entry(weekday(date(1,1,year({&date}))),"7,1,2,3,4,5,6")) - 1) / 7,0))
               else (if entry(weekday(date(1,1,year({&date}) - 1)),"7,1,2,3,4,5,6") <= "4" then 
                    truncate((date(12,31,year({&date}) - 1) - date(1,1,year({&date}) - 1) + int(entry(weekday(date(1,1,year({&date}))) ,"7,1,2,3,4,5,6")) - 1) / 7,0) + 1
               else truncate((date(12,31,year({&date}) - 1) - date(1,1,year({&date}) - 1) + int(entry(weekday(date(1,1,year({&date}))),"7,1,2,3,4,5,6"))  - 1) / 7,0)).

[jelmervos]

Of naamgeving van object in je code verwerken:

code:

case StrToInt(Copy(Screen.ActiveForm.Name, 5, 2)) of
  1: Form1.Sluiten;
  2: Form2.Sluiten;
  3: Form3.Sluiten;
  4: Form4.Sluiten;
end;

[ Voor 4% gewijzigd door jelmervos op 01-04-2003 14:55 ]

[xtra]

NaliXL schreef op 01 april 2003 @ 14:03:
[...]

Die begrijp ik niet helemaal. Ik ben dan misschien wel een slechte programmeur, maar hier staat toch in feite :
1. sorteer lijst
2. Return het hoogste element uit de lijst
Wat het beoogde resultaat was? Ik zie ook geen manier om dit in minder stappen te doen, geloof ik. Wat had dan de efficiëntere versie geweest?

Niet sorteren?

Door één keer de lijst langs te lopen weet je wat de hoogste waarde is. Dan voorkom je het arbeidsintensieve sorteerwerk.

[Korben]

Het ranzigste vind ik toch over het algemeen stukken code waarin op meerdere plekken het resultaat van een ingewikkelde en tijdsintensieve functie wordt gebruikt. En dan wordt uiteraard het resultaat niet opgeslagen in een tijdelijke automatische variablele, neeheej, de functie wordt gewoon meerdere keren aangeroepen. Als voorbeeld, het ranzige misbruik van een zwaar recursieve functie uit mijn ternary search tree class, gebruikt met lange strings.

C++:

if (ptstTree->Find(pszString) == EInvalidArguments)
{
  // ..
}
else if (pstTree->Find(pszString) == ENoMem)
{
  // ..
}

// enzovoort :r

[EfBe]

Kwam net wat oude ASP reut van mezelf tegen. Deze code is dus overbodige dingen aan het doen:

code:

<%
    sCP = ""
    if len(trim(rsSub("Geslacht"))) > 0 then
        sCP = sCP & rsSub("Geslacht") & " "
    end if
    if len(trim(rsSub("Titel"))) > 0 then
        sCP = sCP & rsSub("Titel") & " "
    end if
    if len(trim(rsSub("Voorletters"))) > 0 then
        sCP = sCP & rsSub("Voorletters") & " "
    end if
    if len(trim(rsSub("Voorvoegsels"))) > 0 then
        sCP = sCP & rsSub("Voorvoegsels") & " "
    end if
    if len(trim(rsSub("Naam"))) > 0 then
        sCP = sCP & rsSub("Naam") & " "
    end if
%>
<%=sCP%>

(Los van het feit dat het er ranzig uitziet)

Dit is overbodige handelingen aan het doen, want 2 spaties of meer naast elkaar in HTML worden toch 1 in de view in de browser.
Dit kan dus ook in:

code:

<%=rsSub("Geslacht").value & " " & rsSub("Titel").value & " " &  ... etc %>

[ Voor 39% gewijzigd door EfBe op 03-04-2003 17:03 ]

[pistole]

EfBe schreef op 03 April 2003 @ 17:00:
Dit is overbodige handelingen aan het doen, want 2 spaties of meer naast elkaar in HTML worden toch 1 in de view in de browser.
Dit kan dus ook in:

code:

<%=rsSub("Geslacht").value & " " & rsSub("Titel").value & " " &  ... etc %>

Ik vind dat toch ook behoorlijk ranzig hoor...
Doe het in je select query (daar al evt replace / isnull / etc gebruiken) en return een enkel veld of "ontdubbel" wel die spaties voordat je ze eruit poept.
Idealiter maak je een mooie view die een naam in al zijn verschijningsvormen teruggeeft in verschillende kolommen.

* pistole 's 2 cents

[JayTaph]

code:

  switch (c) {
     case   'a' :   a = 1; break;
     case   'A' :   a = 1; break;
     case   'b' :   a = 2; break;
     case   'B' :   a = 2; break;
          .....
     case   'z' :   a = 26; break;
     case   'Z' :   a = 26; break;
  }

Ik zweer het, ik heb het gezien in professionele software die in winkels verkocht wordt

[Erkens]

JayTaph schreef op 07 april 2003 @ 16:34:

code:

  switch (c) {
     case   'a' :   a = 1; break;
     case   'A' :   a = 1; break;
     case   'b' :   a = 2; break;
     case   'B' :   a = 2; break;
          .....
     case   'z' :   a = 26; break;
     case   'Z' :   a = 26; break;
  }

Ik zweer het, ik heb het gezien in professionele software die in winkels verkocht wordt

mja als je per regel betaald krijgt

[Alarmnummer]

Ze hadden ook met if statements alles kunnen doen, en dan kan het nog erger:

if c = 'a' or 'A' then a=1;
if c= 'b' or 'B' then a = 2;
....

Zoals je zit mist dus de else, terwijl het veel verstandiger is om die er wel bij te doen. Ten 1e omdat het gewoon duidelijker is, ten 2e omdat het een stuk sneller is. Het missen van die else heb ik ook een tijdje moeten aanzien: drama!

[ Voor 17% gewijzigd door Alarmnummer op 07-04-2003 16:48 ]

[Erkens]

Alarmnummer schreef op 07 April 2003 @ 16:47:
Ze hadden ook met if statements alles kunnen doen, en dan kan het nog erger:

if c = 'a' or 'A' then a=1;
if c= 'b' or 'B' then a = 2;
....

Zoals je zit mist dus de else, terwijl het veel verstandiger is om die er wel bij te doen. Ten 1e omdat het gewoon duidelijker is, ten 2e omdat het een stuk sneller is. Het missen van die else heb ik ook een tijdje moeten aanzien: drama!

(die code klopt niet )

maar nog erger is om die OR niet te gebruiken
dus 2 regels per letter

[whoami]

Alarmnummer schreef op 07 April 2003 @ 16:47:
Ze hadden ook met if statements alles kunnen doen, en dan kan het nog erger:

if c = 'a' or 'A' then a=1;
if c= 'b' or 'B' then a = 2;
....

Zoals je zit mist dus de else, terwijl het veel verstandiger is om die er wel bij te doen. Ten 1e omdat het gewoon duidelijker is, ten 2e omdat het een stuk sneller is. Het missen van die else heb ik ook een tijdje moeten aanzien: drama!

Je kan dat karakter ook naar een integer casten zodat je de ASCII waarde krijgt, en daar dan een bepaald getal van aftrekken.

[Creepy]

whoami schreef op 07 April 2003 @ 16:52:
[...]


Je kan dat karakter ook naar een integer casten zodat je de ASCII waarde krijgt, en daar dan een bepaald getal van aftrekken.

Kan, maar dan heb je genoeg aan 1 regel code, en dat is niet leuk

[Alarmnummer]

Erkens schreef op 07 april 2003 @ 16:52:
[...]

(die code klopt niet )

Ligt er aan wat voor taal je gebruikt he

Maar het ging me erom om te laten zien dat mensen vaak geen else gebruiken terwijl het wel heel logisch is om het wel te doen. Waarom zou je condities checken die je niet hoeft te checken? Je zit in code waar je niet hoort te komen.

[Dido]

mmm... doet me toch weer denken aan een leuke feature:

Het ging om een boekhoudkundige balans, waar dus de optelsom aan de linkerkant gelijk moest zijn aan de som aan de rechterkant. Maar dat moet je dus niet opnemen in je technische specs want wat stond er in het programma?

totaal_rechts := totaal_links

Alle werkte perfect

[EfBe]

pistole schreef op 07 april 2003 @ 16:27:
[...]

Ik vind dat toch ook behoorlijk ranzig hoor...
Doe het in je select query (daar al evt replace / isnull / etc gebruiken) en return een enkel veld of "ontdubbel" wel die spaties voordat je ze eruit poept.

Nee, nooit concatenaten in de RDBMS, die is daar niet voor. Wel NULL's ombuigen naar empty strings (dus nooit NULL's uit de database). Ontdubbelen van spaties hoeft niet, want het is html! Dus die worden getoond als enkele spatie, vandaar dat het overbodige code was

[whoami]

Creepy schreef op 07 April 2003 @ 16:54:
[...]

Kan, maar dan heb je genoeg aan 1 regel code, en dat is niet leuk

Zeker niet als je per regel betaald wordt.

[Erkens]

Erkens schreef op 07 April 2003 @ 16:39:
[...]

mja als je per regel betaald krijgt

whoami schreef op 07 April 2003 @ 17:19:
[...]


Zeker niet als je per regel betaald wordt.

spuit 11

[wouzer]

Just_a_Gamer schreef op 31 maart 2003 @ 23:30:
[...]


Voor de geinteresseerden ik heb het over FIS. Het enige echte administratie systeem van HAN Je wordt echt naar van wat voor vieze oplossingen er worden bedacht voor dat systeem

Edje is een prutser. Het ene moment predikt hij database-tier-level constraints het andere moment vind je een landentabel met 1 colom, welke ook PK en FK is. Update land set landnaam='Netherlands' where land = 'Nederland'; ?
Zal wel weer vanuit de o-zo fantastisch FCOIM tool gegenereerd zijn.

Anyway, ik vond van de week nog wel een goeie. In een testprogramma voor onder DOS nog, blijkbaar had de baas er zelf nog aangezeten.

code:

printf("Dit programma doet dit en dat, bla bla bla. (Geef letter in en CR om door te gaan)\n");
scanf("%s", &dummy);

[Anoniem: 24260]

Ik weet er enkele in assembly, niet echt slecht, maar wel onefficiënt:

code:

push %edi
xchgl %edi,%eax
imull %edi,%eax
popl %ebp

dit kan beter zijn:

code:

imull %edi,%eax

Bovenstaande is wel niet altijd toepasbaar, maar hier mocht het dus wel.
Evenals hetvolgende die ik de leukste vind maar die blijkbaar wel veel toegepast wordt:

code:

xor %eax,%eax ;voor de leken: eax wordt hier op 0 gezet
inc %eax ; hier wordt er ééntje bij eax opgeteld, wat dus 1 geeft

kan vervangen worden door één instructie:

code:

movl    $1, %eax ;hier plaatst men 1 in eax wat veel efficiënter is dan voorgaande

scheelt weer een instructie, maar eigenlijk zijn er zo oneindig veel op te sommen, compilers zijn niet altijd efficiënt zo blijkt. Dan moeten we dat maar zelf optimaliseren.

[ Voor 19% gewijzigd door Anoniem: 24260 op 07-04-2003 20:58 ]

[hobbit_be]

JayTaph schreef op 07 april 2003 @ 16:34:

code:

  switch (c) {
     case   'a' :   a = 1; break;
     case   'A' :   a = 1; break;
     case   'b' :   a = 2; break;
     case   'B' :   a = 2; break;
          .....
     case   'z' :   a = 26; break;
     case   'Z' :   a = 26; break;
  }

Ik zweer het, ik heb het gezien in professionele software die in winkels verkocht wordt

tja als je niet weet dat characters eigenlijk bytes zijn. Ik vraag me af of unicode ook zo sterk geoptimaliseerd kan worden: is daar alles in alphabetische volgorde? anders word zoiets wel een opzoek tabel nachtmerrie

[hammerhead]

[b][message=17479921,noline]pikachuf schreef op 07 april 2003 @
<knip>
..

code:

xor %eax,%eax ;voor de leken: eax wordt hier op 0 gezet
inc %eax ; hier wordt er ééntje bij eax opgeteld, wat dus 1 geeft

kan vervangen worden door één instructie:

code:

movl    $1, %eax ;hier plaatst men 1 in eax wat veel efficiënter is dan voorgaande

scheelt weer een instructie, maar eigenlijk zijn er zo oneindig veel op te sommen, compilers zijn niet altijd efficiënt zo blijkt. Dan moeten we dat maar zelf optimaliseren.

Dacht het niet..... Staat me namelijk iets van bij van vroeger namelijk dat movl instructie redelijk traag was tov xor.... Weet niet precies hoe het met de inc zit... Maar ik weet wel dat op xor eax,eax echt de meest snelle manier is om eax 0 te maken en nie door middel van een mov instructie.... Ik vermoed dat een inc op zich ook wel een stuk sneller is maar dat weet ik dus niet zeker....

Minder instructies wil niet altijd sneller betekenen, bijvoorbeld als er instructies tussenzitten die gewoon trager zijn...

[kenneth]

Klopt deels, hammerhead.
xorl %eax,%eax is sneller dan movl $0,%eax maar een xorl en een incl is even snel als een enkele movl $1, %eax

Te slim bedacht dus

[hammerhead]

Is een inc + xor nog steeds niet sneller dan 1 enkele mov? Compiler zal het namelijk niet zomaar doen en de huidige compilers zijn op zich best wel goed....

[Sjaaky]

een xor en een inc is kleiner dan een mov.

[madwizard]

xor reg, reg is de beste methode om een register leeg te krijgen op athlons & P4s, maar oudere pentiums hadden een false read dependency op deze instructie (dwz dat de processor denkt dat het resultaat van de instructie afhankelijk is van de vorige waarde van reg, wat normaal ook zo is maar in dit geval niet). Ik denk niet dat xor+inc sneller is, de inc zal moeten wachten op de xor, het is wel kleiner en dat is wel handig. Het voordeel van mov eax, 0 boven xor eax, eax is dat het de status flags niet aanpast, zodat je em tussen andere instructies met onderlinge flag dependencies (cmp+jcc) kan zetten om de doorstroming te bevorderen.

[hobbit_be]

[quote]madwizard schreef op 08 April 2003 @ 00:20:
xor reg, reg is de beste methode om een register leeg te krijgen op athlons & P4s, maar oudere pentiums hadden een false read dependency op deze instructie .... quote]
als code optimiser can ik alvast toevoegen dat het bij eender welke PII+ processor maar vooral PIV bijna onmogelijk word om te gaan zeggen wat nu sneller is - het hangt van zoveel dingen af (cache,prefetch,pipeline,opcode reordering)... zeker bij zulke geisoleerde stukjes code is er geen definitief antwoord... (meer, ten tijde 386x 486x was dat wel even anders)

[pistole]

EfBe schreef op 07 April 2003 @ 17:05:
[...]

Nee, nooit concatenaten in de RDBMS, die is daar niet voor. Wel NULL's ombuigen naar empty strings (dus nooit NULL's uit de database). Ontdubbelen van spaties hoeft niet, want het is html! Dus die worden getoond als enkele spatie, vandaar dat het overbodige code was

Ik bedoelde ook in de SELECT (of in een VIEW), niet in de tabellen.

[Anoniem: 24260]

hammerhead schreef op 07 April 2003 @ 22:36:
Is een inc + xor nog steeds niet sneller dan 1 enkele mov? Compiler zal het namelijk niet zomaar doen en de huidige compilers zijn op zich best wel goed....

Das best wel raar dan want de tijd die nodig is om het programma uit te voeren met die 2 instructies i.p.v. die ene mov met een lusje natuurlijk (om alles te repeteren zodat de tijd meetbaar wordt) geeft een verschil van zo'n 300 ms (5000ms naar 4700ms) niet dat dat zo spectaculair is maar blijkbaar is die mov dan toch sneller?
Die 4 instructies wijzigen naar 1 bracht vervolgens wel spectaculair tijdsverchil. Nuja 't blijft een eigenaardigheidje.
Van een jump weet ik het overigens dat die veel tijd opslorpt, maar een mov. Maybe nog eens uittesten bij iets anders, zo zie je we leren iedere dag wel bij.

[ Voor 31% gewijzigd door Anoniem: 24260 op 08-04-2003 08:37 ]

[EfBe]

pistole schreef op 08 April 2003 @ 08:05:
[...]

Ik bedoelde ook in de SELECT (of in een VIEW), niet in de tabellen.

ja dat weet ik, dat bedoelde ik ook. String concatenaties (dus processing van results) doe je niet in de RDBMS (dus niet in een view of stored proc), de sp gaat dan nl dingen doen waar hij niet voor bedoeld is (het is DAL code, die moet alleen data retrieven en updaten/inserten/deleten)

[MerijnB]

tja.. wat is nou slecht...
deze is wel leuk om je dood op te staren.

stukje code uit een delphi unit door een senior geschreven

Delphi:

procedure TfrmEditor.EditChange(Sender: TObject);
var iTeller: integer;
    bAlleGevuld: boolean;
begin
    bAllegevuld := true;
    for iTeller := 0 to tgroupbox(tedit(sender).Parent).ControlCount -1 do
        if (tgroupbox(tedit(sender).Parent).Controls[iteller] is tedit) and
           (Tedit(tgroupbox(tedit(sender).Parent).Controls[iteller]).Text = '') and
           (m_avelden[Tedit(tgroupbox(tedit(sender).Parent).Controls[iteller]).tag].iRegelNr =
           m_avelden[tedit(sender).tag].iRegelNr) and
           (m_avelden[Tedit(tgroupbox(tedit(sender).Parent).Controls[iteller]).tag].sVerplicht  = 'T') then
            begin
              bAllegevuld := false;
              break
            end;
    for iTeller := 0 to tgroupbox(tedit(sender).Parent).ControlCount -1 do
      IF (tgroupbox(tedit(sender).Parent).Controls[iteller] is TCheckBox) and
         (m_avelden[tedit(sender).tag].iRegelNr =
         (m_avelden[TCheckBox(tgroupbox(tEDIT(sender).Parent).Controls[iteller]).tag].iRegelNr))
      THEN TCheckBox(tgroupbox(tEDIT(sender).Parent).Controls[iteller]).Checked := bAlleGevuld ;
end;

(ja, de andere 2000 regels zien d'r hetzelfde uit...)

[LuCarD]

MerijnB schreef op 08 April 2003 @ 12:08:
tja.. wat is nou slecht...
deze is wel leuk om je dood op te staren.

stukje code uit een delphi unit door een senior geschreven

<SNIP>

(ja, de andere 2000 regels zien d'r hetzelfde uit...)

Valt toch wel mee....

Zolang de if statement niet op 1 regel staat is het redelijk te lezen... Beetje weinig comment maar oke...

[nhimf]

Ik heb eens een mede student geholpen met het vak c++.
Hierin moest er een huis getekend worden dat uit een driehoek en uit een vierkant bestond.
Het moest OO. Dus wat deed deze knakker, in de constructor van de driehoek tekende hij een driehoek en in de constructor van de vierkant tekende hij een vierkant.
Vervolgens riep hij het zo aan:

code:

public void tekenHuis()
{
  Driehoek driehoek = new Driehoek();
  Vierkant vierkant = new Vierkant ();
}

Zoiets deed hij dus. Het werkte prima maar is wel het slechte voorbeeld van OO.

[MerijnB]

LuCarD schreef op 08 April 2003 @ 12:59:
[...]


Valt toch wel mee....

Zolang de if statement niet op 1 regel staat is het redelijk te lezen... Beetje weinig comment maar oke...

als je zo'n stuk code hebt, dan:
- zou je het in ieder geval leesbaar neer moeten zetten
- zou je niet 5x een object op dezelfde manier moeten typecasten
- zou wat commentaar idd geen slecht idee zijn
- zit je OO structuur ws niet echt best in elkaar

met andere woorden: het valt wel, maar zeker niet mee

[EfBe]

nhimf schreef op 08 april 2003 @ 13:14:
Ik heb eens een mede student geholpen met het vak c++.
Hierin moest er een huis getekend worden dat uit een driehoek en uit een vierkant bestond.
Het moest OO. Dus wat deed deze knakker, in de constructor van de driehoek tekende hij een driehoek en in de constructor van de vierkant tekende hij een vierkant.
Vervolgens riep hij het zo aan:

code:

public void tekenHuis()
{
  Driehoek driehoek = new Driehoek();
  Vierkant vierkant = new Vierkant ();
}

Zoiets deed hij dus. Het werkte prima maar is wel het slechte voorbeeld van OO.

Wellicht zie ik iets over het hoofd, maar serieus, wat is het intens slechte hieraan? Dit is typisch een geval van aggregation, niets mis mee.

[Gerco]

EfBe schreef op 08 april 2003 @ 13:32:
Wellicht zie ik iets over het hoofd, maar serieus, wat is het intens slechte hieraan? Dit is typisch een geval van aggregation, niets mis mee.

Ik vermoed dat tekenhuis() niet in een klasse Huis staat, maar in main().

[gjkamstra]

Ik heb vele erge stukken code gezien, heb nl. een heleboel werk van studenten nagekeken, ik zal daar maar geen grappen over maken, deze rare constructie van een docent! vond ik echter toch te leuk om niet te laten zien:

Java:

While (true) do {
    If (!boolexp) {
         break;
    } else {
          rest van code
    }
}

[Alarmnummer]

Er zijn volgens mij veel docenten die hun vak niet meester zijn. En ik ben maar 1 docent tegengekomen die werkelijk gemotiveerd was: Theo Sinnema (HIO Groningen). Geweldige man, die mensen goed kan afbranden Maar er zelf ook wel wat van af wist.

[NaliXL]

nhimf schreef op 08 april 2003 @ 13:14:
Ik heb eens een mede student geholpen met het vak c++.
Hierin moest er een huis getekend worden dat uit een driehoek en uit een vierkant bestond.
Het moest OO. Dus wat deed deze knakker, in de constructor van de driehoek tekende hij een driehoek en in de constructor van de vierkant tekende hij een vierkant.
Vervolgens riep hij het zo aan:

code:

public void tekenHuis()
{
  Driehoek driehoek = new Driehoek();
  Vierkant vierkant = new Vierkant ();
}

Zoiets deed hij dus. Het werkte prima maar is wel het slechte voorbeeld van OO.

Ehm, is dat nou niet juist het idee achter OO? Dat je opdeelt in meerdere objecten (in dit geval vierkant en driehoek) om zo gemakkelijker te kunnen hergebruiken? Of is dat niet wat je bedoelt? (ben geen ster in C++)

[Alarmnummer]

Ik snap ook niet wat er mis is met die compositie.

[whoami]

Hmmm, ik zou het tekenen van het vierkant en de driehoek niet in de constructor laten gebeuren.
Een constructor is er imho voor om waarden te initialiseren. Hij had gewoon best een extra method gemaakt 'Draw' oid waar de figuur getekend werd. (Die Draw kan natuurlijk een method zijn in een interface of in een abstract class ).

[Woy]

Het enige foute wat ik er aan zie is dat elke keer dat tekenHuis wordt aangeroepen er een nieuwe instantie van Driehoek en Vierkant aangemaakt worden. Je kan natuurlijk beter gewoon in de constructor de instanties aanmaken en dan in de methode tekenHuis de methodes tekenVierkant en tekenDriehoek uitvoeren. Tenminste ik denk dat dat is wat hij bedoeld

edit:
Ik bedoel dus zo'n beetje wat whoami ook zei terwijl ik aan het typen was

[ Voor 12% gewijzigd door Woy op 08-04-2003 14:19 ]

[whoami]

Ik heb hier nog een stukje oude code van me tegen gekomen....

't is al zo'n 4 jaar oud, en ik was toen net met C++ Builder begonnen.

code:

void __fastcall TfrmKlantIngeven::FormActivate(TObject *Sender)
{
    dmDataMod->tbKlant->Open();
    dmDataMod->tblLeveringKrant->Open();
    dmDataMod->tblLeveringTijdschriften->Open();
    dmDataMod->tbKlant->Insert();          //Nodige tabellen in edit mode zetten
    dmDataMod->tblLeveringKrant->Insert();
    dmDataMod->tblLeveringTijdschriften->Insert();
    edBeginDatum->EditText = DateToStr(Date());
    Application->OnHint = OnHint;

    dmDataMod->qryKlantnr->Close();
    dmDataMod->qryKlantnr->Open();
    nummer = dmDataMod->qryKlantnr->FieldByName("expr1000")->AsInteger;
    if(nummer == 0)
        nummer = 1;
    else nummer++;
    edKlantnr->Text = nummer;
    dmDataMod->qryHoogstevolgnr->Close();
    dmDataMod->qryHoogstevolgnr->Open();
    int volgnummer;
    volgnummer = dmDataMod->qryHoogstevolgnr->FieldByName("expr1000")->AsInteger;
    if(volgnummer == 0)
        volgnummer = 1;
    else volgnummer++;
    edVolgnr->Text = volgnummer;
    ActiveControl = edReferentie;
}

code:

void __fastcall TfrmKlantIngeven::cbKrantVerlofClick(TObject *Sender)
{
//do nothing;    
}

* whoami kruipt in een hoekje.

[Robtimus]

whoami schreef op 08 April 2003 @ 20:57:
...

code:

....
    if(nummer == 0)
        nummer = 1;
    else nummer++;
....
    if(volgnummer == 0)
        volgnummer = 1;
    else volgnummer++;
....

* whoami kruipt in een hoekje.

Lekker handig zeg....

[whoami]

Zeg wel.

[Anoniem: 77584]

Toch leuk om te zien hoe jullie jezelf zo de hemel inprijzen

_{heb het eigenlijk over de topicstarter}

[ Voor 30% gewijzigd door Anoniem: 77584 op 09-04-2003 17:57 ]

[Alarmnummer]

Hmmz, je voelt je toch niet aangesproken he

En zie verder mijn sig hoe ik over prutsers denk.

[ Voor 118% gewijzigd door Alarmnummer op 09-04-2003 18:33 ]

[EfBe]

Anoniem: 77584 schreef op 09 April 2003 @ 17:56:
Toch leuk om te zien hoe jullie jezelf zo de hemel inprijzen

Huh? we posten eigen krakkemikkigheid!

[WildernessChild]

Stukje code van een universitair docent:

Java:

boolean going = true;
while(going) {
  ...;
  going = blaat();
}

Dit kan veel beter met:

Java:

do {
  ...;
}
while(blaat())

Je zou toch denken dat die gasten er verstand van hebben ofzo...

[Anoniem: 49627]

WildernessChild schreef op 10 April 2003 @ 14:36:
Stukje code van een universitair docent:

Java:

boolean going = true;
while(going) {
  ...;
  going = blaat();
}

Dit kan veel beter met:

Java:

do {
  ...;
}
while(blaat())

Je zou toch denken dat die gasten er verstand van hebben ofzo...

Dit valt met het oog op opleiding nog recht te praten. Als je het moet leren is de eerste manier overzichtelijker.

[WildernessChild]

Anoniem: 49627 schreef op 10 April 2003 @ 14:40:
[...]
Dit valt met het oog op opleiding nog recht te praten. Als je het moet leren is de eerste manier overzichtelijker.

Daar ben ik het niet mee eens. Om te beginnen gebruik je een extra boolean, en niet alleen kost dat geheugen, maar ook moet je bij het leze van de code gaan bijhouden wat de waarde daarvan is tijdens de executie van het programma. Daar wordt het dus minder duidelijk door. Bovendien leer je mensen niet iets door het eerst zelf fout voor te doen 'omdat het duidelijker zou zijn'... Dit soort constructies is toch precies waar een do-while loop voor bedoeld is? Dus eerst een keer uitvoeren, en dan de check of hij nog een keer moet.

[Anoniem: 49627]

Ja ik vind het ook niet goed hoor, maar toch schijnen mensen het makkelijker te leren, want het gebeurd wel vaker. en docenten weten vaak wel beter hoor...

[Altaphista]

Alarmnummer schreef op 29 maart 2003 @ 10:55:
...
een stagaire
...

tja... vrouwen (of was het een stagiair?)


ik ben wel van die vage nietszeggende variabele namen tegegekomen, die je dan met een replace eerst moet vervangen. (var a,b,c ..., aa,ab etc )

[ Voor 5% gewijzigd door Altaphista op 10-04-2003 14:55 ]

[Alarmnummer]

Altaphista schreef op 10 april 2003 @ 14:52:
[...]

tja... vrouwen


ik ben wel van die vage nietszeggende variabele namen tegegekomen, die je dan met een replace eerst moet vervangen. (var a,b,c ..., aa,ab etc )

Nou batman en spiderman zijn ook niet echt van die handige namen

[whoami]

WildernessChild schreef op 10 April 2003 @ 14:48:
[...]


Daar ben ik het niet mee eens. Om te beginnen gebruik je een extra boolean, en niet alleen kost dat geheugen, maar ook moet je bij het leze van de code gaan bijhouden wat de waarde daarvan is tijdens de executie van het programma. Daar wordt het dus minder duidelijk door. Bovendien leer je mensen niet iets door het eerst zelf fout voor te doen 'omdat het duidelijker zou zijn'... Dit soort constructies is toch precies waar een do-while loop voor bedoeld is? Dus eerst een keer uitvoeren, en dan de check of hij nog een keer moet.

Goh, wat is het probleem nu nog als je 1 extra variable moet bijhouden in tijden waar pc's 256mb ram en meer hebben.

[WildernessChild]

whoami schreef op 10 april 2003 @ 15:07:
Goh, wat is het probleem nu nog als je 1 extra variable moet bijhouden in tijden waar pc's 256mb ram en meer hebben.

Waarom zou je het niet voorkomen? Je code wordt leesbaarder, en het scheelt een hele byte. Terwijl het geen enkel voordeel heeft om die boolean wel te gebruiken. (Behalve dan misschien om betwistbare didactische redenen...)

[ Voor 5% gewijzigd door WildernessChild op 10-04-2003 15:10 ]

[Soultaker]

whoami schreef op 10 april 2003 @ 15:07:
Goh, wat is het probleem nu nog als je 1 extra variable moet bijhouden in tijden waar pc's 256mb ram en meer hebben.

Die extra variabele maakt je code nodeloos ingewikkelder, langer en minder inzichtelijk dan de variant met do-while lus. Die argumenten zijn veel belangrijker dan een paar byte op de stack.

Je moet je realiseren dat efficientere code ook vaak eenvoudiger kan zijn (en daardoor beter te begrijpen, schrijven en onderhouden) doordat overbodige programmaregels (variabeledeclaraties maar ook statements) verwijderd worden. Natuurlijk is het optimaliseren van code in het algemeen niet echt bevordelijk voor de leesbaarheid, maar in sommige gevallen (zoals ook hier) zeker wel. Bedenk daarbij dat efficiente code ook vaak voorkomt uit een goed inzicht in het (deel)probleem dat die code oplost. Als je het probleem zo formeel en beknopt mogelijk weet te formuleren, kun je ook een beknopte implementatie schrijven. Over code met veel conditionele expressies, jumps en breaks is soms niet goed nagedacht en die code kan dan efficienter worden door het probleem (en daarna de oplossing) beter te formuleren.

Ik kan me dan ook niet voorstellen waarom het handig zou zijn om studenten te leren om een nodeloos omslachtige en ingewikkelde constructie te gebruiken, terwijl de taal zelf een specifieke oplossing kent voor dit probleem. Programmeurs passen patronen toe bij het oplossen van programmeerproblemen; door slechte patronen aan te leren, gaan ze slechte code schrijven. Zelfs als de do-while constructie later nog aan de orde komt, is de kans groot dat een aantal studenten de ingesleten slechte variant blijven gebruiken. Waarom zou je als docent dat risico willen lopen? Geef studenten waar ze recht op hebben: degelijke voorbeelden die bruikbaar zijn in reeele situaties. Afwijkende voorbeelden kunnen ook leerzaam zijn, maar merk dan wel op dat er van het standaardpatroon afgeweken wordt en hoe het probleem normaal gesproken opgelost zou worden. Dat betekent dat je er als docent ook zelf over na moet denken, welke voorbeelden je aanlevert.

edit:
Hmz, WildernessChild kan mijn gedachtegang heel wat korter formuleren:

WildernessChild schreef op 10 April 2003 @ 15:10:
Waarom zou je het niet voorkomen? Je code wordt leesbaarder, en het scheelt een hele byte. Terwijl het geen enkel voordeel heeft om die boolean wel te gebruiken. (Behalve dan misschien om betwistbare didactische redenen...)

[ Voor 10% gewijzigd door Soultaker op 10-04-2003 15:44 ]

[Crazy D]

Soultaker schreef op 10 April 2003 @ 15:43:
Die extra variabele maakt je code nodeloos ingewikkelder, langer en minder inzichtelijk dan de variant met do-while lus. Die argumenten zijn veel belangrijker dan een paar byte op de stack.

In dit voorbeeld was de keuze voor een while-loop niet goed, en zou het al een do-while loop geweest moeten zijn. Ik kan me wel situaties voorstellen dat gebruik maken van een hulp-boolean de code leesbaarder maakt (maar "leesbaar" is iets persoonlijks denk ik).
Zou de compiler trouwens niet zo slim zijn om, als die boolean alleen wordt gebruikt om de return waarde van blaat() in op te slaan om 'm daarna in de while() te gebruiken, niet zo optimalizeren dat heel die hulp-boolean niet meer wordt gebruikt?

[klinz]

whoami schreef op 08 April 2003 @ 20:57:

code:

void __fastcall TfrmKlantIngeven::cbKrantVerlofClick(TObject *Sender)
{
//do nothing;    
}

* whoami kruipt in een hoekje.

Ik weet niet of je hier voor in een hoekje moet kruipen. De reden achter bovenstaande constructie ken ik wel; voorkomen dat de OnClick van een ancestor object aangeroepen wordt. Op zich niet een hele fraaie oplossing.

Of is TfrmKlantIngeven een rechtstreekse afgeleide van TForm? Dan is het inderdaad tamelijk nutteloos.

[Soultaker]

Crazy D schreef op 10 April 2003 @ 18:49:
In dit voorbeeld was de keuze voor een while-loop niet goed, en zou het al een do-while loop geweest moeten zijn. Ik kan me wel situaties voorstellen dat gebruik maken van een hulp-boolean de code leesbaarder maakt (maar "leesbaar" is iets persoonlijks denk ik).

Dat "leesbaar" een subjectief begrip is, ben ik met je eens, maar in het gegeven voorbeeld was van toegenomen leesbaarheid geen sprake (in tegendeel, denk ik zelf).

Zou de compiler trouwens niet zo slim zijn om, als die boolean alleen wordt gebruikt om de return waarde van blaat() in op te slaan om 'm daarna in de while() te gebruiken, niet zo optimalizeren dat heel die hulp-boolean niet meer wordt gebruikt?

In zo'n simpele lus lukt dat waarschijnlijk wel. Met ingewikkelde constructies misschien niet meer. Hoe het ook zij, wordt dit pas een relevante overweging als de betreffende code een performance bottleneck vormt (waar maar zelden sprake van is); je kunt er het beste naar streven om in de eerste plaats goede programmacode te schrijven. Machinecode optimaliseren doet de compiler wel voor je.

[EfBe]

WildernessChild schreef op 10 April 2003 @ 14:48:
[...]


Daar ben ik het niet mee eens. Om te beginnen gebruik je een extra boolean, en niet alleen kost dat geheugen, maar ook moet je bij het leze van de code gaan bijhouden wat de waarde daarvan is tijdens de executie van het programma. Daar wordt het dus minder duidelijk door. Bovendien leer je mensen niet iets door het eerst zelf fout voor te doen 'omdat het duidelijker zou zijn'... Dit soort constructies is toch precies waar een do-while loop voor bedoeld is? Dus eerst een keer uitvoeren, en dan de check of hij nog een keer moet.

Nee daar is een for lus voor bedoeld. Een while is bedoeld voor loops die 0 of meerdere keren moeten worden doorlopen, een for lus is bedoeld voor 1 of meerdere keren, precies wat het voorbeeld aangaf. Het voorbeeld van die docent met boolean = true en dan die while in die test op die bool is een voorbeeld van 'ik begrijp de taalconstructies niet'. En daarom inderdaad door jou met recht van een entry voorzien in deze thread

[Soultaker]

EfBe schreef op 10 April 2003 @ 20:39:
Nee daar is een for lus voor bedoeld. Een while is bedoeld voor loops die 0 of meerdere keren moeten worden doorlopen, een for lus is bedoeld voor 1 of meerdere keren, precies wat het voorbeeld aangaf.

Wat een bullshit! Hoe kun je ooit een do-while lus MINDER dan 1 keer doorlopen?!

De naamgeving is nog wel zo duidelijk. Een while lus is simpelweg een blok dat je herhaaldelijk wilt doorlopen zolang een conditie geldt. Een for lus gebruik je om een een blok voor een aantal specifieke waarden te doorlopen, vandaar dat je een initialisatie, iteratiestatement en een eindopdracht definieert. Het getuigt daarbij van 'goede stijl' om variabelen die je in je for-lus gebruikt niet daarbuiten te wijzigen. Het aantal iteraties is daarbij niet echt van belang.

[Alarmnummer]

Ik vind het idd ook vrij wazig van Otis om hierop een onderscheid te maken. Het enigste argument dat ik ken is: als je weet hoeveel iteraties-> forlus, anders while (of do while).

Als je bv een lege lijst krijgt dan moet je in otis zijn geval onderscheid gaan maken tussen een for lus als de lijst 1 of meerdere elementen bezig en anders een while:

code:

if(l.size()>0){
     for(int k=0;k<l.size();k++){
         ....
     }
}else{
    int k=0;
    while(k<l.size()){
         ...
    }

}

Volgens mij bedoelt Ef8e dit ook niet (is trouwens ook eigelijk onzin om die while bij die size==0 te doen )

Ik ben er intussen trouwens ook mee begonnen om uit forlussen te springen met returns. Je code wordt een stuk overzichtelijker omdat het gewoon korter is. While lussen gebruik ik al bijna niet meer

[ Voor 11% gewijzigd door Alarmnummer op 10-04-2003 21:02 ]

[EfBe]

Soultaker schreef op 10 april 2003 @ 20:54:
[...]
Wat een bullshit! Hoe kun je ooit een do-while lus MINDER dan 1 keer doorlopen?!

Hey hey! Ik zei niet dat die do while crap was, ik zei dat die while() {} crap was, omdat hij MINSTENS 1 keer die loop doorging / wilde!! do while en for() zijn equivalenten. Ik heb het NIET over de do while gehad. Het is maar net wat je gewend bent, de een wil een do while gebruiken (do repeat of whatever de taal aanbiedt) de ander gebruikt een for loop. Mijn punt was en is dat wanneer je minstens 1 keer de lus door wilt, wat hij wilde ivm het op true zetten van de boolean, je NOOIT naar een while() {} moet grijpen, want die is daar niet voor bedoeld.

De naamgeving is nog wel zo duidelijk. Een while lus is simpelweg een blok dat je herhaaldelijk wilt doorlopen zolang een conditie geldt. Een for lus gebruik je om een een blok voor een aantal specifieke waarden te doorlopen, vandaar dat je een initialisatie, iteratiestatement en een eindopdracht definieert.

Err nee. In VB heb ik bv een for i = vanvalue to totvalue ... next i constructie. Niets initialisatie, iteratie en eindopdracht. Je moet nadenken wat je wilt gaan doen. Als je 0 of meerdere keren een lus door wilt, is de for niet geschikt, dat klopt ook, want daarvoor heb je een while. Wanneer je minstens 1 keer de lus door wilt, is de while dom, want je wilt bij 1 of meerdere keren de lus door aan het eind van de lus testen en niet vooraf, wat inhoudt dat je een do ... while of for gebruikt en niet een while. Dit is ook de reden dat talen BEIDE aanbieden. Dat C-achtigen toevallig een compact for statement hebben waar je veel dingen in kwijt kunt is mooi, maar doet niet ter zake.

Edit: m.a.w. met een while(expressie) { statements } constructie en een do {statements } while (expressie) heb je geen for statement nodig, en is dus overbodig. Dat deze wel in C zit is me dan ook een raadsel.

Het getuigt daarbij van 'goede stijl' om variabelen die je in je for-lus gebruikt niet daarbuiten te wijzigen. Het aantal iteraties is daarbij niet echt van belang.

Wie schrijft die 'goede' stijl voor? Jij ? Fowler? Ik ben in de vele jaren dat ik pruts aan code al erg veel verhalen tegengekomen omtrent stijlen en wat goed/slecht is, dat ik mn neus echt ophaal voor dat soort opmerkingen, nofi . In de jaren 80/begin 90 mocht je eigenlijk geen whiles gebruiken in je C code tenzij je niet anders kon, want while was een Wirth statement en hoorde eigenlijk niet in C thuis. "Een echte goede C programmeur programmeert op zn C's in C, niet op zn Pascal's". De allergrootste doodzonde was do {... } while (expression) gebruiken in C. Ik heb die dan ook behalve in 1 project op de uni dat resulteerde in een reprimande van mn docent nooit meer gebruikt.

In 'C' was het iig zo dat bv de iterator variabele na de for loop 'undefined' was, qua waarde (oude Sun CC compilers iig) . In andere talen is dat niet zo, (geloof nu in C ook niet meer zo) en kun je die variabele die VOOR de for is geinitialiseerd weer gebruiken, waarom niet? Variabelen zijn een scope specific static set locaties waar je waarden neerzet die je in een zekere program state gebruikt en manipuleert. Als op een zekere tijd T variabelen door een loop worden veranderd (for statement), wat is er dan mis mee dat je die nieuwe toestand van die variabele na dat statement gebruikt? Ik zie dat niet.

[ Voor 5% gewijzigd door EfBe op 10-04-2003 21:57 ]

[Soultaker]

EfBe schreef op 10 april 2003 @ 21:51:
Err nee. In VB heb ik bv een for i = vanvalue to totvalue ... next i constructie. Niets initialisatie, iteratie en eindopdracht.

Dat is de C/C++/Java/etc. implementatie. Ik schrijf heel duidelijk: "Een for lus gebruik je om een een blok voor een aantal specifieke waarden te doorlopen." Dat geldt in alle programmeertalen die ik ken. Ook in Basic: je wil het blok doorlopen voor de waarden die i van X tot Y achtereenvolgens aanneemt. Dat de syntax iets anders is, maakt er niet een andere constructie van. Je kunt de "i = X" als initialisatie, "next I" als iteratie en "to Y" als eindconditie beschouwen.

Je moet nadenken wat je wilt gaan doen. Als je 0 of meerdere keren een lus door wilt, is de for niet geschikt, dat klopt ook, want daarvoor heb je een while.

Stel ik heb in C in een functie die een array met strings print. Dan schrijf ik die toch echt zo:

C:

void print(const char *strings[], int aantal)
{
    int n;
    for(n = 0; n < aantal; ++n)
        printf("%s\n", strings[n]);
}

De for-lus drukt namelijk precies uit wat ik wil doen: voor elk van de indices van de array (0 <= n < aantal), wil ik het juiste element printen. Omdat aantal ook best eens gelijk aan 0 kan zijn, ga ik niet opeens een while lus gebruiken, want dan moet ik opeens m'n initialisatie en iteratie buiten de lus gaan zetten! Daar wordt het absoluut niet beter op.

Wanneer je minstens 1 keer de lus door wilt, is de while dom, want je wilt bij 1 of meerdere keren de lus door aan het eind van de lus testen en niet vooraf, wat inhoudt dat je een do ... while of for gebruikt en niet een while.

De conditie in een for-lus wordt in C-achtige talen ook de eerste keer gecontroleerd hoor. De volgende twee constructies zijn semantisch equivalent:

C:

// for-constructie
for(INITIALISATIE; ITERATIE; !EINDCONDITIE)
{
   // OPERATIE
}

// while-constructie
INITIALISATIE;
while(!EINDCONDITIE)
{
    // OPERATIE
    // ITERATIE
}

Het verschil zicht puur in de zelfbeschrijvende kwaliteit van de code. Gebruik van een for-statement drukt net iets anders uit dan een while-statement, maar het is niet gezegd dat je per se de een of de ander moet gebruiken.

Dit is ook de reden dat talen BEIDE aanbieden. Dat C-achtigen toevallig een compact for statement hebben waar je veel dingen in kwijt kunt is mooi, maar doet niet ter zake.

Wat heeft dat 'compact' zijn er dan mee te maken? En waarom doet het for-statement in C niet ter zake als we het over het for-statement in het algemeen hebben? Geldt het for-statement in C of C++ wel? Of alleen het for-statement in BASIC? En in shell scripts dan? Feit is dat je for-statement in C-achtige talen veel veelzijdiger is dan in andere talen (die zich vaak beperken tot een voorgeprogrammeerde initialisatie, iteratie en eindconditie);

Edit: m.a.w. met een while(expressie) { statements } constructie en een do {statements } while (expressie) heb je geen for statement nodig, en is dus overbodig. Dat deze wel in C zit is me dan ook een raadsel.

Dat ben ik dus met je eens. Hij zit er toch in, zoals al ik zei, omdat het gebruik van een for-statement een bepaald patroon is, dat door andere programmeurs eenvoudig begrepen wordt. Door het op de juiste manier te gebruiken, beschrijft de code zijn eigen werking beter. Volgens jouw redenatie is een do-while-constructie ook overbodig, omdat je die ook wel met een 'normale' while-constructie (en wat dubbele code) kan construeren. Eigenlijk heb je helemaal geen while-statement nodig als je labels en goto ondersteund (zoals in C het geval is).

Wie schrijft die 'goede' stijl voor? Jij?

Ja, ik.

Ik ben in de vele jaren dat ik pruts aan code al erg veel verhalen tegengekomen omtrent stijlen en wat goed/slecht is, dat ik mn neus echt ophaal voor dat soort opmerkingen, nofi . In de jaren 80/begin 90 mocht je eigenlijk geen whiles gebruiken in je C code tenzij je niet anders kon, want while was een Wirth statement en hoorde eigenlijk niet in C thuis. "Een echte goede C programmeur programmeert op zn C's in C, niet op zn Pascal's". De allergrootste doodzonde was do {... } while (expression) gebruiken in C. Ik heb die dan ook behalve in 1 project op de uni dat resulteerde in een reprimande van mn docent nooit meer gebruikt.

Tja, lullig voor je dat je nu met zo'n trauma opgescheept zit ( grapje, ey) maar dat neemt niet weg dat het nuttig is als verschillende programmeurs eenzelfde stijl aanhouden. Dat maakt het simpelweg eenvoudiger om elkaar's code te lezen (en ook je eigen code terug te lezen). Ook blijkt in de praktijk gewoon dat bepaalde oplossingen beter geschikt zijn in bepaalde situaties dan anderen. Je kunt daar "je neus voor ophalen" maar daar verdwijnen die voordelen niet mee.

In 'C' was het iig zo dat bv de iterator variabele na de for loop 'undefined' was, qua waarde (oude Sun CC compilers iig) . In andere talen is dat niet zo, (geloof nu in C ook niet meer zo) en kun je die variabele die VOOR de for is geinitialiseerd weer gebruiken, waarom niet? Variabelen zijn een scope specific static set locaties waar je waarden neerzet die je in een zekere program state gebruikt en manipuleert. Als op een zekere tijd T variabelen door een loop worden veranderd (for statement), wat is er dan mis mee dat je die nieuwe toestand van die variabele na dat statement gebruikt? Ik zie dat niet.

In de oorspronkelijke versie van C mocht je helemaal geen lokale variabelen in een for-statement declareren. In C99 mag dat weer wel en daar zijn verder ook geen problemen mee, voor zover ik weet. Wel speelt een soortgelijk probleem een rol in C++: in ieder geval de C++ compiler van Microsoft plaatste de for-variabelen (onterecht) in de outer scope.

De reden dat ik dit zelf onwenselijk vind, is dat dit soort dingen onmogelijk zijn:

C++:

for(int n = 0; n < 123; ++ n)
   whatever(n);

for(int n = 0; n < 123; ++ n)  // error: n is al gedeclareerd
   whatever(n);

Als de identifier slechts in de scope van het for-statement bestaat, is deze code wel goed. Als je toch graag die n buiten de lus wilt gebruiken, kun je 'm expliciet buiten de lus declareren. Dat is ook veel duidelijker.

C++:

int n;

for(n = 0; n < 123; ++ n)  // ok
   whatever(n);

for(n = 0; n < 123; ++ n)  // ok
   whatever(n);

[hobbit_be]

als het proper moet: for loop
//talen MET initialisatie: houd je block's 'clean' - geen 'int already defined' geklooi
als het snel moet: while loop
//vooral voor de dommere compilers en het while(--a){}; is altijd een clock sneller omdat
//geen cmp moet doen

en die snelheid is met deftig compiler al heel miniem.

ik wil in elke taal een foreach!!!

while vind ik vanuit 'artistiek' standpunt wel 'mooier' gewoon een mooi woord.

hoe was het ook al weer in Nederlandse Basic: Voor of Herhaal?

edit:
Iterators!!!

[ Voor 8% gewijzigd door hobbit_be op 10-04-2003 22:37 ]

[whoami]

hobbit_be schreef op 10 April 2003 @ 22:33:
als het proper moet: for loop
//talen MET initialisatie: houd je block's 'clean' - geen 'int already defined' geklooi
als het snel moet: while loop
//vooral voor de dommere compilers en het while(--a){}; is altijd een clock sneller omdat
//geen cmp moet doen

Waarom als het snel moet een while?
een for is afaik de snelste lus als je weet hoeveel iteraties je moet doen.

_{Ik weet niet of je het weet, maar je kraamt hier nogal wartaal uit....}