Dat is ook niet echt een programmeerfout maar kan gezien worden als refactoringDavio schreef op vrijdag 22 juni 2012 @ 12:16:
Toch hoeven we er niet zo streng op te letten.
Laat hem lekker een Inlog en Uitlog-klasse maken en er zelf achterkomen dat het handig is om die samen te voegen.
Als je echt goed wilt worden zul je er nog wel meer moeten kopen ben ik bang ;-)LEDfan schreef op vrijdag 22 juni 2012 @ 13:03:
Oei nog een boek, als ik echt goed wil worden moet ik er nog 5 kopen, de eerste heb ik gelukkig gekregen van men ouders.
Meestal heb ik problemen met men namen doordat ik Engels en Nederlands in de code door elkaar begin te gebruiken. Ik zou eigenlijk alles naar het Engels moeten omzetten. (Nieuwe code ga ik sowieso doen, en een groot deel van de code moet toch nog naar PDO vertaalt worden, dus kan ik evengoed naar Engels omzetten).
Al vind ik zelf dat je een boek zeer goed kan gebruiken voor de basis en vervolgens met verdiepen zul je toch internet gaan gebruiken omdat de boeken verouderd zijn of niet te vinden.
Dat is ook zo, heb al wel een paar applicaties gemaakt, maar de basis zoals arrays of zelfs de verschillende data types kende ik niet. (Toch niet in PHP). Deze ga ik natuurlijk wel verbeteren.
En als je dat jezelf aanleert ga je soms weer denken hoe je een naam toch wat korter kan maken omdat hij zo fucking lang is als hij de lading goed moet dekken.afvalzak schreef op vrijdag 22 juni 2012 @ 12:59:
[...]
Dan raad ik je aan het boek Clean Code te lezen. Het komt er eigenlijk op neer dat je je functies / variabellen gewoon beschrijft zoals ze zijn.
Heeft geen speciale krachten en is daar erg boos over.
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| <p><b>Jaar:</b> <?php $plusyear = date('Y')+1; $minyear = date('Y')-1; ?> <a href="?p=kalender<?php if(isset($_GET['month'])){ echo '&month='.$_GET['month'].'&year='.$minyear;}?>"><?php echo $minyear; ?></a> <a href="?p=kalender<?php if(isset($_GET['month'])){ echo '&month='.$_GET['month'].'&year='.date('Y');}?>"><?php echo date('Y'); ?></a> <a href="?p=kalender<?php if(isset($_GET['month'])){ echo '&month='.$_GET['month'].'&year='.$plusyear;}?>"><?php echo $plusyear; ?></a> <p><b>Maand:</b> <a href="?p=kalender&month=1<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Januari</a> - <a href="?p=kalender&month=2<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Februari</a> - <a href="?p=kalender&month=3<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Maart</a> - <a href="?p=kalender&month=4<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">April</a> - <a href="?p=kalender&month=5<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Mei</a> - <a href="?p=kalender&month=6<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Juni</a> - <a href="?p=kalender&month=7<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Juli</a> - <a href="?p=kalender&month=8<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Augustus</a> - <a href="?p=kalender&month=9<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">September</a> - <a href="?p=kalender&month=10<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">Oktober</a> - <a href="?p=kalender&month=11<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">November</a> - <a href="?p=kalender&month=12<?php if(isset($_GET['year'])){echo '&year='.$_GET['year'];} ?>">December</a> |
Pfoeh.
Front-end developer.
Intellisense en CTRL-space dan valt dat wel mee.bwerg schreef op vrijdag 22 juni 2012 @ 15:36:
[...]
En als je dat jezelf aanleert ga je soms weer denken hoe je een naam toch wat korter kan maken omdat hij zo fucking lang is als hij de lading goed moet dekken.
Gelukkig hoef je je niet druk te maken om xss; je gebruikers zijn immers altijd te vertrouwen!
No trees were harmed in creating this message. However, a large number of electrons were terribly inconvenienced.
Ik niet: ik ben blij dat ik dat soort zooi niet meer hoef te onderhouden
Misschien daarvoor een scriptje schrijven?

