[Alg] Slechtste programmeervoorbeelden deel 3

[mithras]

Database != hiërarchisch. Als je denkt dat een database uit 1 tabel behoort te bestaan, ligt je prioriteit duidelijk niet op efficiëntie, duidelijkheid, overzichtelijkheid en onderhoudbaarheid

[Kettrick]

Je kan natuurlijk ook gewoon table inheritance toepassen, dan zijn jullie beide blij

[Verwijderd]

mithras schreef op donderdag 13 maart 2008 @ 14:54:
Database != hiërarchisch. Als je denkt dat een database uit 1 tabel behoort te bestaan, ligt je prioriteit duidelijk niet op efficiëntie, duidelijkheid, overzichtelijkheid en onderhoudbaarheid

Dat klopt, een database is niet hiërachisch. Maar wat als je content dat wel is?

[Voutloos]

En een directory is toch echt een speciaal soort file, wat ook maar voor het gemak vergeten wordt.

Zo'n fs kan dus generiek (op een bepaald niveau) met alles omgaan alsof het zomaar een file is, net als een db gewoon om kan gaan met rows. Echter is niet elke file hetzelfde (een rits inodes vs zomaar wat binaire data), of elke row hetzelfde (int kolommen, of een blob).

Verwijderd schreef op donderdag 13 maart 2008 @ 15:01:
Dat klopt, een database is niet hiërachisch. Maar wat als je content dat wel is?

Dan zegt het nog niet alles, want er zit hier gewoon een duidelijk verschil tussen de leafnodes en de andere nodes, een detail dat jij steeds voor het gemak negeert.

Maar goed, ik ga niet verder in deze discussie. Ik wil je alleen meegeven dat gezien je opmerkingen in de laatste paar posts je op diverse vlakken toch de nodige basiskennis fout hebt zitten. Ik zou bijna denken dat je express een slecht voorbeeld gaat zitten verdedigen (global vars, slecht datamodel) om maar leuk een discussie uit te lokken en daar doe ik niet aan mee.

[rrrandy]

Verwijderd schreef op donderdag 13 maart 2008 @ 15:01:
[...]


Dat klopt, een database is niet hiërachisch. Maar wat als je content dat wel is?

Als je nou echt vooruitstrevend bent, gebruik je in dat geval toch geen database?

[.oisyn]

Als je vooruitstrevend wilt zijn en een boomstructuur op wilt slaan in een database dan gebruik je daar geen relationele database voor, maar bijvoorbeeld een OO database. Een RDB is per definitie niet geschikt voor boomstructuren.

.edit: oepsie er was alweer een nieuwe pagina

Verwijderd schreef op donderdag 13 maart 2008 @ 15:01:
[...]

Dat klopt, een database is niet hiërachisch. Maar wat als je content dat wel is?

Dan gebruik je the wrong tool for the right job.

[ Voor 40% gewijzigd door .oisyn op 13-03-2008 15:24 ]

[Verwijderd]

rrrandy schreef op donderdag 13 maart 2008 @ 15:15:
[...]


Als je nou echt vooruitstrevend bent, gebruik je in dat geval toch geen database?

offtopic:
Dat klopt, zelf gebruik ik een chineesje en een kaartenbak

[Alex)]

My Pi Goes to Twelve

Op z'n minst een slecht gekozen naam voor een variabele imho

[ Voor 27% gewijzigd door Alex) op 13-03-2008 15:20 ]

[Verwijderd]

FragFrog schreef op maandag 18 februari 2008 @ 13:50:
[...]

Hopelijk zie je nu zelf waarom je in mijn opinie zojuist een vermelding in dit topic hebt verdient

Alhoewel, het is niet zozeer een slecht programmeervoorbeeld natuurlijk, eerder gevalletje maandagochtend

Hiervoor kun je toch het beste een iterator gebruiken?

[PrisonerOfPain]

ouicestmoi schreef op woensdag 12 maart 2008 @ 15:28:
Ik gebruik een library zziplib en daar kom ik onder meer het volgende tegen:

code:

#define ___ {
#define ____ }

Niet nodig te zeggen dat de werking van sommige onderdelen heel lastig te doorgronden is! Ik ben overtuigd geraakt dat #define's zoveel mogelijk vermeden moeten worden.

Waarom worden hier niet gewoon ??< en ??> of <% en %> voor gebruikt? De trigraph en digraph sequences bestaan niet voor niets.

[MLM]

PrisonerOfPain schreef op vrijdag 14 maart 2008 @ 12:53:
[...]


Waarom worden hier niet gewoon ??< en ??> of <% en %> voor gebruikt? De trigraph en digraph sequences bestaan niet voor niets.

Imo zijn beide enorm outdated, tegenwoordig word de meeste software echt wel ontwikkeld op een PC (ook software voor andere platformen) en kun je dus gewoon { en } gebruiken, en kan je digraphs etc. gewoon vergeten. Ik zie geen reden anders dan obfuscation om dit soort defines te doen.

[Soultaker]

Alex) schreef op donderdag 13 maart 2008 @ 15:19:
My Pi Goes to Twelve
Op z'n minst een slecht gekozen naam voor een variabele imho

Ik vind dat echt een van de grootste non-WTFs van de laatste tijd, omdat de waarde compleet uit z'n verband wordt gerukt. Java deelt constanten juist in namespaces en klassen in, zodat je binnen een klasse zo'n naam niet hoeft te kwantificeren als "HTML_PARSER_DTDCONSTANTS_PROCESSING_INSTRUCTION" omdat dat al duidelijk is uit het feit dat de identifier PI in de klasse text.html.parser.DTDConstants staat.

Als je als programmeur niet begrijp dat de identifier PI in een andere klasse dan Math misschien niet voor de wiskundige constant pi staat, tja...

[Voutloos]

Eens met Soultaker. Iedereen kent Math, terwijl maar weinig mensen javax.swing.text.html.parser.DTDConstants nodig hebben.

Imo is thedailywtf uberhaupt al een paar jaar wat minder goed...

[roy-t]

Soultaker schreef op vrijdag 14 maart 2008 @ 16:37:
[...]

Ik vind dat echt een van de grootste non-WTFs van de laatste tijd, omdat de waarde compleet uit z'n verband wordt gerukt. Java deelt constanten juist in namespaces en klassen in, zodat je binnen een klasse zo'n naam niet hoeft te kwantificeren als "HTML_PARSER_DTDCONSTANTS_PROCESSING_INSTRUCTION" omdat dat al duidelijk is uit het feit dat de identifier PI in de klasse text.html.parser.DTDConstants staat.

Als je als programmeur niet begrijp dat de identifier PI in een andere klasse dan Math misschien niet voor de wiskundige constant pi staat, tja...

Aan de andere kant vind ik het extreem vreemd dat het toch PI heet. Want volgens de java guidelines moet je juist alles voluit schrijven om verwarring te voorkomen. Dit zou dan bijv. ProcessingInstruction moeten heten. Maarja de java guidelines en de java taal komen vaak niet goed overeen. Zelfs bij zoiets door de java developers zelf ontwikkeld als Swing. (of nouja eigenlijk wijken ze al af bij de standaard class Util... )

[Snake]

PrisonerOfPain schreef op vrijdag 14 maart 2008 @ 12:53:
[...]


Waarom worden hier niet gewoon ??< en ??> of <% en %> voor gebruikt? De trigraph en digraph sequences bestaan niet voor niets.

Met wat voor nut? Weer iets exotisch?

Als ge gewoon { en } op u ramplank hebt staan, gebruik dat dan.

C++:

??=include <stdio.h>                         /* #          */
 
int main(void)
??<                                          /* {          */
        char n??(5??);                       /* [ and ]    */
 
        n??(4??) = '0' - (??-0 ??' 1 ??! 2); /* ~, ^ and | */
        printf("%c??/n", n??(4??));          /* \, [ and ] */
        return 0;
??>                                          /* }          */

of

C++:

#include <stdio.h>                      
 
int main(void)
{                                         
        char n[5];                       
 
        n[4] = '0' - (~0 ^ 1 | 2);
        printf("%c\n", n[4]);         
        return 0;
}                                      

Zie ook : Wikipedia: C trigraph

[.oisyn]

Snake: het doel van jouw post ontgaat me een beetje...

[KoW]

Voutloos schreef op donderdag 13 maart 2008 @ 13:48:
160 miljoen keer. Wellicht was je verhaal gewoon een stuk duidelijker als je direct "een prutser heeft een onnodig cartesisch product van 160M rijen in een query achtergelaten" had gezegd. Laat je meteen blijken dat jij wel weet wat een cartesisch product is.

erm...
Mij geeft zo'n verwoording juist het gevoel dat de poster vooral wil laten zien hoe goed hij vaktermen kent.
En ja, zijn eerste uitleg was niet helemaal duidelijk.

[Remus]

roy-t schreef op vrijdag 14 maart 2008 @ 23:21:
[...]


Aan de andere kant vind ik het extreem vreemd dat het toch PI heet. Want volgens de java guidelines moet je juist alles voluit schrijven om verwarring te voorkomen. Dit zou dan bijv. ProcessingInstruction moeten heten. Maarja de java guidelines en de java taal komen vaak niet goed overeen. Zelfs bij zoiets door de java developers zelf ontwikkeld als Swing. (of nouja eigenlijk wijken ze al af bij de standaard class Util... )

Zoals ook op de TheDailyWTF wordt vermeldt staat in de Javadoc het volgende:

SGML constants used in a DTD. The names of the constants correspond the the equivalent SGML constructs as described in "The SGML Handbook" by Charles F. Goldfarb.

En dat is IMHO een goede reden voor de naamgeving: je volgt daarmee een reeds gedefinieerde standaard naamgeving, die waarschijnlijk bij alle SGML 'experts' reeds bekend is. Verder is PI ook gewoon de definitie die je gebruikt in een DTD, zie http://www.w3.org/TR/1998/REC-xml-19980210 onder 2.6 Processing Instructions

[ Voor 7% gewijzigd door Remus op 15-03-2008 12:41 ]

[Soultaker]

roy-t schreef op vrijdag 14 maart 2008 @ 23:21:
Aan de andere kant vind ik het extreem vreemd dat het toch PI heet. Want volgens de java guidelines moet je juist alles voluit schrijven om verwarring te voorkomen.

Er staat ook boven bij dat er voor gekozen is om de tokens hetzelfde te noemen als Charles Goldfarb doet in zijn (standaard)beschrijving van de syntax van SGML. Ik kan met goed voorstellen dat termen synchroniseren met standaarddocumenten boven die guidelines gaat (die natuurlijk wel nuttig zijn als je zelf nieuwe termen introduceert).

edit:
Urgh, ik ben te laat.

[ Voor 3% gewijzigd door Soultaker op 15-03-2008 15:03 ]

[ouicestmoi]

PrisonerOfPain schreef op vrijdag 14 maart 2008 @ 12:53:
[...]


Waarom worden hier niet gewoon ??< en ??> of <% en %> voor gebruikt? De trigraph en digraph sequences bestaan niet voor niets.

Het gaat er niet om dat de haakjes missen op het toetsenbord, een iets ruimer stukje code laat zien:

C:

#if __STDC_VERSION__+0 > 199900L
#define ___
#define ____
#else
#define ___ {
#define ____ }
#endif

Het zal vast allemaal wel ergens goed voor zijn, maar het maakt het lezen van de broncode een heel gedoe. Er zijn nog meer define-juweeltjes te vinden zoals

C:

#if !defined ZZIP_OMIT_CONFIG_H
# if defined _MSC_VER || defined __BORLANDC__ || defined __WATCOMC__
# include <zzip/_msvc.h>
# elif defined ZZIP_1_H
# include "zzip-1.h"
# elif defined ZZIP_2_H
# include "zzip-2.h"
# elif defined ZZIP_3_H
# include "zzip-3.h"
# elif defined ZZIP_4_H
# include "zzip-4.h"
# elif defined ZZIP_5_H
# include "zzip-5.h"
# else /* autoconf generated */
# include <zzip/_config.h>
# endif
#endif

en

C:

#ifndef _zzip_const
#ifdef   ZZIP_const
#define _zzip_const ZZIP_const
#else
#define _zzip_const const
#endif
#endif

Dan vind ik het makkelijker om eerst de preprocessor zijn werk te laten doen, en dan pas te bekijken wat er eigenlijk staat...

[.oisyn]

ouicestmoi schreef op woensdag 19 maart 2008 @ 20:52:
[...]


Het gaat er niet om dat de haakjes missen op het toetsenbord, een iets ruimer stukje code laat zien:

C:

#if __STDC_VERSION__+0 > 199900L
#define ___
#define ____
#else
#define ___ {
#define ____ }
#endif

En dan zijn identifiers met dubbele underscores nog steeds gereserveerd voor de implementatie, bovendien hadden ze ook een duidelijkere naamgeving kunnen kiezen, zoals bijv. BEGIN en END

[AtleX]

Stukje code in een site die mijn voormalig werkgever niet al te lang geleden heeft opgeleverd:

JavaScript:

function Key_Up(e) {
    if (window.event.keyCode == 17 || window.event.keyCode == 83 || window.event.keyCode == 18){
        if (window.event.keyCode == 17 || window.event.keyCode == 18) {controltoets = 'ja';}
        if (window.event.keyCode == 83) {stoets = 'ja';}
    }
    else {
        controltoets = 'nee';
        stoets = 'nee';
    }
    if (controltoets == 'ja' && stoets == 'ja') {
        controltoets = 'nee';
        stoets = 'nee';
        newWindow=window.open('<URL weg>','_top');
    }
}
document.onkeydown=Key_Up;

Ook JavaScript kent booleans, flappies Sowieso is die eerste if() ook nogal overbodig, en waarom wil je wat doen met CTRL, ALT en S waarom wil je op deze manier doorverwijzen naar de admin module?

[ Voor 14% gewijzigd door AtleX op 16-04-2008 18:10 ]

[TeeDee]

C#:

public Order LoadFromSession()
{
    Order order;
    if (System.Web.HttpContext.Current.Session["Order"] == null)
    {
        order = new Order();
        order.Orderticket = Guid.NewGuid();
        System.Web.HttpContext.Current.Session["Order"] = order;
    }
    else
    {
        order = (Order)System.Web.HttpContext.Current.Session["Order"];
    }
    return order;
}

Op zich werkt dat prima. Totdat Session["Order"] daadwerkelijk null is waarbij er gewoon vrolijk een nieuwe Order teruggegeven wordt. Niemand merkt het, totdat je (want aan Order hangen een aantal vrij orderspecifieke zaken) een hele hoop corrupte Orders in je DB hebt staan.

Minimaal een null terug geven had een hele hoop gezeik minder gegeven.

[Gomez12]

??? Ik snap hem niet, als je geen order hebt maakt hij een nieuwe order aan, als je wel een order hebt pakt hij die order? Lijkt mij toch goed.

Session["Order"] kan toch geen null zijn als er wel een order is?

Toegegeven, ik zou controleren of er niet buiten de sessie nog een order bestaat voordat ik een nieuwe aanmaak, maar kwalificatie slechtste programmeervoorbeeld vind ik iets te ver gaan.
Het is gewoon vertrouwen dat alles goed gaat en lui programmeren ( en een hel om naderhand terug te vinden, want je hebt een incorrecte db, dan vind je dit maar je weet nog steeds niet waar je sessie gereset wordt )
Maar ik zie dit soort dingen bijna wekelijks voorbijkomen, defensief programmeren lijkt voor sommige mensen een kunst op zich te zijn.

[TeeDee]

Ik vind de method naam in ieder geval belabberd gekozen. Als je Session expired is, en je besluit een Order.LoadFromSession() te doen en je krijgt geen errors mag je verwachten dat er niks aan de hand is.

De reden waarom er voor deze constructie gekozen is, is dat op deze manier je als ontwikkelaar je niet hoeft bezig te houden met SessionManagement. Dus geen zaken als:

C#:

//pagina 1
Session["OrderObject"] = OrderObject;
//pagina 2
Session["OrderObjects"] = OrderObject;

Het hele Session gebeuren is weggestopt in OrderObject. Scheelt een hele hoop typo's en ander geneuzel.

Als ik een LoadFromSession wil doen, en ik krijg een null terug, dan had ik geweten dat er iets fout was. Nu niet.

[ZaZ]

Ben ik nou een zeur als ik zeg dat de titel van dit topic niet de lading dekt?
Ik vind het leuk om te lezen om iets wat verleidelijk of logisch lijkt, dat dat een no-go blijkt te zijn.
Of stukken code die kant noch wal slaan en dat het dan de uitdaging is om je toch te verplaatsen in de programmeur.

Nu zie ik vooral de laatste tijd toch een hoop interessant geneuzel voorbijkomen van 'dit is iets mooier'

[Marientjuh]

Krijg ik een ASP applicatie opgeleverd. Deze steekt zo bagger in elkaar dat we besloten hebben om het geheel naar PHP om te zetten en een totaal nieuwe setup te doen. Mede omdat de ASP ontwikkeling al is gestopt in 1999. Welk bedrijf kiest er dan voor om anno 2008 te gaan ontwikkelen in ASP

Ik kwam tot de code waar ze informatie uit de database halen voor bepaalde eigenschappen van een printer. (een stuk of 20 - 30 items.) Kom je dit tegen:

ASP.NET Visual Basic:

' After Processing '
set rs = server.CreateObject("ADODB.recordset")
selQry = "SELECT * FROM tblAfterProc ORDER BY txtAfterProc"
rs.Open selQry, connCB, 1
    
do until rs.EOF 
    if clng(rsCb("lngCBAfterProc")) = clng(rs("lngAfterProcId")) then
        ProfileAfterProcessing = rs("txtAfterProc")
    end if
    rs.MoveNext 
loop    
rs.Close

[TeeDee]

De echte WTF's zijn natuurlijk: Je gaat niet akkoord, dus maar een compleet ander platform kiezen en een volledige rebuild.

Wat er verder zo fout is aan de code kan ik niet 1 2 3 zien.

rwb schreef op vrijdag 18 april 2008 @ 15:08:
[...]
Ik denk dat de fout is dat hij een select * doet zonder where clause en dan later gaat filteren in een loopje. Het was makkelijker om gewoon een where clause toe te voegen ( al weet ik niet wat voor functie clng is )

Clng = zoiets als ConvertToLong (dacht ik, vbscript msdn niet bij de hand)

Maar nu zie ik 'm ook jah. Ach, zal wel betaald worden per regel

[ Voor 59% gewijzigd door TeeDee op 18-04-2008 15:13 ]

[Woy]

TeeDee schreef op vrijdag 18 april 2008 @ 15:05:
De echte WTF's zijn natuurlijk: Je gaat niet akkoord, dus maar een compleet ander platform kiezen en een volledige rebuild.

Idd dat dacht ik ook. Je besteed blijkbaar een product uit en als het niet goed is besluit je maar om het compleet zelf te maken op een ander platform? Waarom heb je het dan uberhaupt uitbesteed. ( Aaname dat het uitbesteed is omdat er een applicatie "opgeleverd" word )

Wat er verder zo fout is aan de code kan ik niet 1 2 3 zien.

Ik denk dat de fout is dat hij een select * doet zonder where clause en dan later gaat filteren in een loopje. Het was makkelijker om gewoon een where clause toe te voegen ( al weet ik niet wat voor functie clng is )

[ Voor 21% gewijzigd door Woy op 18-04-2008 15:09 ]

[Hydra]

TeeDee schreef op vrijdag 18 april 2008 @ 15:05:
De echte WTF's zijn natuurlijk: Je gaat niet akkoord, dus maar een compleet ander platform kiezen en een volledige rebuild.

Als een rebuild minder tjid en geld kost dan het toevoegen van functionaliteit aan het bestaande systeem, waarom niet? Dat betekent dan waarschijnlijk dat het bestaande systeem echt enorm slecht is, en niet erg groot.

[TeeDee]

Hydra schreef op vrijdag 18 april 2008 @ 15:53:
[...]


Als een rebuild minder tjid en geld kost dan het toevoegen van functionaliteit aan het bestaande systeem, waarom niet? Dat betekent dan waarschijnlijk dat het bestaande systeem echt enorm slecht is, en niet erg groot.

In het geval van een externe partij:

Wat weerhoudt je er van dan om de ontwikkelaar een schop onder de ballen te geven en dat er niks wordt overgemaakt totdat het goed is?

Er is, in het geval van uitbesteding, blijkbaar een goede reden voor. Nu ben je (tijd, mensen en geld)² kwijt.

.oisyn schreef op vrijdag 18 april 2008 @ 15:58:
Bijkomend voordeel is ook dat je mensen in huis hebt die het systeem hebben gemaakt en toekomstige maintenance dus veel goedkoper is.

Dat ontken ik niet, alleen waarom eerst uitbesteden om het vervolgens alsnog inhouse te doen?

[ Voor 21% gewijzigd door TeeDee op 18-04-2008 16:01 ]

[.oisyn]

Bijkomend voordeel is ook dat je mensen in huis hebt die het systeem hebben gemaakt en toekomstige maintenance dus veel goedkoper is.

En als die externe partij echt van die prutsers waren dan ga ik liever niet zitten wachten op een goede implementatie, want dat kunnen ze dan waarschijnlijk niet. Of je mag ze daarna weer 10x schoppen om een feature toegevoegd te krijgen.

Wat jij doet is er domweg vanuit gaan dat de keuze voor outsourcing in eerste instantie een goede keuze was. Terwijl dat helemaal niet zo hoeft te zijn.

[ Voor 64% gewijzigd door .oisyn op 18-04-2008 16:01 ]

[.oisyn]

Ik haat edits om posts onder je te quoten

TeeDee schreef op vrijdag 18 april 2008 @ 15:58:
Dat ontken ik niet, alleen waarom eerst uitbesteden om het vervolgens alsnog inhouse te doen?

Wellicht was er tijdens de beslissing om het uit te besteden nog niet voldoende personeel, en nu wel?

[TeeDee]

Hoewel dit imo buiten de scope van dit topic gaat, ga ik er nog even op door

Als je besluit om iets te outsourcen, vind ik dat je ook een goede beslissing kan maken over welk bedrijf. Iets als rentacoder.com kan goede dingen opleveren, alleen heb je daar weinig kans op. Gevaar met outsourcing is natuurlijk ook dat de wensen/eisen niet goed overgekomen zijn of ronduit slechte communicatie. [insert plaatje met bomen en schommels]

Als ik nog even een opmerking van mij mag nuanceren (ook op basis van .oisyn's opmerking):

Wat weerhoudt je er van dan om de ontwikkelaar een schop onder de ballen te geven en dat er niks wordt overgemaakt totdat het goed is?

wordt

Wat weerhoudt je er dan van om de ontwikkelaar zijn geld te geven.

Ok, het is niet netjes, en ja, contractueel sta je niet sterk. Tenzij je fatsoenlijke afspraken gemaakt heb.

Bottomline is imo: het kan zo zonde van je geld en tijd zijn...

Maar goed, dit is uiteraard allemaal op basis van aannames... en je weet wat daar van gezegd wordt. Zelf heb ik geen ervaring hiermee, dus het kan complete onzin zijn wat ik verkondig maar dit is wat mijn common sense ervan maakt.

offtopic:
en ja, ook deze wilde ik in mijn voorgaande post plaatsen, gewoon... omdat het kan

[Hydra]

TeeDee schreef op vrijdag 18 april 2008 @ 15:58:
Wat weerhoudt je er van dan om de ontwikkelaar een schop onder de ballen te geven en dat er niks wordt overgemaakt totdat het goed is?

Ik heb dit meegemaakt bij een klant van ons. Zij hebben aan een leuk hip amsterdams webdesignbedrijf de opdracht gegeven een nieuwe website te maken. Die hebben er een puinzooi van gemaakt (o.a. enorme memoryleaks, best knap op een .Net based site), en waren niet bepaald meewerkend als het ging om fixes. Kwamen gewoon niet op meetings opdagen, etc. De klant is dus met het hele verhaal naar een andere ontwikkelaar (groot bekend bedrijf) gegaan, met de opdracht het goed te doen, en deze hebben de site moeten herschrijven. De kosten zijn ze dus, juridisch, gaan verhalen op de eerste partij.

En je wil niet weten hoeveel er van dat soort kutbedrijfjes zijn. Bedrijfje van 5 man die na een paar websites voor de lokale korfbalvereniging gemaakt te hebben vinden dat ze klaar zijn voor het 'echte' werk. Helaas stinken veel bedrijven daar met de typische nederlandse zuinigheid enorm hard in, want ze zijn goedkoper dat grote 'bekende' bedrijven.

Wat weerhoudt je er dan van om de ontwikkelaar zijn geld te geven.

Dit soort bedrijven (wij ook) werken op een geld-per-tijdseenheid basis. Als je stopt met betalen, doen ze niks meer.

[ Voor 8% gewijzigd door Hydra op 18-04-2008 16:33 ]

[Face_-_LeSS]

Dit zag ik vandaag staan in Microsoft's Enterprise Library:

C#:

  if (string.IsNullOrEmpty(name))
    throw new ArgumentNullException("name");

Ok, niet super slecht maar ook niet goed!

[TeeDee]

Face_-_LeSS schreef op vrijdag 18 april 2008 @ 16:49:
Ok, niet super slecht maar ook niet goed!

Volgens MSDN:

C#:

//
// Summary:
//     Initializes a new instance of the System.ArgumentNullException class with
//     the name of the parameter that causes this exception.
//
// Parameters:
//   paramName:
//     The name of the parameter that caused the exception.
public ArgumentNullException(string paramName);

is dit gewoon gedocumenteerd. Dus nee, hier ben ik het niet mee eens

[FTL]

Face_-_LeSS schreef op vrijdag 18 april 2008 @ 16:49:
Dit zag ik vandaag staan in Microsoft's Enterprise Library:

C#:

  if (string.IsNullOrEmpty(name))
    throw new ArgumentNullException("name");

Ok, niet super slecht maar ook niet goed!

Normaal een goede gewoonte: argumenten controleren in begin van methode. (trash-in mag niet beteken dat er trash-out uitkomt). Je doelt er zeker op dat je een new ArgumentException had verwacht?

[Face_-_LeSS]

FTL schreef op vrijdag 18 april 2008 @ 16:57:
[...]


Normaal een goede gewoonte: argumenten controleren in begin van methode. (trash-in mag niet beteken dat er trash-out uitkomt). Je doelt er zeker op dat je een new ArgumentException had verwacht?

Yup, een lege string != null voor zover ik weet. Op deze manier kan je soms behoorlijk aan jezelf gaan twijfelen wanneer de parameter "name" toch echt '' is .

[Hydra]

FTL schreef op vrijdag 18 april 2008 @ 16:57:
Normaal een goede gewoonte: argumenten controleren in begin van methode. (trash-in mag niet beteken dat er trash-out uitkomt). Je doelt er zeker op dat je een new ArgumentException had verwacht?

Ik snap echt niet hoe je daar een fout in kunt zien. Bovendien, dit topic heet Slechtste programmeervoorbeelden. "Mwoa dubieus" valt daar sowieso niet onder lijkt me.

Face_-_LeSS schreef op vrijdag 18 april 2008 @ 17:09:
Yup, een lege string != null voor zover ik weet. Op deze manier kan je soms behoorlijk aan jezelf gaan twijfelen wanneer de parameter "name" toch echt '' is .

Ik vermoed dat je in het geval van die methode wel na kunt gaan dat een lege string ook niet mag.

[ Voor 28% gewijzigd door Hydra op 18-04-2008 17:11 ]

[.oisyn]

Hydra schreef op vrijdag 18 april 2008 @ 17:10:
Ik vermoed dat je in het geval van die methode wel na kunt gaan dat een lege string ook niet mag.

En dat verklaart dan ook het gooien van een exception, maar niet zozeer een exception die zegt dat een parameter null is terwijl ie dat niet is . Hou het dan bij een exception die zegt "deze parameter is niet goed"

[Joolee]

Ik betrapte mijzelf er laatst op dit geschreven te hebben:

PHP:

$message .= 'Zijn samengevoegd in'.($newUser ? ' de gebruiker <a href="'.base_url.sub.'profiles/show/user/'.$newUser['id'].'/"><em>'.$newUser['name'].'</em></a>':'') . ($newUser && $newContact ? ' en':'') . ($newContact ? ' het profiel <a href="'.base_url.sub.'profiles/show/contact/'.$newContact['profile_id'].'/"><em>'.$newContact['achternaam'].', '.$newContact['voornaam'].'</em></a>':'').'.';
if($moved['...'] || $moved['facturen'])
    $message .= '<br>Daarbij '.($moved['facturen'] + $moved['...'] > 1 ? 'zijn' : 'is').($moved['facturen'] ? ' '.$moved['facturen'].' '.($moved['facturen'] > 1 ? 'facturen' : 'factuur'):'') . (is_null($newUserId) && $moved['...'] ? ($moved['facturen'] ? ' overgezet op een nieuwe naam en':'') . ($moved['...'] ? $moved['...'].' '.($moved['...'] > 1 ? ' ... lidmaatschappen' : ' ... lidmaatschap'):'').'verwijderd.' : ($moved['facturen'] && $moved['...'] ? ' en':'') . ($moved['...'] ? $moved['...'].' '.($moved['...'] > 1 ? ' ... domeinen' : ' ... domein'):'').' overgezet op een nieuwe naam.');

Naam van een bepaalde functionaliteit even vervangen door ...

Oneliners zijn wel leuk maar ze maken het er niet duidelijker op.

[Hydra]

.oisyn schreef op vrijdag 18 april 2008 @ 17:37:
[...]

En dat verklaart dan ook het gooien van een exception, maar niet zozeer een exception die zegt dat een parameter null is terwijl ie dat niet is . Hou het dan bij een exception die zegt "deze parameter is niet goed"

Blijf er bij dat het wat suf is, maar niet een enorme WTF.

[FTL]

Hydra schreef op vrijdag 18 april 2008 @ 18:11:
[...]
Blijf er bij dat het wat suf is, maar niet een enorme WTF.

Kan ik me bij aansluiten inderdaad.

[Face_-_LeSS]

Hydra schreef op vrijdag 18 april 2008 @ 17:10:
[...]


Ik snap echt niet hoe je daar een fout in kunt zien. Bovendien, dit topic heet Slechtste programmeervoorbeelden. "Mwoa dubieus" valt daar sowieso niet onder lijkt me.


[...]


Ik vermoed dat je in het geval van die methode wel na kunt gaan dat een lege string ook niet mag.

Dit is normaal inderdaad geen blunder tot-en-met maar gezien het in Microsoft's EntLib staat en het .NET framework ook van Microsoft is en ze daar zelf onderscheid gemaakt hebben tussen een ArgumentException en een ArgumentNullException vind ik het eigenlijk toch best fout.

Sterker nog. Volgens de documentatie is het zelfs fout:
"The exception that is thrown when a null reference (Nothing in Visual Basic) is passed to a method that does not accept it as a valid argument."

[Gomez12]

Joolee schreef op vrijdag 18 april 2008 @ 18:01:
Ik betrapte mijzelf er laatst op dit geschreven te hebben:

PHP:

$message .= 'Zijn samengevoegd in'.($newUser ? ' de gebruiker <a href="'.base_url.sub.'profiles/show/user/'.$newUser['id'].'/"><em>'.$newUser['name'].'</em></a>':'') . ($newUser && $newContact ? ' en':'') . ($newContact ? ' het profiel <a href="'.base_url.sub.'profiles/show/contact/'.$newContact['profile_id'].'/"><em>'.$newContact['achternaam'].', '.$newContact['voornaam'].'</em></a>':'').'.';
if($moved['...'] || $moved['facturen'])
    $message .= '<br>Daarbij '.($moved['facturen'] + $moved['...'] > 1 ? 'zijn' : 'is').($moved['facturen'] ? ' '.$moved['facturen'].' '.($moved['facturen'] > 1 ? 'facturen' : 'factuur'):'') . (is_null($newUserId) && $moved['...'] ? ($moved['facturen'] ? ' overgezet op een nieuwe naam en':'') . ($moved['...'] ? $moved['...'].' '.($moved['...'] > 1 ? ' ... lidmaatschappen' : ' ... lidmaatschap'):'').'verwijderd.' : ($moved['facturen'] && $moved['...'] ? ' en':'') . ($moved['...'] ? $moved['...'].' '.($moved['...'] > 1 ? ' ... domeinen' : ' ... domein'):'').' overgezet op een nieuwe naam.');

Naam van een bepaalde functionaliteit even vervangen door ...

Oneliners zijn wel leuk maar ze maken het er niet duidelijker op.

Ach tja, daarom hanteren wij altijd een max line length, theoretisch niet noodzakelijk, maar je hebt opeens veel meer plek voor comments en het leest gewoon lekkerder ( alhoewel sommige mensen het weer iets te strict nemen en variabelen namen gaan afkorten om maar binnen de max line length te blijven )

[AtleX]

Weer een mooie gevonden:

PHP:

if ($link1 == true)
{
    if ($link2 == true)
    {
        if ($link3 == true)
        {
            if ($link1 == true && $link2 == true && $link3 == true)
            {
                // doe iets
            }
            else
            {
                throw new Exception();
            }
        }
        else
        {
            throw new Exception();
        }
    }
    else
    {
        throw new Exception();
    }
}
else
{
    throw new Exception();
}

Dit neem ik over uit een commercieel (behoorlijk duur) pakket, inclusief lege exceptions die gethrowed worden.

[Verwijderd]

Dit is toch wel heel triest idd.
1 is true, 2 is true en 3 is true...en dan nogmaals gaan controleren of 1, 2 en 3 true zijn

[paulh]

AtleX schreef op vrijdag 18 april 2008 @ 19:17:
Weer een mooie gevonden:

PHP:

if ($link1 == true)
{
    if ($link2 == true)
    {
        if ($link3 == true)
        {
            if ($link1 == true && $link2 == true && $link3 == true)
            {
                // doe iets
            }
            else
            {
                throw new Exception();
            }
        }
        else
        {
            throw new Exception();
        }
    }
    else
    {
        throw new Exception();
    }
}
else
{
    throw new Exception();
}

Dit neem ik over uit een commercieel (behoorlijk duur) pakket, inclusief lege exceptions die gethrowed worden.

he he ... wilde het blijkbaar heel erg zeker weten ')

[.oisyn]

Multithreading... misschien zijn ze ondertussen al wel veranderd

[FrozenCow]

Ik wil niemand zwart maken, maar toen ik het volgende tegenkwam moest ik een klein beetje huilen. Ik kwam dit tegen in een voorbeeld-applicatie voor Microsoft BizTalk RFID.
Hier de code :

C#:

try
{
    while (1 == 1)
    {
        KeyValuePair<RfidEventBase, String> rfidKeyEvent = pmp.GetNextErrorEvent(process);
        SuspendedEvent SE = new SuspendedEvent(process, rfidKeyEvent);
        retrivedEvents.Add(SE);
    }
}
catch (RfidClientException rfidEx)
{
    //As above: if you catch NoErrorEventsToReturn, don't do anything; that's the way GetNextErrorEvent 
    //informs you that it is finished. Otherwise, it's an error.
    if (rfidEx.RemoteErrorCode != "NoErrorEventsToReturn")
    {
        throw;
    }
    
}

Even later vind ik dit :

C#:

try
{
...
}
catch (XmlException xmlEx)
{
    MessageBox.Show(xmlEx.Message);
}
catch (Exception Ex)
{
    throw;
}

Nog even later kwam ik dit tegen (er zijn geen smilies met 3 hamers ):

C#:

for (i = 0; i <= nodeList.Count - 1; i++)
{
...
}

Dit alles in hetzelfde bestand.

Wanneer je de applicatie(code) wilt downloaden kan je dat hier doen: http://download.microsoft...uspendedQueueViewerII.exe

[AtleX]

code:

...i <= nodeList.Count - 1...

[NetForce1]

FrozenCow schreef op maandag 28 april 2008 @ 14:07:
Nog even later kwam ik dit tegen (er zijn geen smilies met 3 hamers ):

C#:

for (i = 0; i <= nodeList.Count - 1; i++)
{
...
}

Ik ben maar een simpele Java-programmeur, dus ik zou denken dat dit een loopje is om door de items van een nodelist heen te wandelen, wat is daar mis mee?

[Hydra]

AtleX schreef op maandag 28 april 2008 @ 14:09:

code:

...i <= nodeList.Count - 1...

Ik vond die while(1 == 1) nog een stuk triester eigenlijk. Ik weet niet of iemand grappig wou wezen, maar grappen laat je lekker uit productiecode.

NetForce1 schreef op maandag 28 april 2008 @ 14:15:
[...]

Ik ben maar een simpele Java-programmeur, dus ik zou denken dat dit een loopje is om door de items van een nodelist heen te wandelen, wat is daar mis mee?

Iedereen zou i < nodeList.count schrijven i.p.v. <= nodeList.count - 1. Beetje dom.

[ Voor 37% gewijzigd door Hydra op 28-04-2008 14:17 ]

[kenneth]

Hydra schreef op maandag 28 april 2008 @ 14:16:
[...]


Ik vond die while(1 == 1) nog een stuk triester eigenlijk. Ik weet niet of iemand grappig wou wezen, maar grappen laat je lekker uit productiecode.

Is dat nou zoveel erger dan while (true)? Ik geef ook de voorkeur aan het laatste, maar het is niet alsof het een wereld van verschil is.

[.oisyn]

Misschien is i wel een float, dan doet het weldegelijk wat anders

[NetForce1]

Hydra schreef op maandag 28 april 2008 @ 14:16:
[...]
Iedereen zou i < nodeList.count schrijven i.p.v. <= nodeList.count - 1. Beetje dom.

O, is dat het. Daar kan ik niet zo'n punt van maken hoor, ik dacht eerlijk gezegd dat dat een persoonlijke voorkeur van de betreffende programmeur was. Misschien vind hij het wel duidelijker om expliciet te laten zien wat de laatste index is ofzo
Zelfde geldt voor die while(1 == 1), die exception mis-use daar is imo veel erger.

[Hydra]

kenneth schreef op maandag 28 april 2008 @ 14:21:
Is dat nou zoveel erger dan while (true)? Ik geef ook de voorkeur aan het laatste, maar het is niet alsof het een wereld van verschil is.

Ik vermoed dat het weggeoptimaliseerd wordt, maar je doet natuurlijk wel een vergelijking en dus een onnodige extra optimalisatie. Ik vind het (afhankelijk van de intentie) of dom of gewoon lelijk. En ik hou niet van domme of lelijke code.

NetForce1 schreef op maandag 28 april 2008 @ 14:25:
O, is dat het. Daar kan ik niet zo'n punt van maken hoor, ik dacht eerlijk gezegd dat dat een persoonlijke voorkeur van de betreffende programmeur was. Misschien vind hij het wel duidelijker om expliciet te laten zien wat de laatste index is ofzo

Je doet weer een extra operatie (substractie) voor hetzelfde resultaat. Ik vind het gewoon dom. Lijkt alsof de programmeur die basislogica gewoon niet goed in z'n hoofd heeft zitten.

NetForce1 schreef op maandag 28 april 2008 @ 14:25:
Zelfde geldt voor die while(1 == 1), die exception mis-use daar is imo veel erger.

Ik was bij die While opgehouden met lezen, dus ik dacht dat dat de fout was

[ Voor 48% gewijzigd door Hydra op 28-04-2008 14:28 ]

[PrisonerOfPain]

Hydra schreef op maandag 28 april 2008 @ 14:16:
Ik vond die while(1 == 1) nog een stuk triester eigenlijk. Ik weet niet of iemand grappig wou wezen, maar grappen laat je lekker uit productiecode.

Dit geld niet voor C# in 't specifiek, maar er zijn een aantal programmeertalen / compilers geweest die infinite loops zoals while(true); for(;;) et cetera probeerde te detecteren. In zo'n geval kon je de compiler meestal op zo'n manier te slim af zijn.

[Jrz]

Hydra schreef op maandag 28 april 2008 @ 14:16:
Ik vond die while(1 == 1) nog een stuk triester eigenlijk. Ik weet niet of iemand grappig wou wezen, maar grappen laat je lekker uit productiecode.

Mwa vind het niet zo triest hoor. Die 1 == 1 is een paar opjes. Scheelt misschien weer warnings etc.. Mss niet optimaal, maar iedereen snapt wat er gebeurt.

Iedereen zou i < nodeList.count schrijven i.p.v. <= nodeList.count - 1. Beetje dom.

Ik zou helemaal geen loop variabelen gebruiken als de taal het toestaat.
En als je dan toch bezig bent, waarom niet for (int i = nodeList.count-1; i >= 0; i--) oid? scheelt je weer wat extra cycles en de meeste loopjes hoeven niet in volgorde uitgevoerd te worden

[PrisonerOfPain]

Hydra schreef op maandag 28 april 2008 @ 14:26:
[...]


Ik vermoed dat het weggeoptimaliseerd wordt, maar je doet natuurlijk wel een vergelijking en dus een onnodige extra optimalisatie. Ik vind het (afhankelijk van de intentie) of dom of gewoon lelijk. En ik hou niet van domme of lelijke code.

Zeker bij managed talen kun je in veel gevallen niet rekenen op een al te sterke optimizer en zou ik er zonder metingen ook verder niet van uit gaan dat 't weg geoptimaliseerd word. Maar goed, dat komt voor uit mijn persoonlijke skepsis ten opzichte van die dingen. Mocht het wel weg geoptimaliseerd worden dan is het verder ook niet relevant dat de "onnodige extra optimalisatie" gebeurd; het word immers automatisch voor je gedaan.

[FrozenCow]

PrisonerOfPain schreef op maandag 28 april 2008 @ 15:10:
[...]


Zeker bij managed talen kun je in veel gevallen niet rekenen op een al te sterke optimizer en zou ik er zonder metingen ook verder niet van uit gaan dat 't weg geoptimaliseerd word. Maar goed, dat komt voor uit mijn persoonlijke skepsis ten opzichte van die dingen. Mocht het wel weg geoptimaliseerd worden dan is het verder ook niet relevant dat de "onnodige extra optimalisatie" gebeurd; het word immers automatisch voor je gedaan.

Dit interesseerde mij ook, dus heb het met Reflector opgezocht. Zover ik het uit de code kon opmaken klopt het volgende:

C#:

while (1 == 1)
{
 ...
}

code:

// Begin van de loop
// while (1 == 1)
    L_007a: br.s L_00a0 // Jump naar L_00a0
// Begin van binnenste van de loop
// {
    L_007c: nop // Niets
// ...
// De eigenlijke vergelijking (1 == 1) en jump:
    L_00a0: ldc.i4.1 // Laad de Int32 waarde 1
    L_00a1: stloc.s CS$4$0002 // Stop de waarde in variable CS$4$0002
    L_00a3: br.s L_007c // Jump naar L_007c
// Eind van binnenste van de loop
// }

Variable CS$4$0002 is een boolean variable die door C# (zo lijkt) is gemaakt als tijdelijke variable.
Wat ik eruit kan opmaken is dat de compiler dit wel optimaliseerd, alleen zo te zien niet perfect. De L_00a0 en L_00a1 lijken overbodig bij deze code.

[Hydra]

PrisonerOfPain schreef op maandag 28 april 2008 @ 15:10:
Zeker bij managed talen kun je in veel gevallen niet rekenen op een al te sterke optimizer en zou ik er zonder metingen ook verder niet van uit gaan dat 't weg geoptimaliseerd word. Maar goed, dat komt voor uit mijn persoonlijke skepsis ten opzichte van die dingen. Mocht het wel weg geoptimaliseerd worden dan is het verder ook niet relevant dat de "onnodige extra optimalisatie" gebeurd; het word immers automatisch voor je gedaan.

Was een schrijffout van me, ik bedoelde onnodig extra instructies, niet optimalisatie. Ik vind het hoe dan ook domme code. Je hebt in Java en .Net gewoon true en false, gebruik ze dan ook.

[.oisyn]

Het komt op mij ook meer over alsof iemand dacht dat er per se een vergelijking in moest staan, ipv een algemene expressie met een boolean uitkomst.

[Laurens-R]

Ik vind een while(true) of while(1==1) of whatever zowieso raar om te gebruiken. Waarom zou je uberhaubt een infinite loop willen hebben in je app?

code:

bool IsRunning = true;

while(IsRunning)
{
...
}

lijkt me dan logischer, omdat je dan de loop nog middels de IsRunning variabele kan verlaten... Ik zie for(;;) ook wel eens bij een emulator in de hoofdloop. Zelf persoonlijk vind ik dan een variabele ipv een break gebruiken wel wat beter/duidelijker. Daarnaast kan je uit een andere functie afleiden of je nog in de loop zit of er al uit bent, indien een functie daarop zou reageren.

edit: wat onduidelijke zinnen duidelijker gemaakt.

[ Voor 13% gewijzigd door Laurens-R op 28-04-2008 17:57 ]

[PrisonerOfPain]

Hydra schreef op maandag 28 april 2008 @ 17:08:
[...]


Was een schrijffout van me, ik bedoelde onnodig extra instructies, niet optimalisatie. Ik vind het hoe dan ook domme code. Je hebt in Java en .Net gewoon true en false, gebruik ze dan ook.

Geeft verder niet, al is het natuurlijk vreemd om in de context van de aangehaalde code te discussiëren over dit soort potentiële micro-optimalisaties. De overhead van de exception handling code, of de geheugen allocatie met new zal waarschijnlijk een stuk zwaarder wegen. (Al kan het natuurlijk goed zijn dat new niet zo heel zwaar mee weegt vanwege de garbage collector; die kan er namelijk meestal voor zorgen dat geheugen allocatie niet zo duur is als met non-gc code).

Maar goed, het aantal idiomen om een oneindige loop uit te drukken benaderd waarschijnlijk ook oneindig; dat maakt de een verder niet beter of slechter dan de ander. Persoonlijk zou ik er geen twee keer over nadenken als ik while(1 == 1) in een codebase zou moeten accepteren.

[Hydra]

EvilB2k schreef op maandag 28 april 2008 @ 17:53:
Ik vind een while(true) of while(1==1) of whatever zowieso raar om te gebruiken. Waarom zou je uberhaubt een infinite loop willen hebben in je app?

In microcontroller code heb je altijd een main infinite loop

Over het algemeen heb je gelijk natuurlijk, maar je zou iets dergelijks kunnen hebben:

Java:

while(true)
{
   //Poll input
   if(input == something)
       break;
}

Of het netjes is, is een tweede.

[kenneth]

EvilB2k schreef op maandag 28 april 2008 @ 17:53:

code:

bool IsRunning = true;

while(IsRunning)
{
...
}

lijkt me dan logischer, omdat je dan de loop nog middels de IsRunning variabele kan verlaten...

Dus dan krijg je:

code:

bool isRunning = true;

while (isRunning)
{

    ...

    if (EnoughAlready())
    {
        isRunning = false;
        continue; // want de rest van het while-blok is niet meer interessant
    }
    
    ...

}

ipv:

code:

while (true)
{

    ...

    if (EnoughAlready())
    {
        break;
    }
    
    ...

}

Dat laatste is toch nog twee regels korter en m.i. nou niet echt veel onduidelijker.

[paulh]

"breaks" in de loops zetten heb ik niet zoveel moeite mee. Het kan een hoop vergelijkingen schelen en dan vind ik het vaak zelfs beter. Maar "continue" gebruiken dat vind ik zo waardeloos, daar kan je echt onleesbare code mee maken.

[Ivo]

paulh schreef op maandag 28 april 2008 @ 20:37:
"breaks" in de loops zetten heb ik niet zoveel moeite mee. Het kan een hoop vergelijkingen schelen en dan vind ik het vaak zelfs beter. Maar "continue" gebruiken dat vind ik zo waardeloos, daar kan je echt onleesbare code mee maken.

Vaak is continue wel handig:

code:

for (int i = 0; i < n; ++i) {
        /* ignore exceptional case */
        if (p(i)) continue;

        /* normal behavior */
}

Maar "verkeerd" gebruik van continue kan zeker onleesbare code opleveren.

[Creepy]

kenneth schreef op maandag 28 april 2008 @ 18:41:
[...]

code:

while (true)
{

    ...

    if (EnoughAlready())
    {
        break;
    }
    
    ...

}

Dat laatste is toch nog twee regels korter en m.i. nou niet echt veel onduidelijker.

En als je dan toch al een functie hebt die bepaald of je moet stoppen:

code:

while (!EnoughAlready()) {
 // whatever..
}

Maaruh, als we het al over dat soort dingetjes gaan hebben terwijl bijna alle gegeven loop varianten hier nog erg goed leesbaar zijn........ (ok, de loop waarbij een Exception gebruikt word om uit de loop te knallen is niet echt netjes).

[ Voor 20% gewijzigd door Creepy op 28-04-2008 22:04 ]

[Verwijderd]

Creepy schreef op maandag 28 april 2008 @ 22:02:
[...]
Maaruh, als we het al over dat soort dingetjes gaan hebben terwijl bijna alle gegeven loop varianten hier nog erg goed leesbaar zijn........ (ok, de loop waarbij een Exception gebruikt word om uit de loop te knallen is niet echt netjes).

Mwah weet ik niet, soms kan het best netjes zijn om uit een loop te knallen met een exception.

Bijvoorbeeld bij het inlezen van een file als de structuur ineens niet meer klopt met hetgeen er verwacht was ofzo.

[Verwijderd]

EvilB2k schreef op maandag 28 april 2008 @ 17:53:
Ik vind een while(true) of while(1==1) of whatever zowieso raar om te gebruiken. Waarom zou je uberhaubt een infinite loop willen hebben in je app?

Misschien als je code voor een server schrijft, die eindeloos moet serven?

[Jrz]

Verwijderd schreef op maandag 28 april 2008 @ 23:46:
[...]

Misschien als je code voor een server schrijft, die eindeloos moet serven?

Of als je een win32 proggie maakt

[Laurens-R]

Jrz schreef op dinsdag 29 april 2008 @ 09:34:
[...]

Of als je een win32 proggie maakt

Ja maar daar vind nog een vorm van evaluatie plaats omdat je dan gebruik maakt van:

code:

while (GetMessage(&msg, NULL, 0, 0))
{
...
}

het ging mij vooral om de infinite loops van while(true) e.d. die in princiepe helemaal niets evalueren dat kan veranderen over verloop van tijd.

[ Voor 4% gewijzigd door Laurens-R op 29-04-2008 09:51 ]

[.oisyn]

Creepy schreef op maandag 28 april 2008 @ 22:02:
[...]

En als je dan toch al een functie hebt die bepaald of je moet stoppen:

code:

while (!EnoughAlready()) {
 // whatever..
}

Je vergeet voor het gemak maar even de code die op de plek van de "..." moet. Die kan bij jouw suggestie niet worden toegevoegd (met name het gedeelte vóór de EnoughAlready(), of juist erna als je een do...while zou gebruiken). Of je moet die code in een andere functie vrotten die weer EnoughAlready() aanroept, maar als je dan weer de lokale state nodig hebt moet je die ook weer mee gaan zitten geven.

Doe mij dan gewoon maar een for(;;)

[ Voor 20% gewijzigd door .oisyn op 29-04-2008 11:53 ]

[Woy]

Verwijderd schreef op maandag 28 april 2008 @ 22:08:
[...]

Mwah weet ik niet, soms kan het best netjes zijn om uit een loop te knallen met een exception.

Bijvoorbeeld bij het inlezen van een file als de structuur ineens niet meer klopt met hetgeen er verwacht was ofzo.

Ja maar dat zijn ook Excepties. Om exceptions te gebruiken als normale flow ( Wat in het voorbeeld gebeurt ) is natuurlijk niet echt mooi.

[Creepy]

.oisyn schreef op dinsdag 29 april 2008 @ 11:51:
[...]

Je vergeet voor het gemak maar even de code die op de plek van de "..." moet. Die kan bij jouw suggestie niet worden toegevoegd (met name het gedeelte vóór de EnoughAlready(), of juist erna als je een do...while zou gebruiken). Of je moet die code in een andere functie vrotten die weer EnoughAlready() aanroept, maar als je dan weer de lokale state nodig hebt moet je die ook weer mee gaan zitten geven.

Doe mij dan gewoon maar een for(;;)

Ik zal volgende keer ff een disclaimer neerzetten

for(;;) of een while(true) en er met een break uitspringen is wat mij betreft niet verkeerd hoor en vaak juist duidelijker als de check of je moet stoppen niet uit 1 functiecall bestaat.

[apNia]

dan vind ik het nog altijd correct om iets te doen als
while(running){ ... }

Of een andere naamgeving die slaat op de semi-infinite loop. Zo zou je ook van buitenaf de loop kunnen laten stoppen bijv.

[.oisyn]

apNia: het punt is dat met het aangehaalde voorbeeld het stoppunt niet aan het begin of einde van de loop zit, maar juist in het midden. Het is dan onzinnig om de loop aan het eind te kunnen stoppen. Of je moet code gaan dupliceren om het middelpunt juist naar het begin/einde te verplaatsen, wat ook niet gewenst is. En een boolean die aangeeft dat het de eerste/laatste iteratie is maakt het er ook niet mooier op.

[ Voor 35% gewijzigd door .oisyn op 29-04-2008 12:12 ]

[apNia]

Oh sorry dat was me niet helemaal duidelijk. Ik dacht gewoon of while(true) een lelijke implementatie was of niet

[ Voor 3% gewijzigd door apNia op 29-04-2008 12:22 ]

[farlane]

EvilB2k schreef op dinsdag 29 april 2008 @ 09:50:
Het ging mij vooral om de infinite loops van while(true) e.d. die in princiepe helemaal niets evalueren dat kan veranderen over verloop van tijd.

Als je een embedded applicatie schrijft heb je een dergelijke loop per definitie omdat wanneer main zou eindigen je de stekker eruit en erin moet doen om em weer draaiend te krijgen

[Jrz]

farlane schreef op dinsdag 29 april 2008 @ 15:19:
[...]


Als je een embedded applicatie schrijft heb je een dergelijke loop per definitie omdat wanneer main zou eindigen je de stekker eruit en erin moet doen om em weer draaiend te krijgen

PLC ftw

[farlane]

Jrz schreef op dinsdag 29 april 2008 @ 17:39:
PLC ftw

Een PLC heeft hetzelfde, de loop zit dan echter in het embedded OS. Een uP met een OS erop verschilt niet zo veel van een PLC.

[daniëlpunt]

Ook een mooie :

PHP:

class Foo
{
    public function __construct($Value = null)
    {
        $this->Value = is_null($Value) ? 'Default' : $Value;
    }
}

[.oisyn]

Wat is daar zo vreemd aan? Goed, je zou kunnen zeggen dat $Value dan maar direct de default-waarde 'Default' mee moet krijgen, maar feitelijk doet de code dan wat anders (nu kun je expliciet null opgeven om toch de default waarde te krijgen, dat kan dan niet meer).

[Michali]

Bij mij heeft het ook de voorkeur om standaard null op te geven, en dan later een andere default waarde op te geven indien de parameter null blijkt te zijn. Zeker als je meerdere parameters hebt met optionele waarden, dan is het vrij irritant als je bijvoorbeeld de eerste paar de default waarde wilt laten behouden en eentje daarna wilt overriden. Als ze standaard null als waarde hebben, dan is het vrij simpel om gewoon null in te tikken. Anders moet je voor al die parameters de default waardes gaan zitten intypen.

[mithras]

Michali schreef op donderdag 22 mei 2008 @ 20:11:
Bij mij heeft het ook de voorkeur om standaard null op te geven, en dan later een andere default waarde op te geven indien de parameter null blijkt te zijn. Zeker als je meerdere parameters hebt met optionele waarden, dan is het vrij irritant als je bijvoorbeeld de eerste paar de default waarde wilt laten behouden en eentje daarna wilt overriden. Als ze standaard null als waarde hebben, dan is het vrij simpel om gewoon null in te tikken. Anders moet je voor al die parameters de default waardes gaan zitten intypen.

Als je parameters geen boolean zijn, zal ik altijd nog een false toewijzen:

PHP:

function do( $var = false ){
  if( !$var ) $var = DEFAULT_VALUE;
}

Scheelt typewerk

[Patriot]

Dan moet je natuurlijk wel zeker weten dat het de boolean false is, en dan krijg je dit:

PHP:

<?php
function doe_iets($var = false)
{
  $var = ($var === false) ? DEFAULT_VALUE : $var;
}
?>

[ Voor 0% gewijzigd door Patriot op 22-05-2008 23:58 . Reden: spatie weg voor netheid ]

[Verwijderd]

Lekker nuttig...

PHP:

<?php
function doe_iets($var = false)
{
  if ($var === false) $var = DEFAULT_VALUE;
}
?>

Anders zit je IMHO alleen interessant te doen terwijl het minder efficient is... (hoe marginaal dan ook)

Daarnaast verlies je hiermee natuurlijk de mogelijkheid om daadwerkelijk false mee te geven aan het parameter (of je moet DEFAULT_VALUE ook op false zetten wat al helemaal onzinnig is).

Daarom zou ik altijd voor null gaan, dan maakt het tenminste niets uit of het nu wel of geen boolean is, anders helpt het de handigheid nog om zeep.

[ Voor 42% gewijzigd door Verwijderd op 23-05-2008 01:00 ]

[Patriot]

Sorry hoor, maar persoonlijk vind ik die kortere notatie duidelijker dan de manier waarop jij het doet. Dat heeft helemaal niets te maken met "interessant doen" (alsof ik niet beter weet dan dat dat niet interessant is?)... Het ging namelijk vooral om de toevoeging van de stricte controle op false.

Of het überhaupt handig is om het zo te doen is een ander verhaal. Maar mocht je willen controleren op false, dan moet je dat niet doen op de manier die mithras aangeeft.

[Verwijderd]

Tjah dan deel ik jouw mening niet dat een onzinnige bewerking duidelijker is dan die onzinnige bewerking weglaten...

Daarnaast deel ik ook jouw mening niet dat een korte notatie van een if duidelijker zou zijn.Ik vind het nooit duidelijker maar gebruik het puur in situaties waar het toch duidelijk genoeg blijft en het dus wel minder typwerk is (ik ben dan ook een extreem lui persoon) of layout technisch beter in de code past.

[YopY]

Patriot schreef op vrijdag 23 mei 2008 @ 01:08:
Sorry hoor, maar persoonlijk vind ik die kortere notatie duidelijker dan de manier waarop jij het doet. Dat heeft helemaal niets te maken met "interessant doen" (alsof ik niet beter weet dan dat dat niet interessant is?)... Het ging namelijk vooral om de toevoeging van de stricte controle op false.

ow ja, want

code:

if ($var === false)
{
    $var = DEFAULT_VALUE;
} else {
    $var = $var;
}

is zo logisch, dan moet de kortere versie wel beter zijn!

Kom op zeg, wat een non-discussie. Zet gewoon die $var in op DEFAULT_VALUE, hoef je ook niet te controleren of 'ie nu false is of niet. Of je moet toevallig heel iets anders doen als die $var echt false is. Maar als je een functie hebt die twee hele verschillende dingen doen al naar gelang het type van de parameter, dan moet je toch eens denken om een nieuwe functie aan te maken of iets dergelijks.

Het is niet belangrijk of iets kort is, of dat iets 'lang' duurt om te typen, want dat staat niet in verhouding met, bijvoorbeeld, de uitvoeringstijd of, belangrijker misschien, de ontwikkeltijd van je script.

[Voutloos]

Origineel idee om het topic nu in omgekeertde volgorde te doen!
De initiele code was gewoon prima en de slechte voorbeelden/standpunten volgen daarna pas.

[Patriot]

Voutloos schreef op vrijdag 23 mei 2008 @ 10:03:
Origineel idee om het topic nu in omgekeertde volgorde te doen!
De initiele code was gewoon prima en de slechte voorbeelden/standpunten volgen daarna pas.

Ghehe, ach ja. Ik denk dat je dat snel krijgt, je kunt namelijk iets dat in zijn beginsel al slecht is namelijk wel verbeteren, maar dan blijft het vaak gewoon slecht.

Ik had in mijn post waarin ik de stricte controle voorstelde sowieso even moeten zeggen dat het in feite niet een betere oplossing was dan de is_null controle. Mijn post was puur bedoelt om, mocht je false om één of andere reden willen gebruiken, te stellen dat je dan op zijn minst de stricte controle moet gebruiken om problemen bij bijv. de integer 0 te voorkomen.

Het is niet belangrijk of iets kort is, of dat iets 'lang' duurt om te typen, want dat staat niet in verhouding met, bijvoorbeeld, de uitvoeringstijd of, belangrijker misschien, de ontwikkeltijd van je script.

Je bedoelt te zeggen dat je alles zo efficiënt mogelijk zou moeten doen? Sorry hoor, maar voor mij is de leesbaarheid van de kortere notatie gewoon dusdanig beter dat ik er later profijt van heb als ik het terugzie. Dat er daardoor een kleine berekening extra word uitgevoerd, dat accepteer ik dan gewoon. Net alsof het je merkbaar tijd gaat kosten, het is alom bekend dat dit soort dingen voor de overall performance nagenoeg geen verschil maken.

Het blijft wel een zinlose discussie dit, want we discussiëren nu over een mogelijke oplossing die ik überhaupt nooit zou gebruiken.

[mosymuis]

PHP:

    $sBedrijfSQL = "select * from tblBedrijf ORDER BY Naam";
    $sBedrijfQuery = mysql_query($sBedrijfSQL);
    while($aBedrijven = mysql_fetch_array($sBedrijfQuery))
    {
        $bedrijfindex = $aBedrijven['ID'];
        $sBedrijfSQLas = "select * from tblBedrijf where ID = '$bedrijfindex'";
        $sBedrijfQueryas = mysql_query($sBedrijfSQLas);
        $oBedrijf = mysql_fetch_assoc($sBedrijfQueryas);
        $aBedrijf[$bedrijfindex] = $oBedrijf;
    }

Wie mij de logica kan uitleggen krijgt een bloemetje

[Sebazzz]

Geweldig. Eerst haalt ie alles uit de DB, gesorteerd op naam. Daarna trekt ie alles uit de DB dat het gegeven ID heeft. Er zijn meerdere wegen naar Rome hè, ook omwegen

[g4wx3]

??
NIet zo fijn voor de serverload btw.

[Verwijderd]

mosymuis schreef op woensdag 18 juni 2008 @ 10:40:
Wie mij de logica kan uitleggen krijgt een bloemetje

Rofl

[Gomez12]

mosymuis schreef op woensdag 18 juni 2008 @ 10:40:

Wie mij de logica kan uitleggen krijgt een bloemetje

Persoon heeft ooit eens gehoord dat een dbase sneller iets kan ophalen als je op een id zoekt.

Dus zoek je eerst het id erbij... Lijkt me logisch