[ Voor 8% gewijzigd door LEDfan op 22-06-2012 19:35 ]
Meestal wel, niet altijd. Als je gewoon lange berekeningen hebt (natuurkundige simulaties e.d.) met 10 variabelen wordt je gek als elke variable meer dan twee letters lang is.Davio schreef op vrijdag 22 juni 2012 @ 17:46:
[...]
Intellisense en CTRL-space dan valt dat wel mee.
Maar goed, niet dat de namen x, y, px, py, etc. zo onduidelijk zijn als je de context weet.
Heeft geen speciale krachten en is daar erg boos over.
Ik zie dat for-loopjes nog steeds moeilijk te begrijpen zijn?
//weg weg weg weg
[ Voor 98% gewijzigd door nathanchunkie op 25-06-2012 00:02 ]
Front-end developer.
Ik snap niet echt wat je bedoelt nathanchunkie? Hoe slaag jij erin om iemand een link te bezorgen met xss erin, of hoe slaag jij erin om de company name aan te passen?
Vind dit net in de source van een app:
C#:
1
| if (!isBackup) NeedsToBeSaved = false; |
[ Voor 5% gewijzigd door Soundless op 25-06-2012 13:34 ]
Als je alle kleine fouten hier bij elkaar optelt kom je toch heel snel op een blunder.
App zit trouwens vol met bugs.
+ ik wilde gewoon ff posten
App zit trouwens vol met bugs.
+ ik wilde gewoon ff posten
[ Voor 16% gewijzigd door Soundless op 25-06-2012 14:20 ]
Verwijderd
Ik vind het toch niet echt goed ...Verwijderd schreef op maandag 25 juni 2012 @ 13:44:
Zo slecht is dat toch niet?
Wat is er mis met het volgende?
C#:
1
| NeedsToBeSaved = isBackup; |
Als er een ; achter zou staan, zou het beter, of iig korter zijn.Verwijderd schreef op dinsdag 26 juni 2012 @ 01:48:
[...]
Ik vind het toch niet echt goed ...
Wat is er mis met het volgende?
C#:
1 NeedsToBeSaved = isBackup
Verwijderd
Uiteraard. Die ";" is iets die ik snel vergeet als ik niet echt aan het programmeren ben. Ik ben nochtans wel gewoon een ";" te zetten als ik aan het programmeren ben (C#, Java, PHP, ...)OKA schreef op dinsdag 26 juni 2012 @ 02:27:
[...]
Als er een ; achter zou staan, zou het beter, of iig korter zijn.
Het feit dat dat totaal niet doet wat het originele statement doet?Verwijderd schreef op dinsdag 26 juni 2012 @ 01:48:
Ik vind het toch niet echt goed ...
Wat is er mis met het volgende?
C#:
1 NeedsToBeSaved = isBackup;
roeleboel schreef op dinsdag 26 juni 2012 @ 09:52:
[...]
Het feit dat dat totaal niet doet wat het originele statement doet?
C#:
1
| needsToBeSaved = needsToBeSaved && isBackup; |
Maar of dat nou een verbetering is...
^ Wat hij zegt.
Juweeltje uit onze codebase:
bgwSync is dus een BackgroundWorker die dus op de achtergrond draait en vervolgens op de GUI thread gaat synchroniseren
C#:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| private void bgwSync_DoWork(object sender, DoWorkEventArgs e) { while (true) // constantly run { if (Properties.Settings.Default.BackgroundSyncEnabled && !IsInitializing) { try { Invoke ( RunSyncAsDelegate() ); Thread.Sleep(Properties.Settings.Default.BackgroundSyncTime); } catch { } } else { Thread.Sleep(1000); } } } |
bgwSync is dus een BackgroundWorker die dus op de achtergrond draait en vervolgens op de GUI thread gaat synchroniseren

Hail to the king baby!
Och, ik zat meer te kijken naar de lege catch waarna vervolgens weer keurig verder gegaan wordt (en dan zelfs zonder sleep)
Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'
Wel dus..roeleboel schreef op dinsdag 26 juni 2012 @ 09:52:
[...]
Het feit dat dat totaal niet doet wat het originele statement doet?
Oh?

Heb even geen zin een RML table te gaan klussen, dan maar zo
Het doet dus in 75% van de gevallen hetzelfde, in 25% geeft het de verkeerde uitkomst

Heb even geen zin een RML table te gaan klussen, dan maar zo
"Your life is yours alone. Rise up and live it." - Richard Rahl
Rhàshan - Aditu Sunlock
Niet dus, bij de combinatie isBackup = true en NeedsToBeSaved = false.
code:
1
| if (!isBackup) NeedsToBeSaved = false; |
Nu is NeedsToBeSaved nog steeds false, maar bij:
code:
1
| NeedsToBeSaved = isBackup; |
krijgt NeedsToBeSaved de waarde true. Of die combinatie nodig of zelfs zinnig is, is een tweede, maar de code doet zeker niet hetzelfde.
@Paul
[ Voor 4% gewijzigd door CodeCaster op 26-06-2012 10:37 ]
https://oneerlijkewoz.nl
Op papier is hij aan het tekenen, maar in de praktijk...
Excuus, mijn fout, de code is niet compleet. Er staat ergens bovenaan de method NeedsToBeSaved = true;
ja lap, wat hierboven dus allemaal staat :-)
(ik en mijn af & toe trage verstand typskills ook weer)
[ Voor 57% gewijzigd door roeleboel op 26-06-2012 10:56 ]
Ik kwam deze bug tegen in oude macrocode. Ik werk op z/OS, en we hebben bovenop de assembler een eigen macrotaal gebouwd.
De code die ik wilde draaien loopte oneindig lang:
De DS (DataStore) X is een unsigned byte.
De code genereerde aan het begin van de lus de instructies voor de "TO,255" als "verlaat de lus als INDEX >= 256"
De code die ik wilde draaien loopte oneindig lang:
code:
1
2
3
4
5
6
| DATA WORK INDEX DS X ENDDATA , DO (INDEX,FROM,0,TO,255) .. ENDDO , |
De DS (DataStore) X is een unsigned byte.
De code genereerde aan het begin van de lus de instructies voor de "TO,255" als "verlaat de lus als INDEX >= 256"
[ Voor 14% gewijzigd door Sendy op 26-06-2012 18:48 ]
Dus? Misschien is er halverwege tussen die code wel een andere reden afgeleid waarom er niet opgeslagen hoeft te worden. Dat dat nu misschien weg is maakt de code nog niet fout. NOFI, maar als dit al als een bug gezien wordt dan vraag ik me af of het huidige team niet meer bugs zal gaan veroorzaken...Soundless schreef op dinsdag 26 juni 2012 @ 10:38:
Excuus, mijn fout, de code is niet compleet. Er staat ergens bovenaan de method NeedsToBeSaved = true;
Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'
komt idd beetje in de buurt van het 'not build here'-syndroom waarbij het credo is: 'ik snap het niet dus we bouwen het om'
This message was sent on 100% recyclable electrons.
Nu ga je zelf van dingen uit. Ik plaats hem hier dus niet omdat er tussenin code wordt veranderd maar omdat het apart is dat je zoiets doet terwijl je dus gewoon NeedsToBeSaved = isBackup; kan doen (en ja dat kan dus echt in dit geval)Janoz schreef op dinsdag 26 juni 2012 @ 16:31:
[...]
Dus? Misschien is er halverwege tussen die code wel een andere reden afgeleid waarom er niet opgeslagen hoeft te worden. Dat dat nu misschien weg is maakt de code nog niet fout. NOFI, maar als dit al als een bug gezien wordt dan vraag ik me af of het huidige team niet meer bugs zal gaan veroorzaken...
Ik heb ook nergens beweerd dat dit als bug wordt gezien. Wordt dan ook niks aan gedaan, dit blijft gewoon staan...
We hebben genoeg bugs om te fixen en dit is er geen
If it ain't broken, don't try to refactor.
[ Voor 3% gewijzigd door Davio op 27-06-2012 09:07 ]
Precies
Alles werkt echt net op het puntje dus elke kleine wijziging kan fataal zijn
Nadat we van de grootste bugs af zijn, kunnen we wel gaan refactoren (hoop ik

Gaan we niet een beetje offtopic?
[ Voor 21% gewijzigd door Soundless op 27-06-2012 09:32 ]
Dan werk je met Italiaanse pasta. Denk maar eens zo. Stel dat er een bug is. Hoe ga je het dan oplossen? Werk je dan ook overal omheen?Soundless schreef op woensdag 27 juni 2012 @ 09:31:
[...]
Precies
Alles werkt echt net op het puntje dus elke kleine wijziging kan fataal zijn
Nadat we van de grootste bugs af zijn, kunnen we wel gaan refactoren (hoop ik)
Gaan we niet een beetje offtopic?
Lekker
De hoeveelheid WTF's valt hier de laatste tijd eigenlijk wel mee. Of ik begin gewend te raken aan de code, dat kan natuurlijk ook.
We are shaping the future
Is dat werkelijk zo. je vervangende code betekend:Soundless schreef op woensdag 27 juni 2012 @ 08:42:
[...]
Nu ga je zelf van dingen uit. Ik plaats hem hier dus niet omdat er tussenin code wordt veranderd maar omdat het apart is dat je zoiets doet terwijl je dus gewoon NeedsToBeSaved = isBackup; kan doen (en ja dat kan dus echt in dit geval)
Ik heb ook nergens beweerd dat dit als bug wordt gezien. Wordt dan ook niks aan gedaan, dit blijft gewoon staan...
We hebben genoeg bugs om te fixen en dit is er geen
"Of er opgeslagen moet worden is equivalent aan of het een backup is."
De originele code heeft meer als betekenis:
"Als het geen backup is, dan hoeft er ook niet opgeslagen te worden."
De uitwerking is misschien hetzelfde, maar het zijn wel twee fundamenteel andere dingen. Ik vraag mij dan ook terecht af of de code door die aanpassing beter wordt.
Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'
Bij de kleinere bugs momenteel wel.com2,1ghz schreef op woensdag 27 juni 2012 @ 09:47:
[...]
Dan werk je met Italiaanse pasta. Denk maar eens zo. Stel dat er een bug is. Hoe ga je het dan oplossen? Werk je dan ook overal omheen?
Er is een sectie die vol zit met bugs. Grootste gedeelte van de bugs heeft daarmee te maken. Ik denk er over om heel die sectie te herschrijven maar ik wil dit graag eerst bespreken met een collega (ben nog nieuw in deze afdeling
Zoals ik al zei heb ik hier niks aan aangepast. Dus die ifje staat er nog. Ben het ook niet van plan aan te passen.Janoz schreef op woensdag 27 juni 2012 @ 09:59:
[...]
Is dat werkelijk zo. je vervangende code betekend:
"Of er opgeslagen moet worden is equivalent aan of het een backup is."
De originele code heeft meer als betekenis:
"Als het geen backup is, dan hoeft er ook niet opgeslagen te worden."
De uitwerking is misschien hetzelfde, maar het zijn wel twee fundamenteel andere dingen. Ik vraag mij dan ook terecht af of de code door die aanpassing beter wordt.
[ Voor 18% gewijzigd door Soundless op 27-06-2012 10:17 ]
Ach, als je duidelijke (unit) tests hebt, dan zal je het best kunnen herschrijven omdat je dan makkelijker kunt controleren of de output nog klopt.
Als je die niet hebt, wordt het al een stuk lastiger natuurlijk.
Als je die niet hebt, wordt het al een stuk lastiger natuurlijk.
Dat dusDavio schreef op woensdag 27 juni 2012 @ 11:43:
Ach, als je duidelijke (unit) tests hebt, dan zal je het best kunnen herschrijven omdat je dan makkelijker kunt controleren of de output nog klopt.
Als je die niet hebt, wordt het al een stuk lastiger natuurlijk.
Er zijn geen unit tests.
Maar dat is nog niet alles!
Het is een van de main applicaties van het bedrijf en er is geen documentatie. Er is maar 1 ontwikkelaar die weet hoe het in elkaar zit en dat is omdat hij het heeft gebouwd.
Als hij vertrekt, moet het bedrijf waarschijnlijk 3/4 van de werknemers ontslaan om niet failliet te gaan...
Hahaha, dat plaatje heeft m'n dag gemaakt!
Zo treffend.
Dat gelukkig niet. Hij heeft redelijke variabelnamen.Davio schreef op woensdag 27 juni 2012 @ 12:19:
Ha, mooi staaltje job security.
Heeft hij ook allemaal éénletterige variabelenamen?
Nieuwtje:
Java:
1
2
3
4
| public void setStatus(Character value) { if(status == null) this.status = null; else this.status = status.toString(); } |
Vond ik er ook van! Iemand die een refactor erdoor heeft gejaagd zonder erbij na te denken.
Bleek daarboven nog eens dat dit stukje niet gedekt was door enige unit tests, of uberhaupt niet gebruikt werd (momenteel andere tests aan het draaien om dat te controleren) -> Weghalen is de boodschap.
Wat voor tests zijn dat?cpf_ schreef op donderdag 28 juni 2012 @ 10:39:
[...]
Vond ik er ook van! Iemand die een refactor erdoor heeft gejaagd zonder erbij na te denken.
Bleek daarboven nog eens dat dit stukje niet gedekt was door enige unit tests, of uberhaupt niet gebruikt werd (momenteel andere tests aan het draaien om dat te controleren) -> Weghalen is de boodschap.
Find in Files-tests.
https://oneerlijkewoz.nl
Op papier is hij aan het tekenen, maar in de praktijk...
In Visual Studio: CTRL-K, R.CodeCaster schreef op donderdag 28 juni 2012 @ 10:54:
Find in Files-tests.
In Eclipse: Ctrl +Shift + GCodeCaster schreef op donderdag 28 juni 2012 @ 10:54:
Find in Files-tests.
Of natuurlijk gewoon: De methode verwijderen en kijken of je nog kunt builden.
CTRL-K, R opent bij mij de Repo explorer
CTRL+Shift+F = Find in Files
Eén van de slechtste programmeervoorbeelden die ik heb gezien heb ik ooit zelf geschreven. Typisch gevalletje 'test-code in productie'.
Het achtergrond verhaal: Externe leverancier had zonder goede waarschuwing een API veranderd, waardoor ik in een haastklus de nieuwe API moest implementeren om file informatie te tonen. Natuurlijk moest ik dit 's ochtends vroeg doen terwijl er 250+ KM file stond, en ik wilde m'n code nog even testen voor het geval er geen files/waarschuwingen zijn.
Het resultaat op productie (geen copy paste, maar de situatie uit het hoofd even snel opnieuw getypt):
M'n viewscript:
De echte code was iets anders opgezet en toonde geen notices op het moment dat de traffic array niet bestond, maar regel 1 had dus niet in productie mogen komen
. Wijze les: Als je gebruik maakt van externe API's en je cached de boel toch al in je eigen database.... manipuleer dan de data in je database ipv deze oplossing die uit pure luiheid is ontstaan
.
Het achtergrond verhaal: Externe leverancier had zonder goede waarschuwing een API veranderd, waardoor ik in een haastklus de nieuwe API moest implementeren om file informatie te tonen. Natuurlijk moest ik dit 's ochtends vroeg doen terwijl er 250+ KM file stond, en ik wilde m'n code nog even testen voor het geval er geen files/waarschuwingen zijn.
Het resultaat op productie (geen copy paste, maar de situatie uit het hoofd even snel opnieuw getypt):
M'n viewscript:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
| <? unset($traffic); ?> <li> <? foreach ($traffic['jams'] as $trafficjam): ?> <!-- Toon file --> <? endforeach; ?> </li> <li> <? foreach ($traffic['warnings'] as $warning): ?> <!-- Toon waarschuwing --> <? endforeach; ?> </li> |
De echte code was iets anders opgezet en toonde geen notices op het moment dat de traffic array niet bestond, maar regel 1 had dus niet in productie mogen komen
I think there is a world market for maybe five computers. - Thomas Watson (1874-1956), Directeur van IBM (1943)
Hmm, CTRL-K, R is bij mij Find Symbol Results waar ik op doelde.Soundless schreef op donderdag 28 juni 2012 @ 11:13:
[...]
CTRL-K, R opent bij mij de Repo explorer
CTRL+Shift+F = Find in Files
Wat een reacties. Deze test heb ik iig al gedaanDavio schreef op donderdag 28 juni 2012 @ 11:05:
Of natuurlijk gewoon: De methode verwijderen en kijken of je nog kunt builden.
CTRL+R G had ik ook al gedaan.
Nu hebben we ook Integration Tests, die niet getoont worden in onze sonar: Daar kan ik dus niet vlug zien of het al dan niet nog ergens stiekem gebruikt wordt. Deze draaien (met success) kan daar dan klaring over geven.
Wat heeft dat in hemelsnaam te maken met het unsetten van een variabele?XyritZz schreef op donderdag 28 juni 2012 @ 11:18:Wijze les: Als je gebruik maakt van externe API's en je cached de boel toch al in je eigen database.... manipuleer dan de data in je database ipv deze oplossing die uit pure luiheid is ontstaan.
Het unsetten van de variabele was om te testen hoe de code zich zou gedragen wanneer er geen files/waarschuwingen zijn. Ik had beter de gecachte data in de database kunnen manipuleren om deze situatie na te bootsen omdat er dan geen risico zou zijn om per ongeluk testcode te committen en naar productie te pushenPatriot schreef op donderdag 28 juni 2012 @ 13:03:
[...]
Wat heeft dat in hemelsnaam te maken met het unsetten van een variabele?
I think there is a world market for maybe five computers. - Thomas Watson (1874-1956), Directeur van IBM (1943)
Hier wil ik toch wel even op terugkomen (ja het is een paar pagina's geleden). Maar zeker voor beginnende programmeurs is het juist erg belangrijk om je je te realiseren waarom je nu OOP toepast. Die realisatie, dat inzicht, is van onschatbare waarde en wordt achteraf steeds moeilijker om in te zien.afvalzak schreef op dinsdag 19 juni 2012 @ 15:19:
[...]
Heel leuk maar als dit zijn eerste stukje OOP PHP is wat neem ik aan voor zichzelf is zou ik me daar niet te druk over maken.
Het probleem is dat er snel een "het werkt dus het is goed" gedachte gaat sluimeren. Iedereen in deze wereld kent wel iemand die hard roept dat hij OO programmeert maar in feite alleen z'n functies aan het categoriseren is. En probeer iemand die dat al 10 jaar doet maar 's uit te leggen dat hij/zij er geen bal van snapt....
Als een beginnende programmeur dus dit begint te doen onder de noemer van OO mag wat mij betreft alles aan de kant gelazerd worden. De hoe & waarom van OO echt snappen is een enorm belangrijke en solide basis voor iedere programmeur die professioneel gezien verder wil komen.
You are the all-dancing, all-singing crap of the world - Jack
Een pareltje van m'n werk. Iets dat (toevallig) alleen maar boven kwam drijven als ze runnen met het nieuwe filesystem (gemaakt door moi) dus vingers wezen naar mij. Op basis van de callstack zei ik al dat het vrij onwaarschijnlijk was dat het er ook maar iets mee te maken had, maar people insisted.
Stuitte ik uiteindelijk op:
Stuitte ik uiteindelijk op:
C++:
1
2
3
4
| if (m_streamState == kDestroyed) delete this; return m_next; |
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Eerst jezelf verwijderen en dan returnen? Mag dat?
En waarom werkte het eerst wel??
En waarom werkte het eerst wel??
Natuurlijk mag dat. 't Gaat alleen fout als je daarna nog members aan gaat spreken op 'this', zoals 'm_next'.Davio schreef op vrijdag 29 juni 2012 @ 15:22:
Eerst jezelf verwijderen en dan returnen? Mag dat?
Het heeft nooit gewerkt, alleen door bepaalde racecondities kwam hij nooit in dat codepath terecht. En in final builds clearen we geen memory dat net vrijgegeven is waardoor members meestal nog wel de goede waarde hebben als er geen allocatie tussendoor plaatsvindtEn waarom werkte het eerst wel??
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Verwijderd
Onder het motto: slechte implementatievoorbeelden.
Men neme een XML document
(extra enters voor de duidelijkheid)
Men neme powershell 2.0, en leest dat document in
Returnt 2. Klopt toch?
Returnt... helemaal niets
edit: in powershell 3.0 doet hij wel wel netjes. Ik was toch al van plan om over te gaan op windows 8 zodra de RTM uitkomt...
Men neme een XML document
XML:
1
2
3
4
5
6
7
8
9
| <?xml version="1.0" encoding="UTF-8"?> <products> <foo>1</foo> <foo>2</foo> <bar>3</bar> </products> |
(extra enters voor de duidelijkheid)
Men neme powershell 2.0, en leest dat document in
PowerShell:
1
| $xml = [xml](get-content -en utf8 file.xml) |
code:
1
| ($xml.products.foo).count |
Returnt 2. Klopt toch?
code:
1
| ($xml.products.bar).count |
Returnt... helemaal niets

edit: in powershell 3.0 doet hij wel wel netjes. Ik was toch al van plan om over te gaan op windows 8 zodra de RTM uitkomt...
[ Voor 16% gewijzigd door Verwijderd op 02-07-2012 09:51 ]
Ik werk nu aan een C# project waar warnings as errors aanstaat, en er warnings staan ingesteld op het ontbreken van commentaar voor publieke members. Dat levert dit soort mooi commentaar op (thingy is mijn poging tot anoniemisering):
En dat dus voor elke method, property enzovoort. Ik heb nog geen enkel commentaar gezien dat ook maar 1% waarde toevoegt t.o.v. de functienaam
Dit is gelukkig code die ergens anders is ontwikkeld en nu is overgenomen, dus ik ga het voorstel inschieten om ten eerste die warning uit te zetten, en ten tweede het overbodige commentaar te verwijderen.
C#:
1
2
3
4
5
6
7
8
9
10
11
12
| /// <summary> /// Gets the global thingy status view. /// </summary> /// <value>The global thingy status view.</value> /// <CreatedBy>JCD 4 NOV 2010</CreatedBy> /// <HistoryOfChanges></HistoryOfChanges> /// <CreatedBy>JCD 4 NOV 2010</CreatedBy> /// <HistoryOfChanges></HistoryOfChanges> public IEnumView GlobalThingyStatusView { get { return mThingyStatus; } } |
En dat dus voor elke method, property enzovoort. Ik heb nog geen enkel commentaar gezien dat ook maar 1% waarde toevoegt t.o.v. de functienaam

Dit is gelukkig code die ergens anders is ontwikkeld en nu is overgenomen, dus ik ga het voorstel inschieten om ten eerste die warning uit te zetten, en ten tweede het overbodige commentaar te verwijderen.
[ Voor 10% gewijzigd door MBV op 04-07-2012 09:44 ]
Nou bedankt dat je dit met ons wilde delen. Je kunt er ook fatsoenlijk commentaar neerzetten zodat er onder jou initialen wel commentaar staat.
Tja, ik heb ooit een keer zo'n autocommenter van GhostDoc eroverheen gegooid en al die waardeloze comments ben ik nu handmatig weer aan het verwijderen.
9 vd 10 keer is een goede methodenaam al voldoende.
Zeker een parameterloze constructor behoeft eigenlijk geen comment.
// Creates a new instance of Foo
No shit, Sherlock!
9 vd 10 keer is een goede methodenaam al voldoende.
Zeker een parameterloze constructor behoeft eigenlijk geen comment.
// Creates a new instance of Foo
No shit, Sherlock!
[ Voor 3% gewijzigd door Davio op 04-07-2012 10:21 ]
Ik doe tegenwoordig nooit meer aan comments, ik kies altijd goede namen. Bespaart een hoop tijd, en onderhoud. Ik verbaas me echter wel als ik terug kijk naar oude code van mij hoe ontzettend netjes en overzichtelijk dat is vergeleken met de (commentloze) code die ik nu schrijf 
En dan heb ik het over code van iets meer dan een half jaar geleden
En dan heb ik het over code van iets meer dan een half jaar geleden

code:
1
2
3
4
5
6
7
| if x=1 then y=1 elsif x=2 then y=1 elsif x=3 then y=1 elsif x=4 then y=1 elsif x=5 then y=1 elsif x=6 then y=1 end |
Niet helemaal. Reflection kan een hoop verknallenDavio schreef op donderdag 28 juni 2012 @ 11:05:
Of natuurlijk gewoon: De methode verwijderen en kijken of je nog kunt builden.
[Te koop: 3D printers] [Website] Agile tools: [Return: retrospectives] [Pokertime: planning poker]
Dat is volgens mij niet het doel van documentatie, volgens mij moet je niet "Creates a new instance of Foo" maar uitleggen wat Foo doet.Davio schreef op woensdag 04 juli 2012 @ 10:20:
Zeker een parameterloze constructor behoeft eigenlijk geen comment.
// Creates a new instance of Foo
No shit, Sherlock!
Dat hoort dan juist niet bij de constructor, maar als class commentaar.
Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'
Welk nuttig commentaar wil je bij een parameterloze constructor toevoegen? Wat voor klasse het is staat bovenaan bij de klasse, wat voor wijzigingen er zijn doorgevoerd staat in versiebeheer, en verder krijg je inderdaad 'create new instance of Foo' als nuttige summary. Dat volgt al uit de declaratie... Het enige effect is dat je je een ongeluk scrollt, en snel het overzicht kwijt raakt waar je nu weer zit. Als er verschillende constructors zijn kan het wel nuttig zijn, dan komt er zoiets als 'This is similar to Foo(42, SomeDefault)'jip_86 schreef op woensdag 04 juli 2012 @ 10:04:
Nou bedankt dat je dit met ons wilde delen. Je kunt er ook fatsoenlijk commentaar neerzetten zodat er onder jouw initialen wel commentaar staat.
Uiteraard ga ik mezelf niet verbieden om nuttig commentaar alsnog toe te voegen, maar het verplichte spelletje 'herschrijf de functienaam' doe ik liever niet.
Ik zie hier 2 tegenstrijdigheden:Avalaxy schreef op woensdag 04 juli 2012 @ 10:23:
Ik doe tegenwoordig nooit meer aan comments, ik kies altijd goede namen. Bespaart een hoop tijd, en onderhoud. Ik verbaas me echter wel als ik terug kijk naar oude code van mij hoe ontzettend netjes en overzichtelijk dat is vergeleken met de (commentloze) code die ik nu schrijf
En dan heb ik het over code van iets meer dan een half jaar geleden
- code zonder comments is vaak overzichtelijker, omdat er meer in 1 scherm past
- bespaart een hoop onderhoud, maar je snapt nu al niet meer wat je code van een half jaar geleden doet. Dat kost dus een hoop extra onderhoud
Ehm, wat er gebeurd in die constructor. Stel je al bepaalde dingen in in die constructor of moet ik zelf nog wat doen ten opzichte van een constructor die wel parameters heeft? Die variant met drie slashes word ook meegenomen in je IntelliSense en scheelt je bijv weer een keer f12 om naar je constructor te springen.MBV schreef op woensdag 04 juli 2012 @ 10:46:
[...]
Welk nuttig commentaar wil je bij een parameterloze constructor toevoegen?
Change history is inderdaad nutteloos. Zoveel regels extra regels is niet nodig.
[ Voor 7% gewijzigd door jip_86 op 04-07-2012 11:48 ]
Nee, je begrijpt hem verkeerd. Ja, er past meer code op het scherm zonder comments, dan is het dus JUIST onoverzichtelijker in mijn ogenMBV schreef op woensdag 04 juli 2012 @ 10:46:
[...]
Ik zie hier 2 tegenstrijdigheden:
- code zonder comments is vaak overzichtelijker, omdat er meer in 1 scherm past
- bespaart een hoop onderhoud, maar je snapt nu al niet meer wat je code van een half jaar geleden doet. Dat kost dus een hoop extra onderhoud
En ik snap wel wat de code doet hoor, ik weet niet waar je dat vandaan haalt
Ja, ik heb het boek van Robert C gelezen genaamd clean codejip_86 schreef op woensdag 04 juli 2012 @ 11:10:
[...]
Ehm, wat er gebeurd in die constructor. Stel je al bepaalde dingen in in die constructor of moet ik zelf nog wat doen ten opzichte van een constructor die wel parameters heeft? Die variant met drie slashes word ook meegenomen in je IntelliSense en scheelt je bijv weer een keer f12 om naar je constructor te springen.
Code moet zichzelf uit kunnen leggen! Als een constructor dermate ingewikkeld is dat je er comments bij moet gaan zetten dan zou ik eens nadenken over of die constructor niet een beetje teveel aan het doen is en of die functionaliteit niet kan worden opgedeeld in kleinere functies.
Immers commentaar moet worden aangepast als de functie wordt aangepast en dat gebeurt niet altijd even netjes en dus is je commentaar fout..
[ Voor 8% gewijzigd door Webgnome op 04-07-2012 11:58 ]
Als je commentaar zo nuttig is dat je het het liefste niet ziet, wat is dan het nut van commentaar?wsitedesign schreef op woensdag 04 juli 2012 @ 11:04:
En als je nu eens standaard instelt dat je commentaar ingeklapt is?

Het is wel een oplossing voor het onderhoud aan deze code natuurlijk.
Er staat bij elke constructor "Create new instance of Foo" zonder verdere informatie. Als ik zelf een niet-triviale constructor schrijf zal ik het er zeker bij zetten, maar juist voor die 90% van de gevallen waarbij de constructor er vooral voor de vorm staat kan je het commentaar ook weglaten.jip_86 schreef op woensdag 04 juli 2012 @ 11:10:
[...]
Ehm, wat er gebeurd in die constructor. Stel je al bepaalde dingen in in die constructor of moet ik zelf nog wat doen ten opzichte van een constructor die wel parameters heeft? Die variant met drie slashes word ook meegenomen in je IntelliSense en scheelt je bijv weer een keer f12 om naar je constructor te springen.
oh ja, in C# is het nergens voor nodig om een lege constructor neer te zetten. Misschien de volgende keer dat ook maar weglaten.
Dit gaat gedeeltelijk over iets anders: uit je commentaar voor zo'n constructor wordt ook je documentatie en intellisense informatie gehaald. Als je dus Foo(), Foo(int count), en Foo(int count, MyEnum whatever) hebt is het wel handig om te weten welke van de 3 je nodig hebt zonder naar de code te kijken. "Create new instance of Foo without arguments" voegt dan niks toe, maar "Create instance of foo with index set to 0, and whatever set to Bar" wel.Webgnome schreef op woensdag 04 juli 2012 @ 11:55:
[...]
Ja, ik heb het boek van Robert C gelezen genaamd clean code
Code moet zichzelf uit kunnen leggen! Als een constructor dermate ingewikkeld is dat je er comments bij moet gaan zetten dan zou ik eens nadenken over of die constructor niet een beetje teveel aan het doen is en of die functionaliteit niet kan worden opgedeeld in kleinere functies.
Ah ja, met dit excuus is zo ongeveer heel ons pakket niet voorzien van commentaar op plekken waar dit het leven toch wel een stuk makkelijker zou maken.
[ Voor 10% gewijzigd door jip_86 op 04-07-2012 14:15 ]
Het is niet wel of niet overal comments, ook niet in boeken als Clean Code. Het is: gebruik comments zo min mogelijk omdat deze over het algemeen niet worden onderhouden en denk 2x na voordat je een comment gebruikt, kan je het niet oplossen met betere naamgeving/opsplitsen van functionaliteit?
Edit: het lijkt alsof ik nu zeg dat het zo MOET, maar dat is niet zo, ik wilde er op wijzen dat de "overal comments" vs. "nerges comments" regels niet werken, wat al wordt aangetoond met voorbeelden.
Edit: het lijkt alsof ik nu zeg dat het zo MOET, maar dat is niet zo, ik wilde er op wijzen dat de "overal comments" vs. "nerges comments" regels niet werken, wat al wordt aangetoond met voorbeelden.
[ Voor 25% gewijzigd door Zeebonk op 04-07-2012 14:33 ]
Ik voeg eigenlijk overal commentaar toe. Veelal laat ik me hierbij helpen door GhostDoc, maar ik pas het commentaar wel aan. "Gets or sets the name of the first." is niet echt logisch als de klasse Person heet, bijvoorbeeld. 
Waarom? Enerzijds om gedrag te documenteren, anderzijds omdat ik graag zo veel mogelijk consistente code heb. Alle properties en methods voorzien van documentatie komt op mij iets professioneler over. Al moet ik zeggen dat het niet altijd lukt, i.v.m. tijdsdruk enzo.
Waarom? Enerzijds om gedrag te documenteren, anderzijds omdat ik graag zo veel mogelijk consistente code heb. Alle properties en methods voorzien van documentatie komt op mij iets professioneler over. Al moet ik zeggen dat het niet altijd lukt, i.v.m. tijdsdruk enzo.
We are shaping the future
Eensch. Anyways , is geen echt slecht code voorbeeld maar wel een grappig gebruik van namen. Ben nu bezig met een lotus notes database voor uren registratie.. Kom ik een veldje tegen 'TimeTravelHours'. Ik ben alleen nog aan het zoeken naar de 'Start warpdrive' knopZeebonk schreef op woensdag 04 juli 2012 @ 14:25:
Het is niet wel of niet overal comments, ook niet in boeken als Clean Code. Het is: gebruik comments zo min mogelijk omdat deze over het algemeen niet worden onderhouden en denk 2x na voordat je een comment gebruikt, kan je het niet oplossen met betere naamgeving/opsplitsen van functionaliteit?
Edit: het lijkt alsof ik nu zeg dat het zo MOET, maar dat is niet zo, ik wilde er op wijzen dat de "overal comments" vs. "nerges comments" regels niet werken, wat al wordt aangetoond met voorbeelden.

[ Voor 17% gewijzigd door Webgnome op 04-07-2012 15:01 ]
Code kan nog zo duidelijk en leesbaar zijn, maar als er meerdere manieren zijn om iets te doen kan het soms ook heel handig zijn om even in een comment te zeggen dat je die manieren wel hebt overwogen.
486DX2-50 16MB ECC RAM 4x 500MB Drive array 1.44MB FDD MS-Dos 6.22
Daar heb je dan weer een architectuurdocument voorPiepPiep schreef op woensdag 04 juli 2012 @ 14:59:
Code kan nog zo duidelijk en leesbaar zijn, maar als er meerdere manieren zijn om iets te doen kan het soms ook heel handig zijn om even in een comment te zeggen dat je die manieren wel hebt overwogen.
Commentaar is vooral leuk als het niet (meer) met de code overeenkomt. Welke van de 2 spreekt dan de waarheid
Juist
Bij elke method uitgebreid beschrijven wat code doet hoeft voor mij ook niet, zeker niet als je niet verder komt dan "Insert data into database" boven een functie die insertData heet...Zeebonk schreef op woensdag 04 juli 2012 @ 14:25:
Het is niet wel of niet overal comments, ook niet in boeken als Clean Code. Het is: gebruik comments zo min mogelijk omdat deze over het algemeen niet worden onderhouden en denk 2x na voordat je een comment gebruikt, kan je het niet oplossen met betere naamgeving/opsplitsen van functionaliteit?
Edit: het lijkt alsof ik nu zeg dat het zo MOET, maar dat is niet zo, ik wilde er op wijzen dat de "overal comments" vs. "nerges comments" regels niet werken, wat al wordt aangetoond met voorbeelden.
Echter vind ik het wel zeer prettig als op z'n minst param types en return types gedocumenteerd zijn. Niet in de laatste plaats omdat ik veel PHP schrijf en IDE's de types in de comments nodig hebben voor autocompletion.
I think there is a world market for maybe five computers. - Thomas Watson (1874-1956), Directeur van IBM (1943)
Dat is in C# niet van toepassing, aangezien een functie-argument altijd getypeerd moet zijn (of mag 'var' daar ook?). "int index" heeft geen documentatie nodig bij een array, toch?
var niet, dynamic wel.MBV schreef op woensdag 04 juli 2012 @ 15:42:
Dat is in C# niet van toepassing, aangezien een functie-argument altijd getypeerd moet zijn (of mag 'var' daar ook?). "int index" heeft geen documentatie nodig bij een array, toch?
Zelf vind ik het ook belangrijker dat de intentie van de method wordt beschreven in de comments, dan wat het daadwerkelijk doet. Dat laatste maak ik wel op uit de code. De intentie van een methode of klasse verandert ook wat minder snel. Eigenlijk hoort die zelfs niet te veranderen, maak dan een nieuwe aan en markeer de oude als obsolete (als die dat is).
[ Voor 9% gewijzigd door Caelorum op 04-07-2012 15:52 ]
Code spreekt natuurlijk altijd de waarheid, dat is namelijk wat wordt uitgevoerd ;-).Jeldert schreef op woensdag 04 juli 2012 @ 15:11:
Commentaar is vooral leuk als het niet (meer) met de code overeenkomt. Welke van de 2 spreekt dan de waarheid
Daarnaast kan je dan in je versiebeheer kijken welke van de 2 out-of-date is, mocht het belangrijk zijn.
Mbt commentaar:
Weet niet meer wie:
"If it was hard to write, it should definitively be hard to read"
Ik vind dat alle programmeurs een keer een programma moeten schrijven dat een moeilijk natuurkundig probleem oplost, dan hoor je nooit meer dat gezeur over dat alle code voor zichzelf moet kunnen spreken. 
Nou, als het bijvoorbeeld gaat over javadoc is het nut dat je code gedocumenteerd is, wil je een methode aanroepen dan laat je IDE mooi die documentatie zien... Dat ga ik echt niet ergens in de betreffende code opzoeken als het niet hoeft.MBV schreef op woensdag 04 juli 2012 @ 13:59:
[...]
Als je commentaar zo nuttig is dat je het het liefste niet ziet, wat is dan het nut van commentaar?![]()
Het is wel een oplossing voor het onderhoud aan deze code natuurlijk.
Heeft geen speciale krachten en is daar erg boos over.
Ik zou graag doodles en andere handgeschreven 'comments' kunnen attachen in de comments in code, dat zou mijn 3d intersection library ook enorm helpenbwerg schreef op woensdag 04 juli 2012 @ 21:21:
Ik vind dat alle programmeurs een keer een programma moeten schrijven dat een moeilijk natuurkundig probleem oplost, dan hoor je nooit meer dat gezeur over dat alle code voor zichzelf moet kunnen spreken.
De enige comments die ik meestal schrijf zijn aannames en waarom iets gedaan wordt.
[ Voor 9% gewijzigd door .oisyn op 04-07-2012 21:25 ]
Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.
Ja, of een foto van mijn kladblok met pagina's vol gekrabbel, tekeningetjes en wiskundige afleidingen. En dan onderaan als resultaat een lompe formule die dus in de code gezet is. En dat is dan nog maar in 2D (oke, ik was wel zo puberaal om per sé elastische botsingen te willen, wat veel te moeilijk is en dus faalde
).
Heeft geen speciale krachten en is daar erg boos over.
Tijd voor een IDE waarin de editor ook een canvas is?.oisyn schreef op woensdag 04 juli 2012 @ 21:24:
[...]
Ik zou graag doodles en andere handgeschreven 'comments' kunnen attachen in de comments in code, dat zou mijn 3d intersection library ook enorm helpen
Ipsa Scientia Potestas Est
NNID: ShinNoNoir
Tja, dat is nu eenmaal de dunne scheidslijn.bwerg schreef op woensdag 04 juli 2012 @ 21:21:
Ik vind dat alle programmeurs een keer een programma moeten schrijven dat een moeilijk natuurkundig probleem oplost, dan hoor je nooit meer dat gezeur over dat alle code voor zichzelf moet kunnen spreken.
Bij prive projectjes heb ik over het algemeen zoiets van : als ik erover na moet denken heb ik comments nodig.
Maarja, dat heeft me in het verleden al meerdere keren opgebroken (na 3 dagen natuurkundige problemen ploep ik op de 4e dag er zomaar wat dingen uit zonder na te denken die ik een half jaar later niet meer 1-2-3 begrijp)
Debug comments gebruik ik bijna niet, maar API documentatie zet ik bij zowat alles deel uit maakt van een publieke API. Als ik ergens een enorme hekel aan heb, dan is het wel een publieke API die niet gedocumenteerd is. Absoluut een veel voorkomend manco bij (Java) open-source projecten. En ik vind de source van een 3rd party library doorspitten geen alternatief voor API documentatie.
Dit topic is gesloten.
Let op:
Uiteraard is het in dit topic niet de bedoeling dat andere users en/of topics aangehaald worden om ze voor gek te zetten. Lachen om je eigen code, of over dingen die je "wel eens tegengekomen bent" is prima, maar hou het onderling netjes.
Uiteraard is het in dit topic niet de bedoeling dat andere users en/of topics aangehaald worden om ze voor gek te zetten. Lachen om je eigen code, of over dingen die je "wel eens tegengekomen bent" is prima, maar hou het onderling netjes